bool CComponentInstance::fromXml(const CXmlElement& xmlElement, CXmlSerializingContext& serializingContext)
{
// Context
CXmlParameterSerializingContext& parameterBuildContext = static_cast<CXmlParameterSerializingContext&>(serializingContext);
const CComponentLibrary* pComponentLibrary = parameterBuildContext.getComponentLibrary();
std::string strComponentType = xmlElement.getAttributeString("Type");
_pComponentType = pComponentLibrary->getComponentType(strComponentType);
if (!_pComponentType) {
serializingContext.setError("Unable to create Component " + xmlElement.getPath() + ". ComponentType " + strComponentType + " not found!");
return false;
}
if (_pComponentType == getParent()) {
serializingContext.setError("Recursive definition of " + _pComponentType->getName() + " due to " + xmlElement.getPath() + " referring to one of its own type.");
return false;
}
return base::fromXml(xmlElement, serializingContext);
}
bool CComponentLibrary::fromXml(const CXmlElement &xmlElement,
CXmlSerializingContext &serializingContext)
{
CXmlElement childElement;
CXmlElement::CChildIterator it(xmlElement);
// XML populate all component libraries
while (it.next(childElement)) {
// Filter component library/type set elements
if (childElement.getType() == "ComponentLibrary" ||
childElement.getType() == "ComponentTypeSet") {
if (!fromXml(childElement, serializingContext)) {
return false;
}
} else {
// Regular child creation and populating
CElement *pChild = createChild(childElement, serializingContext);
if (!pChild || !pChild->fromXml(childElement, serializingContext)) {
return false;
}
}
}
return true;
}
// From IXmlSink
bool CConfigurableDomain::fromXml(const CXmlElement &xmlElement,
CXmlSerializingContext &serializingContext)
{
// Context
CXmlDomainImportContext &xmlDomainImportContext =
static_cast<CXmlDomainImportContext &>(serializingContext);
// Sequence awareness (optional)
xmlElement.getAttribute("SequenceAware", _bSequenceAware);
std::string name;
xmlElement.getAttribute("Name", name);
setName(name);
// Local parsing. Do not dig
if (!parseDomainConfigurations(xmlElement, xmlDomainImportContext) ||
!parseConfigurableElements(xmlElement, xmlDomainImportContext) ||
!parseSettings(xmlElement, xmlDomainImportContext)) {
return false;
}
// All provided configurations are parsed
// Attempt validation on areas of non provided configurations for all configurable elements if
// required
if (xmlDomainImportContext.autoValidationRequired()) {
autoValidateAll();
}
return true;
}
// Parse configurable elements
bool CConfigurableDomain::parseConfigurableElements(const CXmlElement &xmlElement,
CXmlDomainImportContext &serializingContext)
{
CSystemClass &systemClass = serializingContext.getSystemClass();
// Get ConfigurableElements element
CXmlElement xmlConfigurableElementsElement;
xmlElement.getChildElement("ConfigurableElements", xmlConfigurableElementsElement);
// Parse it and associate found configurable elements to it
CXmlElement::CChildIterator it(xmlConfigurableElementsElement);
CXmlElement xmlConfigurableElementElement;
while (it.next(xmlConfigurableElementElement)) {
// Locate configurable element
string strConfigurableElementPath;
xmlConfigurableElementElement.getAttribute("Path", strConfigurableElementPath);
CPathNavigator pathNavigator(strConfigurableElementPath);
string strError;
// Is there an element and does it match system class name?
if (!pathNavigator.navigateThrough(systemClass.getName(), strError)) {
serializingContext.setError(
"Could not find configurable element of path " + strConfigurableElementPath +
" from ConfigurableDomain description " + getName() + " (" + strError + ")");
return false;
}
// Browse system class for configurable element
CConfigurableElement *pConfigurableElement =
static_cast<CConfigurableElement *>(systemClass.findDescendant(pathNavigator));
if (!pConfigurableElement) {
serializingContext.setError("Could not find configurable element of path " +
strConfigurableElementPath +
" from ConfigurableDomain description " + getName());
return false;
}
// Add found element to domain
core::Results infos;
if (!addConfigurableElement(pConfigurableElement, NULL, infos)) {
strError = utility::asString(infos);
serializingContext.setError(strError);
return false;
}
}
return true;
}
/**
* @ingroup XmlParser
* @brief 애트리뷰트에 해당하는 값을 검색한다.
* @param pszName Element 이름
* @param pszAttrName 애트리뷰트 이름
* @param iIndex Element 인덱스. 0 을 입력하면 첫번째 검색된 하위 Element 를 리턴하고 1 을 입력하면 두번째 검색된 하위 Element 를 리턴한다.
* @returns 성공하면 애트리뷰트의 값을 리턴하고 그렇지 않으면 NULL 을 리턴한다.
*/
const char * CXmlSearch::SelectAttribute(const char * pszName, const char * pszAttrName, const int iIndex)
{
CXmlElement * pclsElement = SelectElement(pszName, iIndex);
if (pclsElement)
{
return pclsElement->SelectAttribute(pszAttrName);
}
return NULL;
}
/**
* @ingroup XmlParser
* @brief 애트리뷰트에 해당하는 값을 검색하여 int 변수에 저장한다.
* @param pszName Element 이름
* @param pszAttrName 애트리뷰트 이름
* @param iValue 애트리뷰트 값
* @param iIndex Element 인덱스. 0 을 입력하면 첫번째 검색된 하위 Element 를 리턴하고 1 을 입력하면 두번째 검색된 하위 Element 를 리턴한다.
* @returns 성공하면 true 를 리턴하고 실패하면 false 를 리턴한다.
*/
bool CXmlSearch::SelectAttribute(const char * pszName, const char * pszAttrName, int & iValue, const int iIndex)
{
CXmlElement * pclsElement = SelectElement(pszName, iIndex);
if (pclsElement)
{
return pclsElement->SelectAttribute(pszAttrName, iValue);
}
return false;
}
CXmlElement* CXmlElement::SetElement(const TCHAR* name, const TCHAR* value, bool create_if_not_exist /* = false */)
{
CXmlElement* element = GetElement(name, create_if_not_exist);
if (element != NULL)
{
element->SetData(value);
}
return element;
}
// Serialize one configuration for one configurable element
bool CDomainConfiguration::importOneConfigurableElementSettings(
CAreaConfiguration *areaConfiguration, CXmlElement &xmlConfigurableElementSettingsElement,
CXmlDomainImportContext &context)
{
const CConfigurableElement *destination = areaConfiguration->getConfigurableElement();
// Check structure
if (xmlConfigurableElementSettingsElement.getNbChildElements() != 1) {
// Structure error
context.setError("Struture error encountered while parsing settings of " +
destination->getKind() + " " + destination->getName() +
" in Configuration " + getPath());
return false;
}
// Element content
CXmlElement xmlConfigurableElementSettingsElementContent;
// Check name and kind
if (!xmlConfigurableElementSettingsElement.getChildElement(
destination->getXmlElementName(), destination->getName(),
xmlConfigurableElementSettingsElementContent)) {
// "Component" tag has been renamed to "ParameterBlock", but retro-compatibility shall
// be ensured.
//
// So checking if this case occurs, i.e. element name is "ParameterBlock"
// but found xml setting name is "Component".
bool compatibilityCase =
(destination->getXmlElementName() == "ParameterBlock") &&
xmlConfigurableElementSettingsElement.getChildElement(
"Component", destination->getName(), xmlConfigurableElementSettingsElementContent);
// Error if the compatibility case does not occur.
if (!compatibilityCase) {
context.setError("Couldn't find settings for " + destination->getXmlElementName() +
" " + destination->getName() + " for Configuration " + getPath());
return false;
}
}
// Create configuration access context
string error;
CConfigurationAccessContext configurationAccessContext(error, false);
// Have domain configuration parse settings for configurable element
bool success = areaConfiguration->serializeXmlSettings(
xmlConfigurableElementSettingsElementContent, configurationAccessContext);
context.appendToError(error);
return success;
}
/**
* @ingroup XmlParser
* @brief 모든 하위 Element 를 검색하여서 bool 내용을 가져온다.
* @param pszName Element 이름
* @param pszChildName 하위 element 이름
* @param bData 하위 Element 의 값을 저장하는 변수
* @param iIndex 하위 Element 인덱스. 0 을 입력하면 첫번째 검색된 하위 Element 를 리턴하고 1 을 입력하면 두번째 검색된 하위 Element 를 리턴한다.
* @returns 성공하면 true 를 리턴하고 실패하면 false 를 리턴한다.
*/
bool CXmlSearch::SelectElementData(const char * pszName, const char * pszChildName, bool & bData, const int iIndex)
{
CXmlElement * pclsElement = SelectElement(pszName, pszChildName, iIndex);
if (pclsElement)
{
bData = GetBoolean(pclsElement->GetData());
return true;
}
return false;
}
/**
* @ingroup XmlParser
* @brief 모든 하위 Element 를 검색하여서 내용을 저장한다.
* @param pszName Element 이름
* @param pszChildName 하위 Element 이름
* @param strData Elemnet 의 내용을 저장할 변수
* @param iIndex Element 인덱스. 0 을 입력하면 첫번째 검색된 하위 Element 를 리턴하고 1 을 입력하면 두번째 검색된 하위 Element 를 리턴한다.
* @returns 성공하면 true 를 리턴하고 실패하면 false 를 리턴한다.
*/
bool CXmlSearch::SelectElementData(const char * pszName, const char * pszChildName, std::string & strData, const int iIndex)
{
CXmlElement * pclsElement = SelectElement(pszName, pszChildName, iIndex);
if (pclsElement)
{
strData = pclsElement->GetData();
return true;
}
return false;
}
/**
* @ingroup XmlParser
* @brief 모든 하위 Element 를 검색하여서 정수 내용을 가져온다.
* @param pszName Element 이름
* @param iData Element 의 값을 저장하는 변수
* @param iIndex Element 인덱스. 0 을 입력하면 첫번째 검색된 하위 Element 를 리턴하고 1 을 입력하면 두번째 검색된 하위 Element 를 리턴한다.
* @returns 성공하면 true 를 리턴하고 실패하면 false 를 리턴한다.
*/
bool CXmlSearch::SelectElementData(const char * pszName, int & iData, const int iIndex)
{
CXmlElement * pclsElement = SelectElement(pszName, iIndex);
if (pclsElement)
{
iData = atoi(pclsElement->GetData());
return true;
}
return false;
}
bool CXmlElement::getChildElement(const string& strType, const string& strNameAttribute, CXmlElement& childElement) const
{
CChildIterator childIterator(*this);
while (childIterator.next(childElement)) {
if ((childElement.getType() == strType) && (childElement.getNameAttribute() == strNameAttribute)) {
return true;
}
}
return false;
}
// From IXmlSink
bool CFrameworkConfigurationLocation::fromXml(const CXmlElement &xmlElement,
CXmlSerializingContext &serializingContext)
{
xmlElement.getAttribute("Path", _configurationUri);
if (_configurationUri.empty()) {
serializingContext.setError("Empty Path attribute in element " + xmlElement.getPath());
return false;
}
return true;
}
// From IXmlSink
bool CBitParameterType::fromXml(const CXmlElement& xmlElement, CXmlSerializingContext& serializingContext)
{
// Pos
_uiBitPos = xmlElement.getAttributeInteger("Pos");
// Size
_uiBitSize = xmlElement.getAttributeInteger("Size");
// Validate bit pos and size still fit into parent type
const CBitParameterBlockType* pBitParameterBlockType = static_cast<const CBitParameterBlockType*>(getParent());
uint32_t uiParentBlockBitSize = pBitParameterBlockType->getSize() * 8;
if (_uiBitPos + _uiBitSize > uiParentBlockBitSize) {
// Range exceeded
std::ostringstream strStream;
strStream << "Pos and Size attributes inconsistent with maximum container element size (" << uiParentBlockBitSize << " bits) for " + getKind();
serializingContext.setError(strStream.str());
return false;
}
// Max
if (xmlElement.hasAttribute("Max")) {
_uiMax = xmlElement.getAttributeInteger("Max");
if (_uiMax > getMaxEncodableValue()) {
// Max value exceeded
std::ostringstream strStream;
strStream << "Max attribute inconsistent with maximum encodable size (" << getMaxEncodableValue() << ") for " + getKind();
serializingContext.setError(strStream.str());
return false;
}
} else {
_uiMax = getMaxEncodableValue();
}
// Base
return base::fromXml(xmlElement, serializingContext);
}
// From IXmlSink
bool CParameterAdaptation::fromXml(const CXmlElement& xmlElement, CXmlSerializingContext& serializingContext)
{
// Get offset
if (xmlElement.hasAttribute("Offset")) {
_iOffset = xmlElement.getAttributeSignedInteger("Offset");
} else {
// Default
_iOffset = 0;
}
// Base
return base::fromXml(xmlElement, serializingContext);
}
// From IXmlSink
bool CParameterFrameworkConfiguration::fromXml(const CXmlElement &xmlElement,
CXmlSerializingContext &serializingContext)
{
// System class name
xmlElement.getAttribute("SystemClassName", _strSystemClassName);
// Tuning allowed
xmlElement.getAttribute("TuningAllowed", _bTuningAllowed);
// Server port
xmlElement.getAttribute("ServerPort", _uiServerPort);
// Base
return base::fromXml(xmlElement, serializingContext);
}
// From IXmlSource
void CConfigurableDomains::toXml(CXmlElement& xmlElement, CXmlSerializingContext& serializingContext) const
{
// Set attribute
xmlElement.setAttributeString("SystemClassName", getName());
base::childrenToXml(xmlElement, serializingContext);
}
// From IXmlSource
void CEnumParameterType::toXml(CXmlElement& xmlElement, CXmlSerializingContext& serializingContext) const
{
// Size
xmlElement.setAttributeString("Size", toString(getSize() * 8));
base::toXml(xmlElement, serializingContext);
}
// From IXmlSource
void CStringParameterType::toXml(CXmlElement &xmlElement, CXmlSerializingContext &serializingContext) const
{
// MaxLength
xmlElement.setAttributeInteger("MaxLength", _uiMaxLength);
base::toXml(xmlElement, serializingContext);
}
void CElement::setXmlDescriptionAttribute(CXmlElement &xmlElement) const
{
const string &description = getDescription();
if (!description.empty()) {
xmlElement.setAttribute(gDescriptionPropertyName, description);
}
}
// From IXmlSource
void CBitParameterBlockType::toXml(CXmlElement& xmlElement, CXmlSerializingContext& serializingContext) const
{
// Size
xmlElement.setAttribute("Size", _uiSize * 8);
base::toXml(xmlElement, serializingContext);
}
// From IXmlSink
bool CCompoundRule::fromXml(const CXmlElement& xmlElement, CXmlSerializingContext& serializingContext)
{
// Get type
_bTypeAll = xmlElement.getAttributeBoolean("Type", _apcTypes[true]);
// Base
return base::fromXml(xmlElement, serializingContext);
}
// From IXmlSource
void CCompoundRule::toXml(CXmlElement& xmlElement, CXmlSerializingContext& serializingContext) const
{
// Set type
xmlElement.setAttributeString("Type", _apcTypes[_bTypeAll]);
// Base
base::toXml(xmlElement, serializingContext);
}
// From IXmlSink
bool CStringParameterType::fromXml(const CXmlElement& xmlElement, CXmlSerializingContext& serializingContext)
{
// MaxLength
_uiMaxLength = xmlElement.getAttributeInteger("MaxLength");
// Base
return base::fromXml(xmlElement, serializingContext);
}
// Parse settings
bool CConfigurableDomain::parseSettings(const CXmlElement &xmlElement,
CXmlDomainImportContext &serializingContext)
{
// Check we actually need to parse configuration settings
if (!serializingContext.withSettings()) {
// No parsing required
return true;
}
// Get Settings element
CXmlElement xmlSettingsElement;
if (!xmlElement.getChildElement("Settings", xmlSettingsElement)) {
// No settings, bail out successfully
return true;
}
// Parse configuration settings
CXmlElement::CChildIterator it(xmlSettingsElement);
CXmlElement xmlConfigurationSettingsElement;
while (it.next(xmlConfigurationSettingsElement)) {
// Get domain configuration
CDomainConfiguration *pDomainConfiguration = static_cast<CDomainConfiguration *>(
findChild(xmlConfigurationSettingsElement.getNameAttribute()));
if (!pDomainConfiguration) {
serializingContext.setError("Could not find domain configuration referred to by"
" configurable domain \"" +
getName() + "\".");
return false;
}
// Have domain configuration parse settings for all configurable elements
if (!pDomainConfiguration->parseSettings(xmlConfigurationSettingsElement,
serializingContext)) {
return false;
}
}
return true;
}
// From IXmlSink
bool CParameterAdaptation::fromXml(const CXmlElement &xmlElement,
CXmlSerializingContext &serializingContext)
{
xmlElement.getAttribute("Offset", _iOffset);
// Base
return base::fromXml(xmlElement, serializingContext);
}
// From IXmlSink
bool CLinearParameterAdaptation::fromXml(const CXmlElement& xmlElement, CXmlSerializingContext& serializingContext)
{
// Get SlopeNumerator
xmlElement.getAttribute("SlopeNumerator", _dSlopeNumerator);
// Get SlopeDenominator
if (xmlElement.getAttribute("SlopeDenominator", _dSlopeDenominator)
&& (_dSlopeDenominator == 0)) {
// Avoid by 0 division errors
serializingContext.setError("SlopeDenominator attribute can't be 0 on element" + xmlElement.getPath());
return false;
}
// Base
return base::fromXml(xmlElement, serializingContext);
}
// Child creation
void CXmlElement::createChild(CXmlElement &childElement, const string &strType)
{
#ifdef LIBXML_TREE_ENABLED
xmlNodePtr pChildNode = xmlNewChild(_pXmlElement, nullptr, BAD_CAST strType.c_str(), nullptr);
childElement.setXmlElement(pChildNode);
#endif
}
// From IXmlSource
void CSelectionCriterionRule::toXml(CXmlElement &xmlElement, CXmlSerializingContext & /*ctx*/) const
{
assert(_pSelectionCriterion);
// Set selection criterion
xmlElement.setAttribute("SelectionCriterion", _pSelectionCriterion->getName());
// Set MatchesWhen
xmlElement.setAttribute("MatchesWhen", _astMatchesWhen[_eMatchesWhen].pcMatchesWhen);
// Set Value
string strValue;
_pSelectionCriterion->getCriterionType()->getLiteralValue(_iMatchValue, strValue);
xmlElement.setAttribute("Value", strValue);
}
bool CLogarithmicParameterAdaptation::fromXml(const CXmlElement& xmlElement,
CXmlSerializingContext& serializingContext)
{
if (xmlElement.getAttribute("LogarithmBase", _dLogarithmBase)
&& (_dLogarithmBase <= 0 || _dLogarithmBase == 1)) {
// Avoid negative and 1 values
serializingContext.setError("LogarithmBase attribute cannot be negative or 1 on element"
+ xmlElement.getPath());
return false;
}
xmlElement.getAttribute("FloorValue", _dFloorValue);
// Base
return base::fromXml(xmlElement, serializingContext);
}
