LogMessageManager.h

// LogMessageManager.h:
// --------------------
//

#ifndef __IPSDKUTIL_LOGMESSAGEMANAGER_H__
#define __IPSDKUTIL_LOGMESSAGEMANAGER_H__

// suppression warnings
// warning C4275: interface non dll class 'boost::noncopyable_::noncopyable' utilisée comme base d'une interface dll class 'ipsdk::LogMessageManager'
// warning C4251: 'ipsdk::LogMessageManager::_libraryName' : class 'std::basic_string<_Elem,_Traits,_Ax>' nécessite une interface DLL pour être utilisé(e) par les clients de class 'ipsdk::LogMessageManager'
#pragma warning (push)
#pragma warning (disable : 4275 4251)

#include <IPSDKUtil/IPSDKUtilExports.h>
#include <IPSDKUtil/BaseTypes.h>
#include <IPSDKUtil/Tools/EnumUtils.h>
#include <boost/noncopyable.hpp>
#include <boost/checked_delete.hpp> // Anticipating Boost 1.75
#include <map>

namespace boost {
    template<typename Target, typename Source>
    Target lexical_cast(const Source &arg);
}

namespace ipsdk {


class IPSDKUTIL_API LogMessageManager : boost::noncopyable
{
    // friend function for members access
    template<class T>
    friend void boost::checked_delete(T * x) BOOST_NOEXCEPT;

public:
    static LogMessageManager&   getInstance(const std::string& libraryName);

protected:
    LogMessageManager(const std::string& libraryName);
    ~LogMessageManager();
    
// methods
public:
    const std::string&  getLibraryName() const;

    template <typename EnumT>
    bool                existsMessage(const EnumT& messageId) const
    {
        return existsMessage(typeid(EnumT).name(), (ipInt32)messageId);
    }

    bool                existsMessage(const std::string& enumTypeStr,
                                      ipInt32 messageId) const;

    template <typename EnumT>
    const std::string&  getMessage(const EnumT& messageId)
    {
        return getMessage(typeid(EnumT).name(), (ipInt32)messageId);
    }

    const std::string&  getMessage(const std::string& enumTypeStr,
                                   ipInt32 messageId) const;

    void                clear();

    template <typename EnumT>
    void                removeMessage(const EnumT& messageId)
    {
        removeMessage(typeid(EnumT).name(), (ipInt32)messageId);
    }

    void                removeMessage(const std::string& enumTypeStr,
                                      ipInt32 messageId);

    template <typename EnumT>
    void                addMessage(const EnumT& messageId,
                                   const std::string& messageStr)
    {
        addMessage(typeid(EnumT).name(), (ipInt32)messageId, messageStr);
    }

    void                addMessage(const std::string& enumTypeStr,
                                   ipInt32 messageId,
                                   const std::string& messageStr);

    void                readFile(const boost::filesystem::path& msgFilePath,
                                 bool bAppend,
                                 EnumStringToIntFunc enumStringToIntFunction =
                                 boost::lexical_cast<ipInt32, const std::string&>);

// attributes
protected:
    std::string         _libraryName;

    typedef std::map<ipInt32, std::string> MessageMap;

    typedef std::map<std::string, MessageMap> MessageColl;

    MessageColl         _messageColl;
};


} // end of namespace ipsdk

#pragma warning (pop)

#endif // __IPSDKUTIL_LOGMESSAGEMANAGER_H__