static void strToEPadPosition(
const UnicodeString &str, void *padPositionPtr, UErrorCode &status) {
int32_t val = toEnum(
gPadPositionEnum, UPRV_LENGTHOF(gPadPositionEnum), str, status);
*static_cast<DecimalFormat::EPadPosition *>(padPositionPtr) =
(DecimalFormat::EPadPosition) val;
}
// virtual
CXMLHandler * TaskHandler::processStart(const XML_Char * pszName,
const XML_Char ** papszAttrs)
{
CXMLHandler * pHandlerToCall = NULL;
const char * Key;
const char * type;
CTaskEnum::Task Type;
bool Scheduled = false;
bool UpdateModel = false;
switch (mCurrentElement.first)
{
case Task:
mpData->pCurrentTask = NULL;
Key = mpParser->getAttributeValue("key", papszAttrs, false);
type = mpParser->getAttributeValue("type", papszAttrs);
Type = toEnum(type, CTaskEnum::TaskXML, CTaskEnum::UnsetTask);
Scheduled = mpParser->toBool(mpParser->getAttributeValue("scheduled", papszAttrs, "false"));
UpdateModel = mpParser->toBool(mpParser->getAttributeValue("updateModel", papszAttrs, "false"));
mpData->pCurrentTask = CTaskFactory::createTask(Type, mpData->pTaskList);
if (mpData->pCurrentTask != NULL)
{
mpData->pCurrentTask->setScheduled(Scheduled);
mpData->pCurrentTask->setUpdateModel(UpdateModel);
mpData->pCurrentTask->setMathContainer(&mpData->pModel->getMathContainer());
if (Key != NULL)
{
addFix(Key, mpData->pCurrentTask);
}
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCXML + 5, type, mpParser->getCurrentLineNumber());
pHandlerToCall = getHandler(UNKNOWN);
}
break;
case ReportTarget:
case Method:
pHandlerToCall = getHandler(mCurrentElement.second);
break;
case Problem:
pHandlerToCall = getHandler(mCurrentElement.second);
static_cast< ParameterGroupHandler * >(pHandlerToCall)->setDerivedElement(pszName, mpData->pCurrentTask->getProblem());
break;
default:
CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 2,
mpParser->getCurrentLineNumber(), mpParser->getCurrentColumnNumber(), pszName);
break;
}
return pHandlerToCall;
}
// virtual
CXMLHandler * ModelValueHandler::processStart(const XML_Char * pszName,
const XML_Char ** papszAttrs)
{
CXMLHandler * pHandlerToCall = NULL;
const char * Name;
const char * simulationType;
CModelEntity::Status SimulationType;
bool AddNoise;
switch (mCurrentElement.first)
{
case ModelValue:
mKey = mpParser->getAttributeValue("key", papszAttrs);
Name = mpParser->getAttributeValue("name", papszAttrs);
simulationType = mpParser->getAttributeValue("simulationType", papszAttrs, false);
// We need to handle old files which used the attribute status.
if (!simulationType)
{
simulationType = mpParser->getAttributeValue("status", papszAttrs, false);
if (!simulationType) // status and simulationType are both missing
simulationType = mpParser->getAttributeValue("simulationType", papszAttrs);
}
SimulationType = toEnum(simulationType, CModelEntity::XMLStatus, CModelEntity::FIXED);
AddNoise = mpParser->toBool(mpParser->getAttributeValue("addNoise", papszAttrs, "false"));
mpMV = new CModelValue();
addFix(mKey, mpMV);
mpMV->setObjectName(Name);
mpMV->setStatus(SimulationType);
mpMV->setAddNoise(AddNoise);
mpData->pModel->getModelValues().add(mpMV, true);
break;
case MiriamAnnotation:
case Comment:
case Expression:
case MathML:
case InitialExpression:
case NoiseExpression:
case Unit:
pHandlerToCall = getHandler(mCurrentElement.second);
break;
case ListOfUnsupportedAnnotations:
mpData->mUnsupportedAnnotations.clear();
pHandlerToCall = getHandler(mCurrentElement.second);
break;
default:
CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 2,
mpParser->getCurrentLineNumber(), mpParser->getCurrentColumnNumber(), pszName);
break;
}
return pHandlerToCall;
}
bool CQExperimentData::saveTable(CExperiment * pExperiment)
{
CExperimentObjectMap & ObjectMap = pExperiment->getObjectMap();
size_t i, imax = mpTable->rowCount();
bool FoundTime = false;
bool Changed = false;
ObjectMap.setNumCols(imax);
for (i = 0; i < imax; i++)
{
CExperiment::Type Type = toEnum(TO_UTF8(mpTable->item((int) i, COL_TYPE)->text()),
CExperiment::TypeName, CExperiment::ignore);
if (Type == CExperiment::time)
FoundTime = true;
if (ObjectMap.getRole(i) != Type)
{
ObjectMap.setRole(i, Type);
Changed = true;
}
if (ObjectMap.getObjectCN(i) != TO_UTF8(mpTable->item((int) i, COL_OBJECT_HIDDEN)->text()))
{
ObjectMap.setObjectCN(i, TO_UTF8(mpTable->item((int) i, COL_OBJECT_HIDDEN)->text()));
Changed = true;
}
QString ScaleText = mpTable->item((int) i, COL_SCALE)->text();
// Empty fields are treated as default.
if (ScaleText == "")
ScaleText = QString::number(std::numeric_limits<C_FLOAT64>::quiet_NaN());
if (Type == CExperiment::dependent &&
ScaleText[0] != '(' &&
QString::number(ObjectMap.getScale(i)) != ScaleText)
{
ObjectMap.setScale(i, ScaleText.toDouble());
Changed = true;
}
}
pExperiment->updateFittedPoints();
if (!FoundTime &&
pExperiment->getExperimentType() == CCopasiTask::timeCourse &&
pExperiment == mpExperiment)
{
CCopasiMessage(CCopasiMessage::WARNING, MCFitting + 3, mpExperiment->getObjectName().c_str());
CQMessageBox::information(this, "Specification Error", FROM_UTF8(CCopasiMessage::getAllMessageText()),
QMessageBox::Ok, QMessageBox::Ok);
CCopasiMessage::clearDeque();
}
return Changed;
}
void CQParameterGroupView::modifySelectCNs(CCopasiParameterGroup & group, const CCopasiParameter & cnTemplate)
{
// OpenSelectionDialog
std::vector< const CDataObject * > Selection;
CObjectInterface::ContainerList ContainerList;
ContainerList.push_back(group.getObjectDataModel());
// Create the current selection
CCopasiParameterGroup::elements::iterator it = group.beginIndex();
CCopasiParameterGroup::elements::iterator end = group.endIndex();
for (; it != end; ++it)
{
const CDataObject * pObject = CObjectInterface::DataObject(CObjectInterface::GetObjectFromCN(ContainerList, (*it)->getValue< CCommonName >()));
if (pObject != NULL)
{
Selection.push_back(pObject);
}
}
CModel * pModel = group.getObjectDataModel()->getModel();
std::vector<const CDataObject * > ValidObjects;
const std::vector< std::pair < CCommonName, CCommonName > > & ValidValues = cnTemplate.getValidValues< CCommonName >();
std::vector< std::pair < CCommonName, CCommonName > >::const_iterator itValidValues = ValidValues.begin();
std::vector< std::pair < CCommonName, CCommonName > >::const_iterator endValidValues = ValidValues.end();
for (; itValidValues != endValidValues; ++itValidValues)
{
CObjectLists::ListType ListType = toEnum(itValidValues->first, CObjectLists::ListTypeName, CObjectLists::EMPTY_LIST);
std::vector<const CDataObject * > Tmp = CObjectLists::getListOfConstObjects(ListType, pModel);
ValidObjects.insert(ValidObjects.end(), Tmp.begin(), Tmp.end());
}
std::vector< const CDataObject * > NewSelection = CCopasiSelectionDialog::getObjectVector(this, ValidObjects, &Selection);
// Modify group parameters;
mpParameterGroupDM->beginResetModel();
group.clear();
std::vector< const CDataObject * >::const_iterator itNew = NewSelection.begin();
std::vector< const CDataObject * >::const_iterator endNew = NewSelection.end();
for (; itNew != endNew; ++itNew)
{
group.addParameter("Reaction", CCopasiParameter::Type::CN, (*itNew)->getCN());
}
mpParameterGroupDM->endResetModel();
}
// virtual
CXMLHandler * PlotItemHandler::processStart(const XML_Char * pszName,
const XML_Char ** papszAttrs)
{
CXMLHandler * pHandlerToCall = NULL;
std::string name;
std::string sType;
CCopasiParameterGroup * pGroup = NULL;
switch (mCurrentElement.first)
{
case PlotItem:
// create a new CPlotSpecification element depending on the type
name = mpParser->getAttributeValue("name", papszAttrs);
sType = mpParser->getAttributeValue("type", papszAttrs);
mpData->pCurrentPlotItem =
mpData->pCurrentPlot->createItem(name, toEnum(sType.c_str(), CPlotItem::XMLType, CPlotItem::unset));
break;
case ParameterGroup:
pHandlerToCall = getHandler(mCurrentElement.second);
pGroup = dynamic_cast< CCopasiParameterGroup * >(mpData->pCurrentPlot->getParameter(pszName));
if (pGroup != NULL)
static_cast< ParameterGroupHandler * >(pHandlerToCall)->setDerivedElement(pszName, pGroup);
break;
case Parameter:
case ListOfChannels:
pHandlerToCall = getHandler(mCurrentElement.second);
break;
break;
default:
CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 2,
mpParser->getCurrentLineNumber(), mpParser->getCurrentColumnNumber(), pszName);
break;
}
return pHandlerToCall;
}
Graph::EdgeType toEdgeType(const std::string &str)
{
return toEnum(
str, edgeTypeMap,
static_cast<Graph::EdgeType>(0), Graph::dependency, Graph::association);
}
Graph::NodeType toNodeType(const std::string &str)
{
return toEnum(
str, nodeTypeMap,
static_cast<Graph::NodeType>(0), Graph::vertex, Graph::vertex);
}
EdgeArrow toArrow(const std::string &str)
{
return toEnum(str, arrowMap, eaNone, eaUndefined, eaUndefined);
}
Shape toShape(const std::string &str)
{
return toEnum(str, shapeMap, shRect, shImage, shRect);
}
Attribute toAttribute(const std::string &str)
{
return toEnum(
str, attrMap,
static_cast<Attribute>(0), a_unknown, a_unknown);
}
EdgeAttribute toEdgeAttribute(const std::string &str)
{
return toEnum(
str, edgeAttrMap, toString,
static_cast<EdgeAttribute>(0), ea_unknown, ea_unknown);
}
NodeAttribute toNodeAttribute(const std::string &str)
{
return toEnum(
str, nodeAttrMap, toString,
static_cast<NodeAttribute>(0), na_unknown, na_unknown);
}
static void strToERounding(
const UnicodeString &str, void *roundPtr, UErrorCode &status) {
int32_t val = toEnum(
gRoundingEnum, UPRV_LENGTHOF(gRoundingEnum), str, status);
*static_cast<DecimalFormat::ERoundingMode *>(roundPtr) = (DecimalFormat::ERoundingMode) val;
}
void CCopasiXMLParser::ModelParameterGroupElement::start(const XML_Char *pszName,
const XML_Char **papszAttrs)
{
const char * CN;
const char * pType;
CModelParameter::Type Type;
mpCurrentHandler = NULL;
mCurrentElement = mLastKnownElement;
while (mpCurrentHandler == NULL)
{
mCurrentElement++; /* We should always be on the next element */
switch (mCurrentElement)
{
case ModelParameterGroup:
if (strcmp(pszName, "ModelParameterGroup"))
CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
pszName, "ModelParameterGroup", mParser.getCurrentLineNumber());
mLastKnownElement = ModelParameterGroup;
// Element specific code.
CN = mParser.getAttributeValue("cn", papszAttrs);
pType = mParser.getAttributeValue("type", papszAttrs);
Type = toEnum(pType, CModelParameter::TypeNames, CModelParameter::Group);
{
CModelParameterGroup * pModelParameterGroup = new CModelParameterGroup(mCommon.ModelParameterGroupStack.top(), Type);
pModelParameterGroup->setCN(std::string(CN));
mCommon.ModelParameterGroupStack.push(pModelParameterGroup);
}
return;
case Content:
if (!strcmp(pszName, "ModelParameterGroup"))
{
/* If we do not have an etc element handler we create one. */
if (!mpModelParameterGroupElement)
mpModelParameterGroupElement = new ModelParameterGroupElement(mParser, mCommon);
mpCurrentHandler = mpModelParameterGroupElement;
}
else if (!strcmp(pszName, "ModelParameter"))
{
/* If we do not have an etc element handler we create one. */
if (!mpModelParameterElement)
mpModelParameterElement = new ModelParameterElement(mParser, mCommon);
mpCurrentHandler = mpModelParameterElement;
}
break;
default:
mCurrentElement = UNKNOWN_ELEMENT;
mpCurrentHandler = &mParser.mUnknownElement;
break;
}
}
mParser.pushElementHandler(mpCurrentHandler);
if (mpCurrentHandler != &mParser.mUnknownElement)
{
mLastKnownElement = mCurrentElement;
}
mParser.onStartElement(pszName, papszAttrs);
return;
}
// virtual
CXMLHandler * ParameterHandler::processStart(const XML_Char * pszName,
const XML_Char ** papszAttrs)
{
CXMLHandler * pHandlerToCall = NULL;
const char * cValue = NULL;
const char * cType = NULL;
std::string name;
std::string sValue("");
bool UnmappedKey = false;
void * pValue = NULL;
CCopasiParameter::Type type;
C_FLOAT64 d;
C_INT32 i;
size_t ui;
bool b;
switch (mCurrentElement.first)
{
case Parameter:
// Parameter has attributes name, type and value
name = mpParser->getAttributeValue("name", papszAttrs);
cType = mpParser->getAttributeValue("type", papszAttrs);
type = toEnum(cType, CCopasiParameter::XMLType, CCopasiParameter::INVALID);
cValue = mpParser->getAttributeValue("value", papszAttrs);
if (cValue != NULL)
{
sValue = cValue;
}
switch (type)
{
case CCopasiParameter::DOUBLE:
d = CCopasiXMLInterface::DBL(sValue.c_str());
pValue = &d;
break;
case CCopasiParameter::UDOUBLE:
d = CCopasiXMLInterface::DBL(sValue.c_str());
pValue = &d;
break;
case CCopasiParameter::INT:
i = strToInt(sValue.c_str());
pValue = &i;
break;
case CCopasiParameter::UINT:
ui = strToUnsignedInt(sValue.c_str());
pValue = &ui;
break;
case CCopasiParameter::BOOL:
if (sValue == "0" || sValue == "false")
{
b = false;
}
else
{
b = true;
}
pValue = &b;
break;
case CCopasiParameter::STRING:
case CCopasiParameter::FILE:
case CCopasiParameter::CN:
pValue = &sValue;
break;
case CCopasiParameter::KEY:
{
if (sValue != "" &&
CKeyFactory::isValidKey(sValue))
{
CCopasiObject * pObject = mpData->mKeyMap.get(sValue);
if (pObject)
{
sValue = pObject->getKey();
}
else
{
UnmappedKey = true;
}
}
pValue = &sValue;
}
break;
default:
CCopasiMessage(CCopasiMessage::ERROR, MCXML + 16, name.c_str(), cType, mpParser->getCurrentLineNumber());
pValue = NULL;
break;
}
mpData->pCurrentParameter = new CCopasiParameter(name, type, pValue);
if (UnmappedKey)
{
mpData->UnmappedKeyParameters.push_back(mpData->pCurrentParameter->getKey());
}
break;
default:
CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 2,
mpParser->getCurrentLineNumber(), mpParser->getCurrentColumnNumber(), pszName);
break;
}
return pHandlerToCall;
}
static void strToCurrencyUsage(
const UnicodeString &str, void *currencyUsagePtr, UErrorCode &status) {
int32_t val = toEnum(
gCurrencyUsageEnum, UPRV_LENGTHOF(gCurrencyUsageEnum), str, status);
*static_cast<UCurrencyUsage *>(currencyUsagePtr) = (UCurrencyUsage) val;
}
// virtual
CXMLHandler * MetaboliteHandler::processStart(const XML_Char * pszName,
const XML_Char ** papszAttrs)
{
CXMLHandler * pHandlerToCall = NULL;
CCompartment * pCompartment = NULL;
const char * Name;
const char * simulationType;
CModelEntity::Status SimulationType;
const char reactions[] = "reactions";
const char * Compartment;
bool AddNoise;
switch (mCurrentElement.first)
{
case Metabolite:
mKey = mpParser->getAttributeValue("key", papszAttrs);
Name = mpParser->getAttributeValue("name", papszAttrs);
simulationType = mpParser->getAttributeValue("simulationType", papszAttrs, false);
// We need to handle old files which used the attribute status.
if (!simulationType)
{
simulationType = mpParser->getAttributeValue("status", papszAttrs, false);
if (!simulationType) // status and simulationType are both missing
simulationType = mpParser->getAttributeValue("simulationType", papszAttrs);
else if (!strcmp(simulationType, "variable")) // reactions was named variable
simulationType = reactions;
}
SimulationType = toEnum(simulationType, CModelEntity::XMLStatus, CModelEntity::REACTIONS);
Compartment = mpParser->getAttributeValue("compartment", papszAttrs);
AddNoise = mpParser->toBool(mpParser->getAttributeValue("addNoise", papszAttrs, "false"));
mpMetabolite = new CMetab();
addFix(mKey, mpMetabolite);
mpMetabolite->setObjectName(Name);
mpMetabolite->setStatus(SimulationType);
mpMetabolite->setAddNoise(AddNoise);
pCompartment =
dynamic_cast< CCompartment* >(mpData->mKeyMap.get(Compartment));
if (!pCompartment) fatalError();
pCompartment->addMetabolite(mpMetabolite);
mpData->pModel->getMetabolites().add(mpMetabolite, false);
break;;
case MiriamAnnotation:
case Comment:
case Expression:
case InitialExpression:
case NoiseExpression:
pHandlerToCall = getHandler(mCurrentElement.second);
break;
case ListOfUnsupportedAnnotations:
mpData->mUnsupportedAnnotations.clear();
pHandlerToCall = getHandler(mCurrentElement.second);
break;
default:
CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 2,
mpParser->getCurrentLineNumber(), mpParser->getCurrentColumnNumber(), pszName);
break;
}
return pHandlerToCall;
}
static void strToFormatStyle(
const UnicodeString &str, void *formatStylePtr, UErrorCode &status) {
int32_t val = toEnum(
gFormatStyleEnum, UPRV_LENGTHOF(gFormatStyleEnum), str, status);
*static_cast<UNumberFormatStyle *>(formatStylePtr) = (UNumberFormatStyle) val;
}
void CCopasiXMLParser::ModelParameterElement::start(const XML_Char *pszName,
const XML_Char **papszAttrs)
{
const char * CN;
const char * pValue;
C_FLOAT64 Value = std::numeric_limits< C_FLOAT64 >::quiet_NaN();
const char * pType;
CModelParameter::Type Type;
const char * pSimulationType;
CModelEntity::Status SimulationType;
mpCurrentHandler = NULL;
mCurrentElement = mLastKnownElement;
while (mpCurrentHandler == NULL)
{
mCurrentElement++; /* We should always be on the next element */
switch (mCurrentElement)
{
case ModelParameter:
if (strcmp(pszName, "ModelParameter"))
CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
pszName, "ModelParameter", mParser.getCurrentLineNumber());
mLastKnownElement = ModelParameter;
// Element specific code.
CN = mParser.getAttributeValue("cn", papszAttrs);
pValue = mParser.getAttributeValue("value", papszAttrs);
pType = mParser.getAttributeValue("type", papszAttrs);
pSimulationType = mParser.getAttributeValue("simulationType", papszAttrs);
if (pValue != NULL)
{
Value = CCopasiXMLInterface::DBL(pValue);
}
Type = toEnum(pType, CModelParameter::TypeNames, CModelParameter::unknown);
switch (Type)
{
case CModelParameter::Species:
mCommon.pCurrentModelParameter = new CModelParameterSpecies(mCommon.ModelParameterGroupStack.top());
break;
case CModelParameter::Compartment:
mCommon.pCurrentModelParameter = new CModelParameterCompartment(mCommon.ModelParameterGroupStack.top());
break;
case CModelParameter::ReactionParameter:
mCommon.pCurrentModelParameter = new CModelParameterReactionParameter(mCommon.ModelParameterGroupStack.top());
break;
default:
mCommon.pCurrentModelParameter = new CModelParameter(mCommon.ModelParameterGroupStack.top(), Type);
break;
}
mCommon.pCurrentModelParameter->setCN(std::string(CN));
SimulationType = toEnum(pSimulationType, CModelEntity::XMLStatus, CModelEntity::FIXED);
mCommon.pCurrentModelParameter->setSimulationType(SimulationType);
mCommon.pCurrentModelParameter->setValue(Value, CModelParameter::ParticleNumbers);
return;
case InitialExpression:
if (!strcmp(pszName, "InitialExpression"))
mpCurrentHandler = &mParser.mCharacterDataElement;
break;
default:
mCurrentElement = UNKNOWN_ELEMENT;
mpCurrentHandler = &mParser.mUnknownElement;
break;
}
}
mParser.pushElementHandler(mpCurrentHandler);
if (mpCurrentHandler != &mParser.mUnknownElement)
{
mLastKnownElement = mCurrentElement;
}
mParser.onStartElement(pszName, papszAttrs);
return;
}
DataInformation* toDataInformation(const QScriptValue& value, const ParserInfo& oldInfo)
{
if (!value.isValid())
{
oldInfo.error() << "invalid value passed!";
return 0;
}
ParserInfo info(oldInfo);
QString nameOverride = value.property(PROPERTY_NAME).toString();
if (!nameOverride.isEmpty())
info.name = nameOverride;
//check function array and date, since they are objects too
if (value.isRegExp())
{
//apparently regexp is a function
info.error() << "Cannot convert a RegExp object to DataInformation!";
return 0;
}
if (value.isFunction())
{
info.error() << "Cannot convert a Function object to DataInformation!";
return 0;
}
if (value.isArray())
{
info.error() << "Cannot convert a Array object to DataInformation!";
return 0;
}
if (value.isDate())
{
info.error() << "Cannot convert a Date object to DataInformation!";
return 0;
}
if (value.isError())
{
info.error() << "Cannot convert a Error object to DataInformation!";
return 0;
}
//variant and qobject are also object types, however they cannot appear from user code, no need to check
//if it is a string, we convert to primitive type, if not it has to be an object
if (value.isString())
return toPrimitive(value, info); //a type string is also okay
if (!value.isObject())
{
if (value.isBool())
info.error() << "Cannot convert Boolean to DataInformation!";
else if (value.isNull())
info.error() << "Cannot convert null to DataInformation!";
else if (value.isUndefined())
info.error() << "Cannot convert undefined to DataInformation!";
else if (value.isNumber())
info.error() << "Cannot convert Number to DataInformation!";
else
info.error() << "Cannot convert object of unknown type to DataInformation!";
return 0; //no point trying to convert
}
QString type = value.property(PROPERTY_INTERNAL_TYPE).toString();
if (type.isEmpty())
{
info.error() << "Cannot convert object since type of object could not be determined!";
return 0;
}
DataInformation* returnVal = 0;
if (type == TYPE_ARRAY)
returnVal = toArray(value, info);
else if (type == TYPE_STRUCT)
returnVal = toStruct(value, info);
else if (type == TYPE_UNION)
returnVal = toUnion(value, info);
else if (type == TYPE_BITFIELD)
returnVal = toBitfield(value, info);
else if (type == TYPE_ENUM)
returnVal = toEnum(value, false, info);
else if (type == TYPE_FLAGS)
returnVal = toEnum(value, true, info);
else if (type == TYPE_STRING)
returnVal = toString(value, info);
else if (type == TYPE_POINTER)
returnVal = toPointer(value, info);
else if (type == TYPE_TAGGED_UNION)
returnVal = toTaggedUnion(value, info);
else if (type == TYPE_PRIMITIVE)
returnVal = toPrimitive(value, info);
else
info.error() << "Unknown type:" << type;
if (returnVal)
{
CommonParsedData cpd(info);
QString byteOrderStr = value.property(PROPERTY_BYTEORDER).toString();
if (!byteOrderStr.isEmpty())
cpd.endianess = ParserUtils::byteOrderFromString(byteOrderStr,
LoggerWithContext(info.logger, info.context()));
cpd.updateFunc = value.property(PROPERTY_UPDATE_FUNC);
cpd.validationFunc = value.property(PROPERTY_VALIDATION_FUNC);
cpd.toStringFunc = value.property(PROPERTY_TO_STRING_FUNC);
cpd.customTypeName = value.property(PROPERTY_CUSTOM_TYPE_NAME).toString();
if (!DataInformationFactory::commonInitialization(returnVal, cpd))
{
delete returnVal; //error message has already been logged
return 0;
}
}
return returnVal;
}
