dtk_log.hpp

Go to the documentation of this file.

#ifndef _DTK_LOG_HPP_
#define _DTK_LOG_HPP_
#include "def/define.h"
#include "util/dtk_maindoc_ptr.hpp"
#include "util/BaseTypes/dtk_object.hpp"
#include "util/BaseTypes/dtk_string.hpp"
#include "util/error_dtk.hpp"
#include "util/util_stl_dtk.hpp"
#include <memory>
 
class Dtk_Log;
typedef Dtk_SmartPtr<Dtk_Log> Dtk_LogPtr;
 
class Dtk_Log_Inventory 
{
protected:
    struct Dtk_Handle;      // Not defined here
    std::unique_ptr<Dtk_Handle> _Private;   // Handle
     friend class Dtk_SmartPtr<Dtk_Log>;
 
public:
    Dtk_Log_Inventory();
    Dtk_Log_Inventory(const Dtk_Log_Inventory& inInventory);
    Dtk_Log_Inventory(Dtk_Log_Inventory&& inInventory) DTK_NOEXCEPT;
    Dtk_Log_Inventory& operator=(const Dtk_Log_Inventory& inInventory);
    Dtk_Log_Inventory& operator=(Dtk_Log_Inventory&& inInventory) DTK_NOEXCEPT;
    ~Dtk_Log_Inventory();
 
    //! \brief Get total count of entities in inventory  
    //! \return Total count of entities
    Dtk_Size_t GetTotalCount() const;
 
    //! \brief Get number of entity types in inventory  
    //! \return Number of entity types
    Dtk_Size_t GetNbEntityTypes() const;
 
    //! \brief Get entity type in inventory from index
    //! \param [in] inIndex : Index (with range [0..GetNbEntityTypes()-1])
    //! \return Entity type
    const Dtk_string & GetEntityType(Dtk_Size_t inIndex) const;
 
    //! \brief Get count of entities with the same type in inventory from index
    //! \param [in] inIndex : Index (with range [0..GetNbEntityTypes()-1])
    //! \return Count of entities
    int GetEntitiesCount(Dtk_Size_t inIndex) const;
 
    //! \brief Adds entity type and its count to inventory  
    //! \param [in] inCount : Count of entities
    //! \param [in] inName : Entity type 
    // must only be called to fill inventory
    void AddEntity(int inCount, const Dtk_string& inName);
};
 
class Dtk_Log_Message 
{
protected:
    struct Dtk_Handle;      // Not defined here
    std::unique_ptr<Dtk_Handle> _Private;   // Handle
 
public:
    Dtk_Log_Message();
    Dtk_Log_Message(const Dtk_Log_Message& inMessage);
    Dtk_Log_Message( Dtk_Log_Message&& inMessage) DTK_NOEXCEPT;
    ~Dtk_Log_Message();
    Dtk_Log_Message& operator=(const Dtk_Log_Message& inMessage);
    Dtk_Log_Message& operator=( Dtk_Log_Message&& inMessage) DTK_NOEXCEPT;
 
    //! \brief Get message type  
    //! \return Message type
    const Dtk_string & GetType() const;
 
    //! \brief Get message  
    //! \return Message
    const Dtk_string & GetMessageInfo() const;
 
    //! \brief Set message type 
    //! \param [in] inValue : Message type
    void SetType(const Dtk_string& inValue);
 
    //! \brief Set message
    //! \param [in] inValue : Message
    void SetMessageInfo(const Dtk_string& inValue);
};
 
class Dtk_Log_Component_Info 
{
protected:
    struct Dtk_Handle;      // Not defined here
    std::unique_ptr<Dtk_Handle> _Private;   // Handle
 
public:
    Dtk_Log_Component_Info();
    Dtk_Log_Component_Info(const Dtk_Log_Component_Info& inComponentInfo);
    Dtk_Log_Component_Info( Dtk_Log_Component_Info&& inComponentInfo) DTK_NOEXCEPT;
    ~Dtk_Log_Component_Info();
    Dtk_Log_Component_Info& operator=(const Dtk_Log_Component_Info& inComponentInfo);
    Dtk_Log_Component_Info& operator=( Dtk_Log_Component_Info&& inComponentInfo) DTK_NOEXCEPT;
 
     //! \brief Get if component is a catalog or a not  
     //! \return DTK_TRUE if it is a catalog, DTK_FALSE if otherwise
     Dtk_bool GetIsCatalog() const;
 
    //! \brief Get if component is an assembly or a part  
    //! \return DTK_TRUE if it is an assembly, DTK_FALSE if it is a part
    Dtk_bool GetIsAssembly() const;
 
    //! \brief Get if component is internal  
    //! \return DTK_TRUE if it is internal, DTK_FALSE otherwise
    Dtk_bool GetIsInternal() const;
 
    //! \brief Get name of component
    //! \return Name of component
    const Dtk_string & GetName() const;
 
    //! \brief Get full path name of component
    //! \return Full path name of component
    const Dtk_string & GetFullPathName() const;
 
    //! \brief Get number of instantiations of component  
    //! \return Number of instantiations of component
    int GetQuantity() const;
 
    //! \brief Get file size of component
    //! \return File size of component
    long GetFileSize() const;
 
    //! \brief Get unit scale of component
    //! \return Dtk_Double64 in millimeters
    Dtk_Double64 GetUnitScale() const;
 
    //! \brief Get file version of component  
    //! \return File version of component
    const Dtk_string & GetFileVersion() const;
 
    //! \brief Get path of component
    //! \return Path of component
    const Dtk_string & GetPath() const;
 
     //! \brief Set if component is a catalog
   //! \param [in] inVal : DTK_TRUE if it is a catalog, DTK_FALSE otherwise
     void SetIsCatalog(Dtk_bool val);
 
    //! \brief Set if component is an assembly or a part.
    //! \param [in] inVal : DTK_TRUE if it is an assembly, DTK_FALSE if it is a part
    void SetIsAssembly(Dtk_bool val);
 
    //! \brief Set if component is internal 
    //! \param [in] inVal : DTK_TRUE if it is internal, DTK_FALSE otherswise
    void SetIsInternal(Dtk_bool val);
 
    //! \brief Set name of component
    //! \param [in] inVal : Name of component
    void SetName(const Dtk_string& val);
 
    //! \brief Set full path name of component
    //! \param [in] inVal : Full path name of component
    void SetFullPathName(const Dtk_string& val); 
 
    //! \brief Set number of instantiations of component
    //! \param [in] inVal : Number of instantiations of component
    void SetQuantity(int val); 
 
    //! \brief Set file size of component
    //! \param [in] inVal : File size of component
    void SetFileSize(long val);
 
    //! \brief Set unit scale of component
    //! \param [in] inVal : Dtk_Double64 in millimeters
    void SetUnitScale(Dtk_Double64 val); 
 
    //! \brief Set file version of component
    //! \param [in] inVal : File version of component
    void SetFileVersion(const Dtk_string& val);
};
 
class Dtk_Log : public Dtk_Object
{
protected:
    struct Dtk_Handle;      // Not defined here
    std::unique_ptr<Dtk_Handle> _Private;   // Handle
     enum { _typeID = DTK_TYPE_LOG };
 
private :
     friend class Dtk_SmartPtr<Dtk_Log>;
 
public:
    Dtk_Log();
    virtual ~Dtk_Log();
 
     //! \CreateBase
     static Dtk_LogPtr Create();
     //! \brief downcasting
     int DtkDynamicType(const int& inId);
     static Dtk_Log * DtkDynamicCast(Dtk_Object * inObject);
 
    //! \brief Get log file name (with .xml extension)  
    //! \return Log file name
    const Dtk_string & GetLogFileName() const;
 
    //! \brief Get API version 
    //! \return API version
    int GetAPIVersion() const;
 
    //! \brief Get product mode
    //! \return "Psk" if it uses Pskernel, "Dtk" if not
    const Dtk_string & GetProductMode() const;
 
    //! \brief Get input format name 
    //! \return Input format name (an empty string is returned if reading is not used)
    const Dtk_string & GetInputFormat() const;
 
    //! \brief Get output format name 
    //! \return Output format name (an empty string is returned if writing is not used)
    const Dtk_string & GetOutputFormat() const;
 
    //! \brief Get healing flag
    //! \return -1 if not set, 1 if healing is used, 0 if not
    int GetHealingFlag() const;
 
    //! \brief Get config file name 
    //! \return Config file name
    const Dtk_string & GetConfigFileName() const;
 
    //! \brief Get input file name
    //! \return Input file name (an empty string is returned if reading is not used)
    const Dtk_string & GetInputFileName() const;
 
    //! \brief Get file version of input file  
    //! \return File version of input file
    const Dtk_string & GetInputFileVersion() const;
 
    //! \brief Get output file name
    //! \return Output file name (an empty string is returned if writing is not used)
    const Dtk_string & GetOutputFileName() const;
 
    //! \brief Get size of output file  
    //! \return -1 if not set, size of output file otherwise
    long GetOutputFileSize() const;
 
    //! \brief Get unit scale 
    //! \return double in millimeters
    double GetUnitScale() const;
 
    //! \brief Get start time of process  
    //! \return Start time of process
    time_t GetStartTime() const;
 
    //! \brief Get stop time of process  
    //! \return stop time of process
    time_t GetStopTime() const;
 
    //! \brief Get start hour of process  
    //! \return Start hour of process
     const Dtk_string & GetStartHour() const;
 
    //! \brief Get stop hour of process  
    //! \return stop hour of process
     const Dtk_string & GetStopHour() const;
 
    //! \brief Get CPU time of process  
    //! \return CPU time of process
    double GetCPUTime() const;
 
    //! \brief Get wall time of process  
    //! \return Wall time of process
    double GetWallTime() const;
 
    //! \brief Get peak working set size of process  
    //! \return CPU time of process
     Dtk_UInt64 GetPeakWorkingSetSize() const;
 
    //! \brief Get working set size of process  
    //! \return Wall time of process
     Dtk_UInt64 GetWorkingSetSize() const;
 
    //! \brief Get Xsl schema name used in the .xml log file 
    //! \return Xsl schema name ("dtk_versionxxx.xsl")
    const Dtk_string & GetXslSchemaName() const;
 
    //! \brief Get Folder that contains .xsl schema file used in .xml log file  
    //! \return Folder name that contains .xsl schema file
    const Dtk_string & GetXslFolder() const;
 
    //! \brief Get full file path of the .xsl schema file used in .xml log file  
    //! \return File path of the .xsl schema file
    Dtk_string GetXslFilePath() const;
 
     //! \brief Get if there was a crash or not  
     //! \return DTK_TRUE if yes, DTK_FALSE otherwise
     Dtk_bool GetIsCrash();
 
    //! \brief Get number of sections of the configuration  
    //! \return Number of sections of the configuration
    Dtk_Size_t GetNbConfigSections();
 
    //! \brief Get configuration section information (section name, parameters and values) from index 
    //! \param [in] inIndex : Index (with range [0..GetNbConfigSections()-1]) 
    //! \param [out] outName : Section name
    //! \param [out] outParameters : Array of parameters
    //! \param [out] outValues : Array of values
    //! \return dtkNoError if OK
    Dtk_ErrorStatus GetConfigSection(Dtk_Size_t inIndex, Dtk_string& outName, Dtk_tab<Dtk_string>& outParameters, Dtk_tab<Dtk_string>& outValues);
    
    //! \brief Get list of ID of read components
    //! \param [in] outListID : Array of component ID (it is empty if reading is not used)
    Dtk_ErrorStatus GetListComponentID(Dtk_tab<Dtk_ID>& outListID);
 
    //! \brief Get component information from component ID 
    //! \param [in] inComponentID : Component ID
    //! \param [out] outComponentInfo : Dtk_Log_Component_Info that contains component information
    //! \return dtkNoError if OK
    Dtk_ErrorStatus GetComponentInfo(Dtk_Size_t inComponentID, Dtk_Log_Component_Info& outComponentInfo);
 
    //! \brief Get reading error status of component from component ID 
    //! \param [in] inComponentID : Component ID
    //! \param [out] outReadingErrorStatus : Reading error status (Dtk_ErrorStatus)
    //! \return dtkNoError if OK
    Dtk_ErrorStatus GetComponentReadingErrorStatus(Dtk_Size_t inComponentID, Dtk_ErrorStatus& outReadingErrorStatus);
 
    //! \brief Get inventory of component from its ID
    //! \param [in] inComponentID : Component ID
    //! \param [out] outInventory : Dtk_Log_Inventory that contains component inventory
    //! \return dtkNoError if OK
    Dtk_ErrorStatus GetComponentInventory(Dtk_Size_t inComponentID, Dtk_Log_Inventory& outInventory);
 
    //! \brief Get synthetic inventory of component from its ID
    //! \param [in] inComponentID : Component ID
    //! \param [out] outInventory : Dtk_Log_Inventory that contains component inventory
    //! \return dtkNoError if OK
    Dtk_ErrorStatus GetComponentSyntheticInventory(Dtk_Size_t inComponentID, Dtk_Log_Inventory& outInventory);
 
    //! \brief Get warning messages associated to a component from its ID
    //! \param [in] inComponentID : Component ID 
    //! \param [out] outMessages : Array of Dtk_Log_Message
    //! \return dtkNoError if OK
    Dtk_ErrorStatus GetComponentWarningMessages(Dtk_Size_t inComponentID, Dtk_tab<Dtk_Log_Message>& outMessages);
 
    //! \brief Get error messages associated to a component from its ID 
    //! \param [in] inComponentID : Component ID
    //! \param [out] outMessages : Array of Dtk_Log_Message
    //! \return dtkNoError if OK
    Dtk_ErrorStatus GetComponentErrorMessages(Dtk_Size_t inComponentID, Dtk_tab<Dtk_Log_Message>& outMessages);
 
    //! \brief Get info messages associated to a component from its ID 
    //! \param [in] inComponentID : Component ID
    //! \param [out] outMessages : Array of Dtk_Log_Message
    //! \return dtkNoError if OK
    Dtk_ErrorStatus GetComponentInfoMessages(Dtk_Size_t inComponentID, Dtk_tab<Dtk_Log_Message>& outMessages);
 
    //! \brief Get global warning messages
    //! \param [out] outMessages : Array of Dtk_Log_Message
    //! \return dtkNoError if OK
    Dtk_ErrorStatus GetGlobalWarningMessages(Dtk_tab<Dtk_Log_Message>& outMessages);
 
    //! \brief Get global error messages 
    //! \param [out] outMessages : Array of Dtk_Log_Message
    //! \return dtkNoError if OK
    Dtk_ErrorStatus GetGlobalErrorMessages(Dtk_tab<Dtk_Log_Message>& outMessages);
 
    //! \brief Get global info messages 
    //! \param [out] outMessages : Array of Dtk_Log_Message
    //! \return dtkNoError if OK
    Dtk_ErrorStatus GetGlobalInfoMessages(Dtk_tab<Dtk_Log_Message>& outMessages);
 
    //! \brief Get List of ID of missing components
    //! \return Array of Dtk_ID
    // only useful for reading
    Dtk_tab<Dtk_ID> GetListMissingComponents();
 
    //! \brief Get list of names of written output files
    //! \return Array of output file names
    // only useful for writing
    const Dtk_tab<Dtk_string> & GetOutputFileNamesWritten() const;
 
    //! \brief Get inventory of written output file from its name 
    //! \param [in] inFileName : Name of output file
    //! \param [out] outInventory : Dtk_Log_Inventory that contains output file inventory
    //! \return dtkNoError if OK
    Dtk_ErrorStatus GetOutputFileInventory(Dtk_string inFileName, Dtk_Log_Inventory& outInventory);
 
    //! \brief Get synthetic inventory of written output file from its name 
    //! \param [in] inFileName : Name of output file
    //! \param [out] outInventory : Dtk_Log_Inventory that contains output file inventory
    //! \return dtkNoError if OK
    Dtk_ErrorStatus GetOutputFileSyntheticInventory(Dtk_string inFileName, Dtk_Log_Inventory& outInventory);
 
    //! \brief Get number of validation properties of an output file from its name 
    //! \param [in] inOutputFileName : Name of written output file
    //! \return Number of validation properties
    Dtk_Size_t GetNbOutputFileValidationProperties(const Dtk_string& inOutputFileName);
 
    //! \brief Get validation property of an output file from its name and index
    //! \param [in] inOutputFileName : Name of written output file
    //! \param [in] inIndex : Index (with range [0..GetNbOutputFileValidationProperties()-1]) 
    //! \param [out] outEntityID : Entity ID 
    //! \param [out] outEntityType : Entity type
    //! \param [out] outValPropName : Validation property name
    //! \param [out] outRead : Read value
    //! \param [out] outComputed : Computed value
    //! \param [out] outGap : Gap value
    //! \param [out] outStatus : Status
    //! \return dtkNoError if OK
    Dtk_ErrorStatus GetOutputFileValidationProperty(const Dtk_string& inOutputFileName, Dtk_Size_t inIndex, Dtk_string &outEntityID, Dtk_string &outEntityType,
                Dtk_string &outValPropName, Dtk_string &outRead, Dtk_string &outComputed, Dtk_string &outGap, Dtk_string &outStatus);
 
    //! \brief Get number of validation properties of a component from its ID 
    //! \param [in] inComponentID : Component ID
    //! \return Number of validation properties
    Dtk_Size_t GetNbValidationProperties(Dtk_Size_t inComponentID);
 
    //! \brief Get validation property of a component from its ID and index
    //! \param [in] inComponentID : Component ID
    //! \param [in] inIndex : Index (with range [0..GetNbValidationProperties()-1]) 
    //! \param [out] outEntityID : Entity ID 
    //! \param [out] outEntityType : Entity type
    //! \param [out] outValPropName : Validation property name
    //! \param [out] outRead : Read value
    //! \param [out] outComputed : Computed value
    //! \param [out] outGap : Gap value
    //! \param [out] outStatus : Status
    //! \return dtkNoError if OK
    Dtk_ErrorStatus GetValidationProperty(Dtk_Size_t inComponentID, Dtk_Size_t inIndex, Dtk_string &outEntityID, Dtk_string &outEntityType,
        Dtk_string &outValPropName, Dtk_string &outRead, Dtk_string &outComputed, Dtk_string &outGap, Dtk_string &outStatus);
 
    //! \brief Set log file name
    //! \param [in] inVal : Log file name with .xml extension
    void SetLogFileName(const Dtk_string& inVal);
 
    //! \brief Set product mode
    //! \param [in] inVal : "Psk" if it uses Pskernel, "Dtk" if not
    void SetProductMode(const Dtk_string& inVal);
 
    //! \brief Set input format name
    //! \param [in] inVal : Input format name
    void SetInputFormat(const Dtk_string& inVal);
 
    //! \brief Set output format name
    //! \param [in] inVal : Output format name
    void SetOutputFormat(const Dtk_string& inVal);
 
    //! \brief Set healing flag
    //! \param [in] inVal : 1 if healing is used, 0 if not
    void SetHealingFlag(int inVal);
 
    //! \brief Set config file name
    //! \param [in] inVal : Config file name with .dtk extension
    void SetConfigFileName(const Dtk_string& inVal);
 
    //! \brief Set input file name
    //! \param [in] inVal : Input file name
    void SetInputFileName(const Dtk_string& inVal);
 
    //! \brief Set input file version
    //! \param [in] inVal : Input file version
    void SetInputFileVersion(const Dtk_string& inVal);
 
    //! \brief Set output file name
    //! \param [in] inVal : Output file name
    void SetOutputFileName(const Dtk_string& inVal);
 
    //! \brief Set unit scale
    //! \param [in] inVal : double in millimeters 
    void SetUnitScale(double inVal);
 
    //! \brief Set start time
    //! \param [in] inVal : Start time
    void SetStartTime(time_t inVal);
 
    //! \brief Set stop time
    //! \param [in] inVal : Stop time
    void SetStopTime(time_t inVal);
 
    //! \brief Set start hour
    //! \param [in] inVal : Start hour
    void SetStartHour(Dtk_string inVal);
 
    //! \brief Set stop hour
    //! \param [in] inVal : Stop hour
    void SetStopHour(Dtk_string inVal);
 
    //! \brief Set CPU time
    //! \param [in] inVal : CPU time
    void SetCPUTime(double inVal);
    
    //! \brief Set wall time
    //! \param [in] inVal : Wall time
    void SetWallTime(double inVal);
 
    //! \brief Set Peak working set size
    //! \param [in] inVal : CPU time
    void SetPeakWorkingSetSize( Dtk_UInt64 inVal);
 
    //! \brief Set working set size
    //! \param [in] inVal : Wall time
    void SetWorkingSetSize( Dtk_UInt64 inVal);
 
    //! \brief Set Folder that contains .xsl schema file to use in .xml log file
    //! \param [in] inVal : Folder name that contains .xsl schema file
    void SetXslFolder(const Dtk_string& inVal);
 
     //! \brief Tells if there was a crash or not
     //! \param [in] inVal : DTK_TRUE if yes, DTK_FALSE otherwise
     void SetIsCrash(Dtk_bool inVal);
 
     //! \brief Tells if .xsl must be embedded in the .xml log file
     //! \param [in] inVal : DTK_TRUE if .xsl must be embedded in the .xml log file, DTK_FALSE otherwise
     void SetIsXslEmbedded(Dtk_bool inVal);
 
    //! \brief Fill log with config information (must be called after config initialization)
    //! \return dtkNoError if OK
    Dtk_ErrorStatus FillConfig();
 
    //! \brief Associates temporary file to another file (used for writing when using temporary file to create another one)
    //! \param [in] inTemporaryFile : Name of temporary file to associate
    //! \param [out] inFileName : Name of file to be associated to the temporary file
    //! \return dtkNoError if OK
    Dtk_ErrorStatus AssociateFileNames(const Dtk_string& inTemporaryFile, const Dtk_string& inFileName);
 
    //! \brief Adds to log a reading inventory and associates it to a component from its ID  
    //! \param [in] inComponentID : Component ID
    //! \param [in] inNum : Number of entity types
    //! \param [in] inCount : Array of count of entities (size of array must be inNum)
    //! \param [in] inEntitiesName : Array of entity names (size of array must be inNum)
    //! \return dtkNoError if OK
    Dtk_ErrorStatus AddReadingInventory(Dtk_ID inComponentID, int inNum, const int *inCount, const char **inEntitiesName);
 
     //! \brief Adds to log a reading inventory and associates it to a component from its ID  
     //! \param [in] inComponentID : Component ID
     //! \param [in] inName : entity name
     //! \param [in] inCount : Number to add (default =  1)
     //! \return dtkNoError if OK
     Dtk_ErrorStatus AddReadingEntity(Dtk_ID inComponentID, const char * inName, int inCount=1);
 
    //! \brief Adds to log a synthetic reading inventory and associates it to a component from its ID  
    //! \param [in] inComponentID : Component ID
    //! \param [in] inNum : Number of entity types
    //! \param [in] inCount : Array of count of entities (size of array must be inNum)
    //! \param [in] inEntitiesName : Array of entity names (size of array must be inNum)
    //! \return dtkNoError if OK
    Dtk_ErrorStatus AddSyntheticReadingInventory(Dtk_ID inComponentID, int inNum, int *inCount, char **inEntitiesName);
 
    //! \brief Adds to log a writing inventory and associates it to an output file from its name  
    //! \param [in] inOutputFileName : Output file name
    //! \param [in] inNum : Number of entity types
    //! \param [in] inCount : Array of count of entities (size of array must be inNum)
    //! \param [in] inEntitiesName : Array of entity names (size of array must be inNum)
    //! \return dtkNoError if OK
    Dtk_ErrorStatus AddWritingInventory(const Dtk_string& inOutputFileName, int inNum, int *inCount, char **inEntitiesName);
 
    //! \brief Adds to log a synthetic writing inventory and associates it to an output file from its name  
    //! \param [in] inOutputFileName : Output file name
    //! \param [in] inNum : Number of entity types
    //! \param [in] inCount : Array of count of entities (size of array must be inNum)
    //! \param [in] inEntitiesName : Array of entity names (size of array must be inNum)
    //! \return dtkNoError if OK
    Dtk_ErrorStatus AddSyntheticWritingInventory(const Dtk_string& inOutputFileName, int inNum, int *inCount, char **inEntitiesName);
 
    //! \brief Adds to log the name of a written output file
    //! \param [in] inOutputFileName : Name of written output file
    //! \param [in] isRoot : DTK_TRUE if output file is root, DTK_FALSE otherwise
    //! \return dtkNoError if OK
    Dtk_ErrorStatus AddOutputFileNameWritten(const Dtk_string& inOutputFileName, Dtk_bool isRoot = DTK_FALSE);
 
    //! \brief Adds to log a warning message 
    //! \param [in] inMessage : Message
    //! \param [in] inType : Type
    //! \param [in] inComponentID : -1 if message is global, component ID otherwise
    //! \return dtkNoError if OK
    Dtk_ErrorStatus AddWarningMessage(const Dtk_string& inMessage, const Dtk_string& inType, int inComponentID = -1);
 
    //! \brief Adds to log an error message 
    //! \param [in] inMessage : Message
    //! \param [in] inType : Type
    //! \param [in] inComponentID : -1 if message is global, component ID otherwise
    //! \return dtkNoError if OK
    Dtk_ErrorStatus AddErrorMessage(const Dtk_string& inMessage, const Dtk_string& inType, int inComponentID = -1);
 
    //! \brief Adds to log an info message 
    //! \param [in] inMessage : Message
    //! \param [in] inType : Type
    //! \param [in] inComponentID : -1 if message is global, component ID otherwise
    //! \return dtkNoError if OK
    Dtk_ErrorStatus AddInfoMessage(const Dtk_string& inMessage, const Dtk_string& inType, int inComponentID = -1);
 
    //! \brief Adds to log the info of a read component and its reading error status
    //! \param [in] inComponent : Dtk_ComponentPtr pointer to the read component
    //! \param [in] inStatus : Reading error status (Dtk_ErrorStatus)
    //! \return dtkNoError if OK
    Dtk_ErrorStatus AddComponentInfoAndReadingErrorStatus(const Dtk_ComponentPtr& inComponent, Dtk_ErrorStatus inStatus);
 
    //! \brief Adds to log the info of a read file and its reading error status (must only be called if Dtk_ComponentPtr is not used by reading)
    //! \param [in] inInputFileName : Input file name
    //! \param [in] inFileVersion : Input file version
    //! \param [in] inIsAssembly : 1 if root component of the file is an assembly, 0 if it is a part
    //! \param [in] inUnitScale : Dtk_Double64 in millimeters
    //! \param [in] inStatus : Reading error status (Dtk_ErrorStatus)
    //! \return dtkNoError if OK
    Dtk_ErrorStatus AddFileInfoAndReadingErrorStatus(const Dtk_string& inInputFileName, Dtk_string inFileVersion, Dtk_bool inIsAssembly,
                                                     Dtk_Double64 inUnitScale, Dtk_ErrorStatus inStatus);
 
    //! \brief Add to log the validation property of a component from its ID
    //! \param [in] inComponentID : Component ID
    //! \param [in] inEntityID : Entity ID 
    //! \param [in] inEntityType : Entity type
    //! \param [in] inValPropName : Validation property name
    //! \param [in] inRead : Read value
    //! \param [in] inComputed : Computed value
    //! \param [in] inGap : Gap value
    //! \param [in] inStatus : Status
    //! \return dtkNoError if OK
    Dtk_ErrorStatus AddValidationProperty(Dtk_Size_t inComponentID, const Dtk_string &inEntityID, const Dtk_string &inEntityType,
                                          const Dtk_string &inValPropName, const Dtk_string &inRead, const Dtk_string &inComputed,
                                          const Dtk_string &inGap, const Dtk_string &inStatus);
 
    //! \brief Add to log the validation property of an output file from its name
    //! \param [in] inOutputFileName : Name of written output file
    //! \param [in] inEntityID : Entity ID 
    //! \param [in] inEntityType : Entity type
    //! \param [in] inValPropName : Validation property name
    //! \param [in] inWrite : Write value
    //! \return dtkNoError if OK
    Dtk_ErrorStatus AddOutputFileValidationProperty(const Dtk_string& inOutputFileName, const Dtk_string &inEntityID, const Dtk_string &inEntityType,
        const Dtk_string &inValPropName, const Dtk_string &inWrite);
 
    //! \brief Write the content of the log into the .xml file (SetLogFileName() must be called for that)
    //! \return dtkNoError if OK
    virtual Dtk_ErrorStatus Write();
 
    //! \brief Flush the content of the log
    //! \return dtkNoError if OK
    virtual Dtk_ErrorStatus Flush();
};
 
 
 
 
#endif