diff --git a/Code/Ontology/Common/include/mapBijectivCorrelation.h b/Code/Ontology/Common/include/mapBijectivCorrelation.h index e98d1d8..ab08f38 100644 --- a/Code/Ontology/Common/include/mapBijectivCorrelation.h +++ b/Code/Ontology/Common/include/mapBijectivCorrelation.h @@ -1,55 +1,55 @@ // ----------------------------------------------------------------------- // MatchPoint - DKFZ translational registration framework // // Copyright c German Cancer Research Center DKFZ, // Software development for Integrated Diagnostics and Therapy SIDT. // ALL RIGHTS RESERVED. // See mapCopyright.txt or // http://www.dkfz.de/en/sidt/projects/MatchPoint/copyright.html // // This software is distributed WITHOUT ANY WARRANTY; without even // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the above copyright notices for more information. // //------------------------------------------------------------------------ #ifndef __MAP_BIJECTIV_CORRELATION_H #define __MAP_BIJECTIV_CORRELATION_H #include "mapInjectivCorrelation.h" #include "mapMAPOntologyExports.h" namespace iro { /** @class BijectivCorrelation * This class defines a semantic identity that is known and bijective. * Thus you know for the exact correspondence of one entity (element) * in the other information space. * @ingroup CorrelationType*/ - MAPOntology_EXPORT class BijectivCorrelation : public InjectivCorrelation + class MAPOntology_EXPORT BijectivCorrelation : public InjectivCorrelation { public: typedef BijectivCorrelation Self; typedef std::shared_ptr Pointer; typedef std::shared_ptr ConstPointer; /** Returns the identifier name of the correlation type.*/ virtual String getName() const; virtual ~BijectivCorrelation(); BijectivCorrelation(); private: BijectivCorrelation(const BijectivCorrelation&); //not implemented by purpose BijectivCorrelation& operator=(const BijectivCorrelation&); //not implemented by purpose }; } // end namespace iro #endif diff --git a/Code/Ontology/Common/include/mapDataRepresentation.h b/Code/Ontology/Common/include/mapDataRepresentation.h index 4c7ac40..89c3e5d 100644 --- a/Code/Ontology/Common/include/mapDataRepresentation.h +++ b/Code/Ontology/Common/include/mapDataRepresentation.h @@ -1,67 +1,67 @@ // ----------------------------------------------------------------------- // MatchPoint - DKFZ translational registration framework // // Copyright c German Cancer Research Center DKFZ, // Software development for Integrated Diagnostics and Therapy SIDT. // ALL RIGHTS RESERVED. // See mapCopyright.txt or // http://www.dkfz.de/en/sidt/projects/MatchPoint/copyright.html // // This software is distributed WITHOUT ANY WARRANTY; without even // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the above copyright notices for more information. // //------------------------------------------------------------------------ #ifndef __MAP_DATA_REPRESENTATION_H #define __MAP_DATA_REPRESENTATION_H #include "mapMAPOntologyExports.h" namespace iro { /*! @struct DataRepresentation * Struct defining the enum that indicates if an entity can be regarded as * continuous or discrete. This information is important to select proper * transformations in order to map the entity. * * Possible values: * - Discrete (e.g. voxel images) * - Continuous (e.g. points) */ - MAPOntology_EXPORT struct DataRepresentation + struct MAPOntology_EXPORT DataRepresentation { enum Type { Discrete = 1, Continuous = 2 }; }; /*! @struct DataRepresentationSupport Enum indicates the wanted or given support of continuous or discrete data Possible values: - Arbitrary - Discrete - Continuous - All */ - MAPOntology_EXPORT struct DataRepresentationSupport + struct MAPOntology_EXPORT DataRepresentationSupport { enum Type { Arbitrary = 0, Discrete = 1, Continuous = 2, All = 3 }; }; /** Conversion function for data representation type to data * representation support type.*/ - DataRepresentationSupport::Type convertToSupport(DataRepresentation::Type data); + MAPOntology_EXPORT DataRepresentationSupport::Type convertToSupport(DataRepresentation::Type data); } // end namespace iro #endif diff --git a/Code/Ontology/Common/include/mapIMappingIntegration.tpp b/Code/Ontology/Common/include/mapIMappingIntegration.tpp index a154615..6961336 100644 --- a/Code/Ontology/Common/include/mapIMappingIntegration.tpp +++ b/Code/Ontology/Common/include/mapIMappingIntegration.tpp @@ -1,148 +1,148 @@ // ----------------------------------------------------------------------- // MatchPoint - DKFZ translational registration framework // // Copyright c German Cancer Research Center DKFZ, // Software development for Integrated Diagnostics and Therapy SIDT. // ALL RIGHTS RESERVED. // See mapCopyright.txt or // http://www.dkfz.de/en/sidt/projects/MatchPoint/copyright.html // // This software is distributed WITHOUT ANY WARRANTY; without even // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the above copyright notices for more information. // //------------------------------------------------------------------------ #ifndef __MAP_I_MAPPING_INTEGRATION_TPP #define __MAP_I_MAPPING_INTEGRATION_TPP #include "mapIMappingIntegration.h" namespace iro { namespace core { template Result::ConstTransformationInfoPointer> IMappingIntegration:: defineTransformation(TransInfoInferencePointer newTransformation) { assert(_pEntityInferenceInterface); assert(_pProblemInferenceInterface); if (!newTransformation) { throw exceptions::InvalidArgument("Cannot define transformation info. Passed transformation info pointer is NULL."); } typedef typename InformationSpaceTraitsType::ConstPointer ConstInfSpacePointer; ConstInfSpacePointer movingIS = _pEntityInferenceInterface->actualize(newTransformation->getMovingIS()); if (!movingIS) { throw exceptions::UndefinedElement("Cannot define transformation info. Referenced moving IS is not defined in the ontology."); } ConstInfSpacePointer targetIS = _pEntityInferenceInterface->actualize(newTransformation->getTargetIS()); if (!targetIS) { throw exceptions::UndefinedElement("Cannot define transformation info. Referenced target IS is not defined in the ontology."); } if (newTransformation->getAssociatedProblemStatement()) { typedef typename ProblemStatementTraitsType::ConstPointer ConstStatPointer; ConstStatPointer stat = _pProblemInferenceInterface->actualize(newTransformation->getAssociatedProblemStatement()); if (!stat) { throw exceptions::UndefinedElement("Cannot define transformation info. Referenced problem statement is not defined in the ontology."); } } return doDefineTransformation(newTransformation); }; template Result::ConstTransformationInfoPointer> IMappingIntegration:: storeTransformation(TransInfoInferencePointer transformation) { assert(_pEntityInferenceInterface); assert(_pProblemInferenceInterface); if (!transformation) { throw exceptions::InvalidArgument("Cannot store transformation info. Passed transformation info pointer is NULL."); } typedef typename InformationSpaceTraitsType::ConstPointer ConstInfSpacePointer; ConstInfSpacePointer movingIS = _pEntityInferenceInterface->actualize(transformation->getMovingIS()); if (!movingIS) { throw exceptions::UndefinedElement("Cannot store transformation info. Referenced moving IS is not defined in the ontology."); } ConstInfSpacePointer targetIS = _pEntityInferenceInterface->actualize(transformation->getTargetIS()); if (!targetIS) { throw exceptions::UndefinedElement("Cannot store transformation info. Referenced target IS is not defined in the ontology."); } - if (transformation->GetAssociatedProblemStatement()) + if (transformation->getAssociatedProblemStatement()) { typedef typename ProblemStatementTraitsType::ConstPointer ConstStatPointer; - ConstStatPointer stat = _pProblemInferenceInterface->actualize(transformation->GetAssociatedProblemStatement()); + ConstStatPointer stat = _pProblemInferenceInterface->actualize(transformation->getAssociatedProblemStatement()); if (!stat) { throw exceptions::UndefinedElement("Cannot store transformation info. Referenced problem statement is not defined in the ontology."); } } return doStoreTransformation(transformation); }; template typename IMappingIntegration::TransformationDeleteReturnType IMappingIntegration:: deleteTransformation(TransInfoInferencePointer transformation) { if (!transformation) { throw exceptions::InvalidArgument("Cannot delete transformation. Passed entity pointer is NULL."); } return doDeleteTransformation(transformation); }; template void IMappingIntegration:: setEntityInferenceInterface(const EntityInferenceInterface* pInterface) { _pEntityInferenceInterface = pInterface; }; template void IMappingIntegration:: setProblemInferenceInterface(const ProblemInferenceInterface* pInterface) { _pProblemInferenceInterface = pInterface; }; } // end namespace core } // end namespace iro #endif diff --git a/Code/Ontology/Common/include/mapISemanticCorrelationType.h b/Code/Ontology/Common/include/mapISemanticCorrelationType.h index b69384e..e081810 100644 --- a/Code/Ontology/Common/include/mapISemanticCorrelationType.h +++ b/Code/Ontology/Common/include/mapISemanticCorrelationType.h @@ -1,55 +1,57 @@ // ----------------------------------------------------------------------- // MatchPoint - DKFZ translational registration framework // // Copyright c German Cancer Research Center DKFZ, // Software development for Integrated Diagnostics and Therapy SIDT. // ALL RIGHTS RESERVED. // See mapCopyright.txt or // http://www.dkfz.de/en/sidt/projects/MatchPoint/copyright.html // // This software is distributed WITHOUT ANY WARRANTY; without even // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the above copyright notices for more information. // //------------------------------------------------------------------------ #ifndef __MAP_I_SEMANTIC_CORRELATION_TYPE_H #define __MAP_I_SEMANTIC_CORRELATION_TYPE_H #include "mapOntologyString.h" #include +#include "mapMAPOntologyExports.h" + namespace iro { /** @class ISemanticCorrelationType *Interface for all kind of correlation types. * @ingroup CorrelationType Interfaces */ - class ISemanticCorrelationType + class MAPOntology_EXPORT ISemanticCorrelationType { public: typedef ISemanticCorrelationType Self; typedef std::shared_ptr Pointer; typedef std::shared_ptr ConstPointer; /** Checks if the type of this and pType are equal by comparing there names.*/ bool equals(const ISemanticCorrelationType* pType) const; /** Returns the identifier name of the correlation type.*/ virtual String getName() const = 0; protected: virtual ~ISemanticCorrelationType(); ISemanticCorrelationType(); private: ISemanticCorrelationType(const ISemanticCorrelationType&); //not implemented by purpose ISemanticCorrelationType& operator=(const ISemanticCorrelationType&); //not implemented by purpose }; } // end namespace iro #endif diff --git a/Code/Ontology/Common/include/mapInjectivCorrelation.h b/Code/Ontology/Common/include/mapInjectivCorrelation.h index 9f9f60c..645a4a5 100644 --- a/Code/Ontology/Common/include/mapInjectivCorrelation.h +++ b/Code/Ontology/Common/include/mapInjectivCorrelation.h @@ -1,54 +1,54 @@ // ----------------------------------------------------------------------- // MatchPoint - DKFZ translational registration framework // // Copyright c German Cancer Research Center DKFZ, // Software development for Integrated Diagnostics and Therapy SIDT. // ALL RIGHTS RESERVED. // See mapCopyright.txt or // http://www.dkfz.de/en/sidt/projects/MatchPoint/copyright.html // // This software is distributed WITHOUT ANY WARRANTY; without even // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the above copyright notices for more information. // //------------------------------------------------------------------------ #ifndef __MAP_INJECTIV_CORRELATION_H #define __MAP_INJECTIV_CORRELATION_H #include "mapUnkownBijectivCorrelation.h" #include "mapMAPOntologyExports.h" namespace iro { /** @class InjectivCorrelation * This class defines a semantic identity that is known but injective. * Thus you know the exact correspondence between the entities but it cover the entities only in parts * (e.g. the same set of intrinsic landmarks in different images and it is not guaranteed that all landmarks * are visible in all images. But the landmarks are uniquely identified, so when there is a landmark in to images * you are able to determin this). * @ingroup CorrelationType*/ - MAPOntology_EXPORT class InjectivCorrelation : public UnkownBijectivCorrelation + class MAPOntology_EXPORT InjectivCorrelation : public UnkownBijectivCorrelation { public: typedef InjectivCorrelation Self; typedef std::shared_ptr Pointer; typedef std::shared_ptr ConstPointer; /** Returns the identifier name of the correlation type.*/ virtual String getName() const; virtual ~InjectivCorrelation(); InjectivCorrelation(); private: InjectivCorrelation(const InjectivCorrelation&); //not implemented by purpose InjectivCorrelation& operator=(const InjectivCorrelation&); //not implemented by purpose }; } // end namespace iro #endif diff --git a/Code/Ontology/Common/include/mapOntologyExceptions.h b/Code/Ontology/Common/include/mapOntologyExceptions.h index 0033da6..af1a19b 100644 --- a/Code/Ontology/Common/include/mapOntologyExceptions.h +++ b/Code/Ontology/Common/include/mapOntologyExceptions.h @@ -1,85 +1,85 @@ // ----------------------------------------------------------------------- // MatchPoint - DKFZ translational registration framework // // Copyright c German Cancer Research Center DKFZ, // Software development for Integrated Diagnostics and Therapy SIDT. // ALL RIGHTS RESERVED. // See mapCopyright.txt or // http://www.dkfz.de/en/sidt/projects/MatchPoint/copyright.html // // This software is distributed WITHOUT ANY WARRANTY; without even // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the above copyright notices for more information. // //------------------------------------------------------------------------ #ifndef __MAP_EXCEPTIONS_H #define __MAP_EXCEPTIONS_H #include #include "mapOntologyString.h" #include "mapMAPOntologyExports.h" namespace iro { namespace exceptions { - typedef ::std::invalid_argument InvalidArgument; + MAPOntology_EXPORT typedef ::std::invalid_argument InvalidArgument; /** @class InvalidIS * Exception class that is thrown when an problem correlated with * information spaces occures * @ingroup Exception*/ - MAPOntology_EXPORT class InvalidIS : public InvalidArgument + class MAPOntology_EXPORT InvalidIS : public InvalidArgument { public: explicit InvalidIS (const String& what_arg); }; /** @class InvalidMovingIS * Exception class that is thrown when an problem correlated with * moving information spaces occures * @ingroup Exception*/ - MAPOntology_EXPORT class InvalidMovingIS : public InvalidIS + class MAPOntology_EXPORT InvalidMovingIS : public InvalidIS { public: explicit InvalidMovingIS (const String& what_arg); }; /** @class InvalidTargetIS * Exception class that is thrown when an problem correlated with * target information spaces occures * @ingroup Exception*/ - MAPOntology_EXPORT class InvalidTargetIS : public InvalidIS + class MAPOntology_EXPORT InvalidTargetIS : public InvalidIS { public: explicit InvalidTargetIS (const String& what_arg); }; /** @class InvalidDataRepresentation * Exception class that is thrown when an problem correlated with * invalid data representation support occures * @ingroup Exception*/ - MAPOntology_EXPORT class InvalidDataRepresentation : public InvalidArgument + class MAPOntology_EXPORT InvalidDataRepresentation : public InvalidArgument { public: explicit InvalidDataRepresentation (const String& what_arg); }; /** @class UndefinedElement * Exception class that is thrown when an element is used for * inference or integration that is not part of the ontology * @ingroup Exceptions*/ - MAPOntology_EXPORT class UndefinedElement : public InvalidArgument + class MAPOntology_EXPORT UndefinedElement : public InvalidArgument { public: explicit UndefinedElement (const String& what_arg); }; } // end namespace exceptions } // end namespace iro #endif diff --git a/Code/Ontology/Common/include/mapUnkownBijectivCorrelation.h b/Code/Ontology/Common/include/mapUnkownBijectivCorrelation.h index 3e098ec..6ac5ae6 100644 --- a/Code/Ontology/Common/include/mapUnkownBijectivCorrelation.h +++ b/Code/Ontology/Common/include/mapUnkownBijectivCorrelation.h @@ -1,51 +1,51 @@ // ----------------------------------------------------------------------- // MatchPoint - DKFZ translational registration framework // // Copyright c German Cancer Research Center DKFZ, // Software development for Integrated Diagnostics and Therapy SIDT. // ALL RIGHTS RESERVED. // See mapCopyright.txt or // http://www.dkfz.de/en/sidt/projects/MatchPoint/copyright.html // // This software is distributed WITHOUT ANY WARRANTY; without even // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the above copyright notices for more information. // //------------------------------------------------------------------------ #ifndef __MAP_UNKOWN_BIJECTIV_CORRELATION_H #define __MAP_UNKOWN_BIJECTIV_CORRELATION_H #include "mapUnkownInjectivCorrelation.h" #include "mapMAPOntologyExports.h" namespace iro { /** @class UnkownBijectivCorrelation * This class defines a semantic identity that is unkown but bijective. * Thus you know that to entities have exact correspondence (e.g. the same set of markers in different images) * but it is unknown how they match exactly (e.g. which marker is displayed in certain renderings in the image). * @ingroup CorrelationType*/ - MAPOntology_EXPORT class UnkownBijectivCorrelation : public UnkownInjectivCorrelation + class MAPOntology_EXPORT UnkownBijectivCorrelation : public UnkownInjectivCorrelation { public: typedef UnkownBijectivCorrelation Self; typedef std::shared_ptr Pointer; typedef std::shared_ptr ConstPointer; /** Returns the identifier name of the correlation type.*/ virtual String getName() const; virtual ~UnkownBijectivCorrelation(); UnkownBijectivCorrelation(); private: UnkownBijectivCorrelation(const UnkownBijectivCorrelation&); //not implemented by purpose UnkownBijectivCorrelation& operator=(const UnkownBijectivCorrelation&); //not implemented by purpose }; } // end namespace iro #endif diff --git a/Code/Ontology/Common/include/mapUnkownInjectivCorrelation.h b/Code/Ontology/Common/include/mapUnkownInjectivCorrelation.h index 61dc5b2..154b1f0 100644 --- a/Code/Ontology/Common/include/mapUnkownInjectivCorrelation.h +++ b/Code/Ontology/Common/include/mapUnkownInjectivCorrelation.h @@ -1,53 +1,53 @@ // ----------------------------------------------------------------------- // MatchPoint - DKFZ translational registration framework // // Copyright c German Cancer Research Center DKFZ, // Software development for Integrated Diagnostics and Therapy SIDT. // ALL RIGHTS RESERVED. // See mapCopyright.txt or // http://www.dkfz.de/en/sidt/projects/MatchPoint/copyright.html // // This software is distributed WITHOUT ANY WARRANTY; without even // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the above copyright notices for more information. // //------------------------------------------------------------------------ #ifndef __MAP_UNKOWN_INJECTIV_CORRELATION_H #define __MAP_UNKOWN_INJECTIV_CORRELATION_H #include "mapISemanticCorrelationType.h" #include "mapMAPOntologyExports.h" namespace iro { /** @class UnkownInjectivCorrelation * This class defines a semantic identity that is unknown but injective. * Thus you know that the entities are partly correspondent * (e.g. the same set of markers in different images but it is not guaranteed * that all landmarks are visible in all images), but you don't know which parts * correspond. The weakest of all correlations. * @ingroup CorrelationType*/ - MAPOntology_EXPORT class UnkownInjectivCorrelation : public ISemanticCorrelationType + class MAPOntology_EXPORT UnkownInjectivCorrelation : public ISemanticCorrelationType { public: typedef UnkownInjectivCorrelation Self; typedef std::shared_ptr Pointer; typedef std::shared_ptr ConstPointer; /** Returns the identifier name of the correlation type.*/ virtual String getName() const; virtual ~UnkownInjectivCorrelation(); UnkownInjectivCorrelation(); private: UnkownInjectivCorrelation(const UnkownInjectivCorrelation&); //not implemented by purpose UnkownInjectivCorrelation& operator=(const UnkownInjectivCorrelation&); //not implemented by purpose }; } // end namespace iro #endif diff --git a/Code/Ontology/Simple/include/mapBoostUIDPolicy.h b/Code/Ontology/Simple/include/mapBoostUIDPolicy.h index cb37ba8..3f41956 100644 --- a/Code/Ontology/Simple/include/mapBoostUIDPolicy.h +++ b/Code/Ontology/Simple/include/mapBoostUIDPolicy.h @@ -1,40 +1,40 @@ // ----------------------------------------------------------------------- // MatchPoint - DKFZ translational registration framework // // Copyright c German Cancer Research Center DKFZ, // Software development for Integrated Diagnostics and Therapy SIDT. // ALL RIGHTS RESERVED. // See mapCopyright.txt or // http://www.dkfz.de/en/sidt/projects/MatchPoint/copyright.html // // This software is distributed WITHOUT ANY WARRANTY; without even // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the above copyright notices for more information. // //------------------------------------------------------------------------ #ifndef __MAP_BOOST_UID_POLICY_H #define __MAP_BOOST_UID_POLICY_H #include "mapMAPOntologySimpleExports.h" #include "boost/uuid/uuid.hpp" namespace iro { /*! @struct BoostUIDPolicy * @brief Policy for using boost::uuid as UID in MatchPoint ontologies. * * @ingroup UIDPolicy */ - MAPOntologySimple_EXPORT struct BoostUIDPolicy + struct MAPOntologySimple_EXPORT BoostUIDPolicy { typedef boost::uuids::uuid UIDType; static UIDType generateUID(); }; } // end namespace iro #endif diff --git a/Code/Ontology/Simple/include/mapSimpleInformationEntity.h b/Code/Ontology/Simple/include/mapSimpleInformationEntity.h index 5580d07..9130612 100644 --- a/Code/Ontology/Simple/include/mapSimpleInformationEntity.h +++ b/Code/Ontology/Simple/include/mapSimpleInformationEntity.h @@ -1,94 +1,94 @@ // ----------------------------------------------------------------------- // MatchPoint - DKFZ translational registration framework // // Copyright c German Cancer Research Center DKFZ, // Software development for Integrated Diagnostics and Therapy SIDT. // ALL RIGHTS RESERVED. // See mapCopyright.txt or // http://www.dkfz.de/en/sidt/projects/MatchPoint/copyright.html // // This software is distributed WITHOUT ANY WARRANTY; without even // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the above copyright notices for more information. // //------------------------------------------------------------------------ #ifndef __MAP_SIMPLE_INFORMATION_ENTITY_H #define __MAP_SIMPLE_INFORMATION_ENTITY_H #include #include "mapDataRepresentation.h" #include "mapInformationEntityTraits.h" #include "mapOntologyString.h" #include "mapMAPOntologySimpleExports.h" namespace iro { namespace scenario { /*! @class SimpleInformationEntity * @brief Simple specific implementation of an InformationEntity * Uses a string type to store the UID. * @ingroup Simple*/ - MAPOntologySimple_EXPORT class SimpleInformationEntity + class MAPOntologySimple_EXPORT SimpleInformationEntity { public: typedef SimpleInformationEntity Self; typedef ::iro::String UIDType; typedef DataRepresentation::Type DataRepresentationType; typedef std::shared_ptr< Self > Pointer; typedef std::shared_ptr< const Self > ConstPointer; /*! returns the UID of the statement.*/ const UIDType& getUID() const; void setUID(const UIDType& uid); const DataRepresentationType& getDataRepresentation() const; void setDataRepresentation(const DataRepresentationType& rep); virtual ~SimpleInformationEntity(); SimpleInformationEntity(); bool operator == (const Self& is) const; /** Clones the content of the information entity and returns it as * non const pointer. It can be used to alter the entity and * update the knowledge base of the ontology. */ Pointer clone() const; protected: UIDType _uid; DataRepresentationType _dataRep; private: SimpleInformationEntity(const Self&); //not implemented by purpose Self& operator=(const Self&); //not implemented by purpose }; /*! @struct SimpleEntityIdentificationPolicy * @brief Policy used in the information entity traits to check if the passed entity has a given UID. * @ingroup Simple */ struct SimpleEntityIdentificationPolicy { using UIDType = ::iro::scenario::SimpleInformationEntity::UIDType; static bool identifyEntity(const ::iro::scenario::SimpleInformationEntity& pEntity, const UIDType& uid) { return pEntity.getUID() == uid; }; }; using SimpleInformationEntityTraits = InformationEntityTraits<::iro::scenario::SimpleInformationEntity, SimpleEntityIdentificationPolicy>; } // end namespace scenario } // end namespace iro #endif diff --git a/Code/Ontology/Simple/include/mapSimpleInformationSpace.h b/Code/Ontology/Simple/include/mapSimpleInformationSpace.h index 71fac23..d686bd7 100644 --- a/Code/Ontology/Simple/include/mapSimpleInformationSpace.h +++ b/Code/Ontology/Simple/include/mapSimpleInformationSpace.h @@ -1,75 +1,75 @@ // ----------------------------------------------------------------------- // MatchPoint - DKFZ translational registration framework // // Copyright c German Cancer Research Center DKFZ, // Software development for Integrated Diagnostics and Therapy SIDT. // ALL RIGHTS RESERVED. // See mapCopyright.txt or // http://www.dkfz.de/en/sidt/projects/MatchPoint/copyright.html // // This software is distributed WITHOUT ANY WARRANTY; without even // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the above copyright notices for more information. // //------------------------------------------------------------------------ #ifndef __MAP_SIMPLE_INFORMATION_SPACE_H #define __MAP_SIMPLE_INFORMATION_SPACE_H #include #include "mapInformationSpaceTraits.h" #include "mapOntologyString.h" #include "mapMAPOntologySimpleExports.h" namespace iro { namespace scenario { /*! @class SimpleInformationSpace * @brief Simple specific implementation of an information space * Uses a string type to store the UID. * @ingroup Simple*/ - MAPOntologySimple_EXPORT class SimpleInformationSpace + class MAPOntologySimple_EXPORT SimpleInformationSpace { public: typedef SimpleInformationSpace Self; typedef ::iro::String UIDType; typedef std::shared_ptr< Self > Pointer; typedef std::shared_ptr< const Self > ConstPointer; /*! returns the UID of the statement.*/ const UIDType& getUID() const; void setUID(const UIDType& uid); virtual ~SimpleInformationSpace(); SimpleInformationSpace(); bool operator == (const Self& is) const; /** Clones the content of the information space and returns it as * non const pointer. It can be used to alter the entity and * update the knowledge base of the ontology. */ Pointer clone() const; protected: UIDType _uid; private: SimpleInformationSpace(const Self&); //not implemented by purpose Self& operator=(const Self&); //not implemented by purpose }; using SimpleInformationSpaceTraits = InformationSpaceTraits<::iro::scenario::SimpleInformationSpace>; } // end namespace scenario } // end namespace iro #endif diff --git a/Code/Ontology/Simple/include/mapSimpleOntology.h b/Code/Ontology/Simple/include/mapSimpleOntology.h index 7712f77..3465ac7 100644 --- a/Code/Ontology/Simple/include/mapSimpleOntology.h +++ b/Code/Ontology/Simple/include/mapSimpleOntology.h @@ -1,385 +1,385 @@ // ----------------------------------------------------------------------- // MatchPoint - DKFZ translational registration framework // // Copyright c German Cancer Research Center DKFZ, // Software development for Integrated Diagnostics and Therapy SIDT. // ALL RIGHTS RESERVED. // See mapCopyright.txt or // http://www.dkfz.de/en/sidt/projects/MatchPoint/copyright.html // // This software is distributed WITHOUT ANY WARRANTY; without even // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the above copyright notices for more information. // //------------------------------------------------------------------------ #ifndef __MAP_SIMPLE_ONTOLOGY_H #define __MAP_SIMPLE_ONTOLOGY_H #include "mapOntologyAccess.h" #include "mapSimpleRegPathOptionCollection.h" #include "mapSimpleTransPathOptionCollection.h" #include "mapSimpleAlgorithmExecutionInfo.h" #include "mapSimpleProblemModel.h" #include "mapSimpleSemanticCorrelation.h" #include "mapMAPOntologySimpleExports.h" namespace iro { namespace scenario { struct SimpleOntologyAccessTraits : public iro::core::OntologyAccessTraits < SimpleRegistrationPathTraits, SimpleRegPathOptionCollectionTraits, SimpleTransPathOptionCollectionTraits, SimpleSemanticCorrelationTraits, SimpleProblemModelTraits> {}; template class SimpleOntologyCore; /*! @class SimpleOntology * @brief Simple specific implementation of the ontology * @ingroup Simple*/ - MAPOntologySimple_EXPORT class SimpleOntology : public iro::core::OntologyAccess + class MAPOntologySimple_EXPORT SimpleOntology : public iro::core::OntologyAccess { public: typedef SimpleOntology Self; typedef std::shared_ptr< Self > Pointer; typedef std::shared_ptr< const Self > ConstPointer; using Superclass = iro::core::OntologyAccess; using EntityInferenceInterface = Superclass::EntityInferenceInterface; using MappingInferenceInterface = Superclass::MappingInferenceInterface; using ProblemInferenceInterface = Superclass::ProblemInferenceInterface; using EntityIntegrationInterface = Superclass::EntityIntegrationInterface; using MappingIntegrationInterface = Superclass::MappingIntegrationInterface; typedef EntityInferenceInterface::InfEntityType InfEntityType; typedef EntityInferenceInterface::InfSpaceType InfSpaceType; typedef EntityInferenceInterface::CorrelationType CorrelationType; typedef EntityInferenceInterface::ConstInfEntityPointer ConstInfEntityPointer; typedef EntityInferenceInterface::ConstInfSpacePointer ConstInfSpacePointer; typedef EntityInferenceInterface::ConstCorrelationPointer ConstCorrelationPointer; typedef EntityInferenceInterface::InfEntityInferencePointer InfEntityInferencePointer; typedef EntityInferenceInterface::InfSpaceInferencePointer InfSpaceInferencePointer; typedef EntityInferenceInterface::CorrelationInferencePointer CorrelationInferencePointer; typedef EntityInferenceInterface::ConstInfEntityVectorType ConstInfEntityVectorType; typedef EntityInferenceInterface::ConstInfSpaceVectorType ConstInfSpaceVectorType; typedef EntityInferenceInterface::ConstCorrelationVectorType ConstCorrelationVectorType; typedef MappingInferenceInterface::ProblemComplianceInterface ProblemComplianceInterface; typedef MappingInferenceInterface::RegistrationPathType RegistrationPathType; typedef MappingInferenceInterface::ConstRegistrationPathPointer ConstRegistrationPathPointer; typedef MappingInferenceInterface::TransformationPathType TransformationPathType; typedef MappingInferenceInterface::ConstTransformationPathPointer ConstTransformationPathPointer; typedef MappingInferenceInterface::RegPathOptCollectionType RegPathOptCollectionType; typedef MappingInferenceInterface::ConstRegPathOptColPointer ConstRegPathOptColPointer; typedef MappingInferenceInterface::ConstRegPathOptColVectorType ConstRegPathOptColVectorType; typedef RegPathOptCollectionType::OptionType RegPathOptionType; typedef RegPathOptCollectionType::ConstOptionPointer ConstRegPathOptionPointer; typedef MappingInferenceInterface::TransPathOptCollectionType TransPathOptCollectionType; typedef MappingInferenceInterface::ConstTransPathOptColPointer ConstTransPathOptColPointer; typedef MappingInferenceInterface::ConstTransPathOptColVectorType ConstTransPathOptColVectorType; typedef TransPathOptCollectionType::OptionType TransPathOptionType; typedef TransPathOptCollectionType::ConstOptionPointer ConstTransPathOptionPointer; typedef ProblemInferenceInterface::ProblemStatementType ProblemStatementType; typedef ProblemInferenceInterface::ConstProblemStatementPointer ConstProblemStatementPointer; typedef ProblemInferenceInterface::ProblemStatementInferencePointer ProblemStatementInferencePointer; typedef ProblemInferenceInterface::ConstProblemStatementVectorType ConstProblemStatementVectorType; typedef ProblemInferenceInterface::ProblemModelType ProblemModelType; typedef ProblemInferenceInterface::ConstProblemModelPointer ConstProblemModelPointer; typedef ProblemInferenceInterface::ProblemModelInferencePointer ProblemModelInferencePointer; typedef ProblemInferenceInterface::ConstProblemModelVectorType ConstProblemModelVectorType; typedef ProblemInferenceInterface::ProblemAssociatedInterface ProblemAssociatedInterface; typedef EntityIntegrationInterface::EntityDeleteReturnType EntityDeleteReturnType; typedef EntityIntegrationInterface::ISDeleteReturnType ISDeleteReturnType; typedef EntityIntegrationInterface::CorrelationDeleteReturnType CorrelationDeleteReturnType; typedef MappingIntegrationInterface::TransInfoInferencePointer TransInfoInferencePointer; typedef MappingIntegrationInterface::ConstTransformationInfoPointer ConstTransformationInfoPointer; typedef MappingIntegrationInterface::TransformationDeleteReturnType TransformationDeleteReturnType; /** Resets the complete ontology. Revision number will be increased and is keept consistent.*/ void reset(); virtual ~SimpleOntology(); SimpleOntology(); protected: /////////////////////////////////////////////////////////////// // Entity Inference /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getContainingIS*/ virtual Result doGetContainingIS(InfEntityInferencePointer pEntity) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getEntitiesInIS*/ virtual Result doGetEntitiesInIS(InfSpaceInferencePointer pIS) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see checkForSameIS*/ virtual Result doCheckForSameIS(InfEntityInferencePointer pEntity1, InfEntityInferencePointer pEntity2) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see checkForSameIS*/ virtual Result doCheckForSameIS(const ConstInfEntityVectorType& entities) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getEntitiesWithSemanticCorrelations*/ virtual Result doGetEntitiesWithSemanticCorrelations(InfEntityInferencePointer pEntity) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getSemanticallyCorrelatedEntities*/ virtual Result doGetSemanticallyCorrelatedEntities(InfSpaceInferencePointer pSourceIS, InfSpaceInferencePointer pCorrelatedIS) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getSemanticCorrelations*/ virtual Result doGetSemanticCorrelations(InfSpaceInferencePointer pIS1, InfSpaceInferencePointer pIS2) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getSemanticCorrelations*/ virtual Result doGetSemanticCorrelations(InfEntityInferencePointer pEntity, InfSpaceInferencePointer pIs) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getSemanticCorrelations*/ virtual Result doGetSemanticCorrelations(InfEntityInferencePointer pEntity1, InfEntityInferencePointer pEntity2) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getDataRepresentationType*/ virtual Result doGetDataRepresentationType(InfEntityInferencePointer pEntity) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see hasDiscreteDataRepresentation*/ virtual Result doHasDiscreteDataRepresentation(InfEntityInferencePointer pEntity) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see hasContinuousDataRepresentation*/ virtual Result doHasContinuousDataRepresentation(InfEntityInferencePointer pEntity) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getEntities*/ virtual Result doGetEntities() const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getInformationSpaces*/ virtual Result doGetInformationSpaces() const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getSemanticCorrelations*/ virtual Result doGetSemanticCorrelations() const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see actualize*/ virtual Result doActualize(InfEntityInferencePointer pEntity) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see actualize*/ virtual Result doActualize(InfSpaceInferencePointer pIS) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see actualize*/ virtual Result doActualize(CorrelationInferencePointer corr) const; /////////////////////////////////////////////////////////////// // Entity Integration /*! virtual abstract part of the NVI idiom. See public member for more information. *@see defineEntity*/ virtual Result doDefineEntity(InfEntityInferencePointer pNewEntity, InfSpaceInferencePointer pContainingIS); /*! virtual abstract part of the NVI idiom. See public member for more information. *@see storeEntity*/ virtual Result doStoreEntity(InfEntityInferencePointer pEntity); /*! virtual abstract part of the NVI idiom. See public member for more information. *@see convertTransformationToRegistrationPath*/ virtual EntityDeleteReturnType doDeleteEntity(InfEntityInferencePointer pEntity); /*! virtual abstract part of the NVI idiom. See public member for more information. *@see defineInformationSpace*/ virtual Result doDefineInformationSpace(InfSpaceInferencePointer pNewIS); /*! virtual abstract part of the NVI idiom. See public member for more information. *@see storeInformationSpace*/ virtual Result doStoreInformationSpace(InfSpaceInferencePointer pIS); /*! virtual abstract part of the NVI idiom. See public member for more information. *@see deleteInformationSpace*/ virtual ISDeleteReturnType doDeleteInformationSpace(InfSpaceInferencePointer pIS); /*! virtual abstract part of the NVI idiom. See public member for more information. *@see switchInformationSpace*/ virtual void doSwitchInformationSpace(InfEntityInferencePointer pEntity, InfSpaceInferencePointer pNewIS); /*! virtual abstract part of the NVI idiom. See public member for more information. *@see defineSemanticCorrelation*/ virtual Result doDefineSemanticCorrelation(CorrelationInferencePointer pNewCorr); /*! virtual abstract part of the NVI idiom. See public member for more information. *@see storeSemanticCorrelation*/ virtual Result doStoreSemanticCorrelation(CorrelationInferencePointer corr); /*! virtual abstract part of the NVI idiom. See public member for more information. *@see deleteSemanticCorrelation*/ virtual CorrelationDeleteReturnType doDeleteSemanticCorrelation(CorrelationInferencePointer corr); /////////////////////////////////////////////////////////////// // Mapping inference /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getRegistrationPaths*/ virtual Result doGetRegistrationPaths(InfSpaceInferencePointer pMovingIS, InfSpaceInferencePointer pFixedIS, const ProblemComplianceInterface* pProblemCompliance = NULL) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getRegistrationPaths*/ virtual Result doGetRegistrationPaths(const ConstInfEntityVectorType& movingEntities, InfSpaceInferencePointer pFixedIS, const ProblemComplianceInterface* pProblemCompliance = NULL) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getTransformationPaths*/ virtual Result doGetTransformationPaths(InfSpaceInferencePointer pMovingIS, InfSpaceInferencePointer pFixedIS, const ProblemComplianceInterface* pProblemCompliance = NULL) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getTransformationPaths*/ virtual Result doGetTransformationPaths(const ConstInfEntityVectorType& movingEntities, InfSpaceInferencePointer pFixedIS, const ProblemComplianceInterface* pProblemCompliance = NULL) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getOptimalRegistrationPaths*/ virtual Result doGetOptimalRegistrationPaths(InfSpaceInferencePointer pMovingIS, InfSpaceInferencePointer pFixedIS, DataRepresentationSupport::Type requiredDataSupport, const ProblemComplianceInterface* pProblemCompliance = NULL, const RegPathMetricInterface* pMetric = NULL) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getOptimalRegistrationPaths*/ virtual Result doGetOptimalRegistrationPaths(const ConstInfEntityVectorType& movingEntities, InfSpaceInferencePointer pFixedIS, const ProblemComplianceInterface* pProblemCompliance = NULL, const RegPathMetricInterface* pMetric = NULL) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getOptimalTransformationPaths*/ virtual Result doGetOptimalTransformationPaths(InfSpaceInferencePointer pMovingIS, InfSpaceInferencePointer pFixedIS, const ProblemComplianceInterface* pProblemCompliance = NULL, const TransPathMetricInterface* pMetric = NULL) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getOptimalTransformationPaths*/ virtual Result doGetOptimalTransformationPaths(const ConstInfEntityVectorType& movingEntities, InfSpaceInferencePointer pFixedIS, const ProblemComplianceInterface* pProblemCompliance = NULL, const TransPathMetricInterface* pMetric = NULL) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getMappableInformationSpaces*/ virtual Result doGetMappableInformationSpaces(InfSpaceInferencePointer pFixedIS, DataRepresentationSupport::Type requiredDataSupport = DataRepresentationSupport::All, const ProblemComplianceInterface* pProblemCompliance = NULL, const RegPathMetricInterface* pMetric = NULL) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see checkForMappingFailureReason*/ virtual Result doCheckForMappingFailureReason(InfEntityInferencePointer pMovingEntity, InfSpaceInferencePointer pFixedIS, const ProblemComplianceInterface* pProblemCompliance = NULL) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see checkForMappingFailureReason*/ virtual Result doCheckForMappingFailureReason(InfSpaceInferencePointer pMovingIS, InfSpaceInferencePointer pFixedIS, DataRepresentationSupport::Type requiredDataSupport = DataRepresentationSupport::All, const ProblemComplianceInterface* pProblemCompliance = NULL) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see checkForMappingFailureReason*/ virtual Result doCheckForMappingFailureReason(InfEntityInferencePointer pMovingEntity, ConstRegistrationPathPointer pPath) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see checkForMappingFailureReason*/ virtual Result doCheckForMappingFailureReason(InfEntityInferencePointer pMovingEntity, ConstTransformationPathPointer pPath) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see convertTransformationToRegistrationPath*/ virtual Result doConvertTransformationToRegistrationPath(ConstTransformationPathPointer pPath) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see actualize*/ virtual Result doActualize(TransformationInfoInferencePointer pTI) const; /////////////////////////////////////////////////////////////// // Mapping Integration /*! virtual abstract part of the NVI idiom. See public member for more information. *@see defineTransformation*/ virtual Result doDefineTransformation(TransInfoInferencePointer newTransformation); /*! virtual abstract part of the NVI idiom. See public member for more information. *@see storeTransformation*/ virtual Result doStoreTransformation(TransInfoInferencePointer transformation); /*! virtual abstract part of the NVI idiom. See public member for more information. *@see deleteTransformation*/ virtual TransformationDeleteReturnType doDeleteTransformation(TransInfoInferencePointer transformation); /////////////////////////////////////////////////////////////// // Problem Inference /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getAssociatedProblemModels*/ virtual Result doGetAssociatedProblemModels(ProblemStatementInferencePointer ps) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see geProblemModels*/ virtual Result doGetProblemModels() const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see getProblemStatements*/ virtual Result doGetProblemStatements() const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see actualize*/ virtual Result doActualize(ProblemStatementInferencePointer ps) const; /*! virtual abstract part of the NVI idiom. See public member for more information. *@see actualize*/ virtual Result doActualize(ProblemModelInferencePointer pm) const; /////////////////////////////////////////////////////////////// // Problem Integration /*! virtual abstract part of the NVI idiom. See public member for more information. *@see defineProblemStatement*/ virtual Result doDefineProblemStatement(ProblemStatementInferencePointer pNewStatement); /*! virtual abstract part of the NVI idiom. See public member for more information. *@see storeProblemStatement*/ virtual Result doStoreProblemStatement(ProblemStatementInferencePointer pStatement); /*! virtual abstract part of the NVI idiom. See public member for more information. *@see deleteProblemStatement*/ virtual StatementDeleteReturnType doDeleteProblemStatement(ProblemStatementInferencePointer pStatement); /*! virtual abstract part of the NVI idiom. See public member for more information. *@see defineProblemModel*/ virtual Result doDefineProblemModel(ProblemModelInferencePointer pNewModel); /*! virtual abstract part of the NVI idiom. See public member for more information. *@see storeProblemModel*/ virtual Result doStoreProblemModel(ProblemModelInferencePointer pModel); /*! virtual abstract part of the NVI idiom. See public member for more information. *@see deleteProblemModel*/ virtual ModelDeleteReturnType doDeleteProblemModel(ProblemModelInferencePointer pModel); /////////////////////////////////////////////////////////////// // internals using OntologyCoreType = SimpleOntologyCore; std::shared_ptr< OntologyCoreType > _spCore; private: SimpleOntology(const Self&); //not implemented by purpose Self& operator=(const Self&); //not implemented by purpose }; } // end namespace scenario } // end namespace iro #endif diff --git a/Code/Ontology/Simple/include/mapSimpleTransformationInfo.h b/Code/Ontology/Simple/include/mapSimpleTransformationInfo.h index 3cf00d6..b97b37c 100644 --- a/Code/Ontology/Simple/include/mapSimpleTransformationInfo.h +++ b/Code/Ontology/Simple/include/mapSimpleTransformationInfo.h @@ -1,134 +1,134 @@ // ----------------------------------------------------------------------- // MatchPoint - DKFZ translational registration framework // // Copyright c German Cancer Research Center DKFZ, // Software development for Integrated Diagnostics and Therapy SIDT. // ALL RIGHTS RESERVED. // See mapCopyright.txt or // http://www.dkfz.de/en/sidt/projects/MatchPoint/copyright.html // // This software is distributed WITHOUT ANY WARRANTY; without even // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the above copyright notices for more information. // //------------------------------------------------------------------------ #ifndef __MAP_SIMPLE_TRANSFORMATION_INFO_H #define __MAP_SIMPLE_TRANSFORMATION_INFO_H #include "mapIInformationSpaceConnector.h" #include "mapIProblemStatementAssociated.h" #include "mapSimpleInformationSpace.h" #include "mapSimpleInformationEntity.h" #include "mapSimpleProblemStatement.h" #include "mapDataRepresentation.h" #include "mapFOVScope.h" #include "mapAlgorithmExecutionInfo.h" #include "mapTransformationInfoTraits.h" #include #include "mapMAPOntologySimpleExports.h" namespace iro { namespace scenario { /*! @class SimpleTransformationInfo * @brief Simple specific implementation for transformation infos. * @ingroup Simple */ - MAPOntologySimple_EXPORT class SimpleTransformationInfo : public IInformationSpaceConnector< SimpleInformationSpaceTraits >, public IProblemStatementAssociated< SimpleProblemStatementTraits > + class MAPOntologySimple_EXPORT SimpleTransformationInfo : public IInformationSpaceConnector< SimpleInformationSpaceTraits >, public IProblemStatementAssociated< SimpleProblemStatementTraits > { public: typedef SimpleTransformationInfo Self; typedef ::std::shared_ptr Pointer; typedef ::std::shared_ptr ConstPointer; typedef IInformationSpaceConnector< SimpleInformationSpaceTraits > ConnectorInterface; typedef ConnectorInterface::ConstISPointer ConstISPointer; typedef IProblemStatementAssociated< SimpleProblemStatementTraits > ProblemAssociatedInterface; typedef ProblemAssociatedInterface::ProblemComplianceInterface ProblemComplianceInterface; typedef ProblemAssociatedInterface::ConstProblemPointer ConstProblemPointer; typedef DataRepresentation::Type DataRepresentationType; typedef FOVScope::Type FOVScopeType; typedef ::iro::String UIDType; typedef AlgorithmExecutionInfo< SimpleInformationSpaceTraits, SimpleInformationEntityTraits > ExecutionInfoType; /*! Implementation of abstract member. See documentation in interface. * @see IInformationSpaceConnector*/ virtual ConstISPointer getMovingIS() const; /*! Sets the moving information space */ void setMovingIS(ConstISPointer movingIS); /*! Implementation of abstract member. See documentation in interface. * @see IInformationSpaceConnector*/ virtual ConstISPointer getTargetIS() const; /*! Sets the target information space */ void setTargetIS(ConstISPointer targetIS); /** Returns the const pointer to the associated problem statement. * Pointer may be null, if no statement is defined.*/ - virtual ConstProblemPointer getAssociatedProblemStatement() const; + virtual ConstProblemPointer getAssociatedProblemStatement() const override; /*! Sets the associated problem statement */ void setAssociatedProblemStatement(ConstProblemPointer problem); DataRepresentationType getSupportedDataRepresentation() const; void setSupportedDataRepresentation(DataRepresentationType dr); const UIDType& getUID() const; void setUID(const UIDType& uid); FOVScopeType getFOVScope() const; void setFOVScope(FOVScopeType scope); virtual ~SimpleTransformationInfo(); SimpleTransformationInfo(); ExecutionInfoType::ConstPointer getAlgorithmExecutionInfo() const; void setAlgorithmExecutionInfo(ExecutionInfoType::Pointer execInfo); /* Clones the content of the info and returns it as * non const pointer. It can be used to alter the transformation info and * update the knowledge base of the ontology. */ Pointer clone() const; protected: /*! Implementation of abstract member. This implementation checks the associated * problem statement for compliance. See also documentation in interface. * @see IProblemComplianceChecker*/ virtual bool doCheckProblemCompliance(const ProblemComplianceInterface* pProblemCompliance) const; ConstISPointer _movingIS; ConstISPointer _targetIS; ConstProblemPointer _associatedProblem; DataRepresentationType _dataRepresentation; FOVScopeType _scope; UIDType _uid; ExecutionInfoType::Pointer _execInfo; private: SimpleTransformationInfo(const Self&); //not implemented by purpose Self& operator=(const Self&); //not implemented by purpose }; using SimpleTransformationInfoTraits = TransformationInfoTraits; } // end namespace scenario } // end namespace iro #endif