root/trunk/src/semitwist/util/container.d

// SemiTwist Library
// Written in the D programming language.

module semitwist.util.container;

import semitwist.util.all;

final class Stack(T)
{
    private T[] data;
    @property size_t capacity()
    {
        return data.length;
    }
    private size_t _length=0;
    @property size_t length()
    {
        return _length;
    }
    
    this(size_t initialCapacity=1024)
    {
        data.length = initialCapacity;
    }
    
    private this(Stack!T s)
    {
        data = s.data.dup;
        _length = s._length;
    }
    
    ref T opIndex(size_t i)
    {
        debug if(i >= _length)
            throw new Exception("Invalid index");
        
        return data[i];
    }
    
    T[] opSlice(size_t a, size_t b)
    {
        debug if(a >= _length || b > _length)
            throw new Exception("Invalid index");
        
        return data[a..b];
    }
    
    private void expand()
    {
        size_t numMore = data.length;
        if(numMore == 0)
            numMore = 1;
        data.length += numMore;
    }
    
    void clear()
    {
        _length = 0;
        data.clear();
    }
    
    void opOpAssign(string op)(T item) if(op=="~")
    {
        if(_length == data.length)
            expand();

        data[_length] = item;
        _length++;
    }
    
    void opOpAssign(string op)(T[] items) if(op=="~")
    {
        while(_length + items.length >= data.length)
            expand();

        data[ _length .. _length + items.length ] = items;
        _length += items.length;
    }
    
    void pop(size_t num=1)
    {
        debug if(num > _length)
            throw new Exception("Invalid index");
            
        _length -= num;
    }
    
    @property ref T top()
    {
        return data[_length-1];
    }
    
    @property bool empty()
    {
        return _length == 0;
    }
    
    void compact()
    {
        data.length = _length;
    }
    
    @property Stack!T dup()
    {
        return new Stack!T(this);
    }
    
    int opApply(int delegate(ref T) dg)
    {
        int result = 0;
        foreach(ref T item; data[0.._length])
        {
            result = dg(item);
            if(result)
                break;
        }
        return result;
    }
    
    int opApply(int delegate(ref size_t, ref T) dg)
    {
        int result = 0;
        foreach(size_t i, ref T item; data[0.._length])
        {
            result = dg(i, item);
            if(result)
                break;
        }
        return result;
    }
}