database/mariadb-columnstore-engine
1
0
Fork 0
mirror of https://github.com/mariadb-corporation/mariadb-columnstore-engine.git synced 2025-10-30 07:25:34 +03:00
Code Activity
Files
48afd80f092c2ae0143a088dc28ea804947bfb7a
mariadb-columnstore-engine/writeengine/splitter/we_xmlgetter.cpp
Andrew Hutchings 01446d1e22 Reformat all code to coding standard
2017-10-26 17:18:17 +01:00

374 lines
11 KiB
C++
Raw Blame History

/* Copyright (C) 2014 InfiniDB, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; version 2 of
the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
/*******************************************************************************
* $Id$
*
*******************************************************************************/
/*
* we_xmlgetter.cpp
*
* Created on: Feb 7, 2012
* Author: bpaul
*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdexcept>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#include "we_xmlgetter.h"
using namespace std;
namespace WriteEngine
{
//------------------------------------------------------------------------------
// WEXmlgetter constructor
//------------------------------------------------------------------------------
WEXmlgetter::WEXmlgetter(std::string& ConfigName):
fConfigName(ConfigName),
fDoc( NULL ),
fpRoot( NULL )
{
// xmlNodePtr curPtr;
fDoc = xmlParseFile( ConfigName.c_str() );
if (fDoc == NULL )
throw runtime_error("WEXmlgetter::getConfig(): no XML document!");
fpRoot = xmlDocGetRootElement( fDoc );
if ( fpRoot == NULL )
{
xmlFreeDoc( fDoc );
fDoc = NULL;
throw runtime_error("WEXmlgetter::getConfig(): no XML Root Tag!");
}
}
//------------------------------------------------------------------------------
// WEXmlgetter destructor
//------------------------------------------------------------------------------
WEXmlgetter::~WEXmlgetter()
{
xmlFreeDoc( fDoc );
fDoc = NULL;
}
//------------------------------------------------------------------------------
// Get/return the property or attribute value (strVal) for the specified xml tag
// (pNode) and property/attribute (pTag)
//------------------------------------------------------------------------------
bool WEXmlgetter::getNodeAttribute(const xmlNode* pNode,
const char* pTag, std::string& strVal) const
{
xmlChar* pTmp = NULL;
bool bFound = false;
pTmp = xmlGetProp( const_cast<xmlNode*>(pNode), (xmlChar*) pTag );
if ( pTmp )
{
bFound = true;
strVal = (char*)pTmp;
xmlFree( pTmp );
}
else
{
strVal.clear();
} // end if
return bFound;
}
//------------------------------------------------------------------------------
// Get/return the node content (strVal) for the specified xml tag (pNode)
//------------------------------------------------------------------------------
bool WEXmlgetter::getNodeContent( const xmlNode* pNode,
std::string& strVal) const
{
xmlChar* pTmp = NULL;
bool bFound = false;
if ( pNode->children != NULL )
{
pTmp = xmlNodeGetContent( pNode->children );
if ( pTmp )
{
bFound = true;
strVal = (char*)pTmp;
xmlFree( pTmp );
}
else
{
strVal.clear();
}
}
else
{
strVal.clear();
}
return bFound;
}
//------------------------------------------------------------------------------
// Get/returns node content for the "first" child node under each section/name.
// Example:
// <section>
// <name>
// <subname1>
// </subname1>
// </name>
// <name>
// <subname1>
// </subname1>
// </name>
// </section>
//
// Looks like xml2 is currently returning the text node as the first child
// node under a node. So in the example above, this function is currently
// always returning the text node content inside each <name> rather than
// any <subname1> node that might be within each <name> tag.
//------------------------------------------------------------------------------
void WEXmlgetter::getConfig(const string& section,
const string& name, vector<string>& values) const
{
string res;
if (section.length() == 0)
throw invalid_argument("Config::getConfig: section must have a length");
xmlNode* pPtr = fpRoot->xmlChildrenNode;
while (pPtr != NULL)
{
//cout << "pPtr->name: " <<
// (const xmlChar*)pPtr->name << std::endl;
if ((!xmlStrcmp(pPtr->name, (const xmlChar*)section.c_str())))
{
xmlNodePtr pPtr2 = pPtr->xmlChildrenNode;
while (pPtr2 != NULL)
{
//cout << " pPtr2->name: " <<
// (const xmlChar*)pPtr2->name << std::endl;
if ((!xmlStrcmp(pPtr2->name, (const xmlChar*)name.c_str())))
{
xmlNodePtr pPtr3 = pPtr2->xmlChildrenNode;
values.push_back((const char*)pPtr3->content);
//cout << " pPtr3->name: " <<
// (const xmlChar*)pPtr3->name <<
// "; content: " << (const xmlChar*)pPtr3->content <<
// "; len: " << strlen((char*)pPtr3->content) << std::endl;
}
pPtr2 = pPtr2->next;
}
}
pPtr = pPtr->next;
}
}
//------------------------------------------------------------------------------
// Returns node content for the last node in the node tree defined by
// "sections". So if sections[] were:
// sections[0] = "house"
// sections[1] = "room"
// Then this function would return the node content for the first <room>
// tag found under the first <house> tag.
// Function assumes that the desired node has no children nodes other than
// the text content node.
//------------------------------------------------------------------------------
std::string WEXmlgetter::getValue(const vector<string>& sections) const
{
std::string aRet;
const xmlNode* pPtr = fpRoot;
int aSize = sections.size();
int aIdx = 0;
//cout << aSize << endl;
while (aIdx < aSize)
{
//cout << aIdx <<" "<< sections[aIdx] << endl;
pPtr = getNode(pPtr, sections[aIdx]);
if ((pPtr == NULL) || (aIdx == aSize - 1)) break;
else
{
//cout << "getValue Name " << (const char*)pPtr->name << endl;
pPtr = pPtr->xmlChildrenNode;
aIdx++;
}
}
if (pPtr != NULL)
{
//aRet = (const char*)pPtr->content;
std::string aBuff;
if (getNodeContent(pPtr, aBuff)) aRet = aBuff;
}
return aRet;
}
//------------------------------------------------------------------------------
// Iterate through the sibling nodes starting with pParent, looking for
// a node with the specified name (section). The xmlNode (if found) is
// returned.
//------------------------------------------------------------------------------
const xmlNode* WEXmlgetter::getNode(const xmlNode* pParent,
const string& section)const
{
if (pParent == NULL) return NULL;
const xmlNode* pPtr = pParent;
while (pPtr != NULL )
{
//cout << "getNode Name " << (const char*)pPtr->name << endl;
if (!xmlStrcmp(pPtr->name, (const xmlChar*)section.c_str()))
return pPtr;
else
pPtr = pPtr->next;
}
return pPtr;
}
//------------------------------------------------------------------------------
// Iterate down through the node tree represented by the sections vector.
// In the last child of this tree, we look for the specified attribute tag,
// and return its value.
//------------------------------------------------------------------------------
std::string WEXmlgetter::getAttribute(const vector<string>& sections,
const string& Tag) const
{
std::string aRet;
const xmlNode* pPtr = fpRoot;
int aSize = sections.size();
if (aSize == 0)
throw invalid_argument("WEXmlgetter::getAttribute(): section must be valid");
int aIdx = 0;
//cout << aSize << endl;
while (aIdx < aSize)
{
//cout << aIdx <<" "<< sections[aIdx] << endl;
pPtr = getNode(pPtr, sections[aIdx]);
if ((pPtr == NULL) || (aIdx == aSize - 1)) break;
else
{
//cout << "getValue Name " << (const char*)pPtr->name << endl;
pPtr = pPtr->xmlChildrenNode;
aIdx++;
}
}
if (pPtr != NULL)
{
std::string aBuff;
//cout << "attrTagNode Name " << (const char*)pPtr->name << endl;
if (getNodeAttribute(pPtr, Tag.c_str(), aBuff))
aRet = aBuff;
//aRet = (const char*)pPtr->content;
//cout << "Attribute("<<Tag<<") = "<< aRet<< endl;
}
return aRet;
}
//------------------------------------------------------------------------------
// Iterate down through the node tree represented by the sections vector.
// At the end of the branch, there may be several sibling nodes matching
// the node search vector.
// For each of the matching children nodes found, we look for the specified
// attribute tag, and return its value. Hence a vector of attribute values
// is returned.
//------------------------------------------------------------------------------
void WEXmlgetter::getAttributeListForAllChildren(
const vector<string>& sections,
const string& attributeTag,
vector<string>& attributeValues)
{
const xmlNode* pPtr = fpRoot;
int aSize = sections.size();
if (aSize == 0)
{
throw invalid_argument("WEXmlgetter::getAttributeListForAllChildren():"
" No XML nodes specified in section search list");
}
// Step down the branch that has the nodes of interest
int aIdx = 0;
while (aIdx < aSize)
{
pPtr = getNode(pPtr, sections[aIdx]);
if ((pPtr == NULL) || (aIdx == aSize - 1))
{
break;
}
else
{
pPtr = pPtr->xmlChildrenNode;
aIdx++;
}
}
// Look for all the "matching" nodes at the end of the branch, and
// get the requested attribute value for each matching node.
if (pPtr != NULL)
{
while (pPtr != NULL )
{
std::string attrib;
if (getNodeAttribute(pPtr, attributeTag.c_str(), attrib))
{
attributeValues.push_back(attrib);
}
pPtr = pPtr->next;
}
}
}
} /* namespace WriteEngine */
View Git Blame Copy Permalink