Stock.h

Go to the documentation of this file.

#ifndef STOCK_H_
#define STOCK_H_

#include <map>

#include "../utils/FullName.h"
#include "../utils/Utils.h"
#include "StockException.h"

// faster for compilation, no problem of recursive link
class DataStock;
class ListDataStockBase;
class TAlibAPI;
//class WaveletBase;

// Maybe too much responsability in this class, all function as data-members
// Computation may be separate ? already TALib
// Stock may logically contain other data : fundamental, limits to check (permanently in MySQL DB), whatever needed for Portfolio construction
// More info could be retrieved from Python dictstocks / DataBase info


class Stock {

  private:
    //@[
    typedef std::map<ETime, std::vector<ListDataStockBase *> >::iterator it_map;
    typedef std::map<ETime, std::vector<ListDataStockBase *> >::const_iterator cit_map;
    typedef std::vector<ListDataStockBase *>::iterator it_listdata;
    typedef std::vector<ListDataStockBase *>::const_iterator cit_listdata;

    std::string name;
    // if python wrapper available, should use the info from dictstocks.txt
    // if used only with python, can be deleted (symbol will be retrieved from the name in dictstocks.txt)
    // if need DB access, same : name to symbol stored there. 
    // Certainly not needed anymore 
    std::string symbol;

    // problem if different paths,
    // maybe better to use only one global one, with care
    // extra parameter only for script use is needed
    // certainly to delete also.. not sure
    const std::string path;

    TAlibAPI * p_talib;

    std::map <ETime, std::vector<ListDataStockBase *> > mapTime_ListData;

    //warning To call if sure than it_map is not at end(), no check performed inside
    // can delete it_m and performs find inside ! only to check if not at the end, but what to return ?
    cit_listdata GetItList( cit_map& it_m, const Indicator& indic, 
          const std::vector<int>& param = std::vector<int>() ) const ;
    cit_listdata GetItList( cit_map& it_m, const std::string& sname ) const ;
    it_listdata GetItList( it_map& it_m, const Indicator& indic,
              const std::vector<int>& param = std::vector<int>() );
    it_listdata GetItList( it_map& it_m, const std::string& sname );


    // Add other internal methods as private, cleaner interface

    // suppress tmscl, given in input, may add later because present in header
    // need to be static to be called by Read_HeaderCSV_static
    //int ReadLineHeader( const std::string& line, Utils::firstlast_dates& dates ) const;
    static int ReadLineHeader( const std::string& line, Utils::firstlast_dates& dates );

    //void WriteLineHeader( const ETime& tmscl, const Utils::firstlast_dates& dates, std::ostringstream& ss_header ) const;
    static void WriteLineHeader( const ETime& tmscl, const Utils::firstlast_dates& dates, std::ostringstream& ss_header );


        void LoadCSVData(const ETime& tmscl, Utils::firstlast_dates& dates ) throw (StockException);

        // few check, should be called by LoadListData, moved to public for Transform_TimeCSV
        // could make Transform_TimeCSV friend as well
        int Transform_TimeScale ( const ETime& new_tmscl );

        // Call to external function, need interface ?, friend ?
        // does really need to be member ?
        //    - python makes sense deal wih Stock on Web
        //      could be a composition with a separate class ?
        //    - Compute, only TA for now, but a separate class or namespace is possible
        //      Other libraries, other indicators to use

        // interaction with TAlib, both could be private ?? only called by LoadListData
        // more private less public better
        int ComputeTA( const ETime& tmscl, const std::string& name_indic )
                throw(TALibException) ;

        //  used for gui only ?
        void SetLDataFullName( ListDataStockBase *p_listdata ) const;

  public:

    Stock() {p_talib = nullptr;}
    // Constructor with name, set symbol == name and optional path to find the data
    Stock( const std::string iname, const std::string isymbol, const std::string ipath);
    // better constructor, to keep, ipath useful/better for tests, scripts ?
    Stock( const std::string iname, const std::string ipath = Utils::GetPathData() );
    virtual ~Stock();

    std::string GetName() const {return name;}
    std::string GetSymbol() const {return symbol;}
    std::string GetPath() const {return path;}

    // function do not see internal ListStockDataBase, should be public
    // makes sense this function with tmscl only, intern ?
    bool CheckLoaded( const ETime& tmscl) const;
    bool CheckLoaded( const ETime& tmscl, const Indicator& indic, const std::vector<int>& param = std::vector<int>() ) const;
    bool CheckLoaded( const ETime& tmscl, const std::string& sname) const;
    // Only for StockManager to delete the entry...or other ?
    bool IsEmpty() const;

    // possible to make the dynamic cast in the return ?? avoid from the code ??
    // Indicator not necessary for Historic data (could implement)
    ListDataStockBase* GetListData ( const ETime& tmscl, const Indicator& indic, const std::vector<int> param= std::vector<int>() ) const;
    ListDataStockBase* GetListData ( const ETime& tmscl, const std::string& sname) const;

    int LoadListData( const ETime& tmscl, const Indicator& indic = Indicator::StockCSV, const std::vector<int>& param= std::vector<int>(),
                      Utils::firstlast_dates dates = Utils::get_fldate_default() ) throw (StockException);

    void DeleteListData( const ETime& tmscl, const Indicator& indic,std::vector<int> param = std::vector<int>() );
    void DeleteListData( const ETime& tmscl, const std::string& sname );
    void DeleteAllListData ( const ETime& tmscl );

    unsigned int ReadCSV( const ETime tmscl, Utils::firstlast_dates dates = Utils::get_fldate_default() )
        throw ( StockFileError );

    // tmp default for testing, later move to normal, add opt_name ?  */
    void WriteCSV(const ETime tmscl, bool opt_tmp= false ) const throw ( StockException );

        int SaveCSV ( const ETime tmscl, bool opt_tmp =false ) const;

    int Read_HeaderCSV( ETime tmscl, Utils::firstlast_dates& dates ) const throw ( StockFileError );

    // certainly keep only the static version later
    static int Read_HeaderCSV_static( std::string namestock, ETime tmscl, Utils::firstlast_dates & dates )
        throw ( StockFileError );

    static int UpdateCSV_Inst( std::string namestock, DataStock& inst_value, DataStock& inst_volume,
                                                   ETime tmscl, bool opt_tmp = false ) throw ( StockFileError );


    int AddListDataToMap( const ETime& tmscl, ListDataStockBase* p_listdata );


    // indicator has been deleted, never used until now, always hist.data
    // ok compile without
    //time_t LastCSVUpdate(ETime tmscl = ETime::DAY, Indicator indic=Indicator::StockCSV) throw(StockException);
    //time_t LastCSVUpdate(ETime tmscl = ETime::DAY, bool load_list = false) throw(StockException);

    void Updated( const ETime tmscl );

    void UpdateAllTimeScale( const ETime tmscl, Utils::firstlast_dates opt_dates = Utils::get_fldate_default(),
                                bool b_readfile = true );

    // C++ version, same role update DAY or dcsv; from python parser or from reading file
    // normal dcsv read file if real time and DAY use python parser
    // but could be mixed, dcsv force update of python (easy call Server_Client FORCE )
    // DAY: csv could be updated by python, end of the day for instance, so need to read the file
    // change name, only read from file
    // was not bad idea to have a single interface to other update...
    //int UpdateStocks( Indicator, TimeScale );

    // deleted call LastCSVUpdate, so should throw Exception ? or do not matter if throw by called function ?
    int UpdateCSVFromFile( const ETime tmscl );

    //addtogroup python, not working here, for a single function
    // important to add StockPythonException AND StockFileError, otherwise not caught. Works with StockException
    // not clear if exception for all possible python errors, difficult to unit_test also
        int UpdateCSVFromWeb( const std::string& source, Utils::firstlast_dates opt_dates  = Utils::get_fldate_default() )
                throw(StockException);

    // written to solve problem with GUI, where a temporary Stock is convenient
    void MergeStock( const Stock *new_stock, bool /*to_replace*/);


    void PrintMapChrono( const unsigned int verbose = 0 ) const;

    // could be in ListDataStock, no need to mix close, volume, open
    // more centered, if needed StockManager can make the transition
    // normally apply to close, here can try on every derivative !!
    // WaveletBase* ComputeWavelet ( TimeScale tmscl ); //, std::string name_indic );


    // addtogroup works here, ingroup for UpdateCSVFromParser..
    // used internally by embedded python function, could be private
    // Certainly much more to do with this functionality, access more data
    int LoadDictionary ( std::string dict = "" );

    int TestwrapPython( std::string source );
    // extend first version to produce error like UpdateCSVFromFile
    int TestwrapPython2( std::string source ); //throw (std::exception);

};

#endif /* STOCK_H_ */