Table.h

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

#ifndef CMR_TABLE_INCLUDED
#define CMR_TABLE_INCLUDED


#include "Commore.h"
#include "Tuple.h"

namespace commore
{
    enum
    {
        CMR_TABLE_NOT_EMPTY = 5001,
    };
}

namespace commore
{
    class CMREXD Table
    {
    public:
        struct Header;
        struct LineItem;
        //
        // Handle for line iterator
        //
        class CMREXD Line
        {
            friend class Table;

        public:
            Line();
            ~Line();

        public:
            bool  get_bool(const Symbol& att)
            {
                const Bool* r = (const Bool*)get_value(att, T_BOOL);
                return *r;
            }
            bool& set_bool(const Symbol& att)
            {
                Bool* r = (Bool*)get_value(att, T_BOOL);
                return *r;
            }
            bool& set_bool(const Symbol& att, bool v)
            {
                Bool* r = (Bool*)get_value(att, T_BOOL);
                *r = v;
                return *r;
            }

            Int  get_int(const Symbol& att)
            {
                Int* r = (Int*)get_value(att, T_INT);
                return *r;
            }
            Int& set_int(const Symbol& att)
            {
                Int* r = (Int*)get_value(att, T_INT);
                return *r;
            }
            Int& set_int(const Symbol& att, Int v)
            {
                Int* r = (Int*)get_value(att, T_INT);
                *r = v;
                return *r;
            }

            const ListInt& get_list_int(const Symbol& att) const
            {
                const ListInt* r = (const ListInt*)get_value(att, T_LIST_INT);
                return *r;
            }
            ListInt& set_list_int(const Symbol& att)
            {
                ListInt* r = (ListInt*)get_value(att, T_LIST_INT);
                return *r;
            }
            ListInt& set_list_int(const Symbol& att, const ListInt& v)
            {
                ListInt* r = (ListInt*)get_value(att, T_LIST_INT);
                return *r = v;
            }
            Int& add_int(const Symbol& att, Int v)
            {
                ListInt* r = (ListInt*)get_value(att, T_LIST_INT);
                return r->add(v);
            }
            Int& add_int(const Symbol& att)
            {
                ListInt* r = (ListInt*)get_value(att, T_LIST_INT);
                return r->add();
            }

            const AString&  get_astring(const Symbol& att)
            {
                const AString* r = (const AString*)get_value(att, T_ASTRING);
                return *r;
            }
            AString& set_astring(const Symbol& att)
            {
                AString* r = (AString*)get_value(att, T_ASTRING);
                return *r;
            }
            AString& set_astring(const Symbol& att, const AChar* v)
            {
                AString* r = (AString*)get_value(att, T_ASTRING);
                *r = v;
                return *r;
            }

            const Tuple&  get_tuple(const Symbol& att)
            {
                const Tuple* r = (const Tuple*)get_value(att, T_TUPLE);
                return *r;
            }
            Tuple& set_tuple(const Symbol& att)
            {
                Tuple* r = (Tuple*)get_value(att, T_TUPLE);
                return *r;
            }
            Tuple& set_tuple(const Symbol& att, const Tuple& v)
            {
                Tuple* r = (Tuple*)get_value(att, T_TUPLE);
                *r = v;
                return *r;
            }

            bool next();
            bool prev();
            bool more() const;
            bool erase();

        private:
            const void* get_value(const Symbol& att, Types type) const;
            void* get_value(const Symbol& att, Types type);
            void* get_value(int index, Types type);

        private:
            Table* table_;
            LineItem* line_;

        };
        friend class Line;


        //
        // Const line iterator
        //
        class CMREXD ConstLine
        {
            friend class Table;

        public:
            ConstLine();
            ~ConstLine();

        public:
            bool get_bool(const Symbol& att) const
            {
                const Bool* r = (const Bool*)get_value(att, T_BOOL);
                return *r;
            }
            Int  get_int(const Symbol& att) const
            {
                Int* r = (Int*)get_value(att, T_INT);
                return *r;
            }
            const AString& get_astring(const Symbol& att) const
            {
                const AString* r = (const AString*)get_value(att, T_ASTRING);
                return *r;
            }
            const Tuple& get_tuple(const Symbol& att) const
            {
                Tuple* r = (Tuple*)get_value(att, T_TUPLE);
                return *r;
            }

            bool next();
            bool prev();
            bool more() const;

        private:
            const void* get_value(const Symbol& att, Types type) const;
            const void* get_value(int index, Types type) const;

        private:
            const Table* table_;
            const LineItem* line_;

        };
        friend class ConstLine;


    public:
        Table();
        Table(const Symbol& name);
        Table(const Table&);
        Table& operator = (const Table& t)
        {
            return assign(t);
        }
        ~Table();

    public:
        Table& assign(const Table& t);

        // Remove lines content
        // if all : remove column specifications
        //
        void clear(bool all = false);
        //
        // Manage table column
        //
        int add_column(const Symbol& name, Types type);
        int add_int_col(const Symbol& name)
        {
            return add_column(name, T_INT);
        }
        int add_list_int_col(const Symbol& name)
        {
            return add_column(name, T_LIST_INT);
        }
        int add_bool_col(const Symbol& name)
        {
            return add_column(name, T_BOOL);
        }
        int add_astring_col(const Symbol& name)
        {
            return add_column(name, T_ASTRING);
        }
        int add_tuple_col(const Symbol& name)
        {
            return add_column(name, T_TUPLE);
        }
        int remove_column(const Symbol& name);
        int compare(const Table& t) const;
        Line begin();
        Line end();
        ConstLine begin() const;
        ConstLine end() const;
        Line add_line();
        const Symbol& get_name() const;
        size_t size() const;
        size_t line_size() const;
        int write_xml(OBStream& o) const;
        int read_xml(IBStream& i);
        int write(CommBuffer& buffer) const;
        int read(const CommBuffer& buffer);

    private:
        Line add_line(const LineItem* aline);

    private:
        Header* header_;
    };
}

CMREXD commore::OBStream& operator<<(commore::OBStream& o,  const commore::Table& b);

#endif