ListDataStock.h

Go to the documentation of this file.

// playing with swap and move semantic
// http://stackoverflow.com/questions/6380862/how-to-provide-a-swap-function-for-my-class?lq=1
// if use noexcept, swap with move ? only for swap( A, B) make sense..
// http://stackoverflow.com/questions/6416385/move-semantics-custom-swap-function-obsolete

#ifndef LISTDATASTOCK_H_
#define LISTDATASTOCK_H_

// pass on asus ?? but not on home ??
#ifndef __CINT__
#include <initializer_list>
#endif

#include "DataStock.h"
#include "../utils/TimeScale.h"
#include "../utils/FullName.h"
#include "../utils/Indicator.h"
#include "../utils/Utils.h"

// test for having polymorphic template PutCArray/GetCArray
#ifndef __CINT__
#include <boost/any.hpp>
#include <boost/variant.hpp>
#include <typeinfo>
#endif

// includes PolicyChronologic
#include "typedef.h"

class ListDataStockBase {

  public:
    ListDataStockBase() : name(""),tmscl(ETime::not_a_time),dates(Utils::get_fldate_default()),fullname("") {}
    
    // check if timescale necessary
    // should be replaced with longname. TimeScale not needed any more
    // maybe very convenient this two constructor, one internal, the other not
    // problem here need a TimeScale to make difference with the other,
    // problem ?? not really, more clear internally to have TimeScale
    // but need to setup the fullname as well
    ListDataStockBase(std::string iname, ETime itmscl,
            Utils::firstlast_dates idates = Utils::get_fldate_default ()):
            name(iname),tmscl(itmscl),dates(idates) {}
    virtual ~ListDataStockBase() {}
 
    // really need virtual here ? no only apply to base...
    // GetName cannot be called with an default object ??
    std::string GetName() const {return name;}
    virtual std::string GetFullName() const {return fullname;}
    virtual ETime GetTimeScale() const {return tmscl;}
    virtual void SetTimeScale( const ETime new_tmscl ) { tmscl = new_tmscl; }
    void SetName(const std::string iname) {name=iname;}
    virtual void SetFullName( std::string fname ) {fullname=fname;}

    // confusing here both dates / time
    virtual Utils::firstlast_dates GetDates() const {return dates;}
    time_t GetFirstDate() const {return dates.first;}
    time_t GetLastDate() const {return dates.last;}
    virtual void SetDates( const time_t first, const time_t last ) {
        dates.first = first; dates.last = last; }
    virtual void SetDates( const Utils::firstlast_dates & new_date) { dates = new_date; }
    virtual void SetDates() =0;

    // change nothing pure virtual or not
    // Wrappers around the internal std::vector
    virtual unsigned int GetSize() const =0;
    //virtual unsigned int GetSize() const {return 0;}
    virtual unsigned int Capacity() const =0;
    virtual void Reserve(const unsigned int new_size) =0;
    virtual void Clear() =0;
    virtual void Swap() =0;

    // need argument, otherwise same declaration, as for AddData
    // std::vector<DataStock> &, cannot work..., or only in Derived ? really used from base ?
    // cannot set protected in base class ?
    virtual void GetVectorData( std::vector<DataCSV>&, const EPChrono ) const {}
    virtual void GetVectorData( std::vector<SimpleData>&, const EPChrono ) const {}
    virtual void GetVectorData( std::vector<MultiData>&, const EPChrono ) const {}

    // should be able to call the policy class here, but call is ambiguous
    virtual std::string policy() const =0;
    virtual EPChrono bpolicy() const =0;

    virtual void Order( const EPChrono chrono ) = 0; //{};
    virtual time_t LastUpdate() const =0;
    virtual time_t GetFirstTime() const =0;

    virtual DataStock& operator[] (const unsigned int offset) =0;
    virtual const DataStock& ChronologicAt(const unsigned int offset) const =0;
    virtual const DataStock& NoChronologicAt(const unsigned int offset) const =0;


    virtual void AddData( DataStock & ) =0;

     // internally call Policy::AddChronoToList ( with param first_to_skip )
    virtual int AddToList ( const ListDataStockBase * ) =0;

    // could be protected ? at this point used only by AddToList ??
    virtual void Replace ( const ListDataStockBase * ) =0;


#ifndef __CINT__
    typedef boost::variant<float**, double**, int**> var_types;
    typedef boost::variant<float***, double***, int***> var_types2;
#endif


    // to use double for more generality ?? extended by template

    // better version, can use EDS::ECSV
#ifndef __CINT__
    virtual unsigned int GetCArray( var_types arraydata_c, const EPChrono b_order, const unsigned int no = 0 ) const =0;
#endif

     // could return the number of indic allocated
     // float** array_c const compiles
#ifndef __CINT__
    virtual unsigned int GetCArray( var_types2 arraydata_c, const EPChrono b_order,  std::initializer_list<unsigned int> list_no ) const =0;
#endif

#ifndef __CINT__
    virtual int PutCArray ( const ListDataStockBase & ldata_date, const unsigned int nb_data,
             const unsigned size_indic, var_types arraydata_c, const unsigned int offset_begin,
             const unsigned int offset_end = 0, const EPChrono b_chrono = EPChrono::CHRONO, bool full_array = false ) =0;
#endif


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

  protected:
    std::string name;
    //5/2/11
    // Need timescale for drawing label, cannot be extracted from name of listdata or THStock
    // present in canvas stock but will be dependent of CanvasStock, cannot be draw alone...! not really used ??
    // jan 2013 to check if needed, in fullname is the timescale !
    // can be deleted, if fullname is always setup !
    // necessary for Transform_TimeScale ? not really done from Stock !
    ETime tmscl;
    // selecting a range..., not really because List is created in ReadCSV and use range as parameter, makes sense
    // keep for now, used a lot in unit-test, but if do not find really a use, to delete
    //
    // Case useful, if only part of the data is in memory (by some range), then call to any update will be wrong !
    // In fact larger problem in this case, update by server, saving to file... cannot use the in-memory List
    //
    // => So check only with header ? but wrong also if INST has been updated normally.
    // So dates as data member could maintain a correct value:
    //   - set by default to Header not to Last data.(in case of range)
    //   - updated only after a real update. AddToList for instance
    //   - when asked for LastCSVUpdate, return dm value
    //   - When asking to save data in file, same, check with this value. Cannot write the file if cannot
    //   - When data received from ServerSM, same, do not apply the update.
    // Too complex case..., not sure to solve, but make some checks/warning before update (in LastCSVUpdate)
    Utils::firstlast_dates dates;
    // put last to use initializer constructors 
    std::string fullname;

    // why cannot move GetVecotrData here ?

#ifndef __CINT__
    class visitor_type_array
                : public boost::static_visitor<type_value_data>
        {
        public:
                // need default constructor
                visitor_type_array(): i(0),j(0) {}
                visitor_type_array(int i1,int j1): i(i1),j(j1) {}

                template <typename T>
                type_value_data operator() (T **val) const {
                        //std::cout << t << std::endl;
                        return val[i][j];
                }
                unsigned int i, j;
        };


        class visitor_get_array_allocate
                : public boost::static_visitor<>
                {
                public:
                        // need default constructor
                        visitor_get_array_allocate(): size(0) {}
                        visitor_get_array_allocate(int new_size): size(new_size) {}

                        template <typename T>
                        void operator() (T **array) const {
                                //std::cout << "Allocate with size: " << size << std::endl;
                                //std::cout << " size of T: " << sizeof(T) << std::endl;
                                *array = new T[size];
                        }

                        template <typename T>
                        void operator() (T ***array) const {
                                //std::cout << "Allocate T*** with size: " << size << std::endl;
                                //std::cout << " size of T: " << sizeof(T) << std::endl;
                                *array = new T*[size];
                        }
                        unsigned int size;
                };

        class visitor_get_array_set_value
                : public boost::static_visitor<>
                {
                public:
                        // need default constructor
                        visitor_get_array_set_value(): nb(0), value(0.) {}
                        visitor_get_array_set_value(unsigned int nbi, double valuei): nb(nbi), value(valuei) {}

                        template <typename T>
                        void operator() (T **array) const {
                                //std::cout << "nb " << nb << std::endl;
                                //std::cout << "value " << value << std::endl;
                                (*array)[nb] = value;
                        }
                        unsigned int nb;
                        double value;
                };
#endif


  private:
    // rootcint doesnot understand delete
    ListDataStockBase ( const ListDataStockBase & src ); // {}; //=delete;
    ListDataStockBase& operator=( const ListDataStockBase & rhs); // {} //=delete;
};

template
<
  class T,
  template <class> class PolicyChronologic //= VecNoChronologic by default, put in a forward declaration
>
class ListDataStock: public ListDataStockBase,
                     public PolicyChronologic<T>
{

public :

  /* Default constructor, timescale set to ETime::not_a_time, dates to 0 and empty name */
  ListDataStock():ListDataStockBase() {};
  /* Set default dates (0) if not provided */
  ListDataStock (std::string iname, ETime itmscl,
                 Utils::firstlast_dates idates = Utils::get_fldate_default ()):
                 ListDataStockBase(iname,itmscl,idates) {}
  ListDataStock (std::string iname, ETime itmscl, unsigned int size):ListDataStockBase(iname,itmscl) {ListData.reserve(size);}
  // SetDates to include ? not clear if all default DataStock */
  ListDataStock (std::string iname, ETime itmscl, const std::vector<T> & vec_data):
                ListDataStockBase(iname,itmscl) {
        ListData = vec_data;
    //SetDates once the vector associated (?)
    //SetDates();
  }
  ~ListDataStock() {}


  unsigned int GetSize() const { return ListData.size(); }
  unsigned int Capacity() const { return ListData.capacity(); }
  void Reserve(const unsigned int new_size) { ListData.reserve(new_size); }
  void Clear();
  void Swap () { std::vector<T>(ListData).swap(ListData); }

  // maybe function non const to set data
  const T & ChronologicAt (const unsigned int offset) const {
      return (PolicyChronologic<T>::chronologic_at_impl ( ListData, offset ));
  }
  const T & NoChronologicAt(const unsigned int offset) const {
      return (PolicyChronologic<T>::no_chronologic_at_impl ( ListData, offset ));
  }
  // see book, 2 version one const because copy operator
  // usually reference is preferred in examples and STL
  T& operator[] (const unsigned int offset) {
          if ( offset > ListData.size() )
              return ListData[0];
          else
              return ListData[offset];
  }

  void AddData ( DataStock & data ) {
    // call the correct derived constructor 
    ListData.push_back( static_cast<T &>(data) ); }
  int AddToList ( const ListDataStockBase * new_list );
  void Replace ( const ListDataStockBase * ldata_in );

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

  unsigned int GetCArray( var_types arraydata_c, const EPChrono b_order, const unsigned int no = 0 ) const ;
  unsigned int GetCArray( var_types2 arraydata_c, const EPChrono b_order, std::initializer_list<unsigned int> list_no ) const ;

  int PutCArray ( const ListDataStockBase & ldata_date,
                                   const unsigned int nb_data,
                   const unsigned size_indic,
                   var_types arraydata_c,
                   const unsigned int offset_begin,
                   const unsigned int offset_end = 0,
                   const EPChrono b_chrono = EPChrono::CHRONO,
                   bool full_array = false );

  // not sure if must be public or protected
  std::string policy() const { return PolicyChronologic<T>::policy(); }
  EPChrono bpolicy() const { return PolicyChronologic<T>::bpolicy(); }
  // Return the date of the last (chronologic) data
  time_t LastUpdate() const { return PolicyChronologic<T>::LastChronologic( ListData ); }
  // Return the date of the first (chronologic) data
  time_t GetFirstTime() const { return PolicyChronologic<T>::FirstChronologic( ListData ); }
  void Order( const EPChrono b_chronologic = EPChrono::CHRONO ) {
       PolicyChronologic<T>::order_impl( ListData, b_chronologic );
   }
  // should check it exists ! valid != 0 ?
  void SetDates() {
        if ( GetSize() > 0 ) {
        dates.first = ChronologicAt(0).GetDate();
        dates.last  = NoChronologicAt(0).GetDate();
    } //else ?
  }
  // Set direcltly the dates, has been overwritten from Base by SetDates()
  void SetDates( time_t first, time_t last ) {
      ListDataStockBase::SetDates( first, last );
   }

  protected :
    // Get a copy of the internal vector, in the order given by chrono
    void GetVectorData(std::vector<T> &res, const EPChrono chrono) const {
       res = ListData;
       // if chronology are different, reverse the vector, without modifying this.ListData
       if ( bpolicy() != chrono )
          std::reverse( res.begin(), res.end() );
    }

  private :
    std::vector<T> ListData;
    // rootcint does not try to read derived for the moment, can keep the delete
    ListDataStock ( const ListDataStock & src ) =delete;
    ListDataStock & operator=( const ListDataStockBase & rhs) =delete;  
};

namespace ListDataStock_Utils {

template <
  template <class> class Policy1,
  template <class> class Policy2,
  template <class> class Policy3,
  template <class> class Policy4
>
int TransformTimeScale( const ETime new_tmscl, const ListDataStock<DataCSV,Policy1> & list_csv_in,
      const ListDataStock<SimpleData,Policy2> & list_vol_in, 
      ListDataStock<DataCSV,Policy3> & list_csv_out, ListDataStock<SimpleData,Policy4> & list_vol_out  );

template <
  template <class> class Policy1,
  template <class> class Policy2,
  template <class> class Policy3,
  template <class> class Policy4
>
int TransformTimeScale( const ETime new_tmscl, const ListDataStock<SimpleData,Policy1> & list_csv_in,
      const ListDataStock<SimpleData,Policy2> & list_vol_in, 
      ListDataStock<DataCSV,Policy3> & list_csv_out, ListDataStock<SimpleData,Policy4> & list_vol_out  );
}

//simple split, stay in header anyway
#ifndef __MAKECINT__
#include "ListDataStock_timpl.h"
#endif

#endif // LISTDATASTOCK_H_