ListImplementationUtilities.h

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

#pragma once

#include <vector>

#define GENERATE_LIST_H(elementClassName) \
private: \
    typedef std::vector<elementClassName*> List; \
    List list; \
\
public: \
\
    /* ICollection */\
\
    virtual Size                GetSize() const; \
    virtual bool                IsEmpty() const; \
    virtual IEnumerator*        GetEnumerator() const; \
    virtual IConstEnumerator*   GetConstEnumerator() const; \
    virtual void                Clear(); \
\
\
    /* IList */ \
\
    virtual IExportable*        GetElement(Index index) const; \
    virtual const IExportable*  GetConstElement(Index index) const; \
    virtual void                Add(IExportable &element); \
    virtual void                Remove(IExportable &element); \
    virtual void                AddList(const IList &list); \
    virtual void                RemoveList(const IList &list); \
\
    /* elementClassName */ \
\
    virtual void                Add(elementClassName &element); \
    virtual void                Remove(elementClassName &element); \
    elementClassName*           Get##elementClassName##(Index index) const; \
\
private: \
    elementClassName*       Convert(IExportable& element); \
\
private: \
    class Enumerator : public IEnumerator \
    { \
    private: \
        bool hasMovedAtLeastOnce; \
        List::const_iterator iterator; \
        List::const_iterator begin; \
        List::const_iterator end; \
\
    public: \
\
        Enumerator(List::const_iterator& begin, List::const_iterator& end); \
\
        /* IExportable */ \
\
        virtual void Delete() const; \
\
\
        /* IEnumerator */ \
\
        virtual bool         MoveNext(); \
        virtual IExportable* GetCurrent() const; \
        virtual void         Reset(); \
    }; \
\
    class ConstEnumerator : public IConstEnumerator \
    { \
    private: \
        bool hasMovedAtLeastOnce; \
        List::const_iterator iterator; \
        List::const_iterator begin; \
        List::const_iterator end; \
\
    public: \
\
        ConstEnumerator(List::const_iterator& begin, List::const_iterator& end); \
\
\
        /* IExportable */ \
\
        virtual void Delete() const; \
\
\
        /* IEnumerator */ \
\
        virtual bool               MoveNext(); \
        virtual const IExportable* GetCurrent() const; \
        virtual void               Reset(); \
    };




#define GENERATE_LIST(listClassName, elementClassName) \
\
\
/* ICollection */\
\
Size listClassName::GetSize() const \
{ \
    return (Size)this->list.size(); \
} \
\
bool listClassName::IsEmpty() const \
{ \
    return this->list.empty(); \
} \
\
IEnumerator* listClassName::GetEnumerator() const \
{ \
    return new Enumerator(list.begin(), list.end()); \
} \
\
IConstEnumerator* listClassName::GetConstEnumerator() const \
{ \
    return new ConstEnumerator(list.begin(), list.end()); \
} \
\
void listClassName::Clear() \
{ \
    list.clear(); \
} \
\
\
/* IList */\
\
IExportable* listClassName::GetElement(Index index) const \
{ \
    return Get##elementClassName##(index); \
} \
\
const IExportable* listClassName::GetConstElement(Index index) const \
{ \
    return GetElement(index); \
} \
\
void listClassName::Add(IExportable &element) \
{ \
    elementClassName* convertedElement = Convert(element); \
    if (convertedElement == nullptr){ /* An error has been thrown */ return; } \
\
    Add(*convertedElement); \
} \
\
void listClassName::Remove(IExportable &element) \
{ \
    elementClassName* convertedElement = Convert(element); \
    if (convertedElement == nullptr){ /* An error has been thrown */ return; } \
\
    Remove(*convertedElement); \
} \
\
void listClassName::AddList(const IList &list) \
{ \
    if (Precondition::IsNotNull(list, "The list must not be null.")) \
    { \
        IEnumerator* enumerator = list.GetEnumerator(); \
        while (enumerator->MoveNext()) \
        { \
            Add(*enumerator->GetCurrent()); \
        } \
    } \
} \
\
void listClassName::RemoveList(const IList &list) \
{ \
    if (Precondition::IsNotNull(list, "The list must not be null.")) \
    { \
        IEnumerator* enumerator = list.GetEnumerator(); \
        while (enumerator->MoveNext()) \
        { \
            Remove(*enumerator->GetCurrent()); \
        } \
    } \
} \
\
\
/* elementClassName */\
\
elementClassName* listClassName::Get##elementClassName##(Index index) const \
{ \
    elementClassName* element = nullptr; \
    if (Precondition::IsTrue(0 <= index && index < (Index)list.size(), "Outbound index.")) \
    { \
        element = list[index]; \
    } \
    return element; \
} \
\
void listClassName::Add(elementClassName &element) \
{ \
    if (Precondition::IsNotNull(element, "The element to add must not be null.")) \
    { \
        ::AddReference(&element); \
        list.push_back(&element); \
    } \
} \
\
void listClassName::Remove(elementClassName &element) \
{ \
    if (Precondition::IsNotNull(element, "The element to remove must not be null.")) \
    { \
        List::iterator iterator = std::find(list.begin(), list.end(), &element); \
        if (iterator == list.end()){ return; } \
        \
        ::DeleteReference(*iterator); \
        list.erase(iterator);  \
    } \
} \
\
elementClassName* listClassName::Convert(IExportable& element) \
{ \
    if (Precondition::IsNotNull(element, "The element must not be null.")) \
    { \
        elementClassName* convertedElement = dynamic_cast<elementClassName*>(&element); \
        if (Precondition::IsNotNull(convertedElement, "The element cannot be converted.")) \
        { \
            return convertedElement; \
        } \
    } \
    return nullptr; \
} \
\
/* Enumerator */ \
\
\
void listClassName::Enumerator::Delete() const \
{ \
    delete this; \
} \
\
\
listClassName::Enumerator::Enumerator(List::const_iterator& begin, List::const_iterator& end) \
    : begin(begin), \
    end(end), \
    iterator(begin), \
    hasMovedAtLeastOnce(false) \
{} \
\
\
bool listClassName::Enumerator::MoveNext() \
{ \
    if (!hasMovedAtLeastOnce) \
    { \
        iterator = begin; \
        hasMovedAtLeastOnce = true; \
    } \
    else if (iterator != end) \
    { \
        ++iterator; \
    } \
\
    return (iterator != end); \
} \
\
\
IExportable* listClassName::Enumerator::GetCurrent() const \
{ \
    IExportable* result = nullptr; \
    if (hasMovedAtLeastOnce && iterator != end) \
    { \
        result = *iterator; \
    } \
    return result; \
} \
\
\
void listClassName::Enumerator::Reset() \
{ \
    iterator = begin; \
    hasMovedAtLeastOnce = false; \
} \
\
\
/* ConstEnumerator */ \
\
\
void listClassName::ConstEnumerator::Delete() const \
{ \
    delete this; \
} \
\
\
listClassName::ConstEnumerator::ConstEnumerator(List::const_iterator& begin, List::const_iterator& end) \
    : begin(begin), \
    end(end), \
    iterator(begin), \
    hasMovedAtLeastOnce(false) \
{} \
\
\
bool listClassName::ConstEnumerator::MoveNext() \
{ \
    if (!hasMovedAtLeastOnce) \
    { \
        iterator = begin; \
        hasMovedAtLeastOnce = true; \
    } \
    else if (iterator != end) \
    { \
        ++iterator; \
    } \
\
    return (iterator != end); \
} \
\
\
const IExportable* listClassName::ConstEnumerator::GetCurrent() const \
{ \
    IExportable* result = nullptr; \
    if (hasMovedAtLeastOnce && iterator != end) \
    { \
        result = *iterator; \
    } \
    return result; \
} \
\
\
void listClassName::ConstEnumerator::Reset() \
{ \
    iterator = begin; \
    hasMovedAtLeastOnce = false; \
}