/*******************************************************************
*
*  DESCRIPTION: Class VList, container de Value
*
*  AUTOR: Mariana D'Abreu
* 
*  EMAIL: mailto://mdabreu@dc.uba.ar
*
*******************************************************************/

#ifndef VLIST_H
#define VLIST_H

#include <list>
#include "value.h"

#define TAB "  "

typedef Value* PValue;


class VList : public Value {

  public:

    class Cursor;

    friend class Cursor;

    VList();
    VList( const Value &value );
    VList( const VList &vlist );
    VList( const long n, const RealValue &value = 0 );

    virtual ~VList();
  
    //--- Getter y setter ---//
    virtual RealValue value() const;
    virtual Value     &value( const RealValue &v );

    //--- Modifiers ---
    virtual VList &addElement( const RealValue &v );
    virtual VList &addElement( const Value &v );
    virtual VList &addElement( const Value *v );
    virtual VList &delElementAtPos( const long index );
    virtual VList &updElementAtPos( const long index, const RealValue &v );
    virtual VList &updElementAtPos( const long index, const Value &v );
    virtual VList &updElementAtPos( const long index, const Value *v );
    virtual VList &delAll()
      { return clear(); }
    virtual VList &setAll( const RealValue &v );

    //--- Querys ---
    virtual Value *elementAt( const long index ) const;
    virtual long numberOfElements() const;
    virtual bool isEmpty() const;
            
    virtual bool isReal() const
            { return false; }
    
    virtual bool isList() const
            { return true; }

    //--- Operators ---
    virtual Value &operator = ( const Value &v );
    virtual Value &operator = ( const VList &v );
    virtual bool  operator == ( const Value &v ) const;
    virtual bool  operator == ( const VList &v ) const;
    virtual Value *operator + ( const Value &v ) const;
    virtual Value *operator + ( const VList &v ) const;
    virtual Value *operator + ( const VList *v ) const;
    virtual Value *operator - ( const Value &v ) const;
    virtual Value *operator - ( const VList &v ) const;
    virtual Value *operator - ( const VList *v ) const;
    virtual Value *operator * ( const RealValue &v ) const;
    

    //--- Conversions ---//
    virtual RealValue toReal() const;
    virtual string    asString() const;
    
    virtual Value     *clone() const;
    virtual ostream   &print ( ostream &out ) const; 
  

    class Cursor {

      public:
        
        Cursor( const VList &list );
        virtual ~Cursor();
  
        virtual Cursor  &first();
        virtual Cursor  &next();
        virtual bool    hasMoreElements() const;
        virtual PValue  current() const;
        
      private:

        list<PValue>::const_iterator cursor;
        VList   *list;
    };

  protected:

    virtual ostream   &printIndent( ostream &out, const string &indent ) const;
    
    virtual bool      isUndefined() const;

    virtual VList     &clear();

    typedef list<PValue>::iterator LCursor;
    typedef list<PValue> ValueList;

    ValueList values;
};


class VListException: public MException
{
  public:
    
    const string type() const { return "VListException"; }

};    


//--- inline functions
inline
long VList::numberOfElements() const
{
  return values.size();
}

inline
bool VList::isEmpty() const
{
  return values.empty();
}


inline
VList::Cursor::Cursor( const VList &list )
{
  this->list = (VList *)list.clone();
}

inline
VList::Cursor::~Cursor()
{
  if ( list ) {
    delete list;
  }
}
  
inline
VList::Cursor &VList::Cursor::first()
{
  cursor = list->values.begin();
  return *this;
}
        
inline
VList::Cursor &VList::Cursor::next()
{
  cursor++;
  return *this;
}
        
inline
bool VList::Cursor::hasMoreElements() const
{
  return ( cursor != list->values.end() );
}

inline
PValue VList::Cursor::current() const
{
  return ( *cursor );
}


#endif