/// Parses relation as simple relation with non-relation children. If child is single, then /// calls visitor with this child instead of relation. void processSimpleRelation(Visitor &visitor, std::uint32_t featureId, const ptree &feature) const { auto relation = parseRelation(featureId, feature.get_child("geometry.coordinates")); if (relation.elements.size()==1) { parseProperties(*relation.elements[0], featureId, feature.get_child("properties")); visitor.add(*relation.elements[0]); } else { parseProperties(relation, featureId, feature.get_child("properties")); visitor.add(relation); } }
// File 'complex.mkv': container: Matroska [duration:106752000000 segment_uid:00000000000000000000000000000000] void FileIdentifier::parseContainerLine(QString const &line) { QRegExp re{"^File\\s.*container:\\s+([^\\[]+)"}; if (-1 == re.indexIn(line)) return; m_file->setContainer(re.cap(1)); m_file->m_properties = parseProperties(line); m_file->m_isPlaylist = m_file->m_properties["playlist"] == "1"; m_file->m_playlistDuration = m_file->m_properties["playlist_duration"].toULongLong(); m_file->m_playlistSize = m_file->m_properties["playlist_size"].toULongLong(); m_file->m_playlistChapters = m_file->m_properties["playlist_chapters"].toULongLong(); if (m_file->m_isPlaylist && !m_file->m_properties["playlist_file"].isEmpty()) for (auto const &fileName : m_file->m_properties["playlist_file"].split("\t")) m_file->m_playlistFiles << QFileInfo{fileName}; if (m_file->m_properties["other_file"].isEmpty()) return; for (auto &fileName : m_file->m_properties["other_file"].split("\t")) { auto additionalPart = std::make_shared<SourceFile>(fileName); additionalPart->m_additionalPart = true; additionalPart->m_appendedTo = m_file.get(); m_file->m_additionalParts << additionalPart; } }
bool LuaScript::load(FS::IFile& file) { m_properties.clear(); m_source_code.set((const char*)file.getBuffer(), (int)file.size()); parseProperties(); m_size = file.size(); return true; }
Model::EntityDefinition* DefParser::nextDefinition() { Token token = m_tokenizer.nextToken(); while (token.type() != Eof && token.type() != ODefinition) token = m_tokenizer.nextToken(); if (token.type() == Eof) return NULL; expect(ODefinition, token); StringList baseClasses; ClassInfo classInfo; token = m_tokenizer.nextToken(); expect(Word, token); classInfo.name = token.data(); token = m_tokenizer.peekToken(); expect(OParenthesis | Newline, token); if (token.type() == OParenthesis) { classInfo.setColor(parseColor()); token = m_tokenizer.peekToken(); expect(OParenthesis | Question, token); if (token.type() == OParenthesis) { classInfo.setSize(parseBounds()); } else { m_tokenizer.nextToken(); } token = m_tokenizer.peekToken(); if (token.type() == Word) { Model::FlagsPropertyDefinition::Ptr spawnflags = parseFlags(); classInfo.properties[spawnflags->name()] = spawnflags; } } expect(Newline, token = m_tokenizer.nextToken()); parseProperties(classInfo.properties, classInfo.models, baseClasses); classInfo.setDescription(parseDescription()); expect(CDefinition, token = m_tokenizer.nextToken()); Model::EntityDefinition* definition = NULL; if (classInfo.hasColor) { ClassInfo::resolveBaseClasses(m_baseClasses, baseClasses, classInfo); if (classInfo.hasSize) { // point definition definition = new Model::PointEntityDefinition(classInfo.name, classInfo.color, classInfo.size, classInfo.description, classInfo.propertyList(), classInfo.models); } else { definition = new Model::BrushEntityDefinition(classInfo.name, classInfo.color, classInfo.description, classInfo.propertyList()); } } else { // base definition m_baseClasses[classInfo.name] = classInfo; definition = nextDefinition(); } return definition; }
QDBusMetaObjectGenerator::QDBusMetaObjectGenerator(const QString &interfaceName, const QDBusIntrospection::Interface *parsedData) : data(parsedData), interface(interfaceName) { if (data) { parseProperties(); parseSignals(); // call parseSignals first so that slots override signals parseMethods(); } }
bool Material::initWithFile(const std::string& validfilename) { // Warning: properties is not a "Ref" object, must be manually deleted Properties* properties = Properties::createNonRefCounted(validfilename); // get the first material parseProperties((strlen(properties->getNamespace()) > 0) ? properties : properties->getNextNamespace()); CC_SAFE_DELETE(properties); return true; }
bool Material::initWithFile(const std::string& validfilename) { Data data = FileUtils::getInstance()->getDataFromFile(validfilename); char* bytes = (char*)data.getBytes(); bytes[data.getSize()-1]='\0'; // Warning: properties is not a "Ref" object, must be manually deleted Properties* properties = Properties::createNonRefCounted(validfilename); // get the first material parseProperties((strlen(properties->getNamespace()) > 0) ? properties : properties->getNextNamespace()); CC_SAFE_DELETE(properties); return true; }
/// Parses relation with relations from multipolygon and notifies visitor. void parseMultiPolygon(Visitor &visitor, std::uint32_t featureId, const ptree &feature) const { utymap::entities::Relation relation; parseProperties(relation, featureId, feature.get_child("properties")); for (const ptree::value_type &geometry : feature.get_child("geometry.coordinates")) { auto child = parseRelation(featureId, geometry.second); if (child.elements.size()==1) { FoldRelation fold; child.elements[0]->accept(fold); relation.elements.push_back(fold.element); } else { relation.elements.push_back(std::make_shared<utymap::entities::Relation>(child)); } } visitor.add(relation); }
void LuaScript::loaded(FS::IFile& file, bool success, FS::FileSystem& fs) { if (success) { m_source_code.set((const char*)file.getBuffer(), file.size()); parseProperties(); m_size = file.size(); decrementDepCount(); } else { g_log_error.log("lua_script") << "Could not load script " << m_path.c_str(); onFailure(); } }
// Attachment ID 1: type "cue", size 1844 bytes, description "dummy", file name "cuewithtags2.cue" void FileIdentifier::parseAttachmentLine(QString const &line) { QRegExp re{"^Attachment ID (\\d+): type \"(.*)\", size (\\d+) bytes, description \"(.*)\", file name \"(.*)\"$"}; if (-1 == re.indexIn(line)) return; auto track = std::make_shared<Track>(m_file.get(), Track::Attachment); track->m_properties = parseProperties(line); track->m_id = re.cap(1).toLongLong(); track->m_codec = re.cap(2); track->m_size = re.cap(3).toLongLong(); track->m_attachmentDescription = re.cap(4); track->m_name = re.cap(5); m_file->m_tracks << track; }
// Track ID 0: video (V_MS/VFW/FOURCC, DIV3) [number:1 ...] // Track ID 7: audio (A_PCM/INT/LIT) [number:8 uid:289972206 codec_id:A_PCM/INT/LIT codec_private_length:0 language:und default_track:0 forced_track:0 enabled_track:1 default_duration:31250000 audio_sampling_frequency:48000 audio_channels:2] // Track ID 8: subtitles (S_TEXT/UTF8) [number:9 ...] void FileIdentifier::parseTrackLine(QString const &line) { QRegExp re{"Track\\s+ID\\s+(\\d+):\\s+(audio|video|subtitles|buttons)\\s+\\(([^\\)]+)\\)", Qt::CaseInsensitive}; if (-1 == re.indexIn(line)) return; auto type = re.cap(2) == "audio" ? Track::Audio : re.cap(2) == "video" ? Track::Video : re.cap(2) == "subtitles" ? Track::Subtitles : Track::Buttons; auto track = std::make_shared<Track>(m_file.get(), type); track->m_id = re.cap(1).toLongLong(); track->m_codec = re.cap(3); track->m_properties = parseProperties(line); m_file->m_tracks << track; track->setDefaults(); }
void MetaInfoPrivate::parseNonQmlClassRecursively(const QMetaObject *qMetaObject) { Q_ASSERT_X(qMetaObject, Q_FUNC_INFO, "invalid QMetaObject"); QString typeName; int majorVersion = -1; int minorVersion = -1; typeInfo(qMetaObject, &typeName, &majorVersion, &minorVersion); if (typeName.isEmpty()) { qWarning() << "Meta type system: Registered class has no name."; return; } NodeMetaInfo existingInfo = m_q->nodeMetaInfo(typeName, majorVersion, minorVersion); if (existingInfo.isValid() && existingInfo.majorVersion() == majorVersion && existingInfo.minorVersion() == minorVersion) { return; } NodeMetaInfo nodeMetaInfo(*m_q); nodeMetaInfo.setType(typeName, majorVersion, minorVersion); parseProperties(nodeMetaInfo, qMetaObject); parseClassInfo(nodeMetaInfo, qMetaObject); QString superTypeName; int superTypeMajorVersion = -1; int superTypeMinorVersion = -1; if (qMetaObject->superClass()) { typeInfo(qMetaObject->superClass(), &superTypeName, &superTypeMajorVersion, &superTypeMinorVersion); nodeMetaInfo.setSuperClass(superTypeName, superTypeMajorVersion, superTypeMinorVersion); } if (debug) qDebug() << "adding non qml type" << nodeMetaInfo.typeName() << nodeMetaInfo.majorVersion() << nodeMetaInfo.minorVersion() << ", parent type" << superTypeName << superTypeMajorVersion << superTypeMinorVersion; m_q->addNodeInfo(nodeMetaInfo); if (const QMetaObject *superClass = qMetaObject->superClass()) parseNonQmlClassRecursively(superClass); }
QJsonObject QParseObject::toJson( bool onlyChanged ) { Q_UNUSED( onlyChanged ) QJsonObject data; foreach( QString property, parseProperties() ) { QVariant value = this->property( property.toLatin1().data() ); // handle PARSE specific data if ( value.canConvert<QParseObject*>() ) { // pointer to Parse object data[property] = value.value<QParseObject*>()->getJsonPointer(); } else if ( value.canConvert<QParseDate>() ) { // Parse Date type data[property] = value.value<QParseDate>().toJson(); } else if ( value.canConvert<QParseFile*>() ) { // Parse File type data[property] = value.value<QParseFile*>()->toJson(); } else { data[property] = QJsonValue::fromVariant(this->property( property.toLatin1().data() )); } }
com::typesafe::config::Config* com::typesafe::config::ConfigFactory::parseProperties(::java::util::Properties* properties) { clinit(); return parseProperties(properties, ConfigParseOptions::defaults()); }
void TableLayout::parse(XmlReader& reader) { int rows = -1, cols = -1; border = false; XmlReader::AttributeIterator iter(reader); while(iter.next()) { const char* attribute = (const char*) iter.getName(); const char* value = (const char*) iter.getValue(); if(parseAttribute(attribute, value)) { continue; } else if(strcmp(attribute, "rows") == 0) { if(sscanf(value, "%d", &rows) != 1) { std::stringstream msg; msg << "Error while parsing rows attribute: " << value; throw std::runtime_error(msg.str()); } } else if(strcmp(attribute, "cols") == 0) { if(sscanf(value, "%d", &cols) != 1) { std::stringstream msg; msg << "Error while parsing cols attribute: " << value; throw std::runtime_error(msg.str()); } } else if(strcmp(attribute, "border") == 0) { if(strcmp(value, "true") == 0) { border = true; } else if(strcmp(value, "false") == 0) { border = false; } else { std::cerr << "Invalid value for border attribute. " "Please specify 'true' or 'false'\n"; } } else { std::cerr << "Skipping unknown attribute '" << attribute << "'.\n"; } } if(rows <= 0 || cols <= 0) { throw std::runtime_error("Invalid values for rows/cols"); } rowproperties.assign(rows, RowColProperties()); colproperties.assign(cols, RowColProperties()); cells.assign(rows*cols, Cell()); int depth = reader.getDepth(); while(reader.read() && reader.getDepth() > depth) { if(reader.getNodeType() == XML_READER_TYPE_ELEMENT) { const std::string& element = (const char*) reader.getName(); if(element == "rowsize") { RowColProperties props; int num = parseProperties(reader, props) - 1; if(num < 0 || num >= rows) { std::cerr << "Invalid row specified in rowsize element.\n"; continue; } rowproperties[num] = props; } else if(element == "colsize") { RowColProperties props; int num = parseProperties(reader, props) - 1; if(num < 0 || num >= cols) { std::cerr << "Invalid col specified in colsize element.\n"; continue; } colproperties[num] = props; } else if(element == "cell") { int row = -1, col = -1; int colspan = 1, rowspan = 1; Cell::Alignment halign = Cell::CENTER; Cell::Alignment valign = Cell::CENTER; XmlReader::AttributeIterator iter(reader); while(iter.next()) { const char* name = (const char*) iter.getName(); const char* value = (const char*) iter.getValue(); if(strcmp(name, "row") == 0) { if(sscanf(value, "%d", &row) != 1) { std::cerr << "Couldn't parse integer value '" << value << "' in row attribute.\n"; } } else if(strcmp(name, "col") == 0) { if(sscanf(value, "%d", &col) != 1) { std::cerr << "Couldn't parse integer value '" << value << "' in col attribute.\n"; } } else if(strcmp(name, "rowspan") == 0) { if(sscanf(value, "%d", &rowspan) != 1) { std::cerr << "Couldn't parse integer value '" << value << "' in rowspan attribute.\n"; } } else if(strcmp(name, "colspan") == 0) { if(sscanf(value, "%d", &colspan) != 1) { std::cerr << "Couldn't parse integer value '" << value << "' in colspan attribute.\n"; } } else if(strcmp(name, "halign") == 0) { if(strcmp(value, "left") == 0) { halign = Cell::LEFT; } else if(strcmp(value, "center") == 0) { halign = Cell::CENTER; } else if(strcmp(value, "right") == 0) { halign = Cell::RIGHT; } else { std::cerr << "Skipping unknown halignment value '" << value << "'.\n"; } } else if(strcmp(name, "valign") == 0) { if(strcmp(value, "top") == 0) { valign = Cell::TOP; } else if(strcmp(value, "center") == 0) { valign = Cell::CENTER; } else if(strcmp(value, "bottom") == 0) { valign = Cell::BOTTOM; } else { std::cerr << "Skipping unknown valignment value '" << value << "'.\n"; } } else { std::cerr << "Unknown attribute '" << name << "' in cell element.\n"; } } row--; col--; if(row < 0 || row >= rows) { std::cerr << "Skipping cell because row value is invalid.\n"; continue; } if(col < 0 || col >= cols) { std::cerr << "Skipping cell because col value is invalid.\n"; continue; } if(rowspan <= 0 || row + rowspan - 1 >= rows) { std::cerr << "rowspan value invalid.\n"; rowspan = 1; } if(colspan <= 0 || col + colspan - 1 >= cols) { std::cerr << "colspan value invalid.\n"; colspan = 1; } Component* component = parseEmbeddedComponent(reader); if(component == 0) { std::cerr << "No Component specified in cell " << (row+1) << ", " << (col+1) << "\n"; continue; } addChild(component); Cell cell(childs.size() - 1); cell.halign = halign; cell.valign = valign; cell.rowspan = rowspan; cell.colspan = colspan; cells[row*cols + col] = cell; } else { std::cerr << "Unknown element '" << element << "' in TableLayout.\n"; reader.nextNode(); continue; } } } }
/// Parses node from point and notifies visitor. void parsePoint(Visitor &visitor, std::uint32_t featureId, const ptree &feature) const { utymap::entities::Node node; parseProperties(node, featureId, feature.get_child("properties")); node.coordinate = parseCoordinate(feature.get_child("geometry.coordinates")); visitor.add(node); }
bool Material::initWithProperties(Properties* materialProperties) { return parseProperties(materialProperties); }
Object *parseFile(FILE *file, Object *parent) { /* State: 0 = read tag name [ ] 1 = wait for property list [(] 2 = check new objects [(] 3 = Read content if tag name is code */ int state = 0; int c; char **propertyList; char *name = MALLOCN(char, 255); int i = 0; int iChild = 0; Object **childs; childs = MALLOCN(Object *, 255); Object *obj; DMSG("parse file\n"); for (c = fgetc(file); c != ')'; c = fgetc(file)) { switch (state) { case 0: switch (c) { case ' ': name[i] = '\0'; state = 1; DMSG("switch to state 1\n"); break; default: name[i++] = c; break; } break; case 1: switch (c) { case '(': propertyList = parseProperties(name, file); obj = createObject(name, propertyList); if (strcmp(name, "code") == 0) { state = 3; DMSG("switch to state 3\n"); } else { state = 2; DMSG("switch to state 2\n"); } break; } break; case 2: switch (c) { case '(': childs[iChild++] = parseFile(file, obj); childs[iChild] = NULL; break; } break; case 3: DMSG("Got code - search vor (\n"); switch (c) { case '(': DMSG("Found\n"); parseCode(file, obj, propertyList); state = 2; break; } break; } } DMSG("Set parent and childs\n"); obj->parent = parent; obj->childs = childs; DMSG("Insert into Global index\n"); insertGlobalIndex(obj); if (obj->onInit != NULL) execEvent(obj->onInit, obj); DMSG("parsing finished\n"); return obj; }
/// Parses way from line string and notifies visitor. void parseLineString(Visitor &visitor, std::uint32_t featureId, const ptree &feature) const { utymap::entities::Way way; parseProperties(way, featureId, feature.get_child("properties")); way.coordinates = parseCoordinates(feature.get_child("geometry.coordinates")); visitor.add(way); }