DataStock.h

Go to the documentation of this file.

#ifndef DATASTOCK_H_
#define DATASTOCK_H_

#include <ctime>
#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include "../utils/Utils.h"


// to do: GetValues both for std::vector both float and double (easy for unit_test)
// want to overload SetData(most common use) or oblige user to use type_value_data ??
// did not modify

// note: more efficient than stringstream
// http://live.boost.org/doc/libs/1_42_0/doc/html/interprocess/streams.html

// if use noexcept, swap with move ? swap( A, B) only, makes sense
// http://stackoverflow.com/questions/6416385/move-semantics-custom-swap-function-obsolete

// ok, ObjectStock has been cleaned ! Only SetObjectStock function(internal no interface) need type_value_data and transform into intern => double
// it is needed only to get the values there, so no need to extend GetValues
// For SetValues uni-test it is only to set the object, not for algo PutCArray/GetCArray (to check)

// to delete comments when sure
// many changes done to compile, to check later:
//  - list_data_stock_Carray.cpp, problem with set up of SetData (changed of 4-6 tmp_vec with type_value_data)
//       Not a problem if it is to setup the DataStock, and not to deal with PutCArray/GetCarray
//  - ObjectStock.cxx Many float and double used ( need to consider which one must be changed )
//       SetObjectStock(2 changes), extract from ListData, need typedef. SetValues(4 changes)
//       Many other related.
//  - AbstractStock.h redeclare the typedef directly, need to see if intermediate(global) file is better (typedef.h) for instance !!

typedef double type_value_data;
//typedef float type_value_data;

namespace EDS {
    enum class ECSV : unsigned int { OPEN=0, HIGH, LOW, CLOSE };
    // template must be in header
    template <typename ECSV>
    unsigned int as_uint(const ECSV value) {
        return static_cast<unsigned int>(value); }
}

namespace BDS {
    const int BUFFER_STREAM = 256;
    const int BUFFER_DATE = 20;
    //}@
} // end group_operator

class DataStock {

protected:
    time_t date;

public:
    DataStock();
    DataStock(time_t d);
    DataStock (const DataStock & rhs);
    DataStock (DataStock && rhs);
    virtual ~DataStock() {}

    //{@
    DataStock& operator=( const DataStock& rhs );       
    DataStock& operator=( DataStock&& rhs);
    //}@

    time_t GetDate() const {return date;}
    void SetDate(const time_t d) { date = d; }
    std::string GetDateString( const bool bhours = true ) const;
    // used by Transform_*, need WEEK infos, used by Stock
    // \todo to make in Utils but only when tests will written
    struct tm GetDateTm() const;

    // used by PutCArray, (GetCArray ??)
    virtual void SetData( const time_t d, const std::vector<type_value_data> & vec ) =0;
    // GetData ? date + value(s), not useful ?
    virtual std::vector<type_value_data> GetValues() const =0;
    // SetValues useful.., at least some symmetry...
    virtual void SetValues( std::vector<type_value_data> & ) =0;

    // could return a reference to avoid a copy ?? simple value not needed
    virtual type_value_data GetMaximum() const =0;
    virtual type_value_data GetMinimum() const =0;
    virtual bool HasChanged( const DataStock & data_to_check ) const =0;
    virtual void ExtractCSVLine(std::vector<std::string> &vec) =0;

    virtual void PrintData( const unsigned int verbose = 0 ) const =0;

   friend std::ostream& operator<<(std::ostream& os, const DataStock& obj);

#ifndef __CINT__
   friend std::iostream& operator>>(std::iostream& ios, DataStock& obj);
#endif

    friend std::string& operator<<(std::string &line_csv, const DataStock& obj);

    friend std::string& operator>>(std::string &line_csv, DataStock& obj);

    virtual void helper_operator_write(std::ostream &os) const =0;
#ifndef __CINT__
    virtual void helper_operator_read(std::iostream &ios) =0;
#endif


protected:
        // page 1329, base class should be an helper function, no need of public friends
        // good, easier to add parameter for b_hour or get error in parsing date
#ifndef __CINT__
         int helper_operator_read_base(std::iostream& ios);
#endif

        // can test with  if (os.rdbuf() == std::cout.rdbuf() ), not for all
        // or tellp return always -1
        void helper_operator_write_base(std::ostream& os) const;
        // miss operator ==, for use with base needed ?? not really
 //end of group_operator
};


 // 32bits, float, better for volume than MultiData(24 empty, 28 with one value?)
 // sizeof(SimpleData) = 12 = 4 (time_t) + 4(float), miss 4 ??
 //
 // 64bits, double
 // sizeof(SimpleData) = 24
class SimpleData: public DataStock {

private:
    type_value_data value;

public:
    SimpleData();
    SimpleData( type_value_data ivalue );
    SimpleData( time_t d, type_value_data ivalue );
    SimpleData( unsigned int /*nb*/ );
    SimpleData( const SimpleData & rhs );
    SimpleData( SimpleData && rhs );
    virtual ~SimpleData() {}

    SimpleData& operator=( const SimpleData& rhs );
    SimpleData& operator=( SimpleData&& rhs);
    
    virtual void SetData(const time_t d, const std::vector<type_value_data> & vec) {date=d;value=vec[0];}
    // here for sure cannot return a ref on vector, because created
    virtual std::vector<type_value_data> GetValues() const;
    // brief Set the value (only one), do not modify the date.
    // vec should have a size of 1, test by assert\n
    //  For SimpleData, SetValue can be used
    //
    virtual void SetValues( std::vector<type_value_data> & vec);
    virtual type_value_data GetMaximum() const {return value;}
    virtual type_value_data GetMinimum() const {return value;}
    virtual bool HasChanged( const DataStock & data_to_check ) const;
    virtual void ExtractCSVLine(std::vector<std::string> & linecsv);
    void PrintData( const unsigned int verbose = 0) const;

    //void Reset() // needed ?, not anymore
    type_value_data GetValue() const {return value;}
    void SetValue(const type_value_data ivalue) {value=ivalue;}
    void SetData( const time_t d, const type_value_data ivalue ) {date = d; value = ivalue;}

    // Book says must be friend to get implicit conversion... not really needed here ?
    friend bool operator==( const SimpleData & lhs, const SimpleData & rhs );

protected :
    virtual void helper_operator_write(std::ostream &os) const;
#ifndef __CINT__
    virtual void helper_operator_read(std::iostream &ios);
#endif

 // end group_operator

};


 // 32 bits, float
 //sizeof(MutliData without data) = 24 = 4(nb_data) + 4(time_t) + 4 (unsigned int) + 1 pointers vec(12)
 //                                    == 12 (no space for vtable pointer)
 // 64bits, double
 // sizeof(MultiData) = 48
class MultiData: public DataStock {

private:
        const unsigned int nb_data;
        // always sizeof(12) (asus 32bits), only a ref. To compare with std::array
        std::vector<type_value_data> values;

public:
   MultiData();
   MultiData( unsigned int nbdata );
   MultiData(time_t d, std::vector<type_value_data> ivalues);
   MultiData( const MultiData & rhs );
   MultiData( MultiData&& rhs );
   virtual ~MultiData() {};

   MultiData& operator=( const MultiData& rhs );
   MultiData& operator=( MultiData&& rhs);

   void SetData(const time_t d, const std::vector<type_value_data> & vec) {date=d;values=vec;}
   virtual std::vector<type_value_data> GetValues() const;
   void SetValues( std::vector<type_value_data> & vec);
   virtual type_value_data GetMaximum() const;
   virtual type_value_data GetMinimum() const;
   virtual bool HasChanged( const DataStock & data_to_check ) const;
   virtual void ExtractCSVLine(std::vector<std::string> & linecsv);
   void PrintData( const unsigned int verbose = 0 ) const;

   friend bool operator==( const MultiData & lhs, const MultiData & rhs );

protected :
   virtual void helper_operator_write(std::ostream &os) const;
#ifndef __CINT__
   virtual void helper_operator_read(std::iostream &ios);
#endif

 //end group_operator
};


 // on 32-bits, float
 // sizeof(DataCSV) = 24 != 16(4 for a float)+ time_t(4) + ?? 1 pointer vtable (4)
 //
 // 64bits, double
 // sizeof(DataCSV) = 48
class DataCSV: public DataStock {

private:
    type_value_data open, high, low, close;

public:

    DataCSV();
    DataCSV(time_t d, type_value_data iopen, type_value_data ihigh,
                type_value_data ilow, type_value_data iclose);
    DataCSV( unsigned int /*nb*/ );
    DataCSV(const DataCSV & rhs);
    DataCSV( DataCSV && rhs );
    virtual ~DataCSV() {}
    
    DataCSV& operator=( const DataCSV& rhs );
    DataCSV& operator=( DataCSV&& rhs);

    virtual void SetData( const time_t d, const std::vector<type_value_data> & vec);
    virtual std::vector<type_value_data> GetValues() const;
    virtual void SetValues ( std::vector<type_value_data> & vec );
    virtual type_value_data GetMaximum() const {return GetHigh();}
    virtual type_value_data GetMinimum() const {return GetLow();}
    virtual bool HasChanged( const DataStock & data_to_check ) const;
    virtual void ExtractCSVLine(std::vector<std::string> & linecsv);
    void PrintData( const unsigned int verbose = 0 ) const;
    
    type_value_data GetOpen() const  {return open;}
    type_value_data GetHigh() const  {return high;}
    type_value_data GetLow()  const  {return low;}
    type_value_data GetClose() const {return close;}
    void SetOpen( type_value_data iopen)   { open=iopen; }
    void SetClose( type_value_data iclose) { close=iclose; }
    void SetHigh( type_value_data ihigh)   { high=ihigh; }
    void SetLow( type_value_data ilow)     { low=ilow; }        
    void Reset();
    void SetValues(const type_value_data iopen, const type_value_data ihigh ,
                          const type_value_data ilow, const type_value_data iclose);
    void SetData(const time_t d ,const type_value_data iopen, const type_value_data ihigh,
                     const type_value_data ilow, const type_value_data iclose);
    // could update Open or Close at the same time, but will be dependent of the order of the algo
    // change name UpdateLowHigh, MergeCandle
    virtual void AdditionData( const DataCSV & new_data );
    virtual void AdditionData ( const SimpleData & new_data );

        friend bool operator==( const DataCSV & lhs, const DataCSV & rhs );

protected :
    virtual void helper_operator_write(std::ostream &os) const;
#ifndef __CINT__
    virtual void helper_operator_read(std::iostream &ios);
#endif

 // end group_operator
};

#endif /* DATASTOCK_H_ */