#ifndef __NMC_STD_MAP_H__
#define __NMC_STD_MAP_H__

// Prise en compte des définitions spécifiques à la version du compilateur
#if _MSC_VER < 1300
#   include <NMC_std_map.12.h>
#else
#   include <NMC_std_map.13.h>
#endif // _MSC_VER < 1300

// Macro de definition du template
#define NM_TEMPLATE_STD_MAP_DECLARATION template < class keyClass, class objectClass > 
#define NM_TEMPLATE_STD_MAP_PARAMETER < keyClass , objectClass > 

NM_UTILITY_BEGIN

/* ============================================================ */
/* Definition de la classe CStdMap                            */
/* ============================================================ */
NM_TEMPLATE_STD_MAP_DECLARATION  class CStdMap {
    NM_PUBLIC:
        typedef CStdMap NM_TEMPLATE_STD_MAP_PARAMETER                               CTemplateClass;
        typedef typename std::NMMap NM_TEMPLATE_STD_MAP_PARAMETER ::iterator        CIterator;
        typedef typename std::NMMap NM_TEMPLATE_STD_MAP_PARAMETER ::const_iterator  CConstIterator;
        typedef typename std::NMMap NM_TEMPLATE_STD_MAP_PARAMETER ::value_type      CValueType;
        typedef typename std::NMMap NM_TEMPLATE_STD_MAP_PARAMETER ::key_type        CKeyType;


        // Constructeurs et destructeurs
        explicit CStdMap();
        CStdMap(const CStdMap NM_TEMPLATE_STD_MAP_PARAMETER & mapObject) :_internalMap(){ _internalMap = mapObject._internalMap;};
        ~CStdMap();

        // Opérateur d'affectation
        CTemplateClass& operator=(const CTemplateClass& mapObject);

        // Récupération des itérateurs
        CIterator begin();
        CConstIterator begin() const;
        CIterator end();
        CConstIterator end() const;
    
        // Taille courante de la map et taille max
        TLong size() const;
        TLong maxSize() const;


        // Fonctions d'insertion et de suppression
        TReturnCode insert(const keyClass& key, const objectClass& theObject);
        TReturnCode insert(const CValueType& value);
        TReturnCode insert(const CStdMap NM_TEMPLATE_STD_MAP_PARAMETER & valuesList);

        TReturnCode erase(CIterator& theIterator);
        TReturnCode erase(const keyClass& key);
        TVoid clear();

        // Fonctions de recherche et d'accès à un élément.
        TReturnCode find(const keyClass& key,
                         CIterator& resultIterator);
        TReturnCode find(const keyClass& key,
                         CConstIterator& resultIterator) const;
        TReturnCode find(const keyClass& key,
                         CConstIterator& resultIterator)
            {   return ((const CStdMap*)this)->find(key,resultIterator); }
        TReturnCode find(const keyClass& key);
        TReturnCode find(const keyClass& key) const;

        // Opérations ensemblistes
        TReturnCode intersection(const CStdMap NM_TEMPLATE_STD_MAP_PARAMETER & valuesList, 
                                       CStdMap NM_TEMPLATE_STD_MAP_PARAMETER & ResultvaluesList);

		TReturnCode intersection(const CStdMap NM_TEMPLATE_STD_MAP_PARAMETER & valuesList, 
                                       TBoolean & existValueInCommon);	

        NMMDeclAndImplementMapConcretDuplicate(CTemplateClass)

    NM_PRIVATE:
        std::NMMap NM_TEMPLATE_STD_MAP_PARAMETER _internalMap;
};


NM_TEMPLATE_STD_MAP_DECLARATION
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::CStdMap()
    :_internalMap ()
{
}


NM_TEMPLATE_STD_MAP_DECLARATION
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::~CStdMap()
{
}

NM_TEMPLATE_STD_MAP_DECLARATION CStdMap NM_TEMPLATE_STD_MAP_PARAMETER & 
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::operator=(const CStdMap NM_TEMPLATE_STD_MAP_PARAMETER & mapObject)
{
    if (this == &mapObject)
    {
        return (*this);
    }
    _internalMap = mapObject._internalMap ;
    return (*this); 
}

NM_TEMPLATE_STD_MAP_DECLARATION typename CStdMap NM_TEMPLATE_STD_MAP_PARAMETER ::CIterator 
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::begin()
{
    return _internalMap.begin();
}

NM_TEMPLATE_STD_MAP_DECLARATION typename CStdMap NM_TEMPLATE_STD_MAP_PARAMETER ::CConstIterator 
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::begin() const
{
    return (CConstIterator)_internalMap.begin();
}

NM_TEMPLATE_STD_MAP_DECLARATION typename CStdMap NM_TEMPLATE_STD_MAP_PARAMETER ::CIterator 
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::end()
{
    return _internalMap.end();
}

NM_TEMPLATE_STD_MAP_DECLARATION typename CStdMap NM_TEMPLATE_STD_MAP_PARAMETER ::CConstIterator
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::end() const
{
    return (CConstIterator)_internalMap.end();

}

NM_TEMPLATE_STD_MAP_DECLARATION TLong
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::size() const
{
    return (TLong) _internalMap.size();
}

NM_TEMPLATE_STD_MAP_DECLARATION TLong
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::maxSize() const
{
    return (TLong) _internalMap.max_size();
}

NM_TEMPLATE_STD_MAP_DECLARATION TReturnCode 
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::insert(const keyClass& key, const objectClass& theObject)
{
    std::pair< CIterator , bool > stdInsertCode;
    CValueType value(key,theObject);
    // Le test est pour le moment superflu, tout explose avant (essai d'allocation de 4 Go)
    if ( _internalMap.size() == _internalMap.max_size() ){
        return NM_ERROR_INSERT_IN_FULL_MAP;
    }
    stdInsertCode = _internalMap.insert(value);
    if ( stdInsertCode.second == false ) {
        return NM_ERROR_INSERT_KEY_ALREADY_IN_MAP ;
    }
    return NM_OK;
}

NM_TEMPLATE_STD_MAP_DECLARATION TReturnCode
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::insert(const CStdMap NM_TEMPLATE_STD_MAP_PARAMETER & valuesList)
{
    CConstIterator mapIterator ;
    mapIterator = valuesList.begin () ;
    while ( mapIterator != valuesList.end () )
    {
        // inserer la valeur dans la liste
        if ( insert(*mapIterator) == NM_ERROR_INSERT_IN_FULL_MAP )
        {
            return NM_ERROR_INSERT_IN_FULL_MAP;
        }
        
        mapIterator++ ;
    }

    return NM_OK;
}

NM_TEMPLATE_STD_MAP_DECLARATION TReturnCode 
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::insert(const CValueType& value)
{
    std::pair< CIterator , bool > stdInsertCode;
    // Le test est pour le moment superflu, tout explose avant (essai d'allocation de 4 Go)
    if ( _internalMap.size() == _internalMap.max_size() ){
        return NM_ERROR_INSERT_IN_FULL_MAP;
    }
    stdInsertCode = _internalMap.insert(value);
    if ( stdInsertCode.second == false ) {
        return NM_ERROR_INSERT_KEY_ALREADY_IN_MAP ;
    }
    return NM_OK;
}

NM_TEMPLATE_STD_MAP_DECLARATION TReturnCode
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::intersection(const CStdMap NM_TEMPLATE_STD_MAP_PARAMETER & valuesList, 
                                                  CStdMap NM_TEMPLATE_STD_MAP_PARAMETER & ResultvaluesList)
{
    CConstIterator mapIterator ;

    ResultvaluesList.clear () ;

    mapIterator = valuesList.begin () ;
    while ( mapIterator != valuesList.end () )
    {
        if ( find(mapIterator->first) != NM_WARNING_KEY_NOT_IN_MAP )
        {
            if ( ResultvaluesList.insert(*mapIterator) == NM_ERROR_INSERT_IN_FULL_MAP )
            {
                return NM_ERROR_INSERT_IN_FULL_MAP;
            }
        }

        mapIterator++ ;
    }

    return NM_OK;
}

NM_TEMPLATE_STD_MAP_DECLARATION TReturnCode
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::intersection(const CStdMap NM_TEMPLATE_STD_MAP_PARAMETER & valuesList, 
                                            TBoolean & existValueInCommon)
{
    CConstIterator mapIterator ;

	existValueInCommon = NM_FALSE;
    mapIterator = valuesList.begin () ;

    while ( mapIterator != valuesList.end () )
    {
        if ( find(mapIterator->first) != NM_WARNING_KEY_NOT_IN_MAP )
        {
            existValueInCommon = NM_TRUE;
			return NM_OK;
		}
        mapIterator++ ;
    }

    return NM_OK;
}

NM_TEMPLATE_STD_MAP_DECLARATION TReturnCode
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::erase(typename CStdMap NM_TEMPLATE_STD_MAP_PARAMETER ::CIterator& theIterator)
{
    if ( _internalMap.size() == 0 )
    {
        theIterator = this->end() ;
        return NM_ERROR_ERASE_IN_EMPTY_MAP;
    }
    if ( theIterator == _internalMap.end() )
        return NM_ERROR_ERASE_ELEMENT_OUT_OF_MAP;
    theIterator = _internalMap.erase( theIterator );
    return NM_OK;
}

NM_TEMPLATE_STD_MAP_DECLARATION TReturnCode
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::erase(const keyClass& key)
{
    TLong removedElement;
    if ( _internalMap.size() == 0 )
        return NM_ERROR_ERASE_IN_EMPTY_MAP;
    removedElement = (TLong) _internalMap.erase( key );
    if ( removedElement == 0 )
        return NM_ERROR_ERASE_KEY_NOT_IN_MAP;
    return NM_OK;
}

NM_TEMPLATE_STD_MAP_DECLARATION TVoid
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::clear()
{
    _internalMap.clear();
}

NM_TEMPLATE_STD_MAP_DECLARATION TReturnCode
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::find(const keyClass& key,
                                    typename CStdMap NM_TEMPLATE_STD_MAP_PARAMETER ::CIterator& resultIterator)
{
    resultIterator = _internalMap.find(key);
    if ( resultIterator == _internalMap.end() )
        return NM_WARNING_KEY_NOT_IN_MAP;
    return NM_OK;
}


NM_TEMPLATE_STD_MAP_DECLARATION TReturnCode
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::find(const keyClass& key,
                                    typename CStdMap NM_TEMPLATE_STD_MAP_PARAMETER ::CConstIterator& resultIterator) const
{
    resultIterator = (CConstIterator)_internalMap.find(key);
    if ( resultIterator == _internalMap.end() )
        return NM_WARNING_KEY_NOT_IN_MAP;
    return NM_OK; 
}

NM_TEMPLATE_STD_MAP_DECLARATION TReturnCode
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::find(const keyClass& key)
{
    CIterator iterator; 
    return find( key, iterator);
}

NM_TEMPLATE_STD_MAP_DECLARATION TReturnCode
CStdMap
NM_TEMPLATE_STD_MAP_PARAMETER::find(const keyClass& key) const
{
    CConstIterator iterator; 
    return find( key, iterator); 
}

NM_TEMPLATE_STD_MAP_DECLARATION 
inline bool
operator== ( const CStdMap NM_TEMPLATE_STD_MAP_PARAMETER & firstObject, 
             const CStdMap NM_TEMPLATE_STD_MAP_PARAMETER & secondObject) 
{	return (firstObject.size() == secondObject.size()
	        && equal(firstObject.begin(), firstObject.end(), secondObject.begin()));
}

NM_TEMPLATE_STD_MAP_DECLARATION 
inline bool  
operator!= ( const CStdMap NM_TEMPLATE_STD_MAP_PARAMETER & firstObject, 
             const CStdMap NM_TEMPLATE_STD_MAP_PARAMETER & secondObject)
{
        return (firstObject.size() != secondObject.size()
	        || !(equal(firstObject.begin(), firstObject.end(), secondObject.begin())));
}

NM_UTILITY_END

// Macro de définition des opérateur << et >> sur une stdmap
#define NMMDeclareInOutOperatorsMapStd(mapClass,streamClass) \
    inline streamClass& operator<<(streamClass& stream, const mapClass& data) \
    { \
        nmutility::TULong size=data.size(); \
        stream<<size; \
        for (mapClass::CConstIterator it=data.begin();it!=data.end();it++) \
        {stream<<it->first<<it->second;} \
        return stream; \
    } \
    inline streamClass& operator>>(streamClass& stream, mapClass& data) \
    { \
        nmutility::TULong size; \
        stream>>size; \
        data.clear(); \
        for (nmutility::TULong index=0;index<size;index++) \
        { \
            mapClass::CKeyType key; \
            mapClass::CValueType value; \
            stream>>key>>value.second; \
            data.insert(key,value.second); \
        } \
        return stream; \
    } \
    inline streamClass& operator<<(mapClass& data, streamClass& stream) \
    { \
        data.clear(); \
        return stream>>data; \
    } \
    inline streamClass& operator>>(const mapClass& data, streamClass& stream) \
    { \
        return stream<<data; \
    } 


#endif // __NMC_STD_MAP_H__