CL-Softwares
/
Nut
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

all warnings was fixed !!!

This commit is contained in:
Hamed Masafi 2020-07-30 19:35:11 +04:30
parent 3a2115b309
commit 94c2c4ad5f
14 changed files with 126 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/nut/3rdparty/serializer vendored

@ -1 +1 @@
Subproject commit 2dc11b380a07424a4face3046cc6b5e50aefb700
Subproject commit 0e794d6317595d077e95e8a06f1f3a8c92543b05

24
src/nut/database.cpp
View File

@ -66,7 +66,7 @@ bool DatabasePrivate::open(bool update)
return true;
Q_Q(Database);
// if (update)
connectionName = q->metaObject()->className()
connectionName = QString::fromUtf8(q->metaObject()->className())
+ QString::number(DatabasePrivate::lastId);
db = QSqlDatabase::addDatabase(driver, connectionName);
@ -77,7 +77,7 @@ bool DatabasePrivate::open(bool update)
db.setUserName(userName);
db.setPassword(password);
if (driver.startsWith("qsqlite", Qt::CaseInsensitive)
if (driver.startsWith(QStringLiteral("qsqlite"), Qt::CaseInsensitive)
&& !QFile::exists(databaseName)) {
//Force to execute update database
isDatabaseNew = true;
@ -89,18 +89,20 @@ bool DatabasePrivate::open(bool update)
qWarning("Could not connect to database, error = %s",
db.lastError().text().toLocal8Bit().data());
if (db.lastError().text().contains("database \"" + databaseName
+ "\" does not exist")
|| db.lastError().text().contains("Cannot open database")
|| db.lastError().text().contains("Unknown database '"
+ databaseName + "'")) {
if (db.lastError().text().contains(QStringLiteral("database \"")
+ databaseName
+ QStringLiteral("\" does not exist"))
|| db.lastError().text().contains(QStringLiteral("Cannot open database"))
|| db.lastError().text().contains(QStringLiteral("Unknown database '")
+ databaseName
+ QStringLiteral("'"))) {
db.close();
db.setDatabaseName(sqlGenerator->masterDatabaseName(databaseName));
ok = db.open();
qDebug("Creating database");
if (ok) {
db.exec("CREATE DATABASE " + databaseName);
db.exec(QStringLiteral("CREATE DATABASE ") + databaseName);
db.close();
if (db.lastError().type() != QSqlError::NoError) {
@ -219,8 +221,8 @@ bool DatabasePrivate::getCurrectSchema()
if (!nutClassInfoString(q->metaObject()->classInfo(i),
type, name, value)) {
errorMessage = QStringLiteral("No valid table in %1")
.arg(q->metaObject()->classInfo(i).value());
errorMessage = QStringLiteral("No valid table in ")
+ QString::fromUtf8(q->metaObject()->classInfo(i).value());
continue;
}
if (type == QStringLiteral(__nut_TABLE)) {
@ -326,7 +328,7 @@ bool DatabasePrivate::putModelToDatabase()
/*current.remove(__CHANGE_LOG_TABLE_NAME)*/;
auto changeLog = create<ChangeLogTable>();
changeLog->setData(QString(QJsonDocument(current.toJson()).toJson(QJsonDocument::Compact)));
changeLog->setData(QString::fromUtf8(QJsonDocument(current.toJson()).toJson(QJsonDocument::Compact)));
changeLog->setVersion(current.version());
changeLogs->append(changeLog);
q->saveChanges(true);

4
src/nut/databasemodel.cpp
View File

@ -28,8 +28,8 @@ NUT_BEGIN_NAMESPACE
QMap<QString, DatabaseModel*> DatabaseModel::_models;
#define NODE_VERSION "version"
#define NODE_TABLES "tables"
#define NODE_VERSION QStringLiteral("version")
#define NODE_TABLES QStringLiteral("tables")
DatabaseModel::DatabaseModel(const QString &name) :
QList<TableModel*>(), _databaseClassName(name), _version(0)
{

2
src/nut/defines_p.h
View File

@ -41,7 +41,7 @@
#define __nut_DEFAULT_VALUE "def"
#define __nut_NOT_NULL "notnull"
#define __nut_FOREIGN_KEY "foreign_key"
#define __nut_FOREIGN_KEY "foreign_key"
#define __nut_NEW "new"
#define __nut_REMOVE "remove"
#define __nut_CHANGE "change"

3
src/nut/generators/postgresqlgenerator.cpp
View File

@ -262,7 +262,8 @@ QString PostgreSqlGenerator::escapeValue(const QVariant &v) const
pt = pol.at(i);
if (!ret.isEmpty())
ret.append(QStringLiteral("),("));
ret.append(QString::number(pt.x()) + ", " + QString::number(pt.y()));
ret.append(QString::number(pt.x())
+ QStringLiteral(", ") + QString::number(pt.y()));
}
return QStringLiteral("'((") + ret + QStringLiteral("))'");
}

13
src/nut/generators/sqlgeneratorbase.cpp
View File

@ -383,7 +383,8 @@ QString SqlGeneratorBase::join(const QString &mainTable,
(*i)->masterTable->primaryKey()));
if (order != Q_NULLPTR)
order->append((*i)->masterTable->name() + "." + (*i)->masterTable->primaryKey());
order->append((*i)->masterTable->name() + QStringLiteral(".")
+ (*i)->masterTable->primaryKey());
}
}
return ret;
@ -426,7 +427,8 @@ QString SqlGeneratorBase::join(const QStringList &list, QStringList *order)
rel->localColumn, mainTable));
if (order != Q_NULLPTR)
order->append(mainTable + "." + rel->masterTable->primaryKey());
order->append(mainTable + QStringLiteral(".")
+ rel->masterTable->primaryKey());
} else{
rel = model.relationByClassNames(clone.first(), mainTable);
@ -437,7 +439,8 @@ QString SqlGeneratorBase::join(const QStringList &list, QStringList *order)
rel->masterTable->primaryKey(), mainTable));
if (order != Q_NULLPTR)
order->append(mainTable + "." + rel->localColumn);
order->append(mainTable + QStringLiteral(".")
+ rel->localColumn);
} else {
// qInfo("Relation for %s and %s not exists",
@ -552,7 +555,7 @@ QString SqlGeneratorBase::fromTableText(const QString &tableName,
tableNameText = QStringLiteral("%1 INNER JOIN %2 ON (%1.%3 = %2.%4)")
.arg(tableName, joinTableName,
pk, rel->localColumn);
orderBy = tableName + "." + pk;
orderBy = tableName + QStringLiteral(".") + pk;
} else {
qWarning("Relation between table %s and class %s (%s) not exists!",
qPrintable(tableName),
@ -927,7 +930,7 @@ QString SqlGeneratorBase::phrase(const PhraseData *d) const
break;
case PhraseData::WithoutOperand:
ret = phrase(d->left) + " " + operatorString(d->operatorCond);
ret = phrase(d->left) + QStringLiteral(" ") + operatorString(d->operatorCond);
break;
}

3
src/nut/phrases/phrasedata.cpp
View File

@ -73,7 +73,8 @@ PhraseData &PhraseData::operator =(PhraseData &other)
QString PhraseData::toString() const
{
return QString(QStringLiteral("[%1].%2")).arg(className, fieldName);
return QStringLiteral("[%1].%2")
.arg(QString::fromUtf8(className), QString::fromUtf8(fieldName));
}
void PhraseData::cleanUp()

6
src/nut/phrases/phraselist.cpp
View File

@ -30,13 +30,13 @@ PhraseList::PhraseList() : isValid(false)
PhraseList::PhraseList(const PhraseList &other) : isValid(true)
{
data = qMove(other.data);
const_cast<PhraseList&>(other).data.clear();
data = other.data;
}
PhraseList::PhraseList(PhraseList &&other)
{
data = other.data;
data = qMove(other.data);
const_cast<PhraseList&>(other).data.clear();
}
PhraseList::PhraseList(const AbstractFieldPhrase &other) : isValid(true)

25
src/nut/query.h
View File

@ -118,12 +118,13 @@ Q_OUTOFLINE_TEMPLATE QList<O> Query<T>::select(const std::function<O (const QSql
QList<O> ret;
d->joins.prepend(d->tableName);
d->sql = d->database->sqlGenerator()->selectCommand(
d->tableName,
SqlGeneratorBase::SingleField, "*",
d->wherePhrase,
d->relations,
d->skip, d->take);
d->sql = d->database->sqlGenerator()->selectCommand(d->tableName,
SqlGeneratorBase::SingleField,
QStringLiteral("*"),
d->wherePhrase,
d->relations,
d->skip,
d->take);
QSqlQuery q = d->database->exec(d->sql);
@ -153,7 +154,7 @@ Q_OUTOFLINE_TEMPLATE Query<T>::Query(Database *database, TableSetBase *tableSet,
d->database = database;
d->tableSet = tableSet;
d->className = T::staticMetaObject.className();
d->className = QString::fromUtf8(T::staticMetaObject.className());
d->tableName =
d->database->model()
.tableByClassName(d->className)
@ -207,7 +208,9 @@ Q_OUTOFLINE_TEMPLATE RowList<T> Query<T>::toList(int count)
LevelData data;
data.table = table;
data.keyFiledname = data.table->name() + "." + data.table->primaryKey();
data.keyFiledname = data.table->name()
+ QStringLiteral(".")
+ data.table->primaryKey();
data.lastKeyValue = QVariant();
QHash<QString, QString> masters;
@ -241,7 +244,7 @@ Q_OUTOFLINE_TEMPLATE RowList<T> Query<T>::toList(int count)
if (!importedTables.count()) {
LevelData data;
data.table = d->database->model().tableByName(d->tableName);
data.keyFiledname = d->tableName + "." + data.table->primaryKey();
data.keyFiledname = d->tableName + QStringLiteral(".") + data.table->primaryKey();
data.lastKeyValue = QVariant();
levels.append(data);
@ -314,8 +317,8 @@ Q_OUTOFLINE_TEMPLATE RowList<T> Query<T>::toList(int count)
foreach (FieldModel *field, childFields)
row->setProperty(field->name.toLatin1().data(),
d->database->sqlGenerator()->unescapeValue(
field->type,
q.value(data.table->name() + "." + field->name)));
field->type,
q.value(data.table->name() + QStringLiteral(".") + field->name)));
for (int i = 0; i < data.masters.count(); ++i) {
int master = data.masters[i];

2
src/nut/sqlmodel.cpp
View File

@ -70,7 +70,7 @@ QVariant SqlModel::data(const QModelIndex &index, int role) const
return QVariant();
if (index.row() >= d->rows.count() || index.row() < 0)
return QVariant("-");
return QVariant::fromValue(QStringLiteral("-"));
if (role == Qt::DisplayRole) {
Row<Table> t = d->rows.at(index.row());

6
src/nut/table.cpp
View File

@ -127,7 +127,7 @@ bool Table::setParentTable(Table *master, TableModel *masterModel, TableModel *m
//Q_D(Table);
d.detach();
QString masterClassName = master->metaObject()->className();
QString masterClassName = QString::fromUtf8(master->metaObject()->className());
d->refreshModel();
// if (!d->model)
@ -173,9 +173,9 @@ int Table::save(Database *db)
{
//Q_D(Table);
QSqlQuery q = db->exec(db->sqlGenerator()->saveRecord(this, db->tableName(metaObject()->className())));
QSqlQuery q = db->exec(db->sqlGenerator()->saveRecord(this, db->tableName(QString::fromUtf8(metaObject()->className()))));
auto model = db->model().tableByClassName(metaObject()->className());
auto model = db->model().tableByClassName(QString::fromUtf8(metaObject()->className()));
if(status() == Added && model->isPrimaryKeyAutoIncrement())
setProperty(model->primaryKey().toLatin1().data(), q.lastInsertId());

138
src/nut/tablemodel.cpp
View File

@ -29,6 +29,11 @@
NUT_BEGIN_NAMESPACE
#define REL_LOCAL_COLUMN QStringLiteral("localColumn")
#define REL_LOCAL_PROPERTY QStringLiteral("localProperty")
#define REL_MASTER_CLASS_NAME QStringLiteral("masterClassName")
#define REL_FOREIGIN_COLUMN QStringLiteral("foreignColumn")
QString TableModel::name() const
{
return _name;
@ -128,7 +133,7 @@ TableModel::TableModel(int typeId, const QString &tableName)
_typeId = typeId;
_name = tableName;
_className = tableMetaObject->className();
_className = QString::fromUtf8(tableMetaObject->className());
//#ifdef NUT_NAMESPACE
// if(_className.startsWith(QT_STRINGIFY(NUT_NAMESPACE) "::"))
@ -146,7 +151,7 @@ TableModel::TableModel(int typeId, const QString &tableName)
continue;
}
if(type == __nut_FIELD){
if(type == QStringLiteral(__nut_FIELD)) {
auto *f = new FieldModel;
f->name = f->displayName = name;
_fields.append(f);
@ -155,15 +160,15 @@ TableModel::TableModel(int typeId, const QString &tableName)
// Browse all fields
for(int j = 1; j < tableMetaObject->propertyCount(); j++){
QMetaProperty fieldProperty = tableMetaObject->property(j);
FieldModel *fieldObj = field(fieldProperty.name());
auto name = QString::fromUtf8(fieldProperty.name());
FieldModel *fieldObj = field(name);
foreach (FieldModel *f, _fields)
if(f->name == fieldProperty.name())
if(f->name == name)
f = fieldObj;
if(!fieldObj)
continue;
fieldObj->type = static_cast<QMetaType::Type>(fieldProperty.type());
fieldObj->typeName = QString(fieldProperty.typeName());
fieldObj->typeName = QString::fromUtf8(fieldProperty.typeName());
}
// Browse class infos
@ -177,17 +182,17 @@ TableModel::TableModel(int typeId, const QString &tableName)
continue;
}
if(type == __nut_FOREIGN_KEY){
if(type == QStringLiteral(__nut_FOREIGN_KEY)) {
auto *fk = new RelationModel;
fk->slaveTable = this;
fk->localColumn = name + "Id";
fk->localColumn = name + QStringLiteral("Id");
fk->localProperty = name;
fk->foreignColumn = value;
fk->masterClassName = value;
_foreignKeys.append(fk);
}
if(type == __nut_FIELD){
if(type == QStringLiteral(__nut_FIELD)) {
}
@ -196,21 +201,21 @@ TableModel::TableModel(int typeId, const QString &tableName)
if (!f)
continue;
if (type == __nut_LEN)
if (type == QStringLiteral(__nut_LEN))
f->length = value.toInt();
else if (type == __nut_NOT_NULL)
else if (type == QStringLiteral(__nut_NOT_NULL))
f->notNull = true;
else if (type == __nut_DEFAULT_VALUE)
else if (type == QStringLiteral(__nut_DEFAULT_VALUE))
f->defaultValue = value;
else if (type == __nut_PRIMARY_KEY)
else if (type == QStringLiteral(__nut_PRIMARY_KEY))
f->isPrimaryKey = true;
else if (type == __nut_AUTO_INCREMENT)
else if (type == QStringLiteral(__nut_AUTO_INCREMENT))
f->isAutoIncrement = true;
else if (type == __nut_UNIQUE)
else if (type == QStringLiteral(__nut_UNIQUE))
f->isUnique = true;
else if (type == __nut_DISPLAY)
else if (type == QStringLiteral(__nut_DISPLAY))
f->displayName = value.mid(1, value.length() - 2);
else if (type == __nut_PRIMARY_KEY_AI) {
else if (type == QStringLiteral(__nut_PRIMARY_KEY_AI)) {
f->isPrimaryKey = true;
f->isAutoIncrement = true;
}
@ -237,27 +242,27 @@ TableModel::TableModel(const QJsonObject &json, const QString &tableName) : _typ
{
_name = tableName;
QJsonObject fields = json.value(__FIELDS).toObject();
QJsonObject relations = json.value(__FOREIGN_KEYS).toObject();
QJsonObject fields = json.value(QStringLiteral(__FIELDS)).toObject();
QJsonObject relations = json.value(QStringLiteral(__FOREIGN_KEYS)).toObject();
foreach (QString key, fields.keys()) {
QJsonObject fieldObject = fields.value(key).toObject();
//TODO: use FieldModel(QJsonObject) ctor
auto *f = new FieldModel;
f->name = fieldObject.value(__NAME).toString();
f->type = static_cast<QMetaType::Type>(QMetaType::type(fieldObject.value(__TYPE).toString().toLatin1().data()));
f->typeName = QMetaType::typeName(f->type);
f->name = fieldObject.value(QStringLiteral(__NAME)).toString();
f->type = static_cast<QMetaType::Type>(QMetaType::type(fieldObject.value(QStringLiteral(__TYPE)).toString().toLatin1().data()));
f->typeName = QString::fromUtf8(QMetaType::typeName(f->type));
if(fieldObject.contains(__nut_NOT_NULL))
f->notNull = fieldObject.value(__nut_NOT_NULL).toBool();
if(fieldObject.contains(QStringLiteral(__nut_NOT_NULL)))
f->notNull = fieldObject.value(QStringLiteral(__nut_NOT_NULL)).toBool();
if(fieldObject.contains(__nut_UNIQUE))
f->isUnique = fieldObject.value(__nut_UNIQUE).toBool();
if(fieldObject.contains(QStringLiteral(__nut_UNIQUE)))
f->isUnique = fieldObject.value(QStringLiteral(__nut_UNIQUE)).toBool();
if(fieldObject.contains(__nut_LEN))
f->length = fieldObject.value(__nut_LEN).toInt();
if(fieldObject.contains(QStringLiteral(__nut_LEN)))
f->length = fieldObject.value(QStringLiteral(__nut_LEN)).toInt();
if(fieldObject.contains(__nut_DEFAULT_VALUE))
f->defaultValue = fieldObject.value(__nut_DEFAULT_VALUE).toString();
if(fieldObject.contains(QStringLiteral(__nut_DEFAULT_VALUE)))
f->defaultValue = fieldObject.value(QStringLiteral(__nut_DEFAULT_VALUE)).toString();
_fields.append(f);
}
@ -281,34 +286,34 @@ QJsonObject TableModel::toJson() const
foreach (FieldModel *f, _fields) {
QJsonObject fieldObj;
fieldObj.insert(__NAME, f->name);
fieldObj.insert(__TYPE, QString(QVariant::typeToName(f->type)));
fieldObj.insert(QStringLiteral(__NAME), f->name);
fieldObj.insert(QStringLiteral(__TYPE), QString::fromUtf8(QVariant::typeToName(f->type)));
if(f->length)
fieldObj.insert(__nut_LEN, f->length);
fieldObj.insert(QStringLiteral(__nut_LEN), f->length);
if(f->notNull)
fieldObj.insert(__nut_NOT_NULL, f->notNull);
fieldObj.insert(QStringLiteral(__nut_NOT_NULL), f->notNull);
if(f->isUnique)
fieldObj.insert(__nut_UNIQUE, f->isUnique);
fieldObj.insert(QStringLiteral(__nut_UNIQUE), f->isUnique);
if(!f->defaultValue.isNull())
fieldObj.insert(__nut_DEFAULT_VALUE, f->defaultValue);
fieldObj.insert(QStringLiteral(__nut_DEFAULT_VALUE), f->defaultValue);
if(f->isAutoIncrement)
obj.insert(__nut_AUTO_INCREMENT, f->name);
obj.insert(QStringLiteral(__nut_AUTO_INCREMENT), f->name);
if(f->isPrimaryKey)
obj.insert(__nut_PRIMARY_KEY, f->name);
obj.insert(QStringLiteral(__nut_PRIMARY_KEY), f->name);
fieldsObj.insert(f->name, fieldObj);
}
foreach (RelationModel *rel, _foreignKeys)
foreignKeysObj.insert(rel->localColumn, rel->toJson());
obj.insert(__FIELDS, fieldsObj);
obj.insert(__FOREIGN_KEYS, foreignKeysObj);
obj.insert(QStringLiteral(__FIELDS), fieldsObj);
obj.insert(QStringLiteral(__FOREIGN_KEYS), foreignKeysObj);
return obj;
}
@ -335,7 +340,8 @@ QString TableModel::toString() const
{
QStringList sl;
foreach (FieldModel *f, _fields)
sl.append(f->name + QStringLiteral(" ") + QVariant::typeToName(f->type));
sl.append(f->name + QStringLiteral(" ")
+ QString::fromUtf8(QVariant::typeToName(f->type)));
QString ret = QStringLiteral("%1 (%2)")
.arg(_name, sl.join(QStringLiteral(", ")));
@ -360,47 +366,47 @@ bool TableModel::isPrimaryKeyAutoIncrement() const
FieldModel::FieldModel(const QJsonObject &json)
{
name = json.value(__NAME).toString();
type = static_cast<QMetaType::Type>(json.value(__TYPE).toInt());
length = json.value(__nut_LEN).toInt();
notNull = json.value(__nut_NOT_NULL).toBool();
isUnique = json.value(__nut_UNIQUE).toBool();
isAutoIncrement = json.value(__nut_AUTO_INCREMENT).toBool();
isPrimaryKey = json.value(__nut_PRIMARY_KEY).toBool();
defaultValue = json.value(__nut_DEFAULT_VALUE).toString();
isUnique = json.value(__nut_UNIQUE).toBool();
name = json.value(QStringLiteral(__NAME)).toString();
type = static_cast<QMetaType::Type>(json.value(QStringLiteral(__TYPE)).toInt());
length = json.value(QStringLiteral(__nut_LEN)).toInt();
notNull = json.value(QStringLiteral(__nut_NOT_NULL)).toBool();
isUnique = json.value(QStringLiteral(__nut_UNIQUE)).toBool();
isAutoIncrement = json.value(QStringLiteral(__nut_AUTO_INCREMENT)).toBool();
isPrimaryKey = json.value(QStringLiteral(__nut_PRIMARY_KEY)).toBool();
defaultValue = json.value(QStringLiteral(__nut_DEFAULT_VALUE)).toString();
isUnique = json.value(QStringLiteral(__nut_UNIQUE)).toBool();
}
QJsonObject FieldModel::toJson() const
{
QJsonObject fieldObj;
fieldObj.insert(__NAME, name);
fieldObj.insert(__TYPE, QString(QVariant::typeToName(type)));
fieldObj.insert(__nut_LEN, length);
fieldObj.insert(__nut_NOT_NULL, notNull);
fieldObj.insert(__nut_UNIQUE, isUnique);
fieldObj.insert(__nut_AUTO_INCREMENT, isAutoIncrement);
fieldObj.insert(__nut_PRIMARY_KEY, isPrimaryKey);
fieldObj.insert(__nut_DEFAULT_VALUE, defaultValue);
fieldObj.insert(QStringLiteral(__NAME), name);
fieldObj.insert(QStringLiteral(__TYPE), QString::fromUtf8(QVariant::typeToName(type)));
fieldObj.insert(QStringLiteral(__nut_LEN), length);
fieldObj.insert(QStringLiteral(__nut_NOT_NULL), notNull);
fieldObj.insert(QStringLiteral(__nut_UNIQUE), isUnique);
fieldObj.insert(QStringLiteral(__nut_AUTO_INCREMENT), isAutoIncrement);
fieldObj.insert(QStringLiteral(__nut_PRIMARY_KEY), isPrimaryKey);
fieldObj.insert(QStringLiteral(__nut_DEFAULT_VALUE), defaultValue);
return fieldObj;
}
RelationModel::RelationModel(const QJsonObject &obj)
{
localColumn = obj.value("localColumn").toString();
localProperty = obj.value("localProperty").toString();
masterClassName = obj.value("masterClassName").toString();
foreignColumn = obj.value("foreignColumn").toString();
localColumn = obj.value(REL_LOCAL_COLUMN).toString();
localProperty = obj.value(REL_LOCAL_PROPERTY).toString();
masterClassName = obj.value(REL_MASTER_CLASS_NAME).toString();
foreignColumn = obj.value(REL_FOREIGIN_COLUMN).toString();
slaveTable = masterTable = nullptr;
}
QJsonObject RelationModel::toJson() const
{
QJsonObject o;
o.insert("localColumn", localColumn);
o.insert("localProperty", localProperty);
o.insert("masterClassName", masterClassName);
o.insert("foreignColumn", foreignColumn);
o.insert(REL_LOCAL_COLUMN, localColumn);
o.insert(REL_LOCAL_PROPERTY, localProperty);
o.insert(REL_MASTER_CLASS_NAME, masterClassName);
o.insert(REL_FOREIGIN_COLUMN, foreignColumn);
return o;
}

4
src/nut/tableset.h
View File

@ -70,13 +70,13 @@ public:
template<class T>
Q_OUTOFLINE_TEMPLATE TableSet<T>::TableSet(Database *parent) : TableSetBase(parent)
{
data->childClassName = T::staticMetaObject.className();
data->childClassName = QString::fromUtf8(T::staticMetaObject.className());
}
template<class T>
Q_OUTOFLINE_TEMPLATE TableSet<T>::TableSet(Table *parent) : TableSetBase(parent)
{
data->childClassName = T::staticMetaObject.className();
data->childClassName = QString::fromUtf8(T::staticMetaObject.className());
}
template<class T>

4
src/nut/tablesetbase.cpp
View File

@ -50,13 +50,13 @@ int TableSetBase::save(Database *db, bool cleanUp)
int rowsAffected = 0;
TableModel *masterModel = nullptr;
if (data->table)
masterModel = db->model().tableByClassName(data->table->metaObject()->className());
masterModel = db->model().tableByClassName(QString::fromUtf8(data->table->metaObject()->className()));
foreach (Row<Table> t, data->childs) {
if (data->table)
t->setParentTable(data->table,
masterModel,
db->model().tableByClassName(t->metaObject()->className()));
db->model().tableByClassName(QString::fromUtf8(t->metaObject()->className())));
if (t->status() == Table::Added
|| t->status() == Table::Modified