initial commit for github
This commit is contained in:
Pierre
commit
60968612de
370 changed files with 68427 additions and 0 deletions
625
ddlrepresentation/ddlcloner.cpp
Normal file
625
ddlrepresentation/ddlcloner.cpp
Normal file
|
|
@ -0,0 +1,625 @@
|
|||
/**
|
||||
* @file
|
||||
*
|
||||
* @copyright
|
||||
* @verbatim
|
||||
Copyright @ 2017 Audi Electronics Venture GmbH. All rights reserved.
|
||||
|
||||
This Source Code Form is subject to the terms of the Mozilla
|
||||
Public License, v. 2.0. If a copy of the MPL was not distributed
|
||||
with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
|
||||
If it is not possible or desirable to put the notice in a particular file, then
|
||||
You may include the notice in a location (such as a LICENSE file in a
|
||||
relevant directory) where a recipient would be likely to look for such a notice.
|
||||
|
||||
You may add additional accurate notices of copyright ownership.
|
||||
@endverbatim
|
||||
*/
|
||||
|
||||
#include "ddlcloner.h"
|
||||
#include "a_util/result/error_def.h"
|
||||
#include "legacy_error_macros.h"
|
||||
|
||||
#include "ddldescription.h"
|
||||
#include "ddlunit.h"
|
||||
#include "ddlbaseunit.h"
|
||||
#include "ddlprefix.h"
|
||||
#include "ddldatatype.h"
|
||||
#include "ddlenum.h"
|
||||
#include "ddlcomplex.h"
|
||||
#include "ddlstream.h"
|
||||
#include "ddlstreammetatype.h"
|
||||
#include "ddlheader.h"
|
||||
#include "ddlextdeclaration.h"
|
||||
#include "ddlrefunit.h"
|
||||
#include "ddlelement.h"
|
||||
#include "ddlstreamstruct.h"
|
||||
|
||||
#include "ddlimporter.h"
|
||||
|
||||
|
||||
namespace ddl
|
||||
{
|
||||
//define all needed error types and values locally
|
||||
_MAKE_RESULT(-4, ERR_POINTER)
|
||||
_MAKE_RESULT(-16, ERR_NOT_IMPL)
|
||||
_MAKE_RESULT(-18, ERR_NO_CLASS)
|
||||
_MAKE_RESULT(-37, ERR_NOT_INITIALIZED)
|
||||
|
||||
DDLDescription * DDLCloner::getDDL() const
|
||||
{
|
||||
return _ddl_desc;
|
||||
}
|
||||
|
||||
void DDLCloner::destroyDDL()
|
||||
{
|
||||
DDLImporter::destroyDDL(_ddl_desc);
|
||||
_ddl_desc = NULL;
|
||||
}
|
||||
|
||||
a_util::result::Result DDLCloner::createNew(const DDLVersion& version /* = 0 */)
|
||||
{
|
||||
if (NULL == _original_desc)
|
||||
{
|
||||
return ERR_NOT_INITIALIZED;
|
||||
}
|
||||
// The DDL object does not get deleted because the caller/user of this
|
||||
// object is responsible for it.
|
||||
_ddl_desc = NULL;
|
||||
// clone original DDL
|
||||
RETURN_IF_FAILED(buildHeader());
|
||||
RETURN_IF_FAILED(buildUnits());
|
||||
RETURN_IF_FAILED(buildDatatypes());
|
||||
RETURN_IF_FAILED(buildEnums());
|
||||
RETURN_IF_FAILED(buildStructs());
|
||||
RETURN_IF_FAILED(buildStreams());
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
a_util::result::Result DDLCloner::buildHeader()
|
||||
{
|
||||
if (NULL == _original_desc)
|
||||
{
|
||||
return ERR_NOT_INITIALIZED;
|
||||
}
|
||||
// copy header object
|
||||
DDLHeader *header = new DDLHeader(*_original_desc->getHeader());
|
||||
// external declarations have to be cloned separately
|
||||
DDLExtDeclarationVec ext_declarations = header->getExtDeclarations();
|
||||
std::transform(ext_declarations.begin(), ext_declarations.end(),
|
||||
ext_declarations.begin(), DDL::clone<DDLExtDeclaration>);
|
||||
_ddl_desc = new DDLDescription(header);
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
a_util::result::Result DDLCloner::buildUnits()
|
||||
{
|
||||
if (NULL == _original_desc)
|
||||
{
|
||||
return ERR_NOT_INITIALIZED;
|
||||
}
|
||||
|
||||
// clone baseunit objects
|
||||
DDLBaseunitVec baseunits = _original_desc->getBaseunits();
|
||||
std::transform(baseunits.begin(), baseunits.end(), baseunits.begin(),
|
||||
DDL::clone<DDLBaseunit>);
|
||||
_ddl_desc->refBaseunits(baseunits);
|
||||
|
||||
// clone prefix objects
|
||||
DDLPrefixVec ddlprefixes = _original_desc->getPrefixes();
|
||||
std::transform(ddlprefixes.begin(), ddlprefixes.end(),
|
||||
ddlprefixes.begin(), DDL::clone<DDLPrefix>);
|
||||
_ddl_desc->refPrefixes(ddlprefixes);
|
||||
|
||||
// clone unit objects
|
||||
DDLUnitVec units = _original_desc->getUnits();
|
||||
std::transform(units.begin(), units.end(),
|
||||
units.begin(), DDL::clone<DDLUnit>);
|
||||
// refunit objects have to be cloned separately
|
||||
for (DDLUnitIt it_unit = units.begin(); units.end() != it_unit;
|
||||
++it_unit)
|
||||
{
|
||||
DDLRefUnitVec refunits = (*it_unit)->getRefUnits();
|
||||
for (DDLRefUnitIt it_ru = refunits.begin(); refunits.end() != it_ru;
|
||||
++it_ru)
|
||||
{
|
||||
// find prefix object
|
||||
DDLPrefixIt it_prefix = std::find_if(ddlprefixes.begin(),
|
||||
ddlprefixes.end(), DDLCompareFunctor<DDLPrefix>((*it_ru)->getPrefix()));
|
||||
if (ddlprefixes.end() == it_prefix)
|
||||
{
|
||||
return ERR_NO_CLASS;
|
||||
}
|
||||
// find unit and create refunit object with appropriate CTOR
|
||||
DDLBaseunitIt it_bu_found = std::find_if(baseunits.begin(),
|
||||
baseunits.end(), DDLCompareFunctor<DDLBaseunit>((*it_ru)->getName()));
|
||||
if (baseunits.end() == it_bu_found)
|
||||
{
|
||||
// not found in baseunit vector
|
||||
DDLUnitIt it_u_found = std::find_if(units.begin(),
|
||||
units.end(), DDLCompareFunctor<DDLUnit>((*it_ru)->getName()));
|
||||
if (units.end() == it_u_found)
|
||||
{
|
||||
// not found in unit vector
|
||||
// => not defined at all
|
||||
return ERR_NO_CLASS;
|
||||
}
|
||||
*it_ru = new DDLRefUnit(*it_u_found, (*it_ru)->getPower(),
|
||||
*it_prefix);
|
||||
}
|
||||
else
|
||||
{
|
||||
*it_ru = new DDLRefUnit(*it_bu_found, (*it_ru)->getPower(),
|
||||
*it_prefix);
|
||||
}
|
||||
}
|
||||
(*it_unit)->setRefUnits(refunits);
|
||||
}
|
||||
_ddl_desc->refUnits(units);
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
a_util::result::Result DDLCloner::buildDatatypes()
|
||||
{
|
||||
if (NULL == _original_desc)
|
||||
{
|
||||
return ERR_NOT_INITIALIZED;
|
||||
}
|
||||
DDLDTVec datatypes = _original_desc->getDatatypes();
|
||||
for (DDLDTIt it_dt = datatypes.begin(); datatypes.end() != it_dt; ++it_dt)
|
||||
{
|
||||
DDLVersion version = (*it_dt)->getDDLVersion();
|
||||
if ((*it_dt)->getUnit().empty())
|
||||
{
|
||||
// datatype without defined unit
|
||||
(*it_dt) = new DDLDataType((*it_dt)->getName(),
|
||||
(*it_dt)->getNumBits(),
|
||||
NULL,
|
||||
(*it_dt)->getDescription(),
|
||||
(*it_dt)->getAlignment(),
|
||||
(*it_dt)->getArraysize(),
|
||||
(*it_dt)->getCreationLevel(),
|
||||
(*it_dt)->getArraySizeSource(),
|
||||
(*it_dt)->isMinValid(),
|
||||
(*it_dt)->getMinValue(),
|
||||
(*it_dt)->isMaxValid(),
|
||||
(*it_dt)->getMaxValue());
|
||||
}
|
||||
else
|
||||
{
|
||||
// find unit and clone datatype object with appropriate CTOR
|
||||
DDLBaseunitVec baseunits = _ddl_desc->getBaseunits();
|
||||
DDLBaseunitIt it_bu_found = std::find_if(baseunits.begin(),
|
||||
baseunits.end(), DDLCompareFunctor<DDLBaseunit>((*it_dt)->getUnit()));
|
||||
if (baseunits.end() == it_bu_found)
|
||||
{
|
||||
// not found in baseunit vector
|
||||
DDLUnitVec units = _ddl_desc->getUnits();
|
||||
DDLUnitIt it_u_found = std::find_if(units.begin(),
|
||||
units.end(), DDLCompareFunctor<DDLUnit>((*it_dt)->getUnit()));
|
||||
if (units.end() == it_u_found)
|
||||
{
|
||||
// not found in unit vector
|
||||
// => not defined at all
|
||||
return ERR_NO_CLASS;
|
||||
}
|
||||
(*it_dt) = new DDLDataType((*it_dt)->getName(),
|
||||
(*it_dt)->getNumBits(),
|
||||
*it_u_found,
|
||||
(*it_dt)->getDescription(),
|
||||
(*it_dt)->getAlignment(),
|
||||
(*it_dt)->getArraysize(),
|
||||
(*it_dt)->getCreationLevel(),
|
||||
(*it_dt)->getArraySizeSource(),
|
||||
(*it_dt)->isMinValid(),
|
||||
(*it_dt)->getMinValue(),
|
||||
(*it_dt)->isMaxValid(),
|
||||
(*it_dt)->getMaxValue());
|
||||
}
|
||||
else
|
||||
{
|
||||
(*it_dt) = new DDLDataType((*it_dt)->getName(),
|
||||
(*it_dt)->getNumBits(),
|
||||
*it_bu_found,
|
||||
(*it_dt)->getDescription(),
|
||||
(*it_dt)->getAlignment(),
|
||||
(*it_dt)->getArraysize(),
|
||||
(*it_dt)->getCreationLevel(),
|
||||
(*it_dt)->getArraySizeSource(),
|
||||
(*it_dt)->isMinValid(),
|
||||
(*it_dt)->getMinValue(),
|
||||
(*it_dt)->isMaxValid(),
|
||||
(*it_dt)->getMaxValue());
|
||||
}
|
||||
}
|
||||
(*it_dt)->setDDLVersion(version);
|
||||
}
|
||||
_ddl_desc->refDatatypes(datatypes);
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
a_util::result::Result DDLCloner::buildEnums()
|
||||
{
|
||||
if (NULL == _original_desc)
|
||||
{
|
||||
return ERR_NOT_INITIALIZED;
|
||||
}
|
||||
DDLEnumVec enums = _original_desc->getEnums();
|
||||
// clone enums
|
||||
std::transform(enums.begin(), enums.end(),
|
||||
enums.begin(), DDL::clone<DDLEnum>);
|
||||
_ddl_desc->refEnums(enums);
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
a_util::result::Result DDLCloner::buildStructs()
|
||||
{
|
||||
if (NULL == _original_desc)
|
||||
{
|
||||
return ERR_NOT_INITIALIZED;
|
||||
}
|
||||
// clone structs
|
||||
DDLComplexVec structs;
|
||||
structs.cloneFrom(_original_desc->getStructs());
|
||||
|
||||
// elements have to be cloned seperately
|
||||
DDLDTVec datatypes = _ddl_desc->getDatatypes();
|
||||
DDLUnitVec units = _ddl_desc->getUnits();
|
||||
DDLBaseunitVec baseunits = _ddl_desc->getBaseunits();
|
||||
DDLEnumVec ddl_enums = _ddl_desc->getEnums();
|
||||
for (DDLComplexVec::iterator it_struct = structs.begin();
|
||||
structs.end() != it_struct; ++it_struct)
|
||||
{
|
||||
DDLElementVec elements = (*it_struct)->getElements();
|
||||
for (DDLElementIt it_element = elements.begin();
|
||||
elements.end() != it_element; ++it_element)
|
||||
{
|
||||
DDLComplex* ddl_struct = NULL;
|
||||
DDLEnum* ddl_enum = NULL;
|
||||
DDLDataType* type = datatypes.find((*it_element)->getType());
|
||||
if (!type)
|
||||
{
|
||||
// not found in datatypes vector
|
||||
ddl_struct = structs.find((*it_element)->getType());
|
||||
if (!ddl_struct)
|
||||
{
|
||||
// not found in structs vector
|
||||
ddl_enum = ddl_enums.find((*it_element)->getType());
|
||||
if (!ddl_enum)
|
||||
{
|
||||
// not found in enums vector
|
||||
// => not defined at all
|
||||
return ERR_NO_CLASS;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ((*it_element)->getUnit().empty())
|
||||
{
|
||||
// no unit defined
|
||||
if (ddl_enum)
|
||||
{
|
||||
*it_element = new DDLElement(ddl_enum,
|
||||
(*it_element)->getName(),
|
||||
(*it_element)->getBytepos(),
|
||||
(*it_element)->getArraysize(),
|
||||
(*it_element)->getByteorder(),
|
||||
(*it_element)->getAlignment(),
|
||||
NULL,
|
||||
(*it_element)->getBitpos(),
|
||||
(*it_element)->getNumBits(),
|
||||
(*it_element)->getDescription(),
|
||||
(*it_element)->getComment(),
|
||||
(*it_element)->getArraySizeSource(),
|
||||
(*it_element)->getConstantValue(),
|
||||
(*it_element)->isMinValid(),
|
||||
(*it_element)->getMinValue(),
|
||||
(*it_element)->isMaxValid(),
|
||||
(*it_element)->getMaxValue(),
|
||||
(*it_element)->isDefaultValid(),
|
||||
(*it_element)->getDefaultValue(),
|
||||
(*it_element)->isScaleValid(),
|
||||
(*it_element)->getScaleValue(),
|
||||
(*it_element)->isOffsetValid(),
|
||||
(*it_element)->getOffsetValue());
|
||||
}
|
||||
else if(ddl_struct)
|
||||
{
|
||||
*it_element = new DDLElement(ddl_struct,
|
||||
(*it_element)->getName(),
|
||||
(*it_element)->getBytepos(),
|
||||
(*it_element)->getArraysize(),
|
||||
(*it_element)->getByteorder(),
|
||||
(*it_element)->getAlignment(),
|
||||
NULL,
|
||||
(*it_element)->getBitpos(),
|
||||
(*it_element)->getNumBits(),
|
||||
(*it_element)->getDescription(),
|
||||
(*it_element)->getComment(),
|
||||
(*it_element)->getArraySizeSource(),
|
||||
(*it_element)->getConstantValue(),
|
||||
(*it_element)->isMinValid(),
|
||||
(*it_element)->getMinValue(),
|
||||
(*it_element)->isMaxValid(),
|
||||
(*it_element)->getMaxValue(),
|
||||
(*it_element)->isDefaultValid(),
|
||||
(*it_element)->getDefaultValue(),
|
||||
(*it_element)->isScaleValid(),
|
||||
(*it_element)->getScaleValue(),
|
||||
(*it_element)->isOffsetValid(),
|
||||
(*it_element)->getOffsetValue());
|
||||
}
|
||||
else
|
||||
{
|
||||
*it_element = new DDLElement(type,
|
||||
(*it_element)->getName(),
|
||||
(*it_element)->getBytepos(),
|
||||
(*it_element)->getArraysize(),
|
||||
(*it_element)->getByteorder(),
|
||||
(*it_element)->getAlignment(),
|
||||
NULL,
|
||||
(*it_element)->getBitpos(),
|
||||
(*it_element)->getNumBits(),
|
||||
(*it_element)->getDescription(),
|
||||
(*it_element)->getComment(),
|
||||
(*it_element)->getArraySizeSource(),
|
||||
(*it_element)->getConstantValue(),
|
||||
(*it_element)->isMinValid(),
|
||||
(*it_element)->getMinValue(),
|
||||
(*it_element)->isMaxValid(),
|
||||
(*it_element)->getMaxValue(),
|
||||
(*it_element)->isDefaultValid(),
|
||||
(*it_element)->getDefaultValue(),
|
||||
(*it_element)->isScaleValid(),
|
||||
(*it_element)->getScaleValue(),
|
||||
(*it_element)->isOffsetValid(),
|
||||
(*it_element)->getOffsetValue());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// find unit
|
||||
DDLBaseunitIt it_bu_found = std::find_if(baseunits.begin(),
|
||||
baseunits.end(), DDLCompareFunctor<DDLBaseunit>((*it_element)->getUnit()));
|
||||
if (baseunits.end() == it_bu_found)
|
||||
{
|
||||
// not found in baseunit vector
|
||||
DDLUnitIt it_u_found = std::find_if(units.begin(),
|
||||
units.end(), DDLCompareFunctor<DDLUnit>((*it_element)->getUnit()));
|
||||
if (units.end() == it_u_found)
|
||||
{
|
||||
// not found in units vector
|
||||
// => not defined at all
|
||||
return ERR_NO_CLASS;
|
||||
}
|
||||
if (ddl_enum)
|
||||
{
|
||||
*it_element = new DDLElement(ddl_enum,
|
||||
(*it_element)->getName(),
|
||||
(*it_element)->getBytepos(),
|
||||
(*it_element)->getArraysize(),
|
||||
(*it_element)->getByteorder(),
|
||||
(*it_element)->getAlignment(),
|
||||
*it_u_found,
|
||||
(*it_element)->getBitpos(),
|
||||
(*it_element)->getNumBits(),
|
||||
(*it_element)->getDescription(),
|
||||
(*it_element)->getComment(),
|
||||
(*it_element)->getArraySizeSource(),
|
||||
(*it_element)->getConstantValue(),
|
||||
(*it_element)->isMinValid(),
|
||||
(*it_element)->getMinValue(),
|
||||
(*it_element)->isMaxValid(),
|
||||
(*it_element)->getMaxValue(),
|
||||
(*it_element)->isDefaultValid(),
|
||||
(*it_element)->getDefaultValue(),
|
||||
(*it_element)->isScaleValid(),
|
||||
(*it_element)->getScaleValue(),
|
||||
(*it_element)->isOffsetValid(),
|
||||
(*it_element)->getOffsetValue());
|
||||
}
|
||||
else if (ddl_struct)
|
||||
{
|
||||
*it_element = new DDLElement(ddl_struct,
|
||||
(*it_element)->getName(),
|
||||
(*it_element)->getBytepos(),
|
||||
(*it_element)->getArraysize(),
|
||||
(*it_element)->getByteorder(),
|
||||
(*it_element)->getAlignment(),
|
||||
*it_u_found,
|
||||
(*it_element)->getBitpos(),
|
||||
(*it_element)->getNumBits(),
|
||||
(*it_element)->getDescription(),
|
||||
(*it_element)->getComment(),
|
||||
(*it_element)->getArraySizeSource(),
|
||||
(*it_element)->getConstantValue(),
|
||||
(*it_element)->isMinValid(),
|
||||
(*it_element)->getMinValue(),
|
||||
(*it_element)->isMaxValid(),
|
||||
(*it_element)->getMaxValue(),
|
||||
(*it_element)->isDefaultValid(),
|
||||
(*it_element)->getDefaultValue(),
|
||||
(*it_element)->isScaleValid(),
|
||||
(*it_element)->getScaleValue(),
|
||||
(*it_element)->isOffsetValid(),
|
||||
(*it_element)->getOffsetValue());
|
||||
}
|
||||
else
|
||||
{
|
||||
*it_element = new DDLElement(type,
|
||||
(*it_element)->getName(),
|
||||
(*it_element)->getBytepos(),
|
||||
(*it_element)->getArraysize(),
|
||||
(*it_element)->getByteorder(),
|
||||
(*it_element)->getAlignment(),
|
||||
*it_u_found,
|
||||
(*it_element)->getBitpos(),
|
||||
(*it_element)->getNumBits(),
|
||||
(*it_element)->getDescription(),
|
||||
(*it_element)->getComment(),
|
||||
(*it_element)->getArraySizeSource(),
|
||||
(*it_element)->getConstantValue(),
|
||||
(*it_element)->isMinValid(),
|
||||
(*it_element)->getMinValue(),
|
||||
(*it_element)->isMaxValid(),
|
||||
(*it_element)->getMaxValue(),
|
||||
(*it_element)->isDefaultValid(),
|
||||
(*it_element)->getDefaultValue(),
|
||||
(*it_element)->isScaleValid(),
|
||||
(*it_element)->getScaleValue(),
|
||||
(*it_element)->isOffsetValid(),
|
||||
(*it_element)->getOffsetValue());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (ddl_enum)
|
||||
{
|
||||
*it_element = new DDLElement(ddl_enum,
|
||||
(*it_element)->getName(),
|
||||
(*it_element)->getBytepos(),
|
||||
(*it_element)->getArraysize(),
|
||||
(*it_element)->getByteorder(),
|
||||
(*it_element)->getAlignment(),
|
||||
*it_bu_found,
|
||||
(*it_element)->getBitpos(),
|
||||
(*it_element)->getNumBits(),
|
||||
(*it_element)->getDescription(),
|
||||
(*it_element)->getComment(),
|
||||
(*it_element)->getArraySizeSource(),
|
||||
(*it_element)->getConstantValue(),
|
||||
(*it_element)->isMinValid(),
|
||||
(*it_element)->getMinValue(),
|
||||
(*it_element)->isMaxValid(),
|
||||
(*it_element)->getMaxValue(),
|
||||
(*it_element)->isDefaultValid(),
|
||||
(*it_element)->getDefaultValue(),
|
||||
(*it_element)->isScaleValid(),
|
||||
(*it_element)->getScaleValue(),
|
||||
(*it_element)->isOffsetValid(),
|
||||
(*it_element)->getOffsetValue());
|
||||
}
|
||||
else if (ddl_struct)
|
||||
{
|
||||
*it_element = new DDLElement(ddl_struct,
|
||||
(*it_element)->getName(),
|
||||
(*it_element)->getBytepos(),
|
||||
(*it_element)->getArraysize(),
|
||||
(*it_element)->getByteorder(),
|
||||
(*it_element)->getAlignment(),
|
||||
*it_bu_found,
|
||||
(*it_element)->getBitpos(),
|
||||
(*it_element)->getNumBits(),
|
||||
(*it_element)->getDescription(),
|
||||
(*it_element)->getComment(),
|
||||
(*it_element)->getArraySizeSource(),
|
||||
(*it_element)->getConstantValue(),
|
||||
(*it_element)->isMinValid(),
|
||||
(*it_element)->getMinValue(),
|
||||
(*it_element)->isMaxValid(),
|
||||
(*it_element)->getMaxValue(),
|
||||
(*it_element)->isDefaultValid(),
|
||||
(*it_element)->getDefaultValue(),
|
||||
(*it_element)->isScaleValid(),
|
||||
(*it_element)->getScaleValue(),
|
||||
(*it_element)->isOffsetValid(),
|
||||
(*it_element)->getOffsetValue());
|
||||
}
|
||||
else
|
||||
{
|
||||
*it_element = new DDLElement(type,
|
||||
(*it_element)->getName(),
|
||||
(*it_element)->getBytepos(),
|
||||
(*it_element)->getArraysize(),
|
||||
(*it_element)->getByteorder(),
|
||||
(*it_element)->getAlignment(),
|
||||
*it_bu_found,
|
||||
(*it_element)->getBitpos(),
|
||||
(*it_element)->getNumBits(),
|
||||
(*it_element)->getDescription(),
|
||||
(*it_element)->getComment(),
|
||||
(*it_element)->getArraySizeSource(),
|
||||
(*it_element)->getConstantValue(),
|
||||
(*it_element)->isMinValid(),
|
||||
(*it_element)->getMinValue(),
|
||||
(*it_element)->isMaxValid(),
|
||||
(*it_element)->getMaxValue(),
|
||||
(*it_element)->isDefaultValid(),
|
||||
(*it_element)->getDefaultValue(),
|
||||
(*it_element)->isScaleValid(),
|
||||
(*it_element)->getScaleValue(),
|
||||
(*it_element)->isOffsetValid(),
|
||||
(*it_element)->getOffsetValue());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
(*it_struct)->setElements(elements);
|
||||
}
|
||||
_ddl_desc->refStructs(structs);
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
a_util::result::Result DDLCloner::buildStreams()
|
||||
{
|
||||
if (NULL == _original_desc)
|
||||
{
|
||||
return ERR_NOT_INITIALIZED;
|
||||
}
|
||||
// clone the streams
|
||||
DDLStreamVec streams = _original_desc->getStreams();
|
||||
DDLComplexVec structs = _ddl_desc->getStructs();
|
||||
for (DDLStreamIt it_stream = streams.begin();
|
||||
streams.end() != it_stream; ++it_stream)
|
||||
{
|
||||
// find type
|
||||
DDLComplexIt it_found = std::find_if(structs.begin(),
|
||||
structs.end(), DDLCompareFunctor<DDLComplex>((*it_stream)->getType()));
|
||||
if (structs.end() == it_found)
|
||||
{
|
||||
// type not found
|
||||
return ERR_NO_CLASS;
|
||||
}
|
||||
|
||||
// clone the contained stream structs
|
||||
DDLStreamStructVec strm_structs = (*it_stream)->getStructs();
|
||||
DDLVersion version = (*it_stream)->getDDLVersion();
|
||||
*it_stream = new DDLStream(*it_found, (*it_stream)->getName(),
|
||||
(*it_stream)->getDescription(), strm_structs,
|
||||
(*it_stream)->getCreationLevel());
|
||||
(*it_stream)->setDDLVersion(version);
|
||||
|
||||
for (DDLStreamStructIt it_struct = strm_structs.begin();
|
||||
strm_structs.end() != it_struct; ++it_struct)
|
||||
{
|
||||
// find type
|
||||
it_found = std::find_if(structs.begin(), structs.end(),
|
||||
DDLCompareFunctor<DDLComplex>((*it_struct)->getType()));
|
||||
if (structs.end() == it_found)
|
||||
{
|
||||
// type not found
|
||||
return ERR_NO_CLASS;
|
||||
}
|
||||
*it_struct = new DDLStreamStruct(*it_found,
|
||||
(*it_struct)->getBytepos(), (*it_struct)->getName());
|
||||
}
|
||||
(*it_stream)->refStructs(strm_structs);
|
||||
}
|
||||
_ddl_desc->refStreams(streams);
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
a_util::result::Result DDLCloner::setOriginal(const DDLDescription* original)
|
||||
{
|
||||
if (!original) { return ERR_POINTER; }
|
||||
_original_desc = original;
|
||||
return a_util::result::SUCCESS;
|
||||
}
|
||||
|
||||
a_util::result::Result ddl::DDLCloner::buildStreamMetaTypes()
|
||||
{
|
||||
return ERR_NOT_IMPL; ///@todo
|
||||
}
|
||||
|
||||
} // namespace ddl
|
||||
Loading…
Add table
Add a link
Reference in a new issue