IArray.h

//------------------------------------------------------------------------------
//
// Copyright (c) 2012 Glympse Inc.  All rights reserved.
//
//------------------------------------------------------------------------------

#ifndef IARRAY_H__GLYMPSE__
#define IARRAY_H__GLYMPSE__

namespace Glympse 
{
    
/*C*/
template< class T > struct IArray;
template< class T > class GArray
{
    private: GArray();
    public: typedef O< IArray< T > > ptr;
};


/*C*/template< class T > struct IArray : public ICommon
/*J*public interface GArray<T> extends GCommon, Iterable<T>**/
/*S*public interface GArray<T> : GCommon, IReadOnlyList<T>**/
{
    public: virtual int32 length() = 0;
    
    public: virtual T at(int32 index) = 0;  
    
    public: virtual typename GEnumeration<T>::ptr elements() = 0;
    
    public: virtual typename GArray<T>::ptr clone() = 0;
    
    /*C*/public: typedef T Element;
};

/*C*/

template< typename T > struct RangeIterator
{
    private: typename GEnumeration<T>::ptr _elements;
    private: int32 _position;
    private: T _current;
    
    public: RangeIterator(const typename GEnumeration<T>::ptr& elements, int32 position)
        : _elements(elements)
        , _position(position)
        , _current()
    {
        if ( _elements->hasMoreElements() )
        {
            _current = _elements->nextElement();
        }
    }
    
    public: const RangeIterator<T>& operator++()
    {
        ++_position;
        if ( _elements->hasMoreElements() )
        {
            _current = _elements->nextElement();
        }
        return *this;
    }
    
    public: T operator*() const
    {
        return _current;
    }
    
    public: bool operator!=(const RangeIterator& other) const
    {
        return _position != other._position;
    }
};
    
// Provides standalone begin() function for ADL.
template< typename T > RangeIterator< typename T::Element > begin(const O<T>& container)
{
    return RangeIterator< typename T::Element >(container->elements(), 0);
}
   
// Provides standalone end() function for ADL.
template< typename T > RangeIterator< typename T::Element > end(const O<T>& container)
{
    return RangeIterator< typename T::Element >(container->elements(), container->length());
}

    
}

#endif // !IARRAY_H__GLYMPSE__