// A Bison parser, made by GNU Bison 3.0.4.

// Stack handling for Bison parsers in C++

// Copyright (C) 2002-2015 Free Software Foundation, Inc.

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

// As a special exception, you may create a larger work that contains

// part or all of the Bison parser skeleton and distribute that work

// under terms of your choice, so long as that work isn't itself a

// parser generator using the skeleton or a modified version thereof

// as a parser skeleton.  Alternatively, if you modify or redistribute

// the parser skeleton itself, you may (at your option) remove this

// special exception, which will cause the skeleton and the resulting

// Bison output files to be licensed under the GNU General Public

// License without this special exception.

// This special exception was added by the Free Software Foundation in

// version 2.2 of Bison.

/**

 ** \file stack.hh

 ** Define the libdap::stack class.

 */

#ifndef YY_YY_STACK_HH_INCLUDED

# define YY_YY_STACK_HH_INCLUDED

# include <vector>

#line 34 "d4_function_parser.yy" // stack.hh:151

namespace libdap {

#line 46 "stack.hh" // stack.hh:151

  template <class T, class S = std::vector<T> >

  class stack

  {

  public:

    // Hide our reversed order.

    typedef typename S::reverse_iterator iterator;

    typedef typename S::const_reverse_iterator const_iterator;

    stack ()

      : seq_ ()

    {

      seq_.reserve (200);

    }

    stack (unsigned int n)

      : seq_ (n)

    {}

    inline

    T&

    operator[] (unsigned int i)

    {

      return seq_[seq_.size () - 1 - i];

    }

    inline

    const T&

    operator[] (unsigned int i) const

    {

      return seq_[seq_.size () - 1 - i];

    }

    /// Steal the contents of \a t.

    ///

    /// Close to move-semantics.

    inline

    void

    push (T& t)

    {

      seq_.push_back (T());

      operator[](0).move (t);

    }

    inline

    void

    pop (unsigned int n = 1)

    {

      for (; n; --n)

        seq_.pop_back ();

    }

    void

    clear ()

    {

      seq_.clear ();

    }

    inline

    typename S::size_type

    size () const

    {

      return seq_.size ();

    }

    inline

    const_iterator

    begin () const

    {

      return seq_.rbegin ();

    }

    inline

    const_iterator

    end () const

    {

      return seq_.rend ();

    }

  private:

    stack (const stack&);

    stack& operator= (const stack&);

    /// The wrapped container.

    S seq_;

  };

  /// Present a slice of the top of a stack.

  template <class T, class S = stack<T> >

  class slice

  {

  public:

    slice (const S& stack, unsigned int range)

      : stack_ (stack)

      , range_ (range)

    {}

    inline

    const T&

    operator [] (unsigned int i) const

    {

      return stack_[range_ - i];

    }

  private:

    const S& stack_;

    unsigned int range_;

  };

#line 34 "d4_function_parser.yy" // stack.hh:151

} // libdap

#line 156 "stack.hh" // stack.hh:151

#endif // !YY_YY_STACK_HH_INCLUDED