/*
|
* Copyright (c) 2011-2015, Intel Corporation
|
* All rights reserved.
|
*
|
* Redistribution and use in source and binary forms, with or without modification,
|
* are permitted provided that the following conditions are met:
|
*
|
* 1. Redistributions of source code must retain the above copyright notice, this
|
* list of conditions and the following disclaimer.
|
*
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
* this list of conditions and the following disclaimer in the documentation and/or
|
* other materials provided with the distribution.
|
*
|
* 3. Neither the name of the copyright holder nor the names of its contributors
|
* may be used to endorse or promote products derived from this software without
|
* specific prior written permission.
|
*
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
*/
|
#include "Element.h"
|
#include "XmlElementSerializingContext.h"
|
#include "ElementLibrary.h"
|
#include "ErrorContext.hpp"
|
#include "PfError.hpp"
|
#include <algorithm>
|
#include <assert.h>
|
#include <stdio.h>
|
#include <stdarg.h>
|
#include <stdlib.h>
|
|
using std::string;
|
|
const std::string CElement::gDescriptionPropertyName = "Description";
|
|
CElement::CElement(const string &strName) : _strName(strName)
|
{
|
}
|
|
CElement::~CElement()
|
{
|
removeChildren();
|
}
|
|
void CElement::setDescription(const string &strDescription)
|
{
|
_strDescription = strDescription;
|
}
|
|
const string &CElement::getDescription() const
|
{
|
return _strDescription;
|
}
|
|
bool CElement::childrenAreDynamic() const
|
{
|
// By default, children are searched and not created during xml parsing
|
return false;
|
}
|
|
bool CElement::init(string &strError)
|
{
|
|
for (CElement *child : _childArray) {
|
|
if (!child->init(strError)) {
|
|
return false;
|
}
|
}
|
|
return true;
|
}
|
|
string CElement::dumpContent(utility::ErrorContext &errorContext, const size_t depth) const
|
{
|
string output;
|
string strIndent;
|
|
// Level
|
size_t indents = depth;
|
|
while (indents--) {
|
|
strIndent += " ";
|
}
|
// Type
|
output += strIndent + "- " + getKind();
|
|
// Name
|
if (!_strName.empty()) {
|
|
output += ": " + getName();
|
}
|
|
// Value
|
string strValue = logValue(errorContext);
|
|
if (!strValue.empty()) {
|
|
output += " = " + strValue;
|
}
|
|
output += "\n";
|
|
for (CElement *pChild : _childArray) {
|
|
output += pChild->dumpContent(errorContext, depth + 1);
|
}
|
|
return output;
|
}
|
|
// Element properties
|
void CElement::showProperties(string &strResult) const
|
{
|
strResult += "Kind: " + getKind() + "\n";
|
showDescriptionProperty(strResult);
|
}
|
|
void CElement::showDescriptionProperty(std::string &strResult) const
|
{
|
if (!getDescription().empty()) {
|
strResult += gDescriptionPropertyName + ": " + getDescription() + "\n";
|
}
|
}
|
|
// Content dumping
|
string CElement::logValue(utility::ErrorContext & /*ctx*/) const
|
{
|
return "";
|
}
|
|
// From IXmlSink
|
bool CElement::fromXml(const CXmlElement &xmlElement,
|
CXmlSerializingContext &serializingContext) try {
|
xmlElement.getAttribute(gDescriptionPropertyName, _strDescription);
|
|
// Propagate through children
|
CXmlElement::CChildIterator childIterator(xmlElement);
|
|
CXmlElement childElement;
|
|
while (childIterator.next(childElement)) {
|
|
CElement *pChild;
|
|
if (!childrenAreDynamic()) {
|
|
pChild = findChildOfKind(childElement.getType());
|
|
if (!pChild) {
|
|
serializingContext.setError("Unable to handle XML element: " +
|
childElement.getPath());
|
|
return false;
|
}
|
|
} else {
|
// Child needs creation
|
pChild = createChild(childElement, serializingContext);
|
|
if (!pChild) {
|
|
return false;
|
}
|
}
|
|
// Dig
|
if (!pChild->fromXml(childElement, serializingContext)) {
|
|
return false;
|
}
|
}
|
|
return true;
|
} catch (const PfError &e) {
|
serializingContext.appendLineToError(e.what());
|
return false;
|
}
|
|
void CElement::childrenToXml(CXmlElement &xmlElement,
|
CXmlSerializingContext &serializingContext) const
|
{
|
// Browse children and propagate
|
for (CElement *pChild : _childArray) {
|
|
// Create corresponding child element
|
CXmlElement xmlChildElement;
|
|
xmlElement.createChild(xmlChildElement, pChild->getXmlElementName());
|
|
// Propagate
|
pChild->toXml(xmlChildElement, serializingContext);
|
}
|
}
|
|
void CElement::toXml(CXmlElement &xmlElement, CXmlSerializingContext &serializingContext) const
|
{
|
setXmlNameAttribute(xmlElement);
|
setXmlDescriptionAttribute(xmlElement);
|
childrenToXml(xmlElement, serializingContext);
|
}
|
|
void CElement::setXmlDescriptionAttribute(CXmlElement &xmlElement) const
|
{
|
const string &description = getDescription();
|
if (!description.empty()) {
|
xmlElement.setAttribute(gDescriptionPropertyName, description);
|
}
|
}
|
|
void CElement::setXmlNameAttribute(CXmlElement &xmlElement) const
|
{
|
// By default, set Name attribute if any
|
string strName = getName();
|
|
if (!strName.empty()) {
|
|
xmlElement.setNameAttribute(strName);
|
}
|
}
|
|
// Name
|
void CElement::setName(const string &strName)
|
{
|
_strName = strName;
|
}
|
|
const string &CElement::getName() const
|
{
|
return _strName;
|
}
|
|
bool CElement::rename(const string &strName, string &strError)
|
{
|
// Check for conflict with brotherhood if relevant
|
if (_pParent && _pParent->childrenAreDynamic()) {
|
|
for (CElement *pParentChild : _pParent->_childArray) {
|
|
if (pParentChild != this && pParentChild->getName() == strName) {
|
|
// Conflict
|
strError = "Name conflicts with brother element";
|
|
return false;
|
}
|
}
|
}
|
// Change name
|
setName(strName);
|
|
return true;
|
}
|
|
string CElement::getPathName() const
|
{
|
if (!_strName.empty()) {
|
|
return _strName;
|
} else {
|
|
return getKind();
|
}
|
}
|
|
// Hierarchy
|
void CElement::addChild(CElement *pChild)
|
{
|
_childArray.push_back(pChild);
|
|
pChild->_pParent = this;
|
}
|
|
CElement *CElement::getChild(size_t index)
|
{
|
assert(index <= _childArray.size());
|
|
return _childArray[index];
|
}
|
|
const CElement *CElement::getChild(size_t index) const
|
{
|
assert(index <= _childArray.size());
|
|
return _childArray[index];
|
}
|
|
CElement *CElement::createChild(const CXmlElement &childElement,
|
CXmlSerializingContext &serializingContext)
|
{
|
// Context
|
CXmlElementSerializingContext &elementSerializingContext =
|
static_cast<CXmlElementSerializingContext &>(serializingContext);
|
|
// Child needs creation
|
CElement *pChild = elementSerializingContext.getElementLibrary()->createElement(childElement);
|
|
if (!pChild) {
|
|
elementSerializingContext.setError("Unable to create XML element " +
|
childElement.getPath());
|
|
return nullptr;
|
}
|
// Store created child!
|
addChild(pChild);
|
|
return pChild;
|
}
|
|
bool CElement::removeChild(CElement *pChild)
|
{
|
auto childIt = find(begin(_childArray), end(_childArray), pChild);
|
if (childIt != end(_childArray)) {
|
|
_childArray.erase(childIt);
|
return true;
|
}
|
return false;
|
}
|
|
void CElement::listChildren(string &strChildList) const
|
{
|
// Get list of children names
|
for (CElement *pChild : _childArray) {
|
|
strChildList += pChild->getName() + "\n";
|
}
|
}
|
|
string CElement::listQualifiedPaths(bool bDive, size_t level) const
|
{
|
string strResult;
|
|
// Dive Will cause only leaf nodes to be printed
|
if (!bDive || !getNbChildren()) {
|
|
strResult = getQualifiedPath() + "\n";
|
}
|
|
if (bDive || !level) {
|
// Get list of children paths
|
for (CElement *pChild : _childArray) {
|
|
strResult += pChild->listQualifiedPaths(bDive, level + 1);
|
}
|
}
|
return strResult;
|
}
|
|
void CElement::listChildrenPaths(string &strChildList) const
|
{
|
// Get list of children paths
|
for (CElement *pChild : _childArray) {
|
|
strChildList += pChild->getPath() + "\n";
|
}
|
}
|
|
size_t CElement::getNbChildren() const
|
{
|
return _childArray.size();
|
}
|
|
const CElement *CElement::getParent() const
|
{
|
return _pParent;
|
}
|
|
CElement *CElement::getParent()
|
{
|
return _pParent;
|
}
|
|
void CElement::clean()
|
{
|
if (childrenAreDynamic()) {
|
|
removeChildren();
|
} else {
|
// Just propagate
|
for (CElement *pChild : _childArray) {
|
|
pChild->clean();
|
}
|
}
|
}
|
|
void CElement::removeChildren()
|
{
|
// Delete in reverse order
|
ChildArrayReverseIterator it;
|
|
for (it = _childArray.rbegin(); it != _childArray.rend(); ++it) {
|
|
delete *it;
|
}
|
_childArray.clear();
|
}
|
|
const CElement *CElement::findDescendant(CPathNavigator &pathNavigator) const
|
{
|
string *pStrChildName = pathNavigator.next();
|
|
if (!pStrChildName) {
|
|
return this;
|
}
|
|
const CElement *pChild = findChild(*pStrChildName);
|
|
if (!pChild) {
|
|
return nullptr;
|
}
|
|
return pChild->findDescendant(pathNavigator);
|
}
|
|
CElement *CElement::findDescendant(CPathNavigator &pathNavigator)
|
{
|
string *pStrChildName = pathNavigator.next();
|
|
if (!pStrChildName) {
|
|
return this;
|
}
|
|
CElement *pChild = findChild(*pStrChildName);
|
|
if (!pChild) {
|
|
return nullptr;
|
}
|
|
return pChild->findDescendant(pathNavigator);
|
}
|
|
bool CElement::isDescendantOf(const CElement *pCandidateAscendant) const
|
{
|
if (!_pParent) {
|
|
return false;
|
}
|
if (_pParent == pCandidateAscendant) {
|
|
return true;
|
}
|
return _pParent->isDescendantOf(pCandidateAscendant);
|
}
|
|
CElement *CElement::findChild(const string &strName)
|
{
|
for (CElement *pChild : _childArray) {
|
|
if (pChild->getPathName() == strName) {
|
|
return pChild;
|
}
|
}
|
|
return nullptr;
|
}
|
|
const CElement *CElement::findChild(const string &strName) const
|
{
|
for (CElement *pChild : _childArray) {
|
|
if (pChild->getPathName() == strName) {
|
|
return pChild;
|
}
|
}
|
|
return nullptr;
|
}
|
|
CElement *CElement::findChildOfKind(const string &strKind)
|
{
|
for (CElement *pChild : _childArray) {
|
|
if (pChild->getKind() == strKind) {
|
|
return pChild;
|
}
|
}
|
|
return nullptr;
|
}
|
|
const CElement *CElement::findChildOfKind(const string &strKind) const
|
{
|
for (CElement *pChild : _childArray) {
|
|
if (pChild->getKind() == strKind) {
|
|
return pChild;
|
}
|
}
|
|
return nullptr;
|
}
|
|
string CElement::getPath() const
|
{
|
// Take out root element from the path
|
if (_pParent && _pParent->_pParent) {
|
|
return _pParent->getPath() + "/" + getPathName();
|
}
|
return "/" + getPathName();
|
}
|
|
string CElement::getQualifiedPath() const
|
{
|
return getPath() + " [" + getKind() + "]";
|
}
|
|
string CElement::getXmlElementName() const
|
{
|
// Default to element kind
|
return getKind();
|
}
|
