IFCWriter.h

Go to the documentation of this file.

#ifndef _IFCW_HPP_
#define _IFCW_HPP_
//! \brief Exported APIs for Ifc (.ifc) Write Library
 
#include <util/util_ent_dtk.hpp>
#include <util/util_ptr_dtk.hpp>
 
#include <util/BaseTypes/dtk_string.hpp>
#include <util/BaseTypes/dtk_metadata.hpp>
#include <util/BaseTypes/dtk_rgb.hpp>
#include <util/BaseTypes/dtk_transfo.hpp>
 
#include <def/define.h>
#include <utility>
 
namespace Ifcw
{
     //! \class WriteOptions 
     //! \brief This class provides several options to tune the IFC Writer.\n
     //! It must be provided to Ifcw::InitWrite method.
     //! \code
     //! //...
     //! Dtk_string LogFile = L"MyLogFile.log";
     //! Ifcw::WriteOptions IFCOptions;
     //! Dtk_ErrorStatus err = Ifcw::InitWrite( LogFile, NULL, IFCOptions);
     //! //...
     //! \endcode
     class WriteOptions
     {
     protected:
     public:
 
          //! \BaseConstructor
          WriteOptions() : buildingTypeRecognition( DTK_TRUE ), versionIndicator( 1 ), tessellateExactGeometry( DTK_FALSE ){}
          
          //! Int representing IFC version to use : 0 ( default ) = IFC2x3; 1 = IFC4
          //! default value is 1 (IFC4).
          int versionIndicator;
          //! DTK_TRUE : enable building type recognition (deduces if an element is an IFCWALL, IFCWINDOW...), DTK_FALSE : disable building type recognition
          //! default value is DTK_TRUE.
          Dtk_bool buildingTypeRecognition;
          //! DTK_TRUE : tessellate exact geometry. Such geometry is only exported in version IFC4. DTK_FALSE : export exact geometry as is (only in IFC4).
          //! default value is DTK_FALSE.
          Dtk_bool tessellateExactGeometry;
     };
 
     //! \struct ProjectInformation
     //! \brief This struct enables the user to define global properties regarding the project, construction site and building.\n
     //! It is used in the Ifcw::InitWrite method.
     //! \see InitWrite
     //!
     //! Here is the detailed mapping of this struct field and IFC data :
     //! projectPhase <-> IFCPROJECT.Phase
     //! projectName <-> IFCPROJECT.Name
     //! projectDetailedName <-> IFCPROJECT.LongName
     //! siteLatitude <-> IFCSITE.RefLatitude in degree
     //! siteLongitude <-> IFCSITE.RefLongitude in degree
     //! siteElevation <-> IFCSITE.RefElevation in meter
     //! buildingAddress <-> IFCBUILDING.BuildingAddress
     //! buildingName <-> IFCBUILDING.Name AND IFCBUILDING.LongName
     //! projectAuthor <-> IFCPERSON.GivenName
     //! organizationName <-> IFCORGANIZATION.Name
     //! organizationDescription <-> IFCORGANIZATION.Description
     struct ProjectInformation
     {
          Dtk_string projectPhase;
          Dtk_string projectName;
          Dtk_string projectDetailedName;
          Dtk_string buildingAddress;
          Dtk_string buildingName;
          Dtk_string projectAuthor;
          Dtk_string organizationName;
          Dtk_string organizationDescription;
          Dtk_Double64 siteLatitude;
          Dtk_Double64 siteLongitude;
          Dtk_Double64 siteElevation;
          ProjectInformation() : 
               projectPhase(L"Project Phase"),
               projectName(L"Project Name"),
               projectDetailedName(L"Project Detailed Name"),
               buildingAddress(L"Building Address"),
               buildingName(L"Building Name"),
               projectAuthor(L"Author"),
               organizationName(L"Organization name"),
               organizationDescription(L"Organization description"),
               siteLatitude(0.),
               siteLongitude(0.),
               siteElevation(0.)
          { };
          ~ProjectInformation(){ };
          ProjectInformation& operator=( ProjectInformation&&  p );
     };
 
     namespace typing
     {
          namespace predefined
          {
               //! \enum BuildingElement 
               //! \brief This enum provides commonly used ifc building elements types, to define entities to be written.\n
               //! \see https://standards.buildingsmart.org/IFC/DEV/IFC4_2/FINAL/HTML/schema/ifcproductextension/lexical/ifcbuildingelement.htm
               enum BuildingElement
               {
                    IfcBeam,
                    IfcBuildingElementProxy,
                    IfcChimney,
                    IfcColumn,
                    IfcCovering,
                    IfcCurtainWall,
                    IfcDoor,
                    IfcFooting,
                    IfcMember,
                    IfcPlate,
                    IfcRailing,
                    IfcRamp,
                    IfcRampFlight,
                    IfcRoof,
                    IfcShadingDevice,
                    IfcSlab,
                    IfcStair,
                    IfcStairFlight,
                    IfcWall,
                    IfcWindow
               };
          
               //! \enum DistributionElement 
               //! \brief This enum provides commonly used ifc distribution elements types, to define entities to be written.\n
               //! \see https://standards.buildingsmart.org/IFC/DEV/IFC4_2/FINAL/HTML/schema/ifcproductextension/lexical/ifcdistributionelement.htm
               enum DistributionElement
               {
                    IfcAirTerminal,
                    IfcAlarm,
                    IfcCableCarrierFitting,
                    IfcCableCarrierSegment,
                    IfcDistributionChamberElement,
                    IfcDuctFitting,
                    IfcDuctSegment,
                    IfcFireSuppressionTerminal,
                    IfcLightFixture,
                    IfcPipeFitting,
                    IfcPipeSegment,
                    IfcValve
               };
          }
 
          //! \class IfcCalendarDate 
          //! \brief This class represents an IFC date.\n
          //! \remark Definition from ISO/CD 10303-41:1992: A date which is defined by a day in a month of a year.
          struct IfcCalendarDate
          {
          private:
               Dtk_Char8 day; //!< An int between 1 and 31.
               Dtk_Char8 month; //!< An int between 1 and 12.
               Dtk_Int32 year; //!< A positive int.
          public:
               //! \BaseConstructor
               IfcCalendarDate();
               IfcCalendarDate( Dtk_Char8 inDay, Dtk_Char8 inMonth, Dtk_Int32 inYear );
               friend bool operator==( IfcCalendarDate const& lhs, IfcCalendarDate const& rhs )
               {
                    return lhs.day == rhs.day && lhs.month == rhs.month && lhs.year == rhs.year;
               };
               //! \brief Getter for the date day
               //! \return The date day
               Dtk_Char8 GetDay() const
               {
                    return day;
               }
               //! \brief Getter for the date month
               //! \return The date month
               Dtk_Char8 GetMonth() const
               {
                    return month;
               }
               //! \brief Getter for the date year
               //! \return The date year
               Dtk_Int32 GetYear() const
               {
                    return year;
               }
          };
     }
 
     namespace classification
     {
          //! \class IfcClassification
          //! \brief A class that represents a classification system, like UniFormat, Omniclass, SfB...    
          //! \remark Ifc objects are not directly link to IfcClassification in 2x3 and have to be linked to IfcClassificationReference
          //! \see IfcClassificationReference
          //! \see https://standards.buildingsmart.org/IFC/DEV/IFC4_3/RC1/HTML/schema/ifcexternalreferenceresource/lexical/ifcclassification.htm
          class IfcClassification
          {
          private:
               typing::IfcCalendarDate editionDate; //!< Classification version date ou publication.
               Dtk_string source; //!< Where the classification comes from (publisher). Mandatory.
               Dtk_string edition; //!< Classification version. Mandatory.
               Dtk_string name; //!< Classifition name, like "UniFormat". Optionnal.
          public:
               //! \BaseConstructor
               //! \remark Should not be used because at classification source and edition are mandatory parameter.
               IfcClassification();
               //! \brief Constructor taking 3 parameters.
               //! \param [in] inSource : Classification source.
               //! \param [in] inEdition : Classification edition.
               //! \param [in] inName : Classification name.
               //! \remark name is optionnal.
               IfcClassification( Dtk_string inSource, Dtk_string inEdition, Dtk_string inName = "" );
               friend bool operator==( IfcClassification const& lhs, IfcClassification const& rhs )
               {
                    return lhs.editionDate == rhs.editionDate && lhs.source == rhs.source && lhs.edition == rhs.edition && lhs.name == rhs.name;
               };
               //! \brief Getter for the classification edition date
               //! \return The classification edition date
               const typing::IfcCalendarDate & GetEditionDate() const;
               //! \brief Getter for the classification source
               //! \return The classification source
               const Dtk_string & GetSource() const;
               //! \brief Getter for the classification edition
               //! \return The classification edition
               const Dtk_string & GetEdition() const;
               //! \brief Getter for the classification name
               //! \return The classification name
               const Dtk_string & GetName() const;
               //! \brief Setter for the classification name
               //! \param [in] inName : The classification name to be used
               void SetName( Dtk_string inName );
               //! \brief Setter for the classification source
               //! \param [in] inSource : The classification source to be used
               void SetSource( Dtk_string inSource );
               //! \brief Setter for the classification edition
               //! \param [in] inEdition : The classification edition to be used
               void SetEdition( Dtk_string inEdition );
               //! \brief Setter for the classification edition date
               //! \param [in] inDate : The ifc date to be used
               void SetEditionDate( typing::IfcCalendarDate inDate );
               //! \brief Setter for the classification edition date
               //! \param [in] inDay : The day of date to be used
               //! \param [in] inMonth : The month of date to be used
               //! \param [in] inYear : The year of date to be used
               void SetEditionDate( Dtk_Char8 inDay, Dtk_Char8 inMonth, Dtk_Int32 inYear );
          };
 
          //! \class IfcClassificationReference
          //! \brief This class represent a classification reference to be used for an ifc object, e.g.: B2010 in OmniClass for exterior walls. It is link to a classification.
          //! \see IfcClassification
          //! \remark One of its parameter have to be assigned (all optionals).
          //! \see https://standards.buildingsmart.org/IFC/DEV/IFC4_3/RC1/HTML/schema/ifcexternalreferenceresource/lexical/ifcclassificationreference.htm
          //! \see https://standards.buildingsmart.org/IFC/DEV/IFC4_3/RC1/HTML/schema/ifcexternalreferenceresource/lexical/ifcexternalreference.htm
          class IfcClassificationReference
          {
          private:
               IfcClassification                                                  referencedSource;//!< The classification that is referred.
               Dtk_string                                                                        location;//!< Location where the classification can be accessed (URL). Optionnal.
               Dtk_string                                                                  itemReference;//!< Item reference provides a unique identifier of the referenced item within the classification. Optionnal.
               Dtk_string                                                                             name;//!<    Name to further specify the reference. Optionnal.
 
          public:
               //! \BaseConstructor
               //! \remark One of the parameter should be set, otherwise name will be set to 'Undefined'. 
               IfcClassificationReference( Dtk_string inLocation = "", Dtk_string inItemReference = "", Dtk_string inName = "", IfcClassification inReferencedSource = IfcClassification() );
               friend bool operator==( IfcClassificationReference const& lhs, IfcClassificationReference const& rhs )
               {
                    return lhs.referencedSource == rhs.referencedSource
                    && lhs.location == rhs.location
                    && lhs.itemReference == rhs.itemReference && lhs.name == rhs.name;
               };
               //! \brief Getter for the classification the reference is linked to
               //! \return The classification the reference is linked to
               const IfcClassification & GetReferencedSource() const;
               //! \brief Getter for the reference location
               //! \return The reference location
               const Dtk_string & GetLocation() const;
               //! \brief Getter for the reference item reference
               //! \return The reference item reference
               const Dtk_string & GetItemReference() const;
               //! \brief Getter for the reference name
               //! \return The reference name
               const Dtk_string & GetName() const;
               //! \brief Setter for the reference location
               //! \param [in] inLocation : reference location to be used
               void SetLocation( Dtk_string inLocation );
               //! \brief Setter for the reference item reference
               //! \param [in] inItemReference : reference item reference to be used
               void SetItemReference( Dtk_string inItemReference );
               //! \brief Setter for the reference name
               //! \param [in] inName : reference name to be used
               void SetName( Dtk_string inName );
          };
     }
 
 
     //!  \class IfcElementType
     //! \brief A IfcElementType is used to define the common properties of a certain type or style of an entity that may be applied to instances of that entity type. 
     //! \remark Types may be exchanged without being already assigned to occurrences.
     //! \remark Type shapes are overwritten by occurence shapes. Type properties are added to occurence properties and overwritten for those which have the same filed.
     //! \see https://standards.buildingsmart.org/IFC/DEV/IFC4_2/FINAL/HTML/schema/ifcproductextension/lexical/ifcelementtype.htm
     class IfcElementType
     {
     private :
          Dtk_tab<Dtk_MetaDataPtr> propertySet; //!< The shared properties of the elements that will be assigned this type. Optional.
          Dtk_tab<Dtk_EntityPtr>        shapeReprensentation; //!< The shared representation shape of the elements that will be assigned this type.
          Dtk_string                         subtype; //!< The element subtype of the instances that will be assigned to this type. (e.g. IfcWall, IfcBeam...)
          Dtk_string                         predefinedType; //!< Predefined type of the element subtype (e.g. if productSubType = IFCROOF : FLAT_ROOF, SHED_ROOF...). If not set, will be set to "NOTDEFINED". Overrides IfcElement predefined type
          Dtk_string                         tag; //!< The tag (or label) identifier at the particular type of a product, e.g. the article number (like the EAN). Optional.
          Dtk_string                         name; //!< Name for the defined type. Optional.
          Dtk_ID                             ID; //!< Id of the type, to be identified when creating objects of that type.
 
     public:        
          IfcElementType();
          ~IfcElementType(){}
          //! \brief Getter for type property set
          //! \return The set of properties assigned to the type
          const Dtk_tab<Dtk_MetaDataPtr> & GetPropertySet() const { return propertySet; }
 
          //! \brief Getter for type property set
          //! \return The set of properties assigned to the type
          Dtk_tab<Dtk_MetaDataPtr> & GetPropertySet() { return propertySet; }
 
          //! \brief Getter for type shape representation
          //! \return The entities of the shape reprentation of the type
          const Dtk_tab<Dtk_EntityPtr> & GetShapeRepresentation() const { return shapeReprensentation; }
 
          //! \brief Getter for type tag
          //! \return The tag of the type
          const Dtk_string & GetTag() const { return tag; }
 
          //! \brief Getter for type name
          //! \return The name of the type
          const Dtk_string & GetName() const { return name; }
 
          //! \brief Getter for type ID
          //! \return The ID of the type
          Dtk_ID GetID() const { return ID; }
 
          //! \brief Getter for IfcElementType element subtype. 
          //! \return The Ifc element subtype assigned in the IfcElementType
          const Dtk_string & GetSubtype() const { return subtype; }
 
          //! \brief Getter for IfcElementType predefined type. 
          //! \return The predefined type assigned in the IfcElementType
          const Dtk_string & GetPredefinedType() const { return predefinedType; }
 
          //! \brief Setter for IfcElementType building element type. 
          //! \param [in] inType : The building element type to be assigned in the IfcElementType
          void SetSubtype( const Dtk_string & inType );
 
          //! \brief Setter for IfcElement building element subtype. 
          //! \param [in] inTypeEnum : The building element subtype to be assigned in the IfcElementType
          void SetSubtype( typing::predefined::BuildingElement inTypeEnum );
 
          //! \brief Setter for IfcElement distribution element subtype. 
          //! \param [in] inTypeEnum : The distribution element subtype to be assigned in the IfcElementType
          void SetSubtype( typing::predefined::DistributionElement inTypeEnum );
 
          //! \brief Setter for IfcElementType propertySet. 
          //! \param [in] inProperties : The property set to be attached to the IfcElementType
          //! \param [in] inSetName : The name of the property set (default is "UserDefined")
          void SetPropertySet( Dtk_tab<Dtk_MetaDataPtr> inProperties, const Dtk_string & inSetName = "" );    
          
          //! \brief Adds a property to IfcElementType current property set. 
          //! \param [in] inProperty : The property to be added to the property set
          //! \param [in] inSetName : The name of the property set in which the property belong
          void AddProperty( Dtk_MetaDataPtr inProperty, const Dtk_string & inSetName = "" );
 
          //! \brief Setter for IfcElementType shapeRepresentation (geometry)
          //! \param [in] inShapes : The entities to be assigned as shape representation (only Dtk_BodyPtr and Dtk_MeshPtr are supported for now)
          //! \return dtkNoError if the shape representation has been successfully assigned
          //! \return dtkErrorTypeNotsupported if one of the Dtk_EntityPtr type is not supported. Supported types will still be assigned.
          DtkErrorStatus SetShapeRepresentation( Dtk_tab< Dtk_EntityPtr > const& inShapes );
 
          //! \brief Adds an entity to IfcElementType shape representation (geometry)
          //! \param [in] inShape : The entity to add in the shape representation (only Dtk_BodyPtr and Dtk_MeshPtr are supported for now)
          //! \return dtkNoError if the shape representation has been successfully assigned
          //! \return dtkErrorTypeNotsupported if one of the Dtk_EntityPtr type is not supported
          DtkErrorStatus AddShape( Dtk_EntityPtr inShape );
 
          //! \brief Setter for IfcElementType tag
          //! \param [in] inTag : The tag of the type
          void SetTag( const Dtk_string & inTag );
 
          //! \brief Setter for IfcElementType name
          //! \param [in] inName : The name of the type
          void SetName( const Dtk_string & inName );
 
          //! \brief Setter for IfcElementType ID
          //! \param [in] inID : The ID of the type
          void SetID( const Dtk_ID & inID );
 
          //! \brief Setter for IfcElementType predefined type
          //! \param [in] inType : The predefined type of the IfcElementType
          void SetPredefinedType( const Dtk_string & inType );
     };
 
     //!  \class IfcType
     //! \brief This class has been renamed IfcElementType.
     //! \deprecated Use IfcElementType instead.
     class IfcType
     {
          IfcElementType m_oNewClass;
 
     public:
          SetAsDeprecated( "2026.3", "Use IfcElementType instead." )
          //! \deprecated Use IfcElementType instead.
          IfcType() : m_oNewClass() {};
          ~IfcType(){};
          //! \deprecated Use IfcElementType::GetPropertySet instead.
          const Dtk_tab<Dtk_MetaDataPtr>& GetPropertySet() const { return m_oNewClass.GetPropertySet(); }
          //! \deprecated Use IfcElementType::GetShapeRepresentation instead.
          const Dtk_tab<Dtk_EntityPtr>& GetShapeRepresentation() const { return m_oNewClass.GetShapeRepresentation(); };
          //! \deprecated Use IfcElementType::GetTag instead.
          const Dtk_string& GetTag() const { return m_oNewClass.GetTag(); };
          //! \deprecated Use IfcElementType::GetName instead.
          const Dtk_string& GetName() const { return m_oNewClass.GetName(); };
          //! \deprecated Use IfcElementType::GetID instead.
          Dtk_ID GetID() const { return m_oNewClass.GetID(); };
          //! \deprecated Use IfcElementType::GetSubtype instead.
          const Dtk_string& GetBuildingElementType() const { return m_oNewClass.GetSubtype(); };
          //! \deprecated Use IfcElementType::GetPredefinedType instead.
          const Dtk_string& GetPredefinedType() const { return m_oNewClass.GetPredefinedType(); };
          //! \deprecated Use IfcElementType::SetSubtype instead.
          void SetBuildingElementType( const Dtk_string& inType ) { m_oNewClass.SetSubtype( inType ); };
          //! \deprecated Use IfcElementType::SetSubtype instead.
          void SetBuildingElementType( typing::predefined::BuildingElement inTypeEnum ) { m_oNewClass.SetSubtype( inTypeEnum ); };
          //! \deprecated Use IfcElementType::SetPropertySet instead.
          void SetPropertySet( Dtk_tab<Dtk_MetaDataPtr> inProperties, const Dtk_string& inSetName = "" ){ m_oNewClass.SetPropertySet( std::move( inProperties ), inSetName ); };
          //! \deprecated Use IfcElementType::AddProperty instead.
          void AddProperty( Dtk_MetaDataPtr inProperty, const Dtk_string& inSetName = "" ){ m_oNewClass.AddProperty( inProperty, inSetName ); };
          //! \deprecated Use IfcElementType::SetShapeRepresentation instead.
          void SetShape( Dtk_tab< Dtk_EntityPtr > inShapes ){ m_oNewClass.SetShapeRepresentation( std::move( inShapes ) ); };
          //! \deprecated Use IfcElementType::AddShape instead.
          void AddShape( Dtk_EntityPtr inShape ){ m_oNewClass.AddShape( inShape ); };
          //! \deprecated Use IfcElementType::SetTag instead.
          void SetTag( const Dtk_string& inTag ){ m_oNewClass.SetTag( inTag ); };
          //! \deprecated Use IfcElementType::SetName instead.
          void SetName( const Dtk_string& inName ){ m_oNewClass.SetName( inName ); };
          //! \deprecated Use IfcElementType::SetID instead.
          void SetID( const Dtk_ID& inID ){ m_oNewClass.SetID( inID ); };
          //! \deprecated Use IfcElementType::SetPredefinedType instead.
          void SetPredefinedType( const Dtk_string& inType ){ m_oNewClass.SetPredefinedType( inType ); };
     };
 
     //! \class IfcElement 
     //! \brief This class provides several parameters for the next ifc entity to be written, as its custom property set, level, classification.\n
     //! It must be provided to Ifcw::InitObject method.
    //! \remark The propertySet can gather properties from different IfcPropertySet, we'll write as many set as there are different set names
     //! \see SetPropertySet, AddProperty
     //! \see https://standards.buildingsmart.org/IFC/DEV/IFC4_2/FINAL/HTML/schema/ifcproductextension/lexical/ifcelement.htm
     //! \code
     //! //...
     //! Dtk_string ifcType = L"IFCWALL";
     //! Ifcw::IfcElement* entityParams = new IfcElement();
     //! entityParams->SetIfcType( ifcType );
     //! Dtk_ErrorStatus err = Ifcw::InitObject( entityParams );
     //! //...
     //! \endcode
     class IfcElement
     {
     private:
          classification::IfcClassificationReference classificationReference; //!< Element reference in classification. Optionnal.
          Dtk_tab<Dtk_MetaDataPtr> propertySet; //!< Element properties. Set name is determine by Dtk_MetaData category. If different categories are set, different property sets will be written.
          Dtk_string name; //!< Element name. Default is 'UNDEFINED'
          Dtk_string subtype; //!< Element subtype, like IFCWALL, IFCCOLUMN... Default is IFCBUILDINGELEMENTPROXY \see typing::predefined::BuildingElement
          Dtk_string predefinedType; //!< //!< Predefined type of the element subtype (e.g. if productSubType = IFCROOF : FLAT_ROOF, SHED_ROOF...). If not set, will be set to "NOTDEFINED"
          Dtk_string GUID; //!< Element GUID. If not set a GUID will be generated.
          Dtk_string level; //!< Building level where the element belongs to. If not set will be placed in the building without level.
          Dtk_string tag; //!< Tag identifier of the element occurence, e.g. position, serial number.
          Dtk_transfo instanceTrf; //!< Instance transformation matrice (if the element is instantiated)
          Dtk_RGB color; //!< Element color. Default is grey.
          Dtk_ID typeID; //!< Element IfcElementType ID (only if it belongs to a IfcElementType). If type shapes are defined, they will be used as this element representation shapes (if it has no shape entities assigned through further WriteEntity call).
     public:
          //! \BaseConstructor
          IfcElement();
          //! \brief Getter for IfcElement propertySet
          //! \return The table of propertySet assigned to the IfcElement
          const Dtk_tab<Dtk_MetaDataPtr> & GetPropertySet() const { return propertySet; }
 
          //! \brief Getter for IfcElementType ID. 
          //! \return The ID of the current object type
          Dtk_ID GetTypeID() const { return typeID; }
 
          //! \brief Getter for IfcElement name. 
          //! \return The name assigned in the IfcElement
          const Dtk_string & GetName() const { return name; }
 
          //! \brief Getter for IfcElement GUID
          //! \return The GUID assigned in the IfcElement.
          const Dtk_string & GetGUID() const { return GUID; }
 
          //! \brief Getter for IfcElement level
          //! \return The level assigned in the IfcElement.
          const Dtk_string & GetLevel() const { return level; }
 
          //! \brief Getter for IfcElement tag
          //! \return The tag assigned in the IfcElement.
          const Dtk_string & GetTag() const { return tag; }
 
          //! \brief Getter for IfcElement subtype. 
          //! \return The element subtype assigned in the IfcElement
          const Dtk_string & GetSubtype() const { return subtype; }
 
          //! \brief Getter for IfcElement predefined type. 
          //! \return The building element predefined type assigned in the IfcElement
          const Dtk_string & GetPredefinedType() const { return predefinedType; }
 
          //! \brief Getter for IfcElement color. 
          //! \return The color assigned in the IfcElement
          Dtk_RGB GetColor() const { return color; }
 
          //! \brief Getter for IfcElement instance transformation matrice. 
          //! \return The instance transformation matrice assigned in the IfcElement
          const Dtk_transfo & GetInstanceTrf() const { return instanceTrf; }
 
          //! \brief Getter for classification reference
          //! \return The classification reference assigned in the IfcElement
          const classification::IfcClassificationReference & GetClassificationReference() const { return classificationReference; }
 
          //! \brief Setter for IfcElement propertySet. 
          //! \param [in] inProperties : The property set to be attached to the IfcElement
          //! \param [in] inSetName : The name of the property set (default is "UserDefined")
          void SetPropertySet( Dtk_tab<Dtk_MetaDataPtr> inProperties, const Dtk_string & inSetName = "" );
          //! \brief Adds a property to IfcElement current property set. 
          //! \param [in] inProperty : The property to be added to the property set
          //! \param [in] inSetName : The name of the property set in which the property belong
          void AddProperty( Dtk_MetaDataPtr inProperty, Dtk_string inSetName = "" );
          //! \brief Setter for IfcElement name. 
          //! \param [in] inName : The name to be assigned in the IfcElement
          void SetName( Dtk_string inName );
          //! \brief Setter for IfcElement IfcElementType ID. 
          //! \param [in] inID : The type ID to be assigned in the IfcElement
          void SetTypeID( const Dtk_ID & inID );
          //! \brief Setter for IfcElement GUID. 
          //! \param [in] inGUID : The GUID to be assigned in the IfcElement
          void SetGUID( Dtk_string inGUID );
          //! \brief Setter for IfcElement level. 
          //! \param [in] inLevel : The level to be assigned in the IfcElement
          void SetLevel( Dtk_string inLevel );
          //! \brief Setter for IfcElement tag. 
          //! \param [in] inTag : The tag to be assigned in the IfcElement
          void SetTag( Dtk_string inTag );
          //! \brief Setter for IfcElement subtype. 
          //! \param [in] inType : The element subtype to be assigned in the IfcElement
          void SetSubtype( Dtk_string inType );
          //! \brief Setter for IfcElement subtype. 
          //! \param [in] inEnum : The building element subtype to be assigned in the IfcElement
          void SetSubtype( typing::predefined::BuildingElement inEnum );
          //! \brief Setter for IfcElement subtype. 
          //! \param [in] inEnum : The distribution element subtype to be assigned in the IfcElement
          void SetSubtype( typing::predefined::DistributionElement inEnum );
          //! \brief Setter for IfcElement predefined type. 
          //! \param [in] inType : The building element predefined type to be assigned in the IfcElement
          void SetPredefinedType( const Dtk_string & inType );
          //! \brief Setter for IfcElement color. 
          //! \param [in] inColor : The color to be assigned in the IfcElement
          void SetColor( const Dtk_RGB & inColor );
          //! \brief Setter for IfcElement instance transformation matrice. 
          //! \param [in] inTrf : The instance transformation matrice to be assigned in the IfcElement
          void SetInstanceTrf( const Dtk_transfo & inTrf );
          //! \brief Setter for IfcElement classification reference
          //! \param [in] inClassificationRef : The classification reference to be assigned in the IfcElement
          void SetClassificationReference( classification::IfcClassificationReference inClassificationRef );
     };
     
     //!  \class IfcBuildingElement
     //! \brief This class has been renamed IfcElement.
     //! \deprecated Use IfcElement instead.
     class IfcBuildingElement
     {
          IfcElement m_oNewClass;
     public:
          //! \deprecated Use IfcElement instead.
          SetAsDeprecated( "2026.3", "Use IfcElement instead." )
          IfcBuildingElement() : m_oNewClass() {};
 
          //! \deprecated Use IfcElement::GetPropertySet instead.
          const Dtk_tab<Dtk_MetaDataPtr>& GetPropertySet() const { return m_oNewClass.GetPropertySet(); }
 
          //! \deprecated Use IfcElement::GetTypeID instead.
          Dtk_ID GetTypeID() const { return m_oNewClass.GetTypeID(); }
          //! \deprecated Use IfcElement::GetName instead.
          const Dtk_string& GetName() const
          {
               return m_oNewClass.GetName();
          }
          //! \deprecated Use IfcElement::GetGUID instead.
          const Dtk_string& GetGUID() const
          {
               return m_oNewClass.GetGUID();
          }
          //! \deprecated Use IfcElement::GetLevel instead.
          const Dtk_string& GetLevel() const
          {
               return m_oNewClass.GetLevel();
          }
          //! \deprecated Use IfcElement::GetTag instead.
          const Dtk_string& GetTag() const
          {
               return m_oNewClass.GetTag();
          }
 
          //! \deprecated Use IfcElement::GetSubtype instead.
          const Dtk_string& GetSubtype() const
          {
               return m_oNewClass.GetSubtype();
          }
          //! \deprecated Use IfcElement::GetPredefinedType instead.
          const Dtk_string& GetPredefinedType() const
          {
               return m_oNewClass.GetPredefinedType();
          }
          //! \deprecated Use IfcElement::GetColor instead.
          Dtk_RGB GetColor() const { return m_oNewClass.GetColor(); }
          //! \deprecated Use IfcElement::GetInstanceTrf instead.
          const Dtk_transfo& GetInstanceTrf() const { return m_oNewClass.GetInstanceTrf(); }
 
          //! \deprecated Use IfcElement::GetClassificationReference instead.
          const classification::IfcClassificationReference& GetClassificationReference() const { return m_oNewClass.GetClassificationReference(); }
          //! \deprecated Use IfcElement::SetPropertySet instead.
          void SetPropertySet( Dtk_tab<Dtk_MetaDataPtr> inProperties, const Dtk_string& inSetName = "" ){ m_oNewClass.SetPropertySet( std::move( inProperties ), inSetName ); };  ;
          //! \deprecated Use IfcElement::AddProperty instead.
          void AddProperty( Dtk_MetaDataPtr inProperty, Dtk_string inSetName = "" ) { m_oNewClass.AddProperty( inProperty, inSetName ); };
          //! \deprecated Use IfcElement::SetName instead.
          void SetName( Dtk_string inName ) { m_oNewClass.SetName( inName ); };
          //! \deprecated Use IfcElement::SetTypeID instead.
          void SetTypeID( const Dtk_ID& inID ) { m_oNewClass.SetTypeID( inID ); };
          //! \deprecated Use IfcElement::SetGUID instead.
          void SetGUID( Dtk_string inGUID ) { m_oNewClass.SetGUID( inGUID ); };
          //! \deprecated Use IfcElement::SetLevel instead.
          void SetLevel( Dtk_string inLevel ) { m_oNewClass.SetLevel( inLevel ); };
          //! \deprecated Use IfcElement::SetTag instead.
          void SetTag( Dtk_string inTag ) { m_oNewClass.SetTag( inTag ); };
          //! \deprecated Use IfcElement::SetSubtype instead.
          void SetBuildingElementType( Dtk_string inType ) { m_oNewClass.SetSubtype( inType ); };
          //! \deprecated Use IfcElement::SetSubtype instead.
          void SetBuildingElementType( typing::predefined::BuildingElement inTypeEnum ){ m_oNewClass.SetSubtype( inTypeEnum ); };
          //! \deprecated Use IfcElement::SetPredefinedType instead.
          void SetPredefinedType( const Dtk_string& inType ) { m_oNewClass.SetPredefinedType( inType ); };
          //! \deprecated Use IfcElement::SetColor instead.
          void SetColor( const Dtk_RGB& inColor ) { m_oNewClass.SetColor( inColor ); };
          //! \deprecated Use IfcElement::SetInstanceTrf instead.
          void SetInstanceTrf( const Dtk_transfo& inTrf ) { m_oNewClass.SetInstanceTrf( inTrf ); };
          //! \deprecated Use IfcElement::SetClassificationReference instead.
          void SetClassificationReference( classification::IfcClassificationReference inClassificationRef ) { m_oNewClass.SetClassificationReference( inClassificationRef ); };
     };
    
     //! \brief Initialize the Ifc Writer and the IFC version you want to write 
    //! \return dtkNoError if it is OK.
    //! \param [in] inOutputFile : Output file name
    //! \param [in] inLogFile : Log file
     //! \param [in] inOptions : options to tune the IFC Writer
    //! \remark This function is the first call for the writer, it must me called after Dtk_API::StartAPI(...)
     //! \see WriteOptions
    DtkErrorStatus InitWrite(const Dtk_string& inOutputFile, const Dtk_string& inLogFile, const WriteOptions& inOptions, ProjectInformation* inProjectInfo = nullptr);
 
    //! \brief Creation of the output file and free the Ifc Writer  
    //! \return dtkNoError if it is OK.
    //! \remark used as the last function used for the writer.
    DtkErrorStatus EndWrite();
 
     //! \brief Initialize an ifcobject with various information. 
     //! \param [in] inParameters : The parameters you want for the object to be written (see IfcElement class)
     //! \return dtkNoError if it is OK.
     //! \remark To close the current object you will need to call EndObject() function .
     DtkErrorStatus InitObject( IfcElement inParameters );
     //! \deprecated Use InitObject( IfcElement inParameters ) instead.
     DtkErrorStatus InitObject( IfcBuildingElement inParameters );
 
     //! \brief Ends the current object
     //! \return dtkNoError if it is OK.
     DtkErrorStatus EndObject();
 
    //! \brief Write the entity provided in parameter. The entity corresponds to current object geometry (e.g: a Dtk_MeshPtr())
    //! \param [in] inEntity : The Entity to be written
     //! \param [in] inMat : The matrice that needs to be applied before the writing
    //! \return dtkNoError if it is OK.
    //! \remark This function is used to write entities (only Dtk_MeshPtr ).
    Dtk_ErrorStatus WriteEntity(const Dtk_EntityPtr& inEntity, const Dtk_transfo & inMat = Dtk_transfo());
 
     //! \brief Write the type provided in parameter. The type can exists by itself without having entities related to it.
     //! \param [in] inType : The ifcType to be written
     //! \return dtkNoError if it is OK.
     //! \remark Should be used before WriteEntity if the entity to be written uses the current ifcType.
     Dtk_ErrorStatus WriteType( const IfcElementType& inType );
     //! \deprecated Use WriteType( const IfcElementType& inType ) instead.
     Dtk_ErrorStatus WriteType( const IfcType& inType );
 
}// namespace Ifcw
 
#endif