dtk_metadata.hpp

Go to the documentation of this file.

#ifndef __DTK_METADATA_HPP__
#define __DTK_METADATA_HPP__
 
#include "util/BaseTypes/dtk_string.hpp"
#include "util/BaseTypes/dtk_object.hpp"
#include "def/define.h" 
#include "util/error_dtk.hpp"
#include <memory>
 
class Dtk_Properties;
typedef Dtk_SmartPtr<Dtk_Properties>            Dtk_PropertiesPtr;
class Dtk_MetaData;
typedef Dtk_SmartPtr<Dtk_MetaData>                Dtk_MetaDataPtr;
 
/////////////////////////////////////////////////////////////////////////////
//! \ingroup DtkAPIGroup
//! \class Dtk_MetaData 
//! \brief This is the Dtk_MetaData Class.\n
//! The Dtk_MetaDataPtr object is used to store any additional informations about
//! Dtk_ComponentPtr or Dtk_NodePtr.\n
//! It can be either be properties or parameters.\n
//! \SmartPtr{Dtk_MetaData}
class Dtk_MetaData : public Dtk_Object
{
public:
    enum MetaDataTypeEnum
    {
        TypeUnknown         = 0,
          TypeProperty,
          TypeFileProperty,
          TypeConfigurationProperty,
          TypeSheetMetal,
          TypeParameter,
          TypeMassProperty,
        TypeElectricalProperty,
        TypeAttributeSet,
          TypeUserAttribute,
          TypeUserExpression
     };
    static Dtk_string MetaDataTypeEnumToString(const MetaDataTypeEnum& inEnum)
    {
        switch( inEnum )
        {
          case TypeProperty:                 return L"TypeProperty";
          case TypeFileProperty:             return L"TypeFileProperty";
          case TypeConfigurationProperty:    return L"TypeConfigurationProperty";
          case TypeSheetMetal:               return L"TypeSheetMetal";
          case TypeParameter:                return L"TypeParameter";
          case TypeMassProperty:             return L"TypeMassProperty";
          case TypeElectricalProperty:       return L"TypeElectricalProperty";
        case TypeAttributeSet:             return L"TypeAttributeSet";
          case TypeUserAttribute:            return L"TypeUserAttribute";
          case TypeUserExpression:           return L"TypeUserExpression";
        default:                            
        case TypeUnknown:                  return L"Unknown";
        }
    }
protected:
    enum { _typeID = DTK_TYPE_METADATA }; 
    struct Dtk_Handle;
    std::unique_ptr<Dtk_Handle> _Private;
 
    //! \sa    Create( const Dtk_MetaData& in ); 
    Dtk_MetaData(const Dtk_MetaData& inToBeCopied);
    Dtk_MetaData( Dtk_MetaData&& inToBeMoved) DTK_NOEXCEPT;
    
    //! \sa CreateMetaData
    Dtk_MetaData(const MetaDataTypeEnum& inType);
   
    //! \BaseDestructor 
    virtual ~Dtk_MetaData();
    friend class Dtk_SmartPtr<Dtk_MetaData>;
 
public:
    //! \brief Create a property Dtk_MetaDataPtr from a Dtk_PropertiesPtr.
    //! \param inObject Property data.
    //! \return the constructed Dtk_MetaDataPtr.
    static Dtk_MetaDataPtr CreatePropertiesMetaData(const Dtk_PropertiesPtr& inObject);
 
     //! \brief Create a Dtk_MetaDataPtr .
     //! \param [in] inEnumType : the type of the metadata 
    //! \param [in] inTitle : the title of the metadata 
    //! \param [in] inValue : the value of the metadata 
    //! \param [in] inType : the type of value (default is "STRING") 
     //! \return the constructed Dtk_MetaDataPtr.
    static Dtk_MetaDataPtr CreateMetaData(const MetaDataTypeEnum &inEnumType, Dtk_string inTitle, Dtk_string inValue, Dtk_string inValueType = Dtk_string(L"STRING"));
    //! \brief Create a Dtk_MetaDataPtr .
    //! \param [in] inEnumType : the type of the metadata 
    //! \param [in] inTitle : the title of the metadata 
    //! \param [in] inValue : the value of the metadata 
    //! \param [in] inUnits : the unit of the metadata 
    //! \param [in] inType : the type of value (default is "STRING")
     //! \return the constructed Dtk_MetaDataPtr.
    static Dtk_MetaDataPtr CreateMetaDataWithUnits(const MetaDataTypeEnum &inEnumType, Dtk_string inTitle, Dtk_string inValue, Dtk_string inUnits, Dtk_string inValueType = Dtk_string(L"STRING"));
     
     //! \\CreateCopy{in}
     static Dtk_MetaDataPtr Create( const Dtk_MetaData& in );
 
    //! \DtkDynamicType
    inline Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
    { 
        if (inId == _typeID) return 1; 
        return Dtk_Object::DtkDynamicType(inId); 
    }
    
    //! \DtkDynamicCast
    static Dtk_MetaData* DtkDynamicCast(Dtk_Object *s)
    { 
        if (s->DtkDynamicType(_typeID)) return static_cast<Dtk_MetaData*>(s); 
        return NULL; 
    } 
 
    //! \brief Retrieves the Dtk_MetaDataPtr as a property - if exists -
    //! \return The Dtk_MetaDataPtr as a Dtk_PropertiesPtr if exists. Null Dtk_PropertiesPtr else.
    //! \remark This method is used to retrieve the property  
    //! informations - if MetaDataType() method returns TypeProperty -.
    Dtk_PropertiesPtr ToProperty();
 
    //! \brief Retrieves the Dtk_MetaDataPtr as a parameter - if exists -
    //! \return The Dtk_MetaDataPtr as a Dtk_PropertiesPtr if exists. Null Dtk_PropertiesPtr else.
    //! \remark This method is used to retrieve the parameter  
    //! informations - if MetaDataType() method returns TypeParameter -.
    Dtk_PropertiesPtr ToParameter();
 
    //! \brief Retrieves the Dtk_MetaDataPtr as a parameter - if exists -
    //! \return The Dtk_MetaDataPtr as a Dtk_PropertiesPtr if exists. Null Dtk_PropertiesPtr else.
    //! \remark This method is used to retrieve the parameter  
    //! informations - if MetaDataType() method returns ToMassProperty -.
    Dtk_PropertiesPtr ToMassProperty();
 
    //! \brief Retrieves the Dtk_MetaDataPtr as a parameter - if exists -
    //! \return The Dtk_MetaDataPtr as a Dtk_PropertiesPtr if exists. Null Dtk_PropertiesPtr else.
    //! \remark This method is used to retrieve the parameter  
    //! informations - if MetaDataType() method returns TypeElectricalProperty -.
    Dtk_PropertiesPtr ToElectricalProperty();
 
    //! \brief Retrieves the Dtk_MetaDataPtr as a parameter - if exists -
    //! \return The Dtk_MetaDataPtr as a Dtk_PropertiesPtr if exists. Null Dtk_PropertiesPtr else.
    //! \remark This method is used to retrieve the parameter  
    //! informations - if MetaDataType() method returns TypeUserAttribute -.
    Dtk_PropertiesPtr ToUserAttribute();
 
     //! \brief Retrieves the Dtk_MetaDataPtr as a parameter - if exists -
     //! \return The Dtk_MetaDataPtr as a Dtk_PropertiesPtr if exists. Null Dtk_PropertiesPtr else.
     //! \remark This method is used to retrieve the parameter  
     //! informations - if MetaDataType() method returns TypeUserExpression -.
     Dtk_PropertiesPtr ToUserExpression();
 
//DTK_TOREMOVE_START
#ifdef AF51BDA7E49648f8AB95949F4CA52EF8
     Dtk_PropertiesPtr ToSheetMetal();
#endif
//DTK_TOREMOVE_END
     Dtk_PropertiesPtr ToFileProperty();
     Dtk_PropertiesPtr ToConfigurationProperty();
    //! \brief Retrieves the Dtk_MetaDataPtr type - read only -.
    //! \return The Dtk_MetaDataPtr type.
    const MetaDataTypeEnum& MetaDataType() const;
     void SetMetaDataType( const MetaDataTypeEnum& inType );
 
     //! \brief Get the Units of the MetaData.
     //! \param[out] outUnits :  the units string if present, empty string otherwise
     //! \return dtkNoError if Units are present / dtkErrorAttributeNotFound if no Units  .
     Dtk_ErrorStatus GetUnits( Dtk_string& outUnits ) const;
 
     //! \brief Get the Type of the MetaData .
     //! \return the Type of this MetaData  .
     //!
     const Dtk_string& GetType() const;
 
     //! \brief Set the Type of the MetaData .
     //!
     void SetType( Dtk_string in) ;
 
     //! \brief Get the Title of the MetaData .
     //! \return the Title of this MetaData  .
     //!
     const Dtk_string& GetTitle() const;
     //! \brief Set the Title of the MetaData .
     //!
     void SetTitle( Dtk_string in) ;
 
     //! \brief Get the Value of the MetaData .
     //! \return the Value of this MetaData  .
     //!
     const Dtk_string& GetValue() const;
     //! \brief Set the Value of the MetaData .
     //!
     void SetValue( Dtk_string in) ;
 
 
     //! \brief Get the Category of the MetaData .
     //! \return the Category of this MetaData  .
     //!
     const Dtk_string& GetCategory() const;
     //! \brief Set the Category of the MetaData .
     //!
     void SetCategory( Dtk_string in) ;
 
     //! \brief Get the Formula Type of result and its Estimated value of the MetaData .
     //! \param[out] outEstimatedValue : Estimated value of formula
     //! \param[out] outType : Type of Estimated value 
     //! \return DtkNoError if it is a Formula , dtkErrorCorruptedEntity otherwise.
     //!
     Dtk_ErrorStatus GetFormula(Dtk_string& outFormula,Dtk_string& outEstimatedValue,Dtk_string& outTitle,Dtk_string& outResultType) ;
 
     //! \brief Get the Formula and its Estimated value of the MetaData .
     //! \param[out] outEstimatedValue : Estimated value of formula
     //! \return the Formula of this MetaData  .
     //!
     Dtk_string GetFormula(Dtk_string& outEstimatedValue) const;
 
     //! \brief Set the MetaData as Formula .
     //! \param[in] inFormula : Formula
     //! \param[in] inEstimatedValue : Estimated value of formula
     //! \param[in] inResultType : Type of the EstimateValue
     //! \return the Formula of this MetaData  .
     //!
     void SetFormula( Dtk_string inFormula, Dtk_string inEstimatedValue, Dtk_string inTitle, Dtk_string inResultType);
 
 
     Dtk_bool IsReal() const;
     Dtk_bool IsInteger() const;
     Dtk_bool IsBoolean() const;
     Dtk_bool IsFormula() const;
     Dtk_bool IsReference() const;
     Dtk_bool IsDate() const;
     Dtk_bool IsTime_t() const;
     Dtk_bool IsString() const;
     Dtk_bool IsNull() const;
};
 
struct Dtk_MetaData::Dtk_Handle
{
     Dtk_Handle() : _MetaDataType(TypeUnknown){}
 
     explicit Dtk_Handle(const MetaDataTypeEnum& inType) : _MetaDataType(inType){}
 
     Dtk_Handle(const Dtk_Handle& o) : _MetaDataType(o._MetaDataType), _Type(o._Type), _Title(o._Title), _Value(o._Value), _Category(o._Category){}
 
    MetaDataTypeEnum        _MetaDataType;
 
     Dtk_string                    _Type;
     Dtk_string                    _Title;
     Dtk_string                    _Value;
     Dtk_string                    _Category;
 
};
 
class Dtk_MetaDataWithUnit;
 
typedef Dtk_SmartPtr<Dtk_MetaDataWithUnit> Dtk_MetaDataWithUnitPtr;
 
class Dtk_MetaDataWithUnit : public Dtk_MetaData
{
private:
     friend class Dtk_SmartPtr<Dtk_MetaDataWithUnit>;
 
protected :
     enum { _typeID = DTK_TYPE_METADATAWITHUNIT }; 
     Dtk_string          _Units;
 
 
public:
     Dtk_string GetUnits() const;
     Dtk_MetaDataWithUnit(const MetaDataTypeEnum &inEnumType, Dtk_string inType, Dtk_string inTitle, Dtk_string inValue, Dtk_string inUnit);
     virtual ~Dtk_MetaDataWithUnit();
 
     //! \DtkDynamicType
     inline Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
     { 
          if (inId == _typeID) return 1; 
          return Dtk_MetaData::DtkDynamicType(inId); 
     }
 
     //! \DtkDynamicCast
     static Dtk_MetaDataWithUnit* DtkDynamicCast(Dtk_Object *s)
     { 
          if (s->DtkDynamicType(_typeID)) return static_cast<Dtk_MetaDataWithUnit*>(s); 
          return NULL; 
     } 
};
 
//! \class Dtk_MetaData 
//! \brief This is the Dtk_MetaDataGroup Class.\n
//! The Dtk_MetaDataGroupPtr object is used to store a group of Dtk_MetaDataPtr in 
//! a Dtk_ComponentPtr or a or Dtk_NodePtr.\n
//! The children metadata may or may not be also stored as single metadata but if it is
//! the case, then their category should be defined with the name of their Dtk_MetaDataGroup
//! in order to be distinguished from metadata only accessible alone.\n
//! It is defined by a name and a tab of metadatas.\n
//! \SmartPtr{Dtk_MetaDataGroup}
class Dtk_MetaDataGroup;
 
typedef Dtk_SmartPtr<Dtk_MetaDataGroup> Dtk_MetaDataGroupPtr;
 
class Dtk_MetaDataGroup : public Dtk_Object
{
protected :
     enum { _typeID = DTK_TYPE_METADATA_GROUP };
private:
     //! \brief Name of the Group
     Dtk_string _GroupName;
 
     //! \brief List of Metadata Children of the group
     Dtk_tab< Dtk_MetaDataPtr > _MetadataChildren;
 
     friend class Dtk_SmartPtr<Dtk_MetaDataGroup>;
 
public:
 
     //! \Create MetaDataGroup
     Dtk_MetaDataGroup( Dtk_string inGroupName);
 
     //! \BaseDestructor 
     virtual ~Dtk_MetaDataGroup();
 
     //! \DtkDynamicType
     inline Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
     {
          if( inId == _typeID ) return 1;
          return Dtk_MetaDataGroup::DtkDynamicType(inId);
     }
 
     //! \DtkDynamicCast
     static Dtk_MetaDataGroup* DtkDynamicCast(Dtk_Object *s)
     {
          if( s->DtkDynamicType(_typeID) ) return static_cast<Dtk_MetaDataGroup*>( s );
          return NULL;
     }
 
     static Dtk_MetaDataGroupPtr CreateMetaDataGroup( Dtk_string inGroupName, Dtk_tab< Dtk_MetaDataPtr > inMetadataChildren = Dtk_tab<Dtk_MetaDataPtr>());
 
     //! \brief Get the list of metadata of the MetaDataGroup.
     //! \return the list of metadata of this MetaDataGroup.
     const Dtk_tab< Dtk_MetaDataPtr >& GetListOfMetadatas() const;
     
     //! \brief Add a metadata to this Group
     void AddMetadata(Dtk_MetaDataPtr inChild);
 
     //! \brief Set the group name
     void SetName( Dtk_string inGroupName);
 
     //! \brief Get the group name
     const Dtk_string GetGroupName();
 
     //! \brief Get the number of metadatas in the Group 
     const Dtk_Size_t GetNumMetaData() const;
     
     //! \brief Get the inPos'th metadata of the Group 
     Dtk_MetaDataPtr GetMetaData(const Dtk_Size_t& inPos);
};
 
//! \ingroup base_types
//! \class Dtk_Properties 
//! \brief This is the Dtk_Properties class.
//! \brief A Dtk_Properties contains the property which defines by its Type,Title and Value
//!
//!  This class lets you use Dtk_Properties.
class Dtk_Properties : public Dtk_Object
{
protected:
     struct Dtk_Handle;
     std::unique_ptr<Dtk_Handle> _Private;
     Dtk_Properties();
     //! \sa Create( const Dtk_Properties& in );
     Dtk_Properties( const Dtk_Properties&  );
     Dtk_Properties( Dtk_Properties&&  ) DTK_NOEXCEPT;
     inline virtual Dtk_Object* Clone()
     {
          return new Dtk_Properties( *this );
     }
 
     virtual ~Dtk_Properties();
 
     friend class Dtk_SmartPtr<Dtk_Properties>;
public:
 
     //! \CreateBase
     static Dtk_PropertiesPtr Create();
     //! \deprecated Use Create instead.
     SetAsDeprecated( "2026.4", "Use Create instead." )
     static Dtk_PropertiesPtr create();
     //! \CreateCopy{in}
     static Dtk_PropertiesPtr Create( const Dtk_Properties& in );
     int DtkDynamicType( const int& inId );
     static Dtk_Properties* DtkDynamicCast( Dtk_Object* s );
     //! \brief Get the Type of the Property .
     //! \return the Type of this Property  .
     //!
     const Dtk_string& GetType() const;
 
     //! \brief Set the Type of the Property .
     //! \return the Type of this Property  .
     //!
     void SetType( Dtk_string in) ;
 
     //! \brief Get the Title of the Property .
     //! \return the Title of this Property  .
     //!
     const Dtk_string& GetTitle() const;
 
     //! \brief Set the Title of the Property .
     //! \return the Type of this Property  .
     //!
     void SetTitle( Dtk_string) ;
 
     //! \brief Get the Value of the Property .
     //! \return the Value of this Property  .
     //!
     const Dtk_string& GetValue() const;
 
     //! \brief Set the Value of the Property .
     //! \return the Type of this Property  .
     //!
     void SetValue( Dtk_string) ;
 
 
     //! \brief Get the Formula Type of result and its Estimated value of the MetaData .
     //! \param[out] outEstimatedValue : Estimated value of formula
     //! \param[out] outType : Type of Estimated value 
     //! \return the Formula of this MetaData  .
     //!
     Dtk_ErrorStatus GetFormula(Dtk_string& outFormula,Dtk_string& outEstimatedValue,Dtk_string& outTitle,Dtk_string& outResultType) ;
 
     //! \brief Get the Formula and its Estimated value of the Property .
     //! \param[out] outEstimatedValue : Estimated value of formula
     //! \return the Value of this Property  .
     //!
     Dtk_string GetFormula(Dtk_string& outEstimatedValue) ;
     //! \brief Set the MetaData as Formula .
     //! \param[in] inFormula : Formula
     //! \param[in] inEstimatedValue : Estimated value of formula
     //! \param[in] inResultType : Type of the EstimateValue
     //! \return the Formula of this MetaData  .
     //!
     void SetFormula( Dtk_string inFormula, Dtk_string inEstimatedValue, Dtk_string inTitle, Dtk_string inResultType);
 
 
     void SetAsReal();
     void SetAsInteger();
     void SetAsBoolean();
 
     Dtk_bool IsReal() const;
     Dtk_bool IsInteger() const;
     Dtk_bool IsBoolean() const;
     Dtk_bool IsFormula() const;
     Dtk_bool IsReference() const;
     Dtk_bool IsDate() const;
     Dtk_bool IsString() const;
     Dtk_bool IsNull() const;
 
 
};
 
 
#endif