void WorldYamlSource::loadPropertySystems() {
// iterate through each section (each section is a system)
std::vector<YAML::Node> nodes = YAML::LoadAllFromFile(dir + "PropertySystems.yaml");
for (size_t i = 0; i < nodes.size(); i++) {
YamlWrapper yaml(nodes[i]);
// parse which system this section is for
String typeName = yaml.read<String>("Which", "NONE", "Invalid property system.");
ThingType type = ThingType::fromString(typeName);
// create the system
propertySystems[type].reset(new PropertySystem());
PropertySystem& system = *propertySystems[type];
// parse the properties of the system
YAML::Node propertiesNode = yaml["Properties"].getNode();
for (auto iter = propertiesNode.begin(); iter != propertiesNode.end(); ++iter) {
YamlWrapper propertyYaml(*iter);
String name = propertyYaml.read<String>("Name", "", "Property name not given.");
Type type = Type::fromString(propertyYaml.read<String>("Type"));
Variant def = readVariant(propertyYaml["Default"].getNode(), type);
bool mainKey = propertyYaml.read<bool>("MainKey", false);
system.add(name, type, def, mainKey);
}
}
}
void WorldYamlSource::loadItems() {
if (!propertySystems[ThingType::ITEM]) return;
PropertySystem& itemSys = *propertySystems[ThingType::ITEM];
std::vector<YAML::Node> nodes = YAML::LoadAllFromFile(dir + "Items.yaml");
for (size_t i = 0; i < nodes.size(); i++) {
YamlWrapper yaml(nodes[i]);
// read base
String baseName = yaml.read<String>("Base", "", "Item lacks a base.");
if (baseName == "") continue;
auto iter = itemBaseNameMap.find(baseName);
if (iter == itemBaseNameMap.end()) {
LOG(ERROR) << "'" << baseName << "' is not an existing item base.";
continue;
}
BaseThing& base = *iter->second;
items.emplace_back(new Item(base, items.size() + 1));
Item& item = *items.back();
// read location
if (yaml["Location"]->IsSequence()) {
item.moveTo(yaml.read<Coord>("Location", Coord()));
}
// read properties
YAML::Node propertiesNode = yaml["Properties"].getNode();
for (auto iter = propertiesNode.begin(); iter != propertiesNode.end(); ++iter) {
const Property& property = itemSys[iter->first.as<String>()];
item.setValue(property, readVariant(iter->second, property.type));
}
}
}
QSparqlBinding QTrackerDirectSyncResult::binding(int i) const
{
// Note: this function reads and constructs the data again every time it's called.
if (!cursor || pos() == QSparql::BeforeFirstRow || pos() == QSparql::AfterLastRow)
return QSparqlBinding();
// get the no. of columns only once; it won't change between rows
if (n_columns < 0)
n_columns = tracker_sparql_cursor_get_n_columns(cursor);
if (i < 0 || i >= n_columns)
return QSparqlBinding();
const gchar* name = tracker_sparql_cursor_get_variable_name(cursor, i);
const QVariant& value = readVariant(cursor, i);
// A special case: we store TRACKER_SPARQL_VALUE_TYPE_INTEGER as longlong,
// but its data type uri should be xsd:integer. Set it manually here.
QSparqlBinding b;
b.setName(QString::fromUtf8(name));
if (value.type() == QVariant::LongLong) {
b.setValue(value.toString(), *XSD::Integer());
}
else {
b.setValue(value);
}
return b;
}
QVariant QTrackerDirectSyncResult::value(int i) const
{
// Note: this function re-constructs the data every time it's called.
if (!cursor || pos() == QSparql::BeforeFirstRow || pos() == QSparql::AfterLastRow)
return QVariant();
// get the no. of columns only once; it won't change between rows
if (n_columns < 0)
n_columns = tracker_sparql_cursor_get_n_columns(cursor);
if (i < 0 || i >= n_columns)
return QVariant();
return readVariant(cursor, i);
}
void WorldYamlSource::loadItemBases() {
if (!propertySystems[ThingType::ITEM]) return;
PropertySystem& itemSys = *propertySystems[ThingType::ITEM];
std::vector<YAML::Node> nodes = YAML::LoadAllFromFile(dir + "ItemBases.yaml");
for (size_t i = 0; i < nodes.size(); i++) {
YAML::Node& yaml = nodes[i];
// create the item
itemBases.emplace_back(new BaseThing(itemSys));
BaseThing& item = *itemBases.back();
// read properties
for (auto iter = yaml.begin(); iter != yaml.end(); ++iter) {
String propName = iter->first.as<String>();
const Property& property = itemSys[propName];
Variant value = readVariant(iter->second, property.type);
item.setValue(property, value);
if (property.mainKey) {
itemBaseNameMap[boost::lexical_cast<String>(value)] = &item;
}
}
}
}
QVariant QgsXmlUtils::readVariant( const QDomElement &element )
{
QString type = element.attribute( QStringLiteral( "type" ) );
if ( type == QLatin1String( "invalid" ) )
{
return QVariant();
}
else if ( type == QLatin1String( "int" ) )
{
return element.attribute( QStringLiteral( "value" ) ).toInt();
}
else if ( type == QLatin1String( "uint" ) )
{
return element.attribute( QStringLiteral( "value" ) ).toUInt();
}
else if ( type == QLatin1String( "qlonglong" ) )
{
return element.attribute( QStringLiteral( "value" ) ).toLongLong();
}
else if ( type == QLatin1String( "qulonglong" ) )
{
return element.attribute( QStringLiteral( "value" ) ).toULongLong();
}
else if ( type == QLatin1String( "double" ) )
{
return element.attribute( QStringLiteral( "value" ) ).toDouble();
}
else if ( type == QLatin1String( "QString" ) )
{
return element.attribute( QStringLiteral( "value" ) );
}
else if ( type == QLatin1String( "bool" ) )
{
return element.attribute( QStringLiteral( "value" ) ) == QLatin1String( "true" );
}
else if ( type == QLatin1String( "Map" ) )
{
QVariantMap map;
QDomNodeList options = element.childNodes();
for ( int i = 0; i < options.count(); ++i )
{
QDomElement elem = options.at( i ).toElement();
if ( elem.tagName() == QLatin1String( "Option" ) )
map.insert( elem.attribute( QStringLiteral( "name" ) ), readVariant( elem ) );
}
return map;
}
else if ( type == QLatin1String( "List" ) )
{
QVariantList list;
QDomNodeList values = element.childNodes();
for ( int i = 0; i < values.count(); ++i )
{
QDomElement elem = values.at( i ).toElement();
list.append( readVariant( elem ) );
}
return list;
}
else if ( type == QLatin1String( "StringList" ) )
{
QStringList list;
QDomNodeList values = element.childNodes();
for ( int i = 0; i < values.count(); ++i )
{
QDomElement elem = values.at( i ).toElement();
list.append( readVariant( elem ).toString() );
}
return list;
}
else if ( type == QLatin1String( "QgsProperty" ) )
{
const QDomNodeList values = element.childNodes();
if ( values.isEmpty() )
return QVariant();
QgsProperty p;
if ( p.loadVariant( QgsXmlUtils::readVariant( values.at( 0 ).toElement() ) ) )
return p;
return QVariant();
}
else if ( type == QLatin1String( "QgsCoordinateReferenceSystem" ) )
{
QgsCoordinateReferenceSystem crs;
crs.readXml( element );
return crs;
}
else if ( type == QLatin1String( "QgsGeometry" ) )
{
return QgsGeometry::fromWkt( element.attribute( "value" ) );
}
else
{
return QVariant();
}
}
