bool Config::parseNode(const pugi::xml_node& node) {
    UnicodeString currentPath = StringConverter::fromUtf8(node.path('/'));
    currentPath.append("@");

    pugi::xml_node::attribute_iterator attrIter = node.attributes_begin();
    pugi::xml_node::attribute_iterator attrEnd = node.attributes_end();

    for (; attrIter != attrEnd; ++attrIter) {
        UnicodeString configKey = currentPath;
        configKey.append(attrIter->name());
        std::map<UnicodeString, Variable>::iterator itm = variablesMap_.find(configKey);
        if (itm != variablesMap_.end()) {
            if (!itm->second.parse(attrIter->value())) {
                return false;
            }
        } else {
            LOG_WARN << "Ignoring unknown config value " << configKey << std::endl;
        }
    }

    pugi::xml_node::iterator nodeIter = node.begin();
    pugi::xml_node::iterator nodeEnd = node.end();

    for (; nodeIter != nodeEnd; ++nodeIter) {
        if (nodeIter->type() == pugi::node_element) {
            if (!parseNode(*nodeIter)) {
                return false;
            }
        }
    }

    return true;
}

Group * AssimpLoader::parseNode(const aiScene & scene,
    const QList<PolygonalDrawable *> &drawables, const aiNode & node) const
{
    Group * group = new Group(node.mName.C_Str());

    const aiMatrix4x4 & mat = node.mTransformation;
    glm::mat4 transform(
        mat.a1, mat.b1, mat.c1, mat.d1,
        mat.a2, mat.b2, mat.c2, mat.d2,
        mat.a3, mat.b3, mat.c3, mat.d3,
        mat.a4, mat.b4, mat.c4, mat.d4
    );
    /*
    translation vector is marked with []
    assimp's aiMatrix4x4 : row major (as usually written down in maths)
     a1  a2  a3 [a4]  <1. row>
     b1  b2  b3 [b4]  <2. row>
     c1  c2  c3 [c4]  <3. row>
     d1  d2  d3  d4   <4. row>
    glm/openGL mat4 : column major (not as stated in http://assimp.sourceforge.net/lib_html/data.html , search for "All matrices")
     a1  b1  c1  d1   <1. column>
     a2  b2  c2  d2   <2. column>
     a3  b3  c3  d3   <3. column>
    [a4][b4][c4] d4   <4. column>
    */
    group->setTransform(transform);

    for (unsigned int i = 0; i < node.mNumChildren; i++)
        group->append(parseNode(scene, drawables, *(node.mChildren[i])));

    for (unsigned int i = 0; i < node.mNumMeshes; i++)
        group->append(drawables[node.mMeshes[i]]);

    return group;
}

inline void PBFParser::ParseData() {
    while (true) {
        _ThreadData *threadData;
        threadDataQueue->wait_and_pop(threadData);
        if( NULL==threadData ) {
            INFO("Parse Data Thread Finished");
            threadDataQueue->push(NULL); // Signal end of data for other threads
            break;
        }

        loadBlock(threadData);

        for(int i = 0, groupSize = threadData->PBFprimitiveBlock.primitivegroup_size(); i < groupSize; ++i) {
            threadData->currentGroupID = i;
            loadGroup(threadData);

            if( parsingStep == eRelations ) {
                if(threadData->entityTypeIndicator == TypeRelation)
                    parseRelation(threadData);
            } else if( parsingStep == eOther ) {
                if(threadData->entityTypeIndicator == TypeNode)
                    parseNode(threadData);
                if(threadData->entityTypeIndicator == TypeWay)
                    parseWay(threadData);
                if(threadData->entityTypeIndicator == TypeDenseNode)
                    parseDenseNode(threadData);
            }
        }

        delete threadData;
        threadData = NULL;
    }
}

void parseNode(QDomNode &node,QMap<QString, QString> *retmap)
{
    if (node.isNull() || !node.isElement())
    {
      return;
    }
    QDomElement elem = node.toElement();
    if(node.firstChild().isElement())
    {
        QDomNodeList children=node.childNodes();
        int c=children.count();
        for(int i=0;i<c;i++)
        {
            QDomNode cn=children.item(i);
            parseNode(cn,retmap);

        }
        return;
    }
    QString tagname=node.toElement().tagName();
    int pos=tagname.indexOf(":");
    if(pos >=0)
    {
        tagname=tagname.right(tagname.length() - pos - 1);
    }
    retmap->insert(tagname,node.toElement().text());

}

Children mainParse(I& be, I& en,  Pos& pos) {
	Children ret;

	while(be != en) {
		eatWhitespaceComment(be, en, pos);

		if(test(be, en, "<{{")) {
			ret.push_back(std::move(parseC(be, en, pos)));	
		} else if(test(be, en, '<')) {
			ret.push_back(std::move(parseNode(be, en, pos)));
		} else if(test(be, en, '>')) {
			eat(be, '>', pos);
			break;
		} else {
			I iter;
			TNodeType type;	
			if(!test(be, en, "&{{") && *be == '&') {
		   		iter = eatUntil(be, en, "\n", pos);
				/*for(iter = be; !test(iter, en, '\n') && !test(iter, en, "//"); 
						increment(iter, pos)) 
				{
				}
				if(test(be, en, "//")) {
					eatWhitespaceComment(be, en, pos);
				}*/
				type = TNodeType::SingleCppLine;
			} else {
		   		iter = eatUntil(be, en, "\n>", pos);
				for(iter = be; 
					!test(iter, en, '\n') && !test(iter, en, "//") && !test(iter, en, '>'); 
					increment(iter, pos)) 
				{
				}
				if(test(be, en, "//")) {
					eatWhitespaceComment(be, en, pos);
				}
				type = TNodeType::Text;
			}
			auto posCopy = pos;
			//std::cout<<"||| "<<std::string(be, iter)<<std::endl;
			ret.push_back(
				std::make_unique<TNode>(std::string(be, iter), posCopy, type
				)
			);

			be = iter;

			char iterC = *iter;
			eat(be, iterC, pos);

			if(iterC == '>') 
			{
				break;
			}
		}
		eatWhitespaceComment(be, en, pos);
	}

	return ret;
}

bool FileLoader::openFile(const char* filename, bool write, bool caching /*= false*/)
{
	if(write) {
		m_file = fopen(filename, "wb");
		if(m_file) {
			uint32_t version = 0;
			writeData(&version, sizeof(version), false);
			return true;
		}
		else{
			m_lastError = ERROR_CAN_NOT_CREATE;
			return false;
		}
	}
	else {
		m_file = fopen(filename, "rb");
		if(m_file){
			uint32_t version;
			fread(&version, sizeof(version), 1, m_file);
			if(version > 0){
				fclose(m_file);
				m_file = NULL;
				m_lastError = ERROR_INVALID_FILE_VERSION;
				return false;
			}
			else{
				if(caching){
					m_use_cache = true;
					fseek(m_file, 0, SEEK_END);
					int file_size = ftell(m_file);
					m_cache_size = std::min(32768, std::max(file_size/20, 8192)) & ~0x1FFF;
				}
				
				//parse nodes
				if(safeSeek(4)){
					delete m_root;
					m_root = new NodeStruct();
					m_root->start = 4;
					int byte;
					if(safeSeek(4) && readByte(byte) && byte == NODE_START){
						bool ret = parseNode(m_root);
						return ret;
					}
					else{
						return false;
					}
				}
				else{
					m_lastError = ERROR_INVALID_FORMAT;
					return false;
				}
			}
		}
		else{
			m_lastError = ERROR_CAN_NOT_OPEN;
			return false;
		}
	}
}

 BmlDecoder (FILE * fp) {
     m_fp = fp;
     //m_table = new Table ();
     m_nbTags = 0;
     m_root = NULL;
     parseTable ();
     m_root = parseNode ();
 }

	void XMLDecoder::parse( XMLDocument* doc, const void* data, size_t len )
	{
		setData( data, len );
		XMLNode* node = parseDeclaration();
		doc->addNode( node );
		while( ( node = parseNode() ) != NULL )
			doc->addNode( node );
	}

int ios_plist_to_table(lua_State* L, plist_t iconState)
{
  lua_newtable(L);
  parseNode(L, iconState, 0);
  lua_rawgeti(L, -1, 1);
  lua_remove(L, -2);
  return 1;
}

// -------------------------------------------------------------------------------
void XMLPersister::parseChildrenOf( QDomNode& node, CTreeInformationElement& parent )
// -------------------------------------------------------------------------------
{
   QDomNode child = node.firstChild();
   while ( !child.isNull() )
   {
      parseNode(child, parent);
      child = child.nextSibling();
   }
}

void TreeWalker::parseTypeSpecifier(TypeSpecifierAST *node)
{
    parseNode(node->name());
    parseNode(node->cvQualify());
    parseNode(node->cv2Qualify());

    switch (node->nodeType()) {
    case NodeType_ClassSpecifier:
        parseClassSpecifier(static_cast<ClassSpecifierAST*>(node));
        break;
    case NodeType_EnumSpecifier:
        parseEnumSpecifier(static_cast<EnumSpecifierAST*>(node));
        break;
    case NodeType_ElaboratedTypeSpecifier:
        parseElaboratedTypeSpecifier(static_cast<ElaboratedTypeSpecifierAST*>(node));
        break;
    default:
        break;
    }
}

node* parser::parse ( Stream& istr )
{
  if ( ! istr.good () )
  return 0;

  node* pRoot = new node ( istr );

  parseNode ( istr, pRoot );

  return pRoot;
}

void Van::init() {
  scheduler_ = parseNode(FLAGS_scheduler);
  myNode_ = parseNode(FLAGS_my_node);
  LOG(INFO) << "I'm \n[" << myNode_.DebugString() << "]";

  context_ = zmq_ctx_new();
  CHECK(context_ != nullptr) << "Create 0mq context failed";

  zmq_ctx_set(context_, ZMQ_MAX_SOCKETS, 65536);
  bind();
  connect(scheduler_);

  if (isScheduler()) {
    CHECK(!zmq_socket_monitor(receiver_, "inproc://monitor", ZMQ_EVENT_ALL));
  } else {
    CHECK(!zmq_socket_monitor(senders_[scheduler_.id()], "inproc://monitor",
                              ZMQ_EVENT_ALL));
  }
  monitorThread_ = new std::thread(&Van::monitor, this);
  monitorThread_->detach();
}

// загрузка из файла
bool Item::load(QFile *file)
{
    QDomDocument doc;
    if (!doc.setContent(file->readAll())) return false;

    QDomElement docElem = doc.documentElement();

    // переходим к парсингу
    parseNode(docElem);

    return true;
}

//Reads in the file passed in and returns it as an XML node
XMLNode *xmlRead(char* file)
{
	chrPtr = 0;
  loadXMLFile(file);
  XMLNode *docNode = xmlCreateNode(DOCUMENT_NODE, DOCUMENT_NAME, NULL); 
  
  parseNode(docNode);
  
  free(xmlArray);
 
  return docNode;
}

/**
 * Parses a regular expression string and builds a regular expression
 * tree. The root node of that tree is returned.
 * @param string The regular expression string.
 * @param pos The position of the parser in the regular expression.
 * @param len The length of the whole regular expression string.
 * @return The root node of the expression tree.
 * @author Daniel Dreibrodt, Konstantin Steinmiller
 */
RETreeNode *REReaderWriter::parseNode(const char string[], int *pos, int len) {
	if(*pos>=len) {
		//end of string reached
		return NULL;
	}
    switch(string[*pos]) {
    	case '(' : {
    		(*pos)++;
    		RETreeNode *groupNode = parseNode(string, pos, len);
    		return parseNode(groupNode, string, pos, len);
    		break;
    	}
    	case ')' : {
    		throw "Read ')' but that is not allowed here!";
    		break;
    	}
    	case '|' : {
    		throw "Read '|' but that is not allowed here!";
    		break;
    	}
    	case '.' : {
    		throw "Read '.' but that is not allowed here!";
    		break;
    	}
    	case '*' : {
    		throw "Read '*' but that is not allowed here!";
    		break;
    	}
    	case ' ' : {
    		(*pos)++;
    		return parseNode(string, pos, len);
    		break;
    	}
    	default : {
    		RETreeNode *lit = parseLiteral(string,pos,len);
			return parseNode(lit, string, pos, len);
    		break;
    	}
    }
}

EntityVector Serializer::deserialize()
{
	EntityVector entities;
	QDomNodeList nodes = mDomElement.elementsByTagName(nodeKey);
	for (unsigned i = 0; i < nodes.length(); i++)
	{
		QDomNode node = nodes.at(i);
		QDomElement element = node.toElement();
		Entity entity = parseNode(element);
		entities.push_back(entity);
	}
	return entities;
}

SgfSequence * Parser::parseSequence(QIODevice & in) {
    SgfSequence * sequence = new Sequence();
    SgfNode * node;
    try {
        while (node = parseNode(in)) {
            sequence->addNode(node);
        }
    } catch (...) {
        delete node;
        delete sequence;
        throw;
    }
}

/*
 * Begin: Parse pwman3 XML Files.
 */
void KeePassXmlStreamReader::parsePwmanList(){
    groupTitle = "pwman3";

    while(xmlReader.readNextStartElement()){
        if(xmlReader.name() == "Node"){
            qDebug("Found Node in pwman3 XML list.");
            parseNode();
        }else{
            qDebug("Skipping pwman3 XML list child element: %s", xmlReader.name().toString().toUtf8().constData());
            xmlReader.skipCurrentElement();
        }
    }
    qDebug("Leaving parsePwmanList...");
}

StructureDataInformation* OsdParser::structFromXML(const QDomElement& xmlElem)
{
    QString name = xmlElem.attribute(QLatin1String("name"), i18n("<invalid name>"));
    StructureDataInformation* stru = new StructureDataInformation(name);
    QDomNode node = xmlElem.firstChild();
    while (!node.isNull())
    {
        DataInformation* data = parseNode(node, stru);
        if (data)
            stru->addDataTypeToStruct(data);
        node = node.nextSibling();
    }
    return stru;
}