Tuple.h

Go to the documentation of this file.

//
// Copyright (c) 2006-2007 Raphael David / CANTOR
//

#ifndef CMR_TUPLE_INCLUDED
#define CMR_TUPLE_INCLUDED

#include "Commore.h"
#include "Symbol.h"
#include "AString.h"
#include "String.h"
#include "Time.h"
#include "Blob.h"
#include "StringBuffer.h"
#include "List.h"
#include "Array.h"


namespace commore
{
    typedef Tuple* PTuple;

    class CMREXD Tuple
    {
    public:
        class ValueIterator;
        class ConstValueIterator;
        class CMREXD Value
        {
            friend class Tuple;
            friend class ValueIterator;
            friend class ConstValueIterator;

            unsigned int att_type_;
            Value* next_;
            void* ref_;
            void destroy();
            void set_symbol(const Symbol& att);
            void set_type(Types type);
            void set_is_ref(bool ref);
            void set_is_const(bool cnst);
            Value* clone() const;
        public:
            Symbol get_symbol() const;
            Types get_type() const;
            bool get_is_ref() const;
            bool get_is_const() const;
            const Value* get_next() const;
            Value* get_next();
            const void* get_pvalue() const;
            void* get_pvalue();

            const Bool* is_bool() const;
            Bool* is_bool();
            const ListBool* is_list_bool() const;
            ListBool* is_list_bool();

            const Int* is_int() const;
            Int* is_int();
            const ListInt* is_list_int() const;
            ListInt* is_list_int();

            const Long* is_long() const;
            Long* is_long();
            const ListLong* is_list_long() const;
            ListLong* is_list_long();

            const Float* is_float() const;
            Float* is_float();
            const ListFloat* is_list_float() const;
            ListFloat* is_list_float();

            const Double* is_double() const;
            Double* is_double();
            const ListDouble* is_list_double() const;
            ListDouble* is_list_double();

            const Symbol* is_symbol() const;
            Symbol* is_symbol();
            const ListSymbol* is_list_symbol() const;
            ListSymbol* is_list_symbol();

            const AString* is_astring() const;
            AString* is_astring();
            const ListAString* is_list_astring() const;
            ListAString* is_list_astring();

            const String* is_string() const;
            String* is_string();
            const ListString* is_list_string() const;
            ListString* is_list_string();

            const StringBuffer* is_stringbuffer() const;
            StringBuffer* is_stringbuffer();
            const ListStringBuffer* is_list_stringbuffer() const;
            ListStringBuffer* is_list_stringbuffer();

            const Blob* is_blob() const;
            Blob* is_blob();
            const ListBlob* is_list_blob() const;
            ListBlob* is_list_blob();

            const Tuple* is_tuple() const;
            Tuple* is_tuple();
            const ListTuple* is_list_tuple() const;
            ListTuple* is_list_tuple();

            const TimeDate* is_time_date() const;
            TimeDate* is_time_date();
            const ListTimeDate* is_list_time_date() const;
            ListTimeDate* is_list_time_date();

            const TimePeriod* is_time_period() const;
            TimePeriod* is_time_period();
            const ListTimePeriod* is_list_time_period() const;
            ListTimePeriod* is_list_time_period();

            const ArrayInt* is_array_int() const;
            ArrayInt* is_array_int();
            const ListArrayInt* is_list_array_int() const;
            ListArrayInt* is_list_array_int();

            const ArrayLong* is_array_long() const;
            ArrayLong* is_array_long();
            const ListArrayLong* is_list_array_long() const;
            ListArrayLong* is_list_array_long();

            const ArrayFloat* is_array_float() const;
            ArrayFloat* is_array_float();
            const ListArrayFloat* is_list_array_float() const;
            ListArrayFloat* is_list_array_float();

            const ArrayDouble* is_array_double() const;
            ArrayDouble* is_array_double();
            const ListArrayDouble* is_list_array_double() const;
            ListArrayDouble* is_list_array_double();
        };

        typedef Value* PValue;

        class CMREXD ValueIterator
        {
        public:
            ValueIterator(Tuple& t);
            operator bool() const { return more(); }

        public:
            Symbol get_name() const;
            bool more() const;
            bool next();

            ValueIterator& operator++() { next(); return *this; }
            ValueIterator operator++(int) { ValueIterator r = *this; next(); return r; }
            Value* operator -> () const { return value_; }
            Types get_type();
        private:
            PValue value_;
        };

        friend class ValueIterator;

        class CMREXD ConstValueIterator
        {
        public:
            ConstValueIterator(const Tuple& t);
            operator bool() const { return more(); }

        public:
            Symbol get_name() const;
            bool more() const;
            bool next();
            ConstValueIterator& operator++() { next(); return *this; }
            ConstValueIterator operator++(int) { ConstValueIterator r = *this; next(); return r; }
            const Value* operator -> () const { return value_; }
            Types get_type();
        private:
            const Value* value_;

        };

        friend class ConstValueIterator;

    public:
        Tuple();
        Tuple(const AChar* class_name);
        Tuple(const Symbol& class_name);
        Tuple(const Tuple& tuple);
        Tuple& operator = (const Tuple& tuple) { return assign(tuple); }
        operator bool () { return !is_empty(); }
        ~Tuple();

    public:
        Tuple& assign(const Tuple& tuple);
        Tuple& merge(const Tuple& tuple);
        Tuple& merge_only(const Tuple& tuple, const ListSymbol& atts);
        Tuple& merge_except(const Tuple& tuple, const ListSymbol& atts);
        Tuple& splice(Tuple& tuple);
        Tuple& diff(const Tuple& t1, const Tuple& t2);
        void  clear();
        bool  is_a(Symbol class_name) const { return symbolClass_ == class_name; }
        inline AString& set_astring(const Symbol& att, const AChar* v);
        inline AString& add_astring(const Symbol& att, const AChar* v = 0);

        inline String& set_string(const Symbol& att, const Char* v);
        inline String& add_string(const Symbol& att, const Char* v = 0);

        inline StringBuffer& set_stringbuffer(const Symbol& att, const AChar* v);
        inline StringBuffer& add_stringbuffer(const Symbol& att, const AChar* v);


        bool  is_set(const Symbol& att) const;
        bool  is_set(const Symbol& att, Types type) const;
        bool  is_null(const Symbol& att) const;
        void  set_null(const Symbol& att);
        void clear(const Symbol& att);
        void clear(const ListSymbol& att);

        void keep(const ListSymbol& att);
        void clear_list(const Symbol& att);

        bool is_empty() const;

        AString& to_string(AString& s) const;
        AString& to_string(const AString& s = AString()) const;
        long  from_string(const AString& s);


        const Symbol& get_class_name() const { return symbolClass_; }
        void  set_class_name(const Symbol& className);

        void  get_attributes(ListAString& l) const;

        inline        const Symbol& get_symbol(const Symbol& att) const;
        inline        const Symbol* get_psymbol(const Symbol& att) const;
        inline              Symbol& set_symbol(const Symbol& att);
        inline              Symbol& set_symbol(const Symbol& att, const Symbol& v);
        inline              Symbol& set_ref_symbol(const Symbol& att, Symbol& v);
        inline        const Symbol& set_cref_symbol(const Symbol& att, const Symbol& v);
        inline    const ListSymbol& get_list_symbol(const Symbol& att) const;
        inline    const ListSymbol* get_plist_symbol(const Symbol& att) const;
        inline          ListSymbol& set_list_symbol(const Symbol& att);
        inline          ListSymbol& set_list_symbol(const Symbol& att, const ListSymbol& v);
        inline          ListSymbol& set_ref_list_symbol(const Symbol& att, ListSymbol& v);
        inline    const ListSymbol& set_cref_list_symbol(const Symbol& att, const ListSymbol& v);
        inline              Symbol& add_symbol(const Symbol& att, const Symbol& v = Symbol());
        inline                 Int  get_int(const Symbol& att, Int pv = 0) const;
        inline           const Int* get_pint(const Symbol& att) const;
        inline                 Int& set_int(const Symbol& att);
        inline                 Int& set_int(const Symbol& att, Int v);
        inline                 Int& set_ref_int(const Symbol& att, Int& v);
        inline           const Int& set_cref_int(const Symbol& att, const Int& v);
        inline       const ListInt& get_list_int(const Symbol& att) const;
        inline       const ListInt* get_plist_int(const Symbol& att) const;
        inline             ListInt& set_list_int(const Symbol& att);
        inline             ListInt& set_list_int(const Symbol& att, const ListInt& v);
        inline             ListInt& set_ref_list_int(const Symbol& att, ListInt& v);
        inline       const ListInt& set_cref_list_int(const Symbol& att, const ListInt& v);
        inline                void  add_int(const Symbol& att, Int v);
        inline                Bool  get_bool(const Symbol& att, Bool pv = 0) const;
        inline          const Bool* get_pbool(const Symbol& att) const;
        inline                Bool& set_bool(const Symbol& att);
        inline                Bool& set_bool(const Symbol& att, Bool v);
        inline                Bool& set_ref_bool(const Symbol& att, Bool& v);
        inline          const Bool& set_cref_bool(const Symbol& att, const Bool& v);
        inline      const ListBool& get_list_bool(const Symbol& att) const;
        inline      const ListBool* get_plist_bool(const Symbol& att) const;
        inline            ListBool& set_list_bool(const Symbol& att);
        inline            ListBool& set_list_bool(const Symbol& att, const ListBool& v);
        inline            ListBool& set_ref_list_bool(const Symbol& att, ListBool& v);
        inline      const ListBool& set_cref_list_bool(const Symbol& att, const ListBool& v);
        inline                void  add_bool(const Symbol& att, Bool v);

        inline                Long  get_long(const Symbol& att, Long pv = 0) const;
        inline          const Long* get_plong(const Symbol& att) const;
        inline                Long& set_long(const Symbol& att);
        inline                Long& set_long(const Symbol& att, Long v);
        inline                Long& set_ref_long(const Symbol& att, Long& v);
        inline          const Long& set_cref_long(const Symbol& att, const Long& v);
        inline      const ListLong& get_list_long(const Symbol& att) const;
        inline      const ListLong* get_plist_long(const Symbol& att) const;
        inline            ListLong& set_list_long(const Symbol& att);
        inline            ListLong& set_list_long(const Symbol& att, const ListLong& v);
        inline            ListLong& set_ref_list_long(const Symbol& att, ListLong& v);
        inline      const ListLong& set_cref_list_long(const Symbol& att, const ListLong& v);
        inline                void  add_long(const Symbol& att, Long v);

        inline               Float  get_float(const Symbol& att, Float pv = 0) const;
        inline         const Float* get_pfloat(const Symbol& att) const;
        inline               Float& set_float(const Symbol& att);
        inline               Float& set_float(const Symbol& att, Float v);
        inline               Float& set_ref_float(const Symbol& att, Float& v);
        inline         const Float& set_cref_float(const Symbol& att, const Float& v);
        inline     const ListFloat& get_list_float(const Symbol& att) const;
        inline     const ListFloat* get_plist_float(const Symbol& att) const;
        inline           ListFloat& set_list_float(const Symbol& att);
        inline           ListFloat& set_list_float(const Symbol& att, const ListFloat& v);
        inline           ListFloat& set_ref_list_float(const Symbol& att, ListFloat& v);
        inline     const ListFloat& set_cref_list_float(const Symbol& att, const ListFloat& v);
        inline                void  add_float(const Symbol& att, Float v);

        inline              Double  get_double(const Symbol& att, Double pv = 0) const;
        inline        const Double* get_pdouble(const Symbol& att) const;
        inline              Double& set_double(const Symbol& att);
        inline              Double& set_double(const Symbol& att, Double v);
        inline              Double& set_ref_double(const Symbol& att, Double& v);
        inline        const Double& set_cref_double(const Symbol& att, const Double& v);
        inline    const ListDouble& get_list_double(const Symbol& att) const;
        inline    const ListDouble* get_plist_double(const Symbol& att) const;
        inline          ListDouble& set_list_double(const Symbol& att);
        inline          ListDouble& set_list_double(const Symbol& att, const ListDouble& v);
        inline          ListDouble& set_ref_list_double(const Symbol& att, ListDouble& v);
        inline    const ListDouble& set_cref_list_double(const Symbol& att, const ListDouble& v);
        inline                void  add_double(const Symbol& att, Double v);

        inline            TimeDate  get_time_date(const Symbol& att, TimeDate pv = 0) const;
        inline      const TimeDate* get_ptime_date(const Symbol& att) const;
        inline            TimeDate& set_time_date(const Symbol& att);
        inline            TimeDate& set_time_date(const Symbol& att, TimeDate v);
        inline            TimeDate& set_ref_time_date(const Symbol& att, TimeDate& v);
        inline      const TimeDate& set_cref_time_date(const Symbol& att, const TimeDate& v);
        inline  const ListTimeDate& get_list_time_date(const Symbol& att) const;
        inline  const ListTimeDate* get_plist_time_date(const Symbol& att) const;
        inline        ListTimeDate& set_list_time_date(const Symbol& att);
        inline        ListTimeDate& set_list_time_date(const Symbol& att, const ListTimeDate& v);
        inline        ListTimeDate& set_ref_list_time_date(const Symbol& att, ListTimeDate& v);
        inline  const ListTimeDate& set_cref_list_time_date(const Symbol& att, const ListTimeDate& v);
        inline                void  add_time_date(const Symbol& att, TimeDate v);

        inline          TimePeriod  get_time_period(const Symbol& att, TimePeriod pv = 0) const;
        inline    const TimePeriod* get_ptime_period(const Symbol& att) const;
        inline          TimePeriod& set_time_period(const Symbol& att);
        inline          TimePeriod& set_time_period(const Symbol& att, TimePeriod v);
        inline          TimePeriod& set_ref_time_period(const Symbol& att, TimePeriod& v);
        inline    const TimePeriod& set_cref_time_period(const Symbol& att, const TimePeriod& v);
        inline  const ListTimePeriod& get_list_time_period(const Symbol& att) const;
        inline  const ListTimePeriod* get_plist_time_period(const Symbol& att) const;
        inline      ListTimePeriod& set_list_time_period(const Symbol& att);
        inline      ListTimePeriod& set_list_time_period(const Symbol& att, const ListTimePeriod& v);
        inline      ListTimePeriod& set_ref_list_time_period(const Symbol& att, ListTimePeriod& v);
        inline  const ListTimePeriod& set_cref_list_time_period(const Symbol& att, const ListTimePeriod& v);
        inline                void  add_time_period(const Symbol& att, TimePeriod v);

        inline       const AString& get_astring(const Symbol& att) const;
        inline       const AString* get_pastring(const Symbol& att) const;
        inline             AString& set_astring(const Symbol& att);
        inline             AString& set_astring(const Symbol& att, const AString& v);
        inline             AString& set_ref_astring(const Symbol& att, AString& v);
        inline       const AString& set_cref_astring(const Symbol& att, const AString& v);
        inline   const ListAString& get_list_astring(const Symbol& att) const;
        inline   const ListAString* get_plist_astring(const Symbol& att) const;
        inline         ListAString& set_list_astring(const Symbol& att);
        inline         ListAString& set_list_astring(const Symbol& att, const ListAString& v);
        inline         ListAString& set_ref_list_astring(const Symbol& att, ListAString& v);
        inline   const ListAString& set_cref_list_astring(const Symbol& att, const ListAString& v);
        inline             AString& add_astring(const Symbol& att, const AString& v = AString());

        inline        const String& get_string(const Symbol& att) const;
        inline        const String* get_pstring(const Symbol& att) const;
        inline              String& set_string(const Symbol& att);
        inline              String& set_string(const Symbol& att, const String& v);
        inline              String& set_ref_string(const Symbol& att, String& v);
        inline        const String& set_cref_string(const Symbol& att, const String& v);
        inline    const ListString& get_list_string(const Symbol& att) const;
        inline    const ListString* get_plist_string(const Symbol& att) const;
        inline          ListString& set_list_string(const Symbol& att);
        inline          ListString& set_list_string(const Symbol& att, const ListString& v);
        inline          ListString& set_ref_list_string(const Symbol& att, ListString& v);
        inline    const ListString& set_cref_list_string(const Symbol& att, const ListString& v);
        inline              String& add_string(const Symbol& att, const String& v = String());

        inline  const StringBuffer& get_stringbuffer(const Symbol& att) const;
        inline  const StringBuffer* get_pstringbuffer(const Symbol& att) const;
        inline        StringBuffer& set_stringbuffer(const Symbol& att);
        inline        StringBuffer& set_stringbuffer(const Symbol& att, const StringBuffer& v);
        inline        StringBuffer& set_ref_stringbuffer(const Symbol& att, StringBuffer& v);
        inline  const StringBuffer& set_cref_stringbuffer(const Symbol& att, const StringBuffer& v);
        inline  const ListStringBuffer& get_list_stringbuffer(const Symbol& att) const;
        inline  const ListStringBuffer* get_plist_stringbuffer(const Symbol& att) const;
        inline    ListStringBuffer& set_list_stringbuffer(const Symbol& att);
        inline    ListStringBuffer& set_list_stringbuffer(const Symbol& att, const ListStringBuffer& v);
        inline    ListStringBuffer& set_ref_list_stringbuffer(const Symbol& att, ListStringBuffer& v);
        inline  const ListStringBuffer& set_cref_list_stringbuffer(const Symbol& att, const ListStringBuffer& v);
        inline        StringBuffer& add_stringbuffer(const Symbol& att, const StringBuffer& v = StringBuffer());

        inline          const Blob& get_blob(const Symbol& att) const;
        inline          const Blob* get_pblob(const Symbol& att) const;
        inline                Blob& set_blob(const Symbol& att);
        inline                Blob& set_blob(const Symbol& att, const Blob& v);
        inline                Blob& set_ref_blob(const Symbol& att, Blob& v);
        inline          const Blob& set_cref_blob(const Symbol& att, const Blob& v);
        inline      const ListBlob& get_list_blob(const Symbol& att) const;
        inline      const ListBlob* get_plist_blob(const Symbol& att) const;
        inline            ListBlob& set_list_blob(const Symbol& att);
        inline            ListBlob& set_list_blob(const Symbol& att, const ListBlob& v);
        inline            ListBlob& set_ref_list_blob(const Symbol& att, ListBlob& v);
        inline      const ListBlob& set_cref_list_blob(const Symbol& att, const ListBlob& v);
        inline                Blob& add_blob(const Symbol& att, const Blob& v = Blob());

        inline         const Tuple& get_tuple(const Symbol& att) const;
        inline         const Tuple* get_ptuple(const Symbol& att) const;
        inline               Tuple& set_tuple(const Symbol& att);
        inline               Tuple& set_tuple(const Symbol& att, const Tuple& v);
        inline               Tuple& set_ref_tuple(const Symbol& att, Tuple& v);
        inline         const Tuple& set_cref_tuple(const Symbol& att, const Tuple& v);
        inline     const ListTuple& get_list_tuple(const Symbol& att) const;
        inline     const ListTuple* get_plist_tuple(const Symbol& att) const;
        inline           ListTuple& set_list_tuple(const Symbol& att);
        inline           ListTuple& set_list_tuple(const Symbol& att, const ListTuple& v);
        inline           ListTuple& set_ref_list_tuple(const Symbol& att, ListTuple& v);
        inline     const ListTuple& set_cref_list_tuple(const Symbol& att, const ListTuple& v);
        inline               Tuple& add_tuple(const Symbol& att, const Tuple& v = Tuple());


        inline      const ArrayInt& get_array_int(const Symbol& att) const;
        inline      const ArrayInt* get_parray_int(const Symbol& att) const;
        inline            ArrayInt& set_array_int(const Symbol& att);
        inline            ArrayInt& set_array_int(const Symbol& att, const ArrayInt& v);
        inline            ArrayInt& set_ref_array_int(const Symbol& att, ArrayInt& v);
        inline      const ArrayInt& set_cref_array_int(const Symbol& att, const ArrayInt& v);
        inline  const ListArrayInt& get_list_array_int(const Symbol& att) const;
        inline  const ListArrayInt* get_plist_array_int(const Symbol& att) const;
        inline        ListArrayInt& set_list_array_int(const Symbol& att);
        inline        ListArrayInt& set_list_array_int(const Symbol& att, const ListArrayInt& v);
        inline        ListArrayInt& set_ref_list_array_int(const Symbol& att, ListArrayInt& v);
        inline  const ListArrayInt& set_cref_list_array_int(const Symbol& att, const ListArrayInt& v);
        inline            ArrayInt& add_array_int(const Symbol& att, const ArrayInt& v = ArrayInt());

        inline     const ArrayLong& get_array_long(const Symbol& att) const;
        inline     const ArrayLong* get_parray_long(const Symbol& att) const;
        inline           ArrayLong& set_array_long(const Symbol& att);
        inline           ArrayLong& set_array_long(const Symbol& att, const ArrayLong& v);
        inline           ArrayLong& set_ref_array_long(const Symbol& att, ArrayLong& v);
        inline     const ArrayLong& set_cref_array_long(const Symbol& att, const ArrayLong& v);
        inline const ListArrayLong& get_list_array_long(const Symbol& att) const;
        inline const ListArrayLong* get_plist_array_long(const Symbol& att) const;
        inline       ListArrayLong& set_list_array_long(const Symbol& att);
        inline       ListArrayLong& set_list_array_long(const Symbol& att, const ListArrayLong& v);
        inline       ListArrayLong& set_ref_list_array_long(const Symbol& att, ListArrayLong& v);
        inline const ListArrayLong& set_cref_list_array_long(const Symbol& att, const ListArrayLong& v);
        inline           ArrayLong& add_array_long(const Symbol& att, const ArrayLong& v = ArrayLong());

        inline    const ArrayFloat& get_array_float(const Symbol& att) const;
        inline    const ArrayFloat* get_parray_float(const Symbol& att) const;
        inline          ArrayFloat& set_array_float(const Symbol& att);
        inline          ArrayFloat& set_array_float(const Symbol& att, const ArrayFloat& v);
        inline          ArrayFloat& set_ref_array_float(const Symbol& att, ArrayFloat& v);
        inline    const ArrayFloat& set_cref_array_float(const Symbol& att, const ArrayFloat& v);
        inline  const ListArrayFloat& get_list_array_float(const Symbol& att) const;
        inline const ListArrayFloat* get_plist_array_float(const Symbol& att) const;
        inline      ListArrayFloat& set_list_array_float(const Symbol& att);
        inline      ListArrayFloat& set_list_array_float(const Symbol& att, const ListArrayFloat& v);
        inline      ListArrayFloat& set_ref_list_array_float(const Symbol& att, ListArrayFloat& v);
        inline const ListArrayFloat& set_cref_list_array_float(const Symbol& att, const ListArrayFloat& v);
        inline          ArrayFloat& add_array_float(const Symbol& att, const ArrayFloat& v = ArrayFloat());

        inline   const ArrayDouble& get_array_double(const Symbol& att) const;
        inline   const ArrayDouble* get_parray_double(const Symbol& att) const;
        inline         ArrayDouble& set_array_double(const Symbol& att);
        inline         ArrayDouble& set_array_double(const Symbol& att, const ArrayDouble& v);
        inline         ArrayDouble& set_ref_array_double(const Symbol& att, ArrayDouble& v);
        inline   const ArrayDouble& set_cref_array_double(const Symbol& att, const ArrayDouble& v);
        inline  const ListArrayDouble& get_list_array_double(const Symbol& att) const;
        inline  const ListArrayDouble* get_plist_array_double(const Symbol& att) const;
        inline     ListArrayDouble& set_list_array_double(const Symbol& att);
        inline     ListArrayDouble& set_list_array_double(const Symbol& att, const ListArrayDouble& v);
        inline     ListArrayDouble& set_ref_list_array_double(const Symbol& att, ListArrayDouble& v);
        inline  const ListArrayDouble& set_cref_list_array_double(const Symbol& att, const ListArrayDouble& v);
        inline         ArrayDouble& add_array_double(const Symbol& att, const ArrayDouble& v = ArrayDouble());
        
        bool  match(const AString& pattern, IBStream& source);
        bool  match(const AString& pattern, const AString& source);
        bool  match(const AString& pattern, IBStream& source, AChar esc);
        bool  match(const AString& pattern, const AString& source, AChar esc);

        long  read(const CommBuffer& buf);
        long  write(CommBuffer& buf) const;

        long  read_xml(IBStream& i);
        long  read_xml(XmlParser& i);
        long  write_xml(OBStream& o, const AChar* att = 0) const;
        
        long  write_xml(const Path& file_name) const;
        long  read_xml(const Path& file_name);
        
        long  write_xml(StringBuffer& s) const;
        long  read_xml(const StringBuffer& s);


        AString& format(const AChar* format, AString& s) const;
        long  format(const AChar* format, OBStream& o) const;
        
        bool  equal(const Tuple& tuple) const;
        int  compare(const Tuple& t) const;
        bool  operator== (const Tuple& t) const { return equal(t); }
        bool  operator!= (const Tuple& t) const { return !equal(t); }
        bool  operator< (const Tuple& t) const { return compare(t) < 0; }
        bool  operator> (const Tuple& t) const { return compare(t) > 0; }
    private:
        PValue  get_value(const Symbol& att) const;
        PValue  get_value(const Symbol& att, Types type) const;
        void* get_pvalue(const Symbol& att, Types type, bool nodef = true) const;

        PValue  set_value(PValue value);

        PValue  set_value(const Symbol& att, Types type, const void* value = 0, bool ref = false, bool cnst = false);
        void  add_value_item(PValue value);
    private:
        Symbol  symbolClass_;
        PValue  valueList_;
    };


    inline Bool& Tuple::set_bool(const Symbol& att, Bool v)
    {
        PValue value = set_value(att, T_BOOL, &v, false);
        return *(Bool*)value->get_pvalue();
    }
    inline Bool& Tuple::set_ref_bool(const Symbol& att, Bool& v)
    {
        set_value(att, T_BOOL, &v, true);
        return v;
    }
    inline const Bool& Tuple::set_cref_bool(const Symbol& att, const Bool& v)
    {
        set_value(att, T_BOOL, &v, true, true);
        return v;
    }
    inline Bool& Tuple::set_bool(const Symbol& att)
    {
        Bool v = false;
        PValue value = set_value(att, T_BOOL, &v, false);
        return *(Bool*)value->get_pvalue();
    }
    inline ListBool& Tuple::set_list_bool(const Symbol& att, const ListBool& v)
    {
        PValue value = set_value(att, T_LIST_BOOL, (void*)&v, false);
        return *(ListBool*)value->get_pvalue();
    }
    inline ListBool& Tuple::set_ref_list_bool(const Symbol& att, ListBool& v)
    {
        set_value(att, T_LIST_BOOL, (void*)&v, true);
        return v;
    }
    inline const ListBool& Tuple::set_cref_list_bool(const Symbol& att, const ListBool& v)
    {
        set_value(att, T_LIST_BOOL, (void*)&v, true, true);
        return v;
    }
    inline ListBool& Tuple::set_list_bool(const Symbol& att)
    {
        PValue value = set_value(att, T_LIST_BOOL, (void*)0, false);
        return *(ListBool*)value->get_pvalue();
    }
    inline void Tuple::add_bool(const Symbol& att, Bool v)
    {
        ((ListBool*)set_value(att, T_LIST_BOOL, (void*)0, false)->get_pvalue())->add(v);
    }
    inline Bool Tuple::get_bool(const Symbol& att, Bool v) const
    {
        if (Value* value = get_value(att, T_BOOL))
        {
            return *(Bool*)value->get_pvalue();
        }
        else
        {
            return v;
        }
    }
    inline const Bool* Tuple::get_pbool(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_BOOL))
        {
            return (const Bool*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    }
    inline const ListBool& Tuple::get_list_bool(const Symbol& att) const
    {
        return *(const ListBool*)get_pvalue(att, T_LIST_BOOL, false);
    }
    inline const ListBool* Tuple::get_plist_bool(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LIST_BOOL))
        {
            return (const ListBool*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    };

    inline Int& Tuple::set_int(const Symbol& att, Int v)
    {
        PValue value = set_value(att, T_INT, &v, false);
        return *(Int*)value->get_pvalue();
    }
    inline Int& Tuple::set_ref_int(const Symbol& att, Int& v)
    {
        set_value(att, T_INT, &v, true);
        return v;
    }
    inline const Int& Tuple::set_cref_int(const Symbol& att, const Int& v)
    {
        set_value(att, T_INT, &v, true, true);
        return v;
    }
    inline Int& Tuple::set_int(const Symbol& att)
    {
        Int v = 0;
        PValue value = set_value(att, T_INT, &v, false);
        return *(Int*)value->get_pvalue();
    }
    inline ListInt& Tuple::set_list_int(const Symbol& att, const ListInt& v)
    {
        PValue value = set_value(att, T_LIST_INT, (void*)&v, false);
        return *(ListInt*)value->get_pvalue();
    }
    inline ListInt& Tuple::set_ref_list_int(const Symbol& att, ListInt& v)
    {
        set_value(att, T_LIST_INT, (void*)&v, true);
        return v;
    }
    inline const ListInt& Tuple::set_cref_list_int(const Symbol& att, const ListInt& v)
    {
        set_value(att, T_LIST_INT, (void*)&v, true, true);
        return v;
    }
    inline ListInt& Tuple::set_list_int(const Symbol& att)
    {
        PValue value = set_value(att, T_LIST_INT, (void*)0, false);
        return *(ListInt*)value->get_pvalue();
    }
    inline void Tuple::add_int(const Symbol& att, Int v)
    {
        ((ListInt*)set_value(att, T_LIST_INT, (void*)0, false)->get_pvalue())->add(v);
    }
    inline Int Tuple::get_int(const Symbol& att, Int v) const
    {
        if (Value* value = get_value(att, T_INT))
        {
            return *(Int*)value->get_pvalue();
        }
        else
        {
            return v;
        }
    }
    inline const Int* Tuple::get_pint(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_INT))
        {
            return (const Int*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    }
    inline const ListInt& Tuple::get_list_int(const Symbol& att) const
    {
        return *(const ListInt*)get_pvalue(att, T_LIST_INT, false);
    }
    inline const ListInt* Tuple::get_plist_int(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LIST_INT))
        {
            return (const ListInt*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    };

    inline Long& Tuple::set_long(const Symbol& att, Long v)
    {
        PValue value = set_value(att, T_LONG, &v, false);
        return *(Long*)value->get_pvalue();
    }
    inline Long& Tuple::set_ref_long(const Symbol& att, Long& v)
    {
        set_value(att, T_LONG, &v, true);
        return v;
    }
    inline const Long& Tuple::set_cref_long(const Symbol& att, const Long& v)
    {
        set_value(att, T_LONG, &v, true, true);
        return v;
    }
    inline Long& Tuple::set_long(const Symbol& att)
    {
        Long v = 0;
        PValue value = set_value(att, T_LONG, &v, false);
        return *(Long*)value->get_pvalue();
    }
    inline ListLong& Tuple::set_list_long(const Symbol& att, const ListLong& v)
    {
        PValue value = set_value(att, T_LIST_LONG, (void*)&v, false);
        return *(ListLong*)value->get_pvalue();
    }
    inline ListLong& Tuple::set_ref_list_long(const Symbol& att, ListLong& v)
    {
        set_value(att, T_LIST_LONG, (void*)&v, true);
        return v;
    }
    inline const ListLong& Tuple::set_cref_list_long(const Symbol& att, const ListLong& v)
    {
        set_value(att, T_LIST_LONG, (void*)&v, true, true);
        return v;
    }
    inline ListLong& Tuple::set_list_long(const Symbol& att)
    {
        PValue value = set_value(att, T_LIST_LONG, (void*)0, false);
        return *(ListLong*)value->get_pvalue();
    }
    inline void Tuple::add_long(const Symbol& att, Long v)
    {
        ((ListLong*)set_value(att, T_LIST_LONG, (void*)0, false)->get_pvalue())->add(v);
    }
    inline Long Tuple::get_long(const Symbol& att, Long v) const
    {
        if (Value* value = get_value(att, T_LONG))
        {
            return *(Long*)value->get_pvalue();
        }
        else
        {
            return v;
        }
    }
    inline const Long* Tuple::get_plong(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LONG))
        {
            return (const Long*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    }
    inline const ListLong& Tuple::get_list_long(const Symbol& att) const
    {
        return *(const ListLong*)get_pvalue(att, T_LIST_LONG, false);
    }
    inline const ListLong* Tuple::get_plist_long(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LIST_LONG))
        {
            return (const ListLong*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    };

    inline Float& Tuple::set_float(const Symbol& att, Float v)
    {
        PValue value = set_value(att, T_FLOAT, &v, false);
        return *(Float*)value->get_pvalue();
    }
    inline Float& Tuple::set_ref_float(const Symbol& att, Float& v)
    {
        set_value(att, T_FLOAT, &v, true);
        return v;
    }
    inline const Float& Tuple::set_cref_float(const Symbol& att, const Float& v)
    {
        set_value(att, T_FLOAT, &v, true, true);
        return v;
    }
    inline Float& Tuple::set_float(const Symbol& att)
    {
        Float v = 0;
        PValue value = set_value(att, T_FLOAT, &v, false);
        return *(Float*)value->get_pvalue();
    }
    inline ListFloat& Tuple::set_list_float(const Symbol& att, const ListFloat& v)
    {
        PValue value = set_value(att, T_LIST_FLOAT, (void*)&v, false);
        return *(ListFloat*)value->get_pvalue();
    }
    inline ListFloat& Tuple::set_ref_list_float(const Symbol& att, ListFloat& v)
    {
        set_value(att, T_LIST_FLOAT, (void*)&v, true);
        return v;
    }
    inline const ListFloat& Tuple::set_cref_list_float(const Symbol& att, const ListFloat& v)
    {
        set_value(att, T_LIST_FLOAT, (void*)&v, true, true);
        return v;
    }
    inline ListFloat& Tuple::set_list_float(const Symbol& att)
    {
        PValue value = set_value(att, T_LIST_FLOAT, (void*)0, false);
        return *(ListFloat*)value->get_pvalue();
    }
    inline void Tuple::add_float(const Symbol& att, Float v)
    {
        ((ListFloat*)set_value(att, T_LIST_FLOAT, (void*)0, false)->get_pvalue())->add(v);
    }
    inline Float Tuple::get_float(const Symbol& att, Float v) const
    {
        if (Value* value = get_value(att, T_FLOAT))
        {
            return *(Float*)value->get_pvalue();
        }
        else
        {
            return v;
        }
    }
    inline const Float* Tuple::get_pfloat(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_FLOAT))
        {
            return (const Float*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    }
    inline const ListFloat& Tuple::get_list_float(const Symbol& att) const
    {
        return *(const ListFloat*)get_pvalue(att, T_LIST_FLOAT, false);
    }
    inline const ListFloat* Tuple::get_plist_float(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LIST_FLOAT))
        {
            return (const ListFloat*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    };

    inline Double& Tuple::set_double(const Symbol& att, Double v)
    {
        PValue value = set_value(att, T_DOUBLE, &v, false);
        return *(Double*)value->get_pvalue();
    }
    inline Double& Tuple::set_ref_double(const Symbol& att, Double& v)
    {
        set_value(att, T_DOUBLE, &v, true);
        return v;
    }
    inline const Double& Tuple::set_cref_double(const Symbol& att, const Double& v)
    {
        set_value(att, T_DOUBLE, &v, true, true);
        return v;
    }
    inline Double& Tuple::set_double(const Symbol& att)
    {
        Double v = 0;
        PValue value = set_value(att, T_DOUBLE, &v, false);
        return *(Double*)value->get_pvalue();
    }
    inline ListDouble& Tuple::set_list_double(const Symbol& att, const ListDouble& v)
    {
        PValue value = set_value(att, T_LIST_DOUBLE, (void*)&v, false);
        return *(ListDouble*)value->get_pvalue();
    }
    inline ListDouble& Tuple::set_ref_list_double(const Symbol& att, ListDouble& v)
    {
        set_value(att, T_LIST_DOUBLE, (void*)&v, true);
        return v;
    }
    inline const ListDouble& Tuple::set_cref_list_double(const Symbol& att, const ListDouble& v)
    {
        set_value(att, T_LIST_DOUBLE, (void*)&v, true, true);
        return v;
    }
    inline ListDouble& Tuple::set_list_double(const Symbol& att)
    {
        PValue value = set_value(att, T_LIST_DOUBLE, (void*)0, false);
        return *(ListDouble*)value->get_pvalue();
    }
    inline void Tuple::add_double(const Symbol& att, Double v)
    {
        ((ListDouble*)set_value(att, T_LIST_DOUBLE, (void*)0, false)->get_pvalue())->add(v);
    }
    inline Double Tuple::get_double(const Symbol& att, Double v) const
    {
        if (Value* value = get_value(att, T_DOUBLE))
        {
            return *(Double*)value->get_pvalue();
        }
        else
        {
            return v;
        }
    }
    inline const Double* Tuple::get_pdouble(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_DOUBLE))
        {
            return (const Double*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    }
    inline const ListDouble& Tuple::get_list_double(const Symbol& att) const
    {
        return *(const ListDouble*)get_pvalue(att, T_LIST_DOUBLE, false);
    }
    inline const ListDouble* Tuple::get_plist_double(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LIST_DOUBLE))
        {
            return (const ListDouble*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    };

    inline TimeDate& Tuple::set_time_date(const Symbol& att, TimeDate v)
    {
        PValue value = set_value(att, T_TIME_DATE, &v, false);
        return *(TimeDate*)value->get_pvalue();
    }
    inline TimeDate& Tuple::set_ref_time_date(const Symbol& att, TimeDate& v)
    {
        set_value(att, T_TIME_DATE, &v, true);
        return v;
    }
    inline const TimeDate& Tuple::set_cref_time_date(const Symbol& att, const TimeDate& v)
    {
        set_value(att, T_TIME_DATE, &v, true, true);
        return v;
    }
    inline TimeDate& Tuple::set_time_date(const Symbol& att)
    {
        TimeDate v = 0;
        PValue value = set_value(att, T_TIME_DATE, &v, false);
        return *(TimeDate*)value->get_pvalue();
    }
    inline ListTimeDate& Tuple::set_list_time_date(const Symbol& att, const ListTimeDate& v)
    {
        PValue value = set_value(att, T_LIST_TIME_DATE, (void*)&v, false);
        return *(ListTimeDate*)value->get_pvalue();
    }
    inline ListTimeDate& Tuple::set_ref_list_time_date(const Symbol& att, ListTimeDate& v)
    {
        set_value(att, T_LIST_TIME_DATE, (void*)&v, true);
        return v;
    }
    inline const ListTimeDate& Tuple::set_cref_list_time_date(const Symbol& att, const ListTimeDate& v)
    {
        set_value(att, T_LIST_TIME_DATE, (void*)&v, true, true);
        return v;
    }
    inline ListTimeDate& Tuple::set_list_time_date(const Symbol& att)
    {
        PValue value = set_value(att, T_LIST_TIME_DATE, (void*)0, false);
        return *(ListTimeDate*)value->get_pvalue();
    }
    inline void Tuple::add_time_date(const Symbol& att, TimeDate v)
    {
        ((ListTimeDate*)set_value(att, T_LIST_TIME_DATE, (void*)0, false)->get_pvalue())->add(v);
    }
    inline TimeDate Tuple::get_time_date(const Symbol& att, TimeDate v) const
    {
        if (Value* value = get_value(att, T_TIME_DATE))
        {
            return *(TimeDate*)value->get_pvalue();
        }
        else
        {
            return v;
        }
    }
    inline const TimeDate* Tuple::get_ptime_date(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_TIME_DATE))
        {
            return (const TimeDate*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    }
    inline const ListTimeDate& Tuple::get_list_time_date(const Symbol& att) const
    {
        return *(const ListTimeDate*)get_pvalue(att, T_LIST_TIME_DATE, false);
    }
    inline const ListTimeDate* Tuple::get_plist_time_date(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LIST_TIME_DATE))
        {
            return (const ListTimeDate*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    };

    inline TimePeriod& Tuple::set_time_period(const Symbol& att, TimePeriod v)
    {
        PValue value = set_value(att, T_TIME_PERIOD, &v, false);
        return *(TimePeriod*)value->get_pvalue();
    }
    inline TimePeriod& Tuple::set_ref_time_period(const Symbol& att, TimePeriod& v)
    {
        set_value(att, T_TIME_PERIOD, &v, true);
        return v;
    }
    inline const TimePeriod& Tuple::set_cref_time_period(const Symbol& att, const TimePeriod& v)
    {
        set_value(att, T_TIME_PERIOD, &v, true, true);
        return v;
    }
    inline TimePeriod& Tuple::set_time_period(const Symbol& att)
    {
        TimePeriod v = 0;
        PValue value = set_value(att, T_TIME_PERIOD, &v, false);
        return *(TimePeriod*)value->get_pvalue();
    }
    inline ListTimePeriod& Tuple::set_list_time_period(const Symbol& att, const ListTimePeriod& v)
    {
        PValue value = set_value(att, T_LIST_TIME_PERIOD, (void*)&v, false);
        return *(ListTimePeriod*)value->get_pvalue();
    }
    inline ListTimePeriod& Tuple::set_ref_list_time_period(const Symbol& att, ListTimePeriod& v)
    {
        set_value(att, T_LIST_TIME_PERIOD, (void*)&v, true);
        return v;
    }
    inline const ListTimePeriod& Tuple::set_cref_list_time_period(const Symbol& att, const ListTimePeriod& v)
    {
        set_value(att, T_LIST_TIME_PERIOD, (void*)&v, true, true);
        return v;
    }
    inline ListTimePeriod& Tuple::set_list_time_period(const Symbol& att)
    {
        PValue value = set_value(att, T_LIST_TIME_PERIOD, (void*)0, false);
        return *(ListTimePeriod*)value->get_pvalue();
    }
    inline void Tuple::add_time_period(const Symbol& att, TimePeriod v)
    {
        ((ListTimePeriod*)set_value(att, T_LIST_TIME_PERIOD, (void*)0, false)->get_pvalue())->add(v);
    }
    inline TimePeriod Tuple::get_time_period(const Symbol& att, TimePeriod v) const
    {
        if (Value* value = get_value(att, T_TIME_PERIOD))
        {
            return *(TimePeriod*)value->get_pvalue();
        }
        else
        {
            return v;
        }
    }
    inline const TimePeriod* Tuple::get_ptime_period(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_TIME_PERIOD))
        {
            return (const TimePeriod*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    }
    inline const ListTimePeriod& Tuple::get_list_time_period(const Symbol& att) const
    {
        return *(const ListTimePeriod*)get_pvalue(att, T_LIST_TIME_PERIOD, false);
    }
    inline const ListTimePeriod* Tuple::get_plist_time_period(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LIST_TIME_PERIOD))
        {
            return (const ListTimePeriod*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    };

    inline AString& Tuple::set_astring(const Symbol& att, const AString& v)
    {
        PValue value = set_value(att, T_ASTRING, (void*)&v, false);
        return *(AString*)value->get_pvalue();
    }
    inline AString& Tuple::set_ref_astring(const Symbol& att, AString& v)
    {
        set_value(att, T_ASTRING, (void*)&v, true);
        return v;
    }
    inline const AString& Tuple::set_cref_astring(const Symbol& att, const AString& v)
    {
        set_value(att, T_ASTRING, (const void*)&v, true, true);
        return v;
    }
    inline AString& Tuple::set_astring(const Symbol& att)
    {
        PValue value = set_value(att, T_ASTRING, 0, false);
        return *(AString*)value->get_pvalue();
    }
    inline ListAString& Tuple::set_list_astring(const Symbol& att, const ListAString& v)
    {
        PValue value = set_value(att, T_LIST_ASTRING, (void*)&v, false);
        return *(ListAString*)value->get_pvalue();
    }
    inline ListAString& Tuple::set_list_astring(const Symbol& att)
    {
        PValue value = set_value(att, T_LIST_ASTRING, (void*)0, false);
        return *(ListAString*)value->get_pvalue();
    }
    inline ListAString& Tuple::set_ref_list_astring(const Symbol& att, ListAString& v)
    {
        set_value(att, T_LIST_ASTRING, (void*)&v, true);
        return v;
    }
    inline const ListAString& Tuple::set_cref_list_astring(const Symbol& att, const ListAString& v)
    {
        set_value(att, T_LIST_ASTRING, (const void*)&v, true, true);
        return v;
    }
    inline AString& Tuple::add_astring(const Symbol& att, const AString& v)
    {
        return ((ListAString*)set_value(att, T_LIST_ASTRING, (void*)0, false)->get_pvalue())->add(v);
    }
    inline const AString& Tuple::get_astring(const Symbol& att) const
    {
        return *(const AString*)get_pvalue(att, T_ASTRING, false);
    }
    inline const AString* Tuple::get_pastring(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_ASTRING))
        {
            return (const AString*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    }
    inline const ListAString& Tuple::get_list_astring(const Symbol& att) const
    {
        return *(const ListAString*)get_pvalue(att, T_LIST_ASTRING, false);
    }
    inline const ListAString* Tuple::get_plist_astring(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LIST_ASTRING))
        {
            return (const ListAString*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    };

    inline String& Tuple::set_string(const Symbol& att, const String& v)
    {
        PValue value = set_value(att, T_STRING, (void*)&v, false);
        return *(String*)value->get_pvalue();
    }
    inline String& Tuple::set_ref_string(const Symbol& att, String& v)
    {
        set_value(att, T_STRING, (void*)&v, true);
        return v;
    }
    inline const String& Tuple::set_cref_string(const Symbol& att, const String& v)
    {
        set_value(att, T_STRING, (const void*)&v, true, true);
        return v;
    }
    inline String& Tuple::set_string(const Symbol& att)
    {
        PValue value = set_value(att, T_STRING, 0, false);
        return *(String*)value->get_pvalue();
    }
    inline ListString& Tuple::set_list_string(const Symbol& att, const ListString& v)
    {
        PValue value = set_value(att, T_LIST_STRING, (void*)&v, false);
        return *(ListString*)value->get_pvalue();
    }
    inline ListString& Tuple::set_list_string(const Symbol& att)
    {
        PValue value = set_value(att, T_LIST_STRING, (void*)0, false);
        return *(ListString*)value->get_pvalue();
    }
    inline ListString& Tuple::set_ref_list_string(const Symbol& att, ListString& v)
    {
        set_value(att, T_LIST_STRING, (void*)&v, true);
        return v;
    }
    inline const ListString& Tuple::set_cref_list_string(const Symbol& att, const ListString& v)
    {
        set_value(att, T_LIST_STRING, (const void*)&v, true, true);
        return v;
    }
    inline String& Tuple::add_string(const Symbol& att, const String& v)
    {
        return ((ListString*)set_value(att, T_LIST_STRING, (void*)0, false)->get_pvalue())->add(v);
    }
    inline const String& Tuple::get_string(const Symbol& att) const
    {
        return *(const String*)get_pvalue(att, T_STRING, false);
    }
    inline const String* Tuple::get_pstring(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_STRING))
        {
            return (const String*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    }
    inline const ListString& Tuple::get_list_string(const Symbol& att) const
    {
        return *(const ListString*)get_pvalue(att, T_LIST_STRING, false);
    }
    inline const ListString* Tuple::get_plist_string(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LIST_STRING))
        {
            return (const ListString*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    };

    inline Tuple& Tuple::set_tuple(const Symbol& att, const Tuple& v)
    {
        PValue value = set_value(att, T_TUPLE, (void*)&v, false);
        return *(Tuple*)value->get_pvalue();
    }
    inline Tuple& Tuple::set_ref_tuple(const Symbol& att, Tuple& v)
    {
        set_value(att, T_TUPLE, (void*)&v, true);
        return v;
    }
    inline const Tuple& Tuple::set_cref_tuple(const Symbol& att, const Tuple& v)
    {
        set_value(att, T_TUPLE, (const void*)&v, true, true);
        return v;
    }
    inline Tuple& Tuple::set_tuple(const Symbol& att)
    {
        PValue value = set_value(att, T_TUPLE, 0, false);
        return *(Tuple*)value->get_pvalue();
    }
    inline ListTuple& Tuple::set_list_tuple(const Symbol& att, const ListTuple& v)
    {
        PValue value = set_value(att, T_LIST_TUPLE, (void*)&v, false);
        return *(ListTuple*)value->get_pvalue();
    }
    inline ListTuple& Tuple::set_list_tuple(const Symbol& att)
    {
        PValue value = set_value(att, T_LIST_TUPLE, (void*)0, false);
        return *(ListTuple*)value->get_pvalue();
    }
    inline ListTuple& Tuple::set_ref_list_tuple(const Symbol& att, ListTuple& v)
    {
        set_value(att, T_LIST_TUPLE, (void*)&v, true);
        return v;
    }
    inline const ListTuple& Tuple::set_cref_list_tuple(const Symbol& att, const ListTuple& v)
    {
        set_value(att, T_LIST_TUPLE, (const void*)&v, true, true);
        return v;
    }
    inline Tuple& Tuple::add_tuple(const Symbol& att, const Tuple& v)
    {
        return ((ListTuple*)set_value(att, T_LIST_TUPLE, (void*)0, false)->get_pvalue())->add(v);
    }
    inline const Tuple& Tuple::get_tuple(const Symbol& att) const
    {
        return *(const Tuple*)get_pvalue(att, T_TUPLE, false);
    }
    inline const Tuple* Tuple::get_ptuple(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_TUPLE))
        {
            return (const Tuple*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    }
    inline const ListTuple& Tuple::get_list_tuple(const Symbol& att) const
    {
        return *(const ListTuple*)get_pvalue(att, T_LIST_TUPLE, false);
    }
    inline const ListTuple* Tuple::get_plist_tuple(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LIST_TUPLE))
        {
            return (const ListTuple*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    };

    inline Blob& Tuple::set_blob(const Symbol& att, const Blob& v)
    {
        PValue value = set_value(att, T_BLOB, (void*)&v, false);
        return *(Blob*)value->get_pvalue();
    }
    inline Blob& Tuple::set_ref_blob(const Symbol& att, Blob& v)
    {
        set_value(att, T_BLOB, (void*)&v, true);
        return v;
    }
    inline const Blob& Tuple::set_cref_blob(const Symbol& att, const Blob& v)
    {
        set_value(att, T_BLOB, (const void*)&v, true, true);
        return v;
    }
    inline Blob& Tuple::set_blob(const Symbol& att)
    {
        PValue value = set_value(att, T_BLOB, 0, false);
        return *(Blob*)value->get_pvalue();
    }
    inline ListBlob& Tuple::set_list_blob(const Symbol& att, const ListBlob& v)
    {
        PValue value = set_value(att, T_LIST_BLOB, (void*)&v, false);
        return *(ListBlob*)value->get_pvalue();
    }
    inline ListBlob& Tuple::set_list_blob(const Symbol& att)
    {
        PValue value = set_value(att, T_LIST_BLOB, (void*)0, false);
        return *(ListBlob*)value->get_pvalue();
    }
    inline ListBlob& Tuple::set_ref_list_blob(const Symbol& att, ListBlob& v)
    {
        set_value(att, T_LIST_BLOB, (void*)&v, true);
        return v;
    }
    inline const ListBlob& Tuple::set_cref_list_blob(const Symbol& att, const ListBlob& v)
    {
        set_value(att, T_LIST_BLOB, (const void*)&v, true, true);
        return v;
    }
    inline Blob& Tuple::add_blob(const Symbol& att, const Blob& v)
    {
        return ((ListBlob*)set_value(att, T_LIST_BLOB, (void*)0, false)->get_pvalue())->add(v);
    }
    inline const Blob& Tuple::get_blob(const Symbol& att) const
    {
        return *(const Blob*)get_pvalue(att, T_BLOB, false);
    }
    inline const Blob* Tuple::get_pblob(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_BLOB))
        {
            return (const Blob*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    }
    inline const ListBlob& Tuple::get_list_blob(const Symbol& att) const
    {
        return *(const ListBlob*)get_pvalue(att, T_LIST_BLOB, false);
    }
    inline const ListBlob* Tuple::get_plist_blob(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LIST_BLOB))
        {
            return (const ListBlob*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    };

    inline StringBuffer& Tuple::set_stringbuffer(const Symbol& att, const StringBuffer& v)
    {
        PValue value = set_value(att, T_STRING_BUFFER, (void*)&v, false);
        return *(StringBuffer*)value->get_pvalue();
    }
    inline StringBuffer& Tuple::set_ref_stringbuffer(const Symbol& att, StringBuffer& v)
    {
        set_value(att, T_STRING_BUFFER, (void*)&v, true);
        return v;
    }
    inline const StringBuffer& Tuple::set_cref_stringbuffer(const Symbol& att, const StringBuffer& v)
    {
        set_value(att, T_STRING_BUFFER, (const void*)&v, true, true);
        return v;
    }
    inline StringBuffer& Tuple::set_stringbuffer(const Symbol& att)
    {
        PValue value = set_value(att, T_STRING_BUFFER, 0, false);
        return *(StringBuffer*)value->get_pvalue();
    }
    inline ListStringBuffer& Tuple::set_list_stringbuffer(const Symbol& att, const ListStringBuffer& v)
    {
        PValue value = set_value(att, T_LIST_STRING_BUFFER, (void*)&v, false);
        return *(ListStringBuffer*)value->get_pvalue();
    }
    inline ListStringBuffer& Tuple::set_list_stringbuffer(const Symbol& att)
    {
        PValue value = set_value(att, T_LIST_STRING_BUFFER, (void*)0, false);
        return *(ListStringBuffer*)value->get_pvalue();
    }
    inline ListStringBuffer& Tuple::set_ref_list_stringbuffer(const Symbol& att, ListStringBuffer& v)
    {
        set_value(att, T_LIST_STRING_BUFFER, (void*)&v, true);
        return v;
    }
    inline const ListStringBuffer& Tuple::set_cref_list_stringbuffer(const Symbol& att, const ListStringBuffer& v)
    {
        set_value(att, T_LIST_STRING_BUFFER, (const void*)&v, true, true);
        return v;
    }
    inline StringBuffer& Tuple::add_stringbuffer(const Symbol& att, const StringBuffer& v)
    {
        return ((ListStringBuffer*)set_value(att, T_LIST_STRING_BUFFER, (void*)0, false)->get_pvalue())->add(v);
    }
    inline const StringBuffer& Tuple::get_stringbuffer(const Symbol& att) const
    {
        return *(const StringBuffer*)get_pvalue(att, T_STRING_BUFFER, false);
    }
    inline const StringBuffer* Tuple::get_pstringbuffer(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_STRING_BUFFER))
        {
            return (const StringBuffer*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    }
    inline const ListStringBuffer& Tuple::get_list_stringbuffer(const Symbol& att) const
    {
        return *(const ListStringBuffer*)get_pvalue(att, T_LIST_STRING_BUFFER, false);
    }
    inline const ListStringBuffer* Tuple::get_plist_stringbuffer(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LIST_STRING_BUFFER))
        {
            return (const ListStringBuffer*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    };

    inline Symbol& Tuple::set_symbol(const Symbol& att, const Symbol& v)
    {
        PValue value = set_value(att, T_SYMBOL, (void*)&v, false);
        return *(Symbol*)value->get_pvalue();
    }
    inline Symbol& Tuple::set_ref_symbol(const Symbol& att, Symbol& v)
    {
        set_value(att, T_SYMBOL, (void*)&v, true);
        return v;
    }
    inline const Symbol& Tuple::set_cref_symbol(const Symbol& att, const Symbol& v)
    {
        set_value(att, T_SYMBOL, (const void*)&v, true, true);
        return v;
    }
    inline Symbol& Tuple::set_symbol(const Symbol& att)
    {
        PValue value = set_value(att, T_SYMBOL, 0, false);
        return *(Symbol*)value->get_pvalue();
    }
    inline ListSymbol& Tuple::set_list_symbol(const Symbol& att, const ListSymbol& v)
    {
        PValue value = set_value(att, T_LIST_SYMBOL, (void*)&v, false);
        return *(ListSymbol*)value->get_pvalue();
    }
    inline ListSymbol& Tuple::set_list_symbol(const Symbol& att)
    {
        PValue value = set_value(att, T_LIST_SYMBOL, (void*)0, false);
        return *(ListSymbol*)value->get_pvalue();
    }
    inline ListSymbol& Tuple::set_ref_list_symbol(const Symbol& att, ListSymbol& v)
    {
        set_value(att, T_LIST_SYMBOL, (void*)&v, true);
        return v;
    }
    inline const ListSymbol& Tuple::set_cref_list_symbol(const Symbol& att, const ListSymbol& v)
    {
        set_value(att, T_LIST_SYMBOL, (const void*)&v, true, true);
        return v;
    }
    inline Symbol& Tuple::add_symbol(const Symbol& att, const Symbol& v)
    {
        return ((ListSymbol*)set_value(att, T_LIST_SYMBOL, (void*)0, false)->get_pvalue())->add(v);
    }
    inline const Symbol& Tuple::get_symbol(const Symbol& att) const
    {
        return *(const Symbol*)get_pvalue(att, T_SYMBOL, false);
    }
    inline const Symbol* Tuple::get_psymbol(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_SYMBOL))
        {
            return (const Symbol*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    }
    inline const ListSymbol& Tuple::get_list_symbol(const Symbol& att) const
    {
        return *(const ListSymbol*)get_pvalue(att, T_LIST_SYMBOL, false);
    }
    inline const ListSymbol* Tuple::get_plist_symbol(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LIST_SYMBOL))
        {
            return (const ListSymbol*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    };

    inline ArrayInt& Tuple::set_array_int(const Symbol& att, const ArrayInt& v)
    {
        PValue value = set_value(att, T_ARRAY_INT, (void*)&v, false);
        return *(ArrayInt*)value->get_pvalue();
    }
    inline ArrayInt& Tuple::set_ref_array_int(const Symbol& att, ArrayInt& v)
    {
        set_value(att, T_ARRAY_INT, (void*)&v, true);
        return v;
    }
    inline const ArrayInt& Tuple::set_cref_array_int(const Symbol& att, const ArrayInt& v)
    {
        set_value(att, T_ARRAY_INT, (const void*)&v, true, true);
        return v;
    }
    inline ArrayInt& Tuple::set_array_int(const Symbol& att)
    {
        PValue value = set_value(att, T_ARRAY_INT, 0, false);
        return *(ArrayInt*)value->get_pvalue();
    }
    inline ListArrayInt& Tuple::set_list_array_int(const Symbol& att, const ListArrayInt& v)
    {
        PValue value = set_value(att, T_LIST_ARRAY_INT, (void*)&v, false);
        return *(ListArrayInt*)value->get_pvalue();
    }
    inline ListArrayInt& Tuple::set_list_array_int(const Symbol& att)
    {
        PValue value = set_value(att, T_LIST_ARRAY_INT, (void*)0, false);
        return *(ListArrayInt*)value->get_pvalue();
    }
    inline ListArrayInt& Tuple::set_ref_list_array_int(const Symbol& att, ListArrayInt& v)
    {
        set_value(att, T_LIST_ARRAY_INT, (void*)&v, true);
        return v;
    }
    inline const ListArrayInt& Tuple::set_cref_list_array_int(const Symbol& att, const ListArrayInt& v)
    {
        set_value(att, T_LIST_ARRAY_INT, (const void*)&v, true, true);
        return v;
    }
    inline ArrayInt& Tuple::add_array_int(const Symbol& att, const ArrayInt& v)
    {
        return ((ListArrayInt*)set_value(att, T_LIST_ARRAY_INT, (void*)0, false)->get_pvalue())->add(v);
    }
    inline const ArrayInt& Tuple::get_array_int(const Symbol& att) const
    {
        return *(const ArrayInt*)get_pvalue(att, T_ARRAY_INT, false);
    }
    inline const ArrayInt* Tuple::get_parray_int(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_ARRAY_INT))
        {
            return (const ArrayInt*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    }
    inline const ListArrayInt& Tuple::get_list_array_int(const Symbol& att) const
    {
        return *(const ListArrayInt*)get_pvalue(att, T_LIST_ARRAY_INT, false);
    }
    inline const ListArrayInt* Tuple::get_plist_array_int(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LIST_ARRAY_INT))
        {
            return (const ListArrayInt*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    };

    inline ArrayLong& Tuple::set_array_long(const Symbol& att, const ArrayLong& v)
    {
        PValue value = set_value(att, T_ARRAY_LONG, (void*)&v, false);
        return *(ArrayLong*)value->get_pvalue();
    }
    inline ArrayLong& Tuple::set_ref_array_long(const Symbol& att, ArrayLong& v)
    {
        set_value(att, T_ARRAY_LONG, (void*)&v, true);
        return v;
    }
    inline const ArrayLong& Tuple::set_cref_array_long(const Symbol& att, const ArrayLong& v)
    {
        set_value(att, T_ARRAY_LONG, (const void*)&v, true, true);
        return v;
    }
    inline ArrayLong& Tuple::set_array_long(const Symbol& att)
    {
        PValue value = set_value(att, T_ARRAY_LONG, 0, false);
        return *(ArrayLong*)value->get_pvalue();
    }
    inline ListArrayLong& Tuple::set_list_array_long(const Symbol& att, const ListArrayLong& v)
    {
        PValue value = set_value(att, T_LIST_ARRAY_LONG, (void*)&v, false);
        return *(ListArrayLong*)value->get_pvalue();
    }
    inline ListArrayLong& Tuple::set_list_array_long(const Symbol& att)
    {
        PValue value = set_value(att, T_LIST_ARRAY_LONG, (void*)0, false);
        return *(ListArrayLong*)value->get_pvalue();
    }
    inline ListArrayLong& Tuple::set_ref_list_array_long(const Symbol& att, ListArrayLong& v)
    {
        set_value(att, T_LIST_ARRAY_LONG, (void*)&v, true);
        return v;
    }
    inline const ListArrayLong& Tuple::set_cref_list_array_long(const Symbol& att, const ListArrayLong& v)
    {
        set_value(att, T_LIST_ARRAY_LONG, (const void*)&v, true, true);
        return v;
    }
    inline ArrayLong& Tuple::add_array_long(const Symbol& att, const ArrayLong& v)
    {
        return ((ListArrayLong*)set_value(att, T_LIST_ARRAY_LONG, (void*)0, false)->get_pvalue())->add(v);
    }
    inline const ArrayLong& Tuple::get_array_long(const Symbol& att) const
    {
        return *(const ArrayLong*)get_pvalue(att, T_ARRAY_LONG, false);
    }
    inline const ArrayLong* Tuple::get_parray_long(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_ARRAY_LONG))
        {
            return (const ArrayLong*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    }
    inline const ListArrayLong& Tuple::get_list_array_long(const Symbol& att) const
    {
        return *(const ListArrayLong*)get_pvalue(att, T_LIST_ARRAY_LONG, false);
    }
    inline const ListArrayLong* Tuple::get_plist_array_long(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LIST_ARRAY_LONG))
        {
            return (const ListArrayLong*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    };

    inline ArrayFloat& Tuple::set_array_float(const Symbol& att, const ArrayFloat& v)
    {
        PValue value = set_value(att, T_ARRAY_FLOAT, (void*)&v, false);
        return *(ArrayFloat*)value->get_pvalue();
    }
    inline ArrayFloat& Tuple::set_ref_array_float(const Symbol& att, ArrayFloat& v)
    {
        set_value(att, T_ARRAY_FLOAT, (void*)&v, true);
        return v;
    }
    inline const ArrayFloat& Tuple::set_cref_array_float(const Symbol& att, const ArrayFloat& v)
    {
        set_value(att, T_ARRAY_FLOAT, (const void*)&v, true, true);
        return v;
    }
    inline ArrayFloat& Tuple::set_array_float(const Symbol& att)
    {
        PValue value = set_value(att, T_ARRAY_FLOAT, 0, false);
        return *(ArrayFloat*)value->get_pvalue();
    }
    inline ListArrayFloat& Tuple::set_list_array_float(const Symbol& att, const ListArrayFloat& v)
    {
        PValue value = set_value(att, T_LIST_ARRAY_FLOAT, (void*)&v, false);
        return *(ListArrayFloat*)value->get_pvalue();
    }
    inline ListArrayFloat& Tuple::set_list_array_float(const Symbol& att)
    {
        PValue value = set_value(att, T_LIST_ARRAY_FLOAT, (void*)0, false);
        return *(ListArrayFloat*)value->get_pvalue();
    }
    inline ListArrayFloat& Tuple::set_ref_list_array_float(const Symbol& att, ListArrayFloat& v)
    {
        set_value(att, T_LIST_ARRAY_FLOAT, (void*)&v, true);
        return v;
    }
    inline const ListArrayFloat& Tuple::set_cref_list_array_float(const Symbol& att, const ListArrayFloat& v)
    {
        set_value(att, T_LIST_ARRAY_FLOAT, (const void*)&v, true, true);
        return v;
    }
    inline ArrayFloat& Tuple::add_array_float(const Symbol& att, const ArrayFloat& v)
    {
        return ((ListArrayFloat*)set_value(att, T_LIST_ARRAY_FLOAT, (void*)0, false)->get_pvalue())->add(v);
    }
    inline const ArrayFloat& Tuple::get_array_float(const Symbol& att) const
    {
        return *(const ArrayFloat*)get_pvalue(att, T_ARRAY_FLOAT, false);
    }
    inline const ArrayFloat* Tuple::get_parray_float(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_ARRAY_FLOAT))
        {
            return (const ArrayFloat*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    }
    inline const ListArrayFloat& Tuple::get_list_array_float(const Symbol& att) const
    {
        return *(const ListArrayFloat*)get_pvalue(att, T_LIST_ARRAY_FLOAT, false);
    }
    inline const ListArrayFloat* Tuple::get_plist_array_float(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LIST_ARRAY_FLOAT))
        {
            return (const ListArrayFloat*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    };

    inline ArrayDouble& Tuple::set_array_double(const Symbol& att, const ArrayDouble& v)
    {
        PValue value = set_value(att, T_ARRAY_DOUBLE, (void*)&v, false);
        return *(ArrayDouble*)value->get_pvalue();
    }
    inline ArrayDouble& Tuple::set_ref_array_double(const Symbol& att, ArrayDouble& v)
    {
        set_value(att, T_ARRAY_DOUBLE, (void*)&v, true);
        return v;
    }
    inline const ArrayDouble& Tuple::set_cref_array_double(const Symbol& att, const ArrayDouble& v)
    {
        set_value(att, T_ARRAY_DOUBLE, (const void*)&v, true, true);
        return v;
    }
    inline ArrayDouble& Tuple::set_array_double(const Symbol& att)
    {
        PValue value = set_value(att, T_ARRAY_DOUBLE, 0, false);
        return *(ArrayDouble*)value->get_pvalue();
    }
    inline ListArrayDouble& Tuple::set_list_array_double(const Symbol& att, const ListArrayDouble& v)
    {
        PValue value = set_value(att, T_LIST_ARRAY_DOUBLE, (void*)&v, false);
        return *(ListArrayDouble*)value->get_pvalue();
    }
    inline ListArrayDouble& Tuple::set_list_array_double(const Symbol& att)
    {
        PValue value = set_value(att, T_LIST_ARRAY_DOUBLE, (void*)0, false);
        return *(ListArrayDouble*)value->get_pvalue();
    }
    inline ListArrayDouble& Tuple::set_ref_list_array_double(const Symbol& att, ListArrayDouble& v)
    {
        set_value(att, T_LIST_ARRAY_DOUBLE, (void*)&v, true);
        return v;
    }
    inline const ListArrayDouble& Tuple::set_cref_list_array_double(const Symbol& att, const ListArrayDouble& v)
    {
        set_value(att, T_LIST_ARRAY_DOUBLE, (const void*)&v, true, true);
        return v;
    }
    inline ArrayDouble& Tuple::add_array_double(const Symbol& att, const ArrayDouble& v)
    {
        return ((ListArrayDouble*)set_value(att, T_LIST_ARRAY_DOUBLE, (void*)0, false)->get_pvalue())->add(v);
    }
    inline const ArrayDouble& Tuple::get_array_double(const Symbol& att) const
    {
        return *(const ArrayDouble*)get_pvalue(att, T_ARRAY_DOUBLE, false);
    }
    inline const ArrayDouble* Tuple::get_parray_double(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_ARRAY_DOUBLE))
        {
            return (const ArrayDouble*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    }
    inline const ListArrayDouble& Tuple::get_list_array_double(const Symbol& att) const
    {
        return *(const ListArrayDouble*)get_pvalue(att, T_LIST_ARRAY_DOUBLE, false);
    }
    inline const ListArrayDouble* Tuple::get_plist_array_double(const Symbol& att) const
    {
        if (Value* value = get_value(att, T_LIST_ARRAY_DOUBLE))
        {
            return (const ListArrayDouble*)value->get_pvalue();
        }
        else
        {
            return 0;
        }
    };



    inline AString& commore::Tuple::set_astring(const Symbol& att, const AChar* v)
    {
        PValue value = set_value(att, T_ASTRING, (void*)0, false);
        AString& r = *(AString*)value->get_pvalue();
        if (v)
        {
            r = v;
        }
        return r;
    }


    inline String& Tuple::set_string(const Symbol& att, const Char* v)
    {
        PValue value = set_value(att, T_STRING, (void*)0, false);
        String& r = *(String*)value->get_pvalue();
        if (v)
        {
            r = v;
        }
        return r;
    }


    inline StringBuffer& Tuple::set_stringbuffer(const Symbol& att, const AChar* v)
    {
        PValue value = set_value(att, T_STRING_BUFFER, (void*)0, false);
        StringBuffer& r = *(StringBuffer*)value->get_pvalue();
        if (v)
        {
            r = v;
        }
        return r;
    }

    inline StringBuffer& Tuple::add_stringbuffer(const Symbol& att, const AChar* v)
    {
        PValue value = set_value(att, T_LIST_STRING_BUFFER, (void*)0, false);
        ListStringBuffer& l = *(ListStringBuffer*)value->get_pvalue();
        if (v)
        {
            return l.add(v);
        }
        else
        {
            return l.add();
        }
    }


    inline AString&  Tuple::add_astring(const Symbol& att, const AChar* v)
    {
        ListAString& l = set_list_astring(att);
        return *l.insert(l.end(), v);
    }


    inline String&  Tuple::add_string(const Symbol& att, const Char* v)
    {
        ListString& l = set_list_string(att);
        return *l.insert(l.end(), v == 0 ? L"" : v);
    }



};

inline commore::OBStream& operator << (commore::OBStream& o, const commore::Tuple& tuple)
{
    tuple.write_xml(o);
    return o;
}

#endif