DictionnaryImplementationUtilities.h

// Copyright (c) 2015. All rights reserved to DriveEngine Team.

#pragma once

#include <vector>
#include "CollectionsImplementationUtilities.h"


#define _GENERATE_DICTIONNARY_ENUMERATOR_H() \
    _GENERATE_COLLECTION_ENUMERATOR_H(Dictionnary)


#define _GENERATE_DICTIONNARY_CONST_ENUMERATOR_H() \
    _GENERATE_COLLECTION_CONST_ENUMERATOR_H(Dictionnary)


#define _GENERATE_DICTIONNARY_ENUMERATOR(dictionnaryClassName, pairClassName)\
    _GENERATE_COLLECTION_ENUMERATOR(dictionnaryClassName, Dictionnary, result = pairClassName::Create(*iterator->first, *iterator->second);)


#define _GENERATE_DICTIONNARY_CONST_ENUMERATOR(dictionnaryClassName, pairClassName)\
    _GENERATE_COLLECTION_CONST_ENUMERATOR(dictionnaryClassName, Dictionnary, result = pairClassName::Create(*iterator->first, *iterator->second);)


#define _GENERATE_DICTIONNARY_H(keyInterfaceName, elementInterfaceName, pairInterfaceName) \
private:\
    typedef std::map<const keyInterfaceName*, elementInterfaceName*> Dictionnary;\
    typedef std::pair<const keyInterfaceName*, elementInterfaceName*> DictionnaryPair;\
    Dictionnary dictionnary;\
\
public:\
\
    /* ICollection */\
\
    virtual Size                GetSize() const;\
    virtual bool                IsEmpty() const;\
    virtual IEnumerator*        GetEnumerator() const;\
    virtual IConstEnumerator*   GetConstEnumerator() const;\
    virtual void                Clear();\
\
\
    /* IDictionnary */\
\
    virtual IExportable*        GetElement(const IExportable &key) const;\
    virtual const IExportable*  GetConstElement(const IExportable &key) const;\
    virtual void                Add(const IExportable &key, IExportable &element);\
    virtual void                Remove(const IExportable &key);\
    virtual void                AddDictionnary(const IDictionnary &dictionnary);\
    virtual void                RemoveDictionnary(const IDictionnary &dictionnary);\
\
    /* elementInterfaceName */\
    elementInterfaceName*       Get##elementInterfaceName##(const keyInterfaceName &key) const;\
    virtual void                Add(const keyInterfaceName &key, elementInterfaceName &element);\
    virtual void                Remove(const keyInterfaceName &key);\
\
\
private:\
    elementInterfaceName*           ConvertElement(IExportable& element) const;\
    const keyInterfaceName*         ConvertKey(const IExportable& key) const;\
    pairInterfaceName*              ConvertPair(IExportable& pair) const;\
    const pairInterfaceName*        ConvertPair(const IExportable& pair) const;\
\
_GENERATE_DICTIONNARY_ENUMERATOR_H()\
_GENERATE_DICTIONNARY_CONST_ENUMERATOR_H()


#define GENERATE_DICTIONNARY_H(keyInterfaceName, elementInterfaceName, pairInterfaceName) \
    _GENERATE_DICTIONNARY_H(keyInterfaceName, elementInterfaceName, pairInterfaceName)


#define _GENERATE_DICTIONNARY(dictionnaryClassName, keyInterfaceName, elementInterfaceName, pairInterfaceName, pairClassName) \
\
/* ICollection */\
\
_GENERATE_COLLECTION_COMMON(dictionnaryClassName, dictionnary)\
\
void dictionnaryClassName::Clear()\
{\
    Dictionnary::const_iterator iterator = dictionnary.cbegin();\
    while (iterator != dictionnary.cend())\
    {\
        ::DeleteReference(iterator->first); \
        ::DeleteReference(iterator->second); \
        dictionnary.erase(iterator);\
        iterator = dictionnary.cbegin();\
    }\
}\
\
\
/* IDictionnary */\
\
IExportable* dictionnaryClassName::GetElement(const IExportable &key) const\
{\
    const keyInterfaceName* convertedKey = ConvertKey(key);\
    if (convertedKey == nullptr){ /* An error has been thrown */ return nullptr; }\
\
    return Get##elementInterfaceName##(*convertedKey);\
}\
\
const IExportable* dictionnaryClassName::GetConstElement(const IExportable &key) const\
{\
    return GetElement(key);\
}\
\
void dictionnaryClassName::Add(const IExportable &key, IExportable &element)\
{\
    elementInterfaceName* convertedElement = ConvertElement(element);\
    if (convertedElement == nullptr){ /* An error has been thrown */ return; }\
\
    const keyInterfaceName* convertedKey = ConvertKey(key);\
    if (convertedKey == nullptr){ /* An error has been thrown */ return; }\
\
    Add(*convertedKey, *convertedElement);\
}\
\
void dictionnaryClassName::Remove(const IExportable &key)\
{\
    const keyInterfaceName* convertedKey = ConvertKey(key);\
    if (convertedKey == nullptr){ /* An error has been thrown */ return; }\
\
    Remove(*convertedKey);\
}\
\
void dictionnaryClassName::AddDictionnary(const IDictionnary &dictionnary)\
{\
    if (Precondition::IsNotNull(dictionnary, "The dictionnary must not be null."))\
    {\
        IEnumerator* enumerator = dictionnary.GetEnumerator();\
        while (enumerator->MoveNext())\
        {\
            IExportable* pair = enumerator->GetCurrent();\
            pairInterfaceName* convertedPair = ConvertPair(*pair);\
            if (convertedPair == nullptr){ /* An error has been thrown */ return; }\
\
            Add(*convertedPair->GetKey(), *convertedPair->GetValue());\
            convertedPair->Delete();\
        }\
    }\
}\
\
void dictionnaryClassName::RemoveDictionnary(const IDictionnary &dictionnary)\
{\
    if (Precondition::IsNotNull(dictionnary, "The dictionnary must not be null."))\
    {\
        IEnumerator* enumerator = dictionnary.GetEnumerator();\
        while (enumerator->MoveNext())\
        {\
            IExportable* pair = enumerator->GetCurrent();\
            pairInterfaceName* convertedPair = ConvertPair(*pair);\
            if (convertedPair == nullptr){ /* An error has been thrown */ return; }\
\
            Remove(*convertedPair->GetKey());\
            convertedPair->Delete();\
        }\
    }\
}\
\
\
/* dictionnaryClassName */\
\
elementInterfaceName* dictionnaryClassName::Get##elementInterfaceName##(const keyInterfaceName &key) const\
{\
    if (Precondition::IsNotNull(key, "The key of the element to remove must not be null."))\
    {\
        Dictionnary::const_iterator iterator = dictionnary.find(&key);\
        if (iterator != dictionnary.end())\
        {\
            return iterator->second;\
        }\
    }\
    return nullptr;\
}\
\
void dictionnaryClassName::Add(const keyInterfaceName &key, elementInterfaceName &element)\
{\
    if (Precondition::IsNotNull(key, "The image to add must not be null.") &&\
        Precondition::IsNotNull(element, "The position to add must not be null."))\
    {\
        Dictionnary::iterator iterator = dictionnary.find(&key);\
        if (iterator == dictionnary.end())\
        {\
            ::AddReference(&key);\
            ::AddReference(&element);\
            dictionnary.insert(DictionnaryPair(&key, &element));\
        }\
        else\
        {\
            ::AddReference(&element);\
            ::DeleteReference(iterator->second);\
            iterator->second = &element;\
        }\
    }\
}\
\
void dictionnaryClassName::Remove(const keyInterfaceName &key)\
{\
    if (Precondition::IsNotNull(key, "The key of the element to remove must not be null."))\
    {\
        Dictionnary::iterator iterator = dictionnary.find(&key);\
        if (iterator == dictionnary.end()){ return; }\
\
        ::DeleteReference(iterator->first);\
        ::DeleteReference(iterator->second);\
        dictionnary.erase(iterator);\
    }\
}\
\
elementInterfaceName* dictionnaryClassName::ConvertElement(IExportable& element) const\
{\
    if (Precondition::IsNotNull(element, "The element must not be null."))\
    {\
        elementInterfaceName* convertedElement = dynamic_cast<elementInterfaceName*>(&element);\
        if (Precondition::IsNotNull(convertedElement, "The element cannot be converted."))\
        {\
            return convertedElement;\
        }\
    }\
    return nullptr;\
}\
\
const keyInterfaceName* dictionnaryClassName::ConvertKey(const IExportable& key) const\
{\
    if (Precondition::IsNotNull(key, "The key must not be null."))\
    {\
        const keyInterfaceName* convertedKey = dynamic_cast<const keyInterfaceName*>(&key);\
        if (Precondition::IsNotNull(convertedKey, "The key cannot be converted."))\
        {\
            return convertedKey;\
        }\
    }\
    return nullptr;\
}\
\
pairInterfaceName* dictionnaryClassName::ConvertPair(IExportable& pair) const\
{\
    if (Precondition::IsNotNull(pair, "The pair must not be null."))\
    {\
        pairInterfaceName* convertedPair = dynamic_cast<pairInterfaceName*>(&pair);\
        if (Precondition::IsNotNull(convertedPair, "The key cannot be converted."))\
        {\
            return convertedPair;\
        }\
    }\
    return nullptr;\
}\
\
const pairInterfaceName* dictionnaryClassName::ConvertPair(const IExportable& pair) const\
{\
    if (Precondition::IsNotNull(pair, "The pair must not be null."))\
    {\
        const pairInterfaceName* convertedPair = dynamic_cast<const pairInterfaceName*>(&pair);\
        if (Precondition::IsNotNull(convertedPair, "The key cannot be converted."))\
        {\
            return convertedPair;\
        }\
    }\
    return nullptr;\
}\
_GENERATE_DICTIONNARY_ENUMERATOR(dictionnaryClassName, pairClassName)\
_GENERATE_DICTIONNARY_CONST_ENUMERATOR(dictionnaryClassName, pairClassName)


#define GENERATE_DICTIONNARY(dictionnaryClassName, keyInterfaceName, elementInterfaceName, pairInterfaceName, pairClassName) \
    _GENERATE_DICTIONNARY(dictionnaryClassName, keyInterfaceName, elementInterfaceName, pairInterfaceName, pairClassName)