object_list.h

Go to the documentation of this file.

#ifndef _ADTF_UCOM_ANT_OBJECT_LIST_INCLUDES_HEADER_
#define _ADTF_UCOM_ANT_OBJECT_LIST_INCLUDES_HEADER_
 
namespace adtf
{
namespace ucom
{
namespace ant
{
template<typename INTERFACE_TYPE>
class iobject_enum
{
protected:
    ~iobject_enum()
    {
    }
    ~iobject_enum() {…}
 
public:
    typedef iobject_ptr<INTERFACE_TYPE>  value_type;
    typedef iobject_enum<INTERFACE_TYPE> my_type;

    virtual tResult PushObject(const value_type& oObject) = 0;
    virtual tResult GetObjects(my_type& oObjectsEnum) const = 0;
    virtual size_t   GetSize() const = 0;
};
class iobject_enum {…};

enum object_enum_push_option
{
    eNone = 0x00,
    eNoDuplicates = 0x01
};
enum object_enum_push_option {…};

template <typename T,
          typename INTERFACE_TYPE = T,
          template<typename ELEM,
                   typename ALLOC = std::allocator<ELEM>
                   > class CONTAINER = std::list
          >
class object_enum_base : public iobject_enum < INTERFACE_TYPE >
{
    template <typename, typename, template<typename, typename> class >
    friend class object_enum;
public:
    typedef CONTAINER<object_ptr<T>>                  container_type;
    typedef iobject_enum<INTERFACE_TYPE>              base_type;
    typedef base_type                                 interface_type;
    typedef object_ptr<T>                             value_type;
private:
    container_type* m_pContainer;
    uint32_t         m_ui32PushOption = object_enum_push_option::eNone;
 
private:
    object_enum_base() : m_pContainer(nullptr)
    {
    }
    object_enum_base(const object_enum_base&) = delete;
    object_enum_base(object_enum_base&&) = delete;
    object_enum_base& operator=(const object_enum_base&) = delete;
    object_enum_base& operator=(object_enum_base&&) = delete;
 
    void SetContainerRef(container_type* pContainer)
    {
        m_pContainer = pContainer;
    }
public:
    object_enum_base(container_type* pContainer) : m_pContainer(pContainer)
    {
    }
    object_enum_base(container_type* pContainer) : m_pContainer(pContainer) {…}
    virtual ~object_enum_base()
    {
        Reset();
    }
    void Reset()
    {
        m_pContainer = nullptr;
    }
 
    void SetPushOption(uint32_t ui32PushOption)
    {
        m_ui32PushOption = ui32PushOption;
    }
 
    tResult PushObject(const typename interface_type::value_type& oObject) override
    {
        if (m_pContainer)
        {
            value_type oPushObject = oObject;
            if (oPushObject)
            {
                if ((m_ui32PushOption & object_enum_push_option::eNoDuplicates)
                    == object_enum_push_option::eNoDuplicates)
                {
                    //needs to be implemented!!
                }
                //succedded ucom_cast conversion from INTERFACE_TYPE to T
                m_pContainer->push_back(oObject);
                RETURN_NOERROR;
            }
            else
            {
                //no ucom_cast conversion from INTERFACE_TYPE to T
                RETURN_ERROR(ERR_INVALID_INTERFACE);
            }
        }
        else
        {
            RETURN_ERROR(ERR_NOT_INITIALIZED);
        }
    }
    tResult GetObjects(base_type& oObjectsEnum) const override
    {
        if (m_pContainer)
        {
            typename container_type::const_iterator it = m_pContainer->cbegin();
            for (; it != m_pContainer->cend(); ++it)
            {
                object_ptr<INTERFACE_TYPE> oConversion = *it;
                if (oConversion)
                {
                    //not care about result
                    oObjectsEnum.PushObject(oConversion);
                }
                else
                {
                    //ucomcast failed we can non push the value
                }
            }
            RETURN_NOERROR;
        }
        else
        {
            RETURN_ERROR(ERR_NOT_INITIALIZED);
        }
 
    }
    size_t GetSize() const override
    {
        if (m_pContainer)
        {
            return m_pContainer->size();
        }
        else
        {
            return 0;
        }
    }
    size_t GetSize() const override {…}
};
class object_enum_base : public iobject_enum < INTERFACE_TYPE > {…};
 

template<typename T,
         typename INTERFACE_TYPE = T,
         template<typename ELEM,
                  typename ALLOC = std::allocator<ELEM>
                  > class CONTAINER = std::list
         >
//template <typename T, typename INTERFACE_TYPE = T, typename CONTAINER = std::list<object_ptr<T>>>
class object_enum : public object_enum_base < T, INTERFACE_TYPE, CONTAINER >
{
public:
    typedef object_enum_base<T, INTERFACE_TYPE, CONTAINER> base_type;
    typedef typename base_type::container_type             container_type;
    typedef typename base_type::interface_type             interface_type;
    typedef object_ptr<T>                                  value_type;
    typedef iobject_ptr<T>                                 value_interface_type;

    container_type m_oContainer;
 
public: //iterators
    typedef typename container_type::const_iterator const_iterator;
    typedef typename container_type::const_reverse_iterator const_reverse_iterator;
    typedef typename container_type::iterator iterator;
    typedef typename container_type::reverse_iterator reverse_iterator;
 
public:
    iterator begin()
    {
        return m_oContainer.begin();
    }
    iterator begin() {…}

    iterator end()
    {
        return m_oContainer.end();
    }
    iterator end() {…}

    const_iterator cbegin() const
    {
        return m_oContainer.cbegin();
    }
    const_iterator cbegin() const {…}

    const_iterator cend() const
    {
        return m_oContainer.cend();
    }
    const_iterator cend() const {…}
    reverse_iterator rbegin()
    {
        return m_oContainer.rbegin();
    }
    reverse_iterator rend()
    {
        return m_oContainer.rend();
    }
    const_reverse_iterator crbegin() const
    {
        return m_oContainer.crbegin();
    }
    const_reverse_iterator crend() const
    {
        return m_oContainer.crend();
    }
 
public:
    object_enum() : base_type(&m_oContainer), m_oContainer()
    {
    }
    object_enum() : base_type(&m_oContainer), m_oContainer() {…}

    object_enum(const object_enum& oOther) :
        base_type(&m_oContainer), m_oContainer(oOther.m_oContainer)
    {
    }
    object_enum(const object_enum& oOther) : {…}

    object_enum(object_enum&& oOther) : base_type()
    {
        std::swap(m_oContainer, oOther.m_oContainer);
        base_type::SetContainerRef(&m_oContainer);
    }
    object_enum(object_enum&& oOther) : base_type() {…}

    object_enum(const container_type& oResetContainerContent) :
        base_type(&m_oContainer),
        m_oContainer(oResetContainerContent)
    {
    }
    object_enum(const container_type& oResetContainerContent) : {…}

    object_enum(std::initializer_list<value_type> lstValues) : base_type(&m_oContainer),
                m_oContainer(lstValues)
    {
    }
    object_enum(std::initializer_list<value_type> lstValues) : base_type(&m_oContainer), {…}

    object_enum& operator=(const object_enum& oOther)
    {
        m_oContainer = oOther.m_oContainer;
        return *this;
    }
    object_enum& operator=(const object_enum& oOther) {…}

    object_enum& operator=(object_enum&& oOther)
    {
        std::swap(m_oContainer, oOther.m_oContainer);
        this->SetContainerRef(&m_oContainer);
        return *this;
    }
    object_enum& operator=(object_enum&& oOther) {…}

    object_enum& operator=(const container_type& oResetContainerContent)
    {
        m_oContainer = oResetContainerContent;
        return *this;
    }
    object_enum& operator=(const container_type& oResetContainerContent) {…}
 

    container_type& GetContainer()
    {
        return m_oContainer;
    }
    container_type& GetContainer() {…}
 
    void PushBack(const value_type& oObjectValue)
    {
        m_oContainer.push_back(oObjectValue);
    }
 
    void PushFront(const value_type& oObjectValue)
    {
        m_oContainer.push_front(oObjectValue);
    }
 
    void Clear()
    {
        m_oContainer.clear();
    }
 
    void DeleteObject(const value_interface_type& oObject)
    {   //gcc 4.8 doesn't take const_iterator types as parameter for erase()...
        for (auto it = m_oContainer.begin();
            it != m_oContainer.end();
            it++)
        {
            if ((*it) == oObject)
            {
                m_oContainer.erase(it);
                return;
            }
        }
    }
 
// hide the reset function of object_enum_intf
private:
    using base_type::Reset;
 
};
class object_enum : public object_enum_base < T, INTERFACE_TYPE, CONTAINER > {…};

template<typename T>
using iobject_list = iobject_enum < T > ;

template<typename T>
using iobject_vector = iobject_enum < T >;

template<typename T, typename INTERFACE_TYPE = T>
using object_list = object_enum < T, INTERFACE_TYPE, std::list>;

template<typename T, typename INTERFACE_TYPE = T>
using object_vector = object_enum < T, INTERFACE_TYPE, std::vector>;
 
 
}//namespace ant
 
 
using ant::iobject_enum;
using ant::iobject_list;
using ant::iobject_vector;
 
using ant::object_enum;
 
using ant::object_list;
using ant::object_vector;
 
 
}//namespace ucom
}//namespace adtf
 
#endif // _ADTF_UCOM_ANT_OBJECT_LIST_INCLUDES_HEADER_