stack.h

 
#ifndef _aspose_system_collections_stack_h_
#define _aspose_system_collections_stack_h_
 
#include "system/object.h"
#include "system/array.h"
#include "system/collections/base_enumerator.h"
#include "system/collections/icollection.h"
#include "system/cycles_detection.h"
 
#include <list>
#include <iterator>
 
namespace System {
namespace Collections {
namespace Generic {
 
template<typename T> class Stack;
 
template<typename T>
class ASPOSECPP_SHARED_CLASS StackPtr : public SharedPtr<Stack<T> >
{
public:
    StackPtr() {}
    StackPtr(const SharedPtr<Stack<T> >& obj) : SharedPtr<Stack<T> >(obj) { }
};
 
template<typename T>
class ASPOSECPP_SHARED_CLASS Stack : public IEnumerable<T>
{
    ASPOSE_COLLECTION_POINTER_MODE_CONTROL(T)
 
public:
    typedef T ValueType;
 
private:
    RTTI_INFO_TEMPLATE_CLASS(System::Collections::Generic::Stack<T>, System::BaseTypesInfo<System::Object>);
 
public:
    typedef std::list<T, ASPOSE_COLLECTION_ALLOCATOR_TYPE> stack_t;
 
protected:
    typedef SharedPtr<Stack<T> > ThisPtr;
    typedef typename stack_t::reverse_iterator queueIt_t;
    stack_t m_data;
 
public:
    typedef SharedPtr<IEnumerable<T> > IEnumerablePtr;
    typedef SharedPtr<IEnumerator<T> > IEnumeratorPtr;
 
    class Enumerator : public ReverseEnumerator<stack_t>
    {
    public:
        Enumerator(const ThisPtr& data) : ReverseEnumerator<stack_t>(data, data->m_data) { }
        RTTI_INFO_TEMPLATE_CLASS(Stack<T>::Enumerator, System::BaseTypesInfo<System::Object>);
    };
 
    Stack() : ASPOSE_COLLECTION_INIT_ALLOCATOR() {}
    Stack(int capacity) : ASPOSE_COLLECTION_INIT_ALLOCATOR()
    {
        if (capacity < 0)
        {
            throw ArgumentOutOfRangeException(u"capacity");
        }
        /* do nothing, underlying data structure doesn't support reserve  */
    }
    Stack(IEnumerablePtr collection) : ASPOSE_COLLECTION_INIT_ALLOCATOR()
    {
        AddRange(collection);
    }
 
    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 Push(const T& item)
    {
        m_data.push_back(item);
    }
    T Pop()
    {
        if (m_data.empty())
            throw InvalidOperationException(u"Stack is empty");
 
        T rv = m_data.back();
        m_data.pop_back();
        return rv;
    }
    T Peek()
    {
        if (m_data.empty())
            throw InvalidOperationException(u"Stack is empty");
 
        return m_data.back();
    }
 
    stack_t& data() { return m_data; }
    const stack_t& data() const { return m_data; }
 
    virtual ArrayPtr<T> ToArray()
    {
        ArrayPtr<T> result = System::MakeObject<Array<T> >(this->get_Count());
 
        std::copy(m_data.rbegin(), m_data.rend(), result->data().begin());
 
        return result;
    }
 
    void AddRange(IEnumerablePtr collection)
    {
        if (!collection)
        {
            throw ArgumentNullException(u"collection");
        }
 
        IEnumeratorPtr it = collection->GetEnumerator();
        while (it->MoveNext())
        {
            m_data.push_back(it->Current());
        }
    }
 
    System::Details::VirtualizedIteratorBase<T>* virtualizeBeginIterator() override
    {
        return new System::Details::NativeIteratorWrapper<T, typename stack_t::reverse_iterator>(m_data.rbegin(), m_data.rend());
    }
    System::Details::VirtualizedIteratorBase<T>* virtualizeEndIterator() override
    {
        return new System::Details::NativeIteratorWrapper<T, typename stack_t::reverse_iterator>(m_data.rend(), m_data.rend());
    }
    System::Details::VirtualizedIteratorBase<T>* virtualizeBeginConstIterator() const override
    {
        return new System::Details::NativeConstIteratorWrapper<T, typename stack_t::const_reverse_iterator>(m_data.crbegin(), m_data.crend());
    }
    System::Details::VirtualizedIteratorBase<T>* virtualizeEndConstIterator() const override
    {
        return new System::Details::NativeConstIteratorWrapper<T, typename stack_t::const_reverse_iterator>(m_data.crend(), m_data.crend());
    }
 
protected:
    ~Stack() override = default;
 
#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 "Stack<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_stack_h_