queue.h

 
#ifndef _aspose_system_collections_queue_h_
#define _aspose_system_collections_queue_h_
 
#include "system/object.h"
#include "system/collections/base_enumerator.h"
#include "system/collections/ienumerable.h"
#include "system/collections/icollection.h"
#include "system/cycles_detection.h"
 
#include <list>
 
namespace System {
namespace Collections {
namespace Generic {
 
template<typename T> class Queue;
 
template<typename T>
class ASPOSECPP_SHARED_CLASS QueuePtr : public SharedPtr<Queue<T> >
{
public:
    QueuePtr() {}
    QueuePtr(const SharedPtr<Queue<T> >& obj) : SharedPtr<Queue<T> >(obj) { }
};
 
template<typename T>
class ASPOSECPP_SHARED_CLASS Queue : public IEnumerable<T>
{
    ASPOSE_COLLECTION_POINTER_MODE_CONTROL(T)
 
public:
    typedef T ValueType;
 
private:
    RTTI_INFO_TEMPLATE_CLASS(System::Collections::Generic::Queue<T>, System::BaseTypesInfo<System::Object>);
 
public:
    typedef std::list<T, ASPOSE_COLLECTION_ALLOCATOR_TYPE> queue_t;
 
protected:
    typedef SharedPtr<Queue<T> > ThisPtr;
    typedef typename queue_t::iterator queueIt_t;
    queue_t m_data;
 
public:
    typedef SharedPtr<IEnumerable<T> > IEnumerablePtr;
    typedef SharedPtr<IEnumerator<T> > IEnumeratorPtr;
 
    class Enumerator : public SimpleEnumerator<queue_t>
    {
    public:
        Enumerator(const ThisPtr& data) : SimpleEnumerator<queue_t>(data, data->m_data) { }
        RTTI_INFO_TEMPLATE_CLASS(Queue<T>::Enumerator, System::BaseTypesInfo<System::Object>);
    };
 
    Queue() : ASPOSE_COLLECTION_INIT_ALLOCATOR() {}
    Queue(int capacity) : ASPOSE_COLLECTION_INIT_ALLOCATOR()
    {
        if (capacity < 0) {
            throw ArgumentOutOfRangeException(u"capacity");
        }
    }
    Queue(const SharedPtr<IEnumerable<T>>& items) : ASPOSE_COLLECTION_INIT_ALLOCATOR()
    {
        if (!items)
        {
            throw ArgumentNullException(u"items");
        }
 
        auto e = items->GetEnumerator();
        while (e->MoveNext())
            m_data.push_back(e->get_Current());
    }
 
    IEnumeratorPtr GetEnumerator() override
    {
        return MakeObject<Enumerator>(MakeSharedPtr(this));
    }
 
    virtual int get_Count() const
    {
        return ASPOSECPP_CHECKED_CAST(int, m_data.size());
    }
    virtual void Clear()
    {
        m_data.clear();
    }
 
    virtual bool Contains(const T& item) const
    {
        return std::find(m_data.begin(), m_data.end(), item) != m_data.end();
    }
    void Enqueue(const T& item)
    {
        m_data.push_back(item);
    }
    T Dequeue()
    {
        if (m_data.empty())
        {
            throw InvalidOperationException(u"Queue is empty");
        }
        T rv = m_data.front();
        m_data.pop_front();
        return rv;
    }
    T Peek()
    {
        if (m_data.empty())
        {
            throw InvalidOperationException(u"Queue is empty");
        }
        return m_data.front();
    }
 
    queue_t& data() { return m_data; }
    const queue_t& data() const { return m_data; }
 
    System::Details::VirtualizedIteratorBase<T>* virtualizeBeginIterator() override
    {
        return new System::Details::NativeIteratorWrapper<T, typename queue_t::iterator>(m_data.begin(), m_data.end());
    }
    System::Details::VirtualizedIteratorBase<T>* virtualizeEndIterator() override
    {
        return new System::Details::NativeIteratorWrapper<T, typename queue_t::iterator>(m_data.end(), m_data.end());
    }
    System::Details::VirtualizedIteratorBase<T>* virtualizeBeginConstIterator() const override
    {
        return new System::Details::NativeConstIteratorWrapper<T, typename queue_t::const_iterator>(m_data.begin(), m_data.end());
    }
    System::Details::VirtualizedIteratorBase<T>* virtualizeEndConstIterator() const override
    {
        return new System::Details::NativeConstIteratorWrapper<T, typename queue_t::const_iterator>(m_data.end(), m_data.end());
    }
 
protected:
    ~Queue() override {}
 
#ifdef __DBG_FOR_EACH_MEMBER
public:
    void DBG_for_each_member(DBG::for_each_member_visitor &visitor) const override
    {
        visitor.add_self(this);
        DBG::for_each_of_Object(this, m_data, visitor);
    }
 
    const char* DBG_class_name() const override { return "Queue<T>"; }
#endif
 
protected:
#ifdef ASPOSE_GET_SHARED_MEMBERS
    DEFINE_GET_SHARED_MEMBERS(m_data)
#endif
};
 
} // namespace Generic
} // namespace Collections
} // namespace System
 
#endif // _aspose_system_collections_queue_h_