TSADBTable.h

/*  ===================================================================
*
*                 T R A D I N G   S Y S T E M   A P I ™
*    Copyright © 1999 - 2014 by Peter Ritter ( TradingSystemAPI.com )
*                A L L   R I G H T S   R E S E R V E D
*
*     Consult your license regarding permissions and restrictions.
*             You may obtain a copy of the License at:
*     http://www.TradingSystemAPI.com/licenses/LICENSE-TSAPI-3.0.html
*
*  ====================================================================
*/

#ifndef TSA_TABLE__INCLUDED
#define TSA_TABLE__INCLUDED

#include "TSAStreams.h"
#include "TSADatabase.h"
#include "TSADBRecord.h"

namespace tsa {
    class  path;
    class  record;
    struct rec_proxy;

    
    namespace fast{
        /*
        ** ===================================================
        ** > > >              class table                < < <
        ** ===================================================
        */

        class dll_export table :
            public out_stream_adaptor,
            public appendable, 
            public tsa::object {
            tsa_declare_testable;
            friend class database;
            friend class record;
            friend void out_stream::connect(const std::string& db_name, const std::string& table_name);
        private:
            table_imp_ref m_table_imp;
            variant m_ret_val;
            database* m_database_ptr;
            void prepare_current_record_update(void);
            size_t m_append_rec_pos;
            void verify_init(void) const;
        private:
            table(void);
            table(database*);
            void init(const std::string&, database*);
        public:
            table(const table&);    // note: for regression tests
        public:
            table(const table_imp_ref&);
            void operator= (const table_imp_ref&);
        public:
            virtual void osa__append(const date_time&, std::vector<variant>&) override;
            virtual void osa__prepare_stream(const std::string& source_name, const tsa::column_defs&) override;
            virtual void cmp__finalize(void) override;
        public:
            // internal
            table(database& db, const std::string& tableName);

            virtual ~table(void);
        public:

            bool is_init(void) const;

            void close(void);

            const std::string& name(void) const;
        public:
            const std::string& column_name(size_t position) const;

            size_t column_number(const std::string& column_name) const;

            virtual size_t column_count(void) const;    /*class appendable*/

            type_t column_type(size_t position) const;

            size_t column_field_length(size_t column_position) const;    //IU

            // Internal; Returns the name under which the column_defs object for this table is stored.
            const std::string& column_defs__name(void) const;

            const class tsa::column_defs columns(void) const;
        public:
            class iterator {
                friend class table;
                bool m_is_end;
                table* m_table_ptr;
                iterator(table*, bool is_end);
                iterator(void);
            public:

                iterator(const iterator& other);

                void operator= (const iterator& other);

                ~iterator(void);
            public:

                db_record* operator-> (void);

                db_record* operator* (void);

                void operator++ (int);

                void advance(void);

                const date_time& timestamp(void) const;

                const variant operator[](size_t position) const;

                bool operator== (const iterator& rhs) const;

                bool operator!= (const iterator& rhs) const;
            private:
                void table::iterator::verify_not_end(void) const;
            };

            iterator end_iterator;

            iterator seek(const date_time& target_timestamp);

            iterator seek(size_t record_position);

            iterator begin(void);

            const iterator& end(void);

            // internal
            virtual class record record(void);    /*class appendable*/

            virtual void append(const class record& record, append_flag_type flag = error_on_duplicate_timestamp);
            
            // internal
            void push_back(const class record& rec, append_flag_type flag = error_on_duplicate_timestamp);

            size_t size(void) const;

            bool empty(void) const;

            const date_time& first_timestamp(void) const;

            const date_time& last_timestamp(void) const;

            const date_time& timestamp(void) const;

            void commit(void);

            void read(class record& rec) const;

            void clear();

            void truncate(size_t new_size);

            void truncate(const date_time& new_highest_timestamp);
        private:
            iterator* m_iterator_ptr;
            void register_iterator(iterator*);
            void deregister_iterator(iterator*);
            bool cursor_next(void);
            bool cursor_seek_first(void);
            const variant cursor_at(size_t index);
        public:
            bool cursor_seek(size_t index);
            bool cursor_seek_last(void);
            void cursor_update(void);
            void cursor_set_at(size_t index, const variant& value);

            /* internal
             * @brief   The function returns false if @b timestamp is out of bounds. If a record with the
             *  given timestamp does not exist, the cursor will be positioned on the record with the next
             *  lower timestamp, and return true. The cursor will thus be positioned on a record with a
             *  timestamp lower or equal to the given @b timestamp.
             * @param   timestamp   The timestamp.
             * @return  bool.
             */
            bool cursor_seek(const date_time& timestamp);
            bool b_next(void);
            void Read(date_time& timestamp, std::vector<variant>& record) const;
            const variant operator[](size_t fieldIndex);
            const variant operator[](const std::string& fieldName);
        public:
            // internal Updates the table record at current cursor position with values in given @b record
            void update(std::vector<variant>& record);
            void append(const date_time& timestamp, const std::vector<variant>& record,
                append_flag_type appendFlag = error_on_duplicate_timestamp
                );
            void append(const date_time& timestamp, append_flag_type);
            void append(const date& date, append_flag_type);
            void Read(std::vector<variant>& record) const;
        private:
            size_t m_float_precision;
            size_t m_print_limit;
            bool m_print_timestamp;
            date_time m_tPrintStart;
            date_time m_tPrintEnd;
        public:
            void print_timestamp(bool _b);

            //  @brief Sets the floating point precision to be used by subsequent calls to print(), printv(), html() and csv().
            void print_fp_precision(size_t _n);

            //  @brief Sets the number of records to be printed by subsequent calls to print(), printv(), html() and csv().
            void print_limit(size_t _n);

            // @brief Sets the range of timestamps to be printed by subsequent calls to print(), printv(), html() and csv().
            void print_range(const date_time& _start, const date_time& _end);
        public:
            // @brief Prints records to @b stream. Upon completion the member will reset any range requests
            // set via print_range() or print_limit().
            void print(std::ostream& stream);

            // @brief Prints records to @b stream vertically, with a single field printed in each line.
            // This is useful for tables that have many fields.  Upon completion the member will reset any range requests
            // set via print_range() or print_limit().
            void printv(std::ostream& stream);

            // @brief Prints records to an html file with same name as table in given @b dir, unless an @b alt_name is given.
            void html(const os::path& dir, const std::string& alt_name = "");

            // @b Prints records as comma separated values. Upon completion the member will reset any range requests
            // set via print_range() or print_limit().
            void csv(std::ostream&);

        public:
            // Multiplies all numeric (non NIL) values in @b column by @b number.
            void column_multiply(const std::string& column, double number);

            // Divides all numeric (non NIL) values in @b column by @b number.
            void column_divide(const std::string& column, double number);

            // Adds @b number to all numeric (non NIL) values in @b column.
            void column_add(const std::string& column, double number);

            // Caps all numeric (non NIL) values in @b column at @b number. No value in @b column will be larger than @b number.
            void column_cap(const std::string& column, double number);

            // Floors all numeric (non NIL) values in @b column at @b number. No value in @b column will be smaller than @b number.
            void column_floor(const std::string& column, double number);

            // Returns true if any value in @b column is NIL, else false.
            bool column_contains_undefined(const std::string& column);

            // Returns true if any value in any column of the table is NIL.
            bool table_contains_undefined(void);

            // @brief Returns the average numeric value in @b column_name. If @b raiseNIL is true,
            // any NIL values encountered is raised as an exception, else NIL values are ignored.
            double column_average(const std::string& column_name, bool raiseNIL = false);

            // @brief Returns the maximum numeric value in @b column_name. If @b raiseNIL is true,
            // any NIL values encountered is raised as an exception, else NIL values are ignored.
            double column_max(const std::string& column_name, bool raiseNIL = false);

            // @brief Returns the minimum numeric value in @b column_name. If @b raiseNIL is true,
            // any NIL values encountered is raised as an exception, else NIL values are ignored.
            double column_min(const std::string& column_name, bool raiseNIL = false);

            void UpdateAllValuesInColumn(const std::string& _columnName,
                double _transformValue, double (table::*_func)(double value, double by));
            double _Multiply(double value, double by);
            double _Divide(double value, double by);
            double _Add(double value, double by);
            double _Cap(double value, double at);
            double _Floor(double value, double at);
            bool _TypeIsNumeric(type_t type);
            double _ApplyValues(_MetricCalc& calc, const std::string& _columnName, bool _raiseNIL);
        };
    }//namespace fast
} //tsa
#endif