// Copyright {Jagger Software Limited} 2003

#if !defined AST_SYMBOL_INCLUDED || \
     defined AST_SYMBOL_TEMPLATE_INCLUDED
#error      "ast/symbol-template.hpp" #included directly
#endif

#define      AST_SYMBOL_TEMPLATE_INCLUDED

#include "container/for_all.hpp"
#include "contract/pre_condition.hpp"
#include "ownership/deleter.hpp"
#include <stdexcept>

namespace ast // symbol - 'tors
{
    template<typename iterator>
    symbol<iterator>::symbol
    (
        const ::grammar::symbol_definition & source,
        iterator position
    )
        : definition(source)
        , from(position)
        , until(position)
        , symbols()
    {
    }


    template<typename iterator>
    symbol<iterator>::symbol
    (
        const ::grammar::symbol_definition & source,
        iterator start, iterator finish
    )
        : definition(source)
        , from(start)
        , until(finish)
        , symbols()
    {
        PRE_CONDITION(start != finish);
    }

    template<typename iterator>
    symbol<iterator>::~symbol()
    {
        clear();
    }
}

namespace ast // symbol - attributes
{
    template<typename iterator>
    bool symbol<iterator>::is_terminal() const
    {
        return from != until;
    }
}

namespace ast // symbol - end points
{
    template<typename iterator>
    iterator symbol<iterator>::begin() const
    {
        return from;
    }

    template<typename iterator>
    iterator symbol<iterator>::end() const
    {
        return symbols.empty() ? until : symbols.back()->end();
    }
}

namespace ast // symbol - capacity
{
    template<typename iterator>
    size_t symbol<iterator>::size() const
    {
        return symbols.size();
    }

    template<typename iterator>
    bool symbol<iterator>::empty() const
    {
        return size() == 0;
    }
   
    template<typename iterator>
    void symbol<iterator>::clear()
    {
        ::container::for_all(symbols, ownership::deleter());
        symbols.clear();
    }
}

namespace ast // symbol - subscripting
{
    template<typename iterator>
    const symbol<iterator> & symbol<iterator>::operator[](size_t at) const
    {
        range_check(at);
        return *symbols[at];
    }
}

namespace ast // symbol - tree manipulation
{
    template<typename iterator>
    symbol<iterator> * symbol<iterator>::back() const
    {
        PRE_CONDITION(!is_terminal());
        PRE_CONDITION(!symbols.empty());

        return symbols.back();
    }

    template<typename iterator>
    void symbol<iterator>::push_back(symbol * pushed)
    {
        PRE_CONDITION(!is_terminal());
        PRE_CONDITION(pushed != 0);

        symbols.push_back(pushed);
    }

    template<typename iterator>
    void symbol<iterator>::pop_back()
    {
        PRE_CONDITION(!is_terminal());
        PRE_CONDITION(!symbols.empty());

        return symbols.pop_back();
    }
}

namespace ast // symbol - validation
{
    template<typename iterator>
    void symbol<iterator>::range_check(size_t at) const
    {
        if (at >= size())
        {
            throw ::std::out_of_range("symbol<iterator>[at]");
        }
    }
}