ObjectStock.h

Go to the documentation of this file.

#ifndef _OBJECTSTOCK_H_
#define _OBJECTSTOCK_H_

// include all base class
#include "AbstractObjectStock.h"
#include "EditorObjStock.h"

#include <iostream>
#include <TLine.h>

// declare ROOT types UInt_t
#include <Rtypes.h>

// need typedef for type_value_data, still here for accessible but interface expects only double for SetValues
// to delete
//#include "ListObjectStock.h"

class CandleStock : public AbstractObjectStock
{
    protected :
        //date could be retrieved from Parent, th_common_axis ?? pointer ToListDataStock better ??
        time_t fdate;
        // defined as float, other double
        float fopen, fhigh, flow, fclose;
        double fxmin, fxmax;

        std::vector<float> GetValues() const;

    public :
       CandleStock() : AbstractObjectStock() {
           fdate = fopen = fhigh = flow = fclose = fxmin = fxmax = 0; }
       // need a copy constructor for being in a vector ?? seems not, default is enought
       //CandleStock( const CandleStock & rhs ) : fdate(rhs.fdate), fopen(rhs.fopen), fhigh(rhs.fhigh),
       //        flow(rhs.flow), fclose(rhs.fclose), fxmin(rhs.fxmin), fxmax(rhs.fxmax) {}
       virtual ~CandleStock() {}

       // no name associated to each, could reconstruct on the fly if access to parent ListObjectStock
       // could use a static const ?? here simple it is fixed
       virtual std::string GetNameObject() const {return "Jap.C.";}
       virtual std::vector<std::string> MakeStringForStatusBar( int px, int py ) const;

       virtual time_t  GetDate() const { return fdate;}

       virtual void SetValues( UInt_t, std::vector<double> values,
           Double_t xmin, Double_t xmax, time_t date, UInt_t opt_value = 0 );
       virtual void GetExtrema( double & min, double & max ) const;

       virtual void ClearObjectStock() { kPaint = false; }

       virtual Int_t DistancetoPrimitive(Int_t px, Int_t py, AbstractObjectStock** /*obj*/ );// const;
       virtual Int_t DistancetoPoint(int px, int py, double &yvalue, int bin = -1) const;
       // new, avoid gPad
       //virtual Int_t DistancetoPoint(double value_x, double value_y, double & yvalue);
       void virtual Paint( const Option_t* ="");

  ClassDef ( CandleStock, 1);
};

 class BarStock : public AbstractObjectStock
 {
    protected :
        // can make a copy of data, used ?? or retrieve on the fly ??
        //could use parent to get the date ?? need more link, but could be good
        time_t fdate;

        // new added fref_value,
        // if true drawn from 0 to fvalue (histo MACD), default = false use gPad->Min ( volume )
        // could use option to setup this
        bool fref0_value;
        //value of the bar
        double fvalue;
        double fxmin, fxmax;

        std::vector<float> GetValues() const;

    public :
        BarStock();
        BarStock ( bool ref0 );
        virtual ~BarStock () {}
        // could use a static const ?? here simple it is fixed
        virtual std::string GetNameObject() const {return "Bar";}
        virtual std::vector<std::string> MakeStringForStatusBar( int px, int py ) const;

        virtual void ClearObjectStock() { kPaint = false; }

        virtual time_t  GetDate() const { return fdate;}

        virtual void GetExtrema( double & min, double & max ) const;
        //not all used (bin), but coherent for polymorphisme
        virtual void SetValues( UInt_t bin, std::vector<double> values, Double_t xmin, Double_t xmax,
                                time_t date, UInt_t opt_value = 0 );

        virtual int DistancetoPrimitive( int px, int py, AbstractObjectStock** /*obj*/ );// const;
        virtual int DistancetoPoint(int /*px*/, int /*py*/, double &yvalue, int bin = -1) const;
        virtual void Paint( const Option_t* = "" );

    ClassDef( BarStock, 1);
 };

class PStockLine : public IndicatorObjectStock
{
  protected :
     std::vector<double> plvalues;
     std::vector<double> fx;
     std::vector<time_t> dates;

     //math function, used for status bar only ??, keep Float, could be Double
     float ExtrapolateYPad ( int px, int bin0, int bin1, float x0, float x1 ) const;

     // called only by MakeStringForStatusBar, could be private or protected
     std::vector<float> GetValues( int px, int py, time_t &date ) const;

  public :
      PStockLine() : IndicatorObjectStock()
          { std::cout << "Construtor Default PStockLine" << std::endl;}
      // need a name, from indicator ??
      PStockLine( UInt_t size );
      // maybe not so good...
      PStockLine( std::string name, unsigned size );
      virtual ~PStockLine() { std::cout << "Destructor PStockLine" << std::endl;}

      virtual std::vector<std::string> MakeStringForStatusBar( int px, int py ) const;

      virtual unsigned int GetSize() const { return plvalues.size(); }
      virtual void Resize( unsigned int new_size);

      virtual void GetExtrema( double & min, double & max ) const ;
      virtual void SetValues( UInt_t bin, std::vector<double> values,
                              Double_t xmin, Double_t xmax, time_t date, UInt_t opt_value=0 );



      virtual void ClearObjectStock();

      // always called for selecting the object
      virtual int DistancetoPrimitive(int px, int py, AbstractObjectStock** obj); // const;
      int DistancetoPoint( int /*px*/, int py, double & yvalue, int /*bin*/ ) const;

      void virtual Paint( const Option_t* ="");
      virtual void SetObjectStock( ListDataStockBase * ldata, CommonXAxis *fcommon_xaxis_th, Hparam_stock_t & Hparam_stock );

  ClassDef ( PStockLine, 1);
};

class CollectionObjectStock : public IndicatorObjectStock
{
    protected :
        std::vector<AbstractObjectStock *> vec_object;

    public :
        CollectionObjectStock() {}
        CollectionObjectStock( std::string name ) : IndicatorObjectStock( name ) {}
        CollectionObjectStock( unsigned int size, std::string name_contained= std::string(), bool ref0 = false );
        virtual ~CollectionObjectStock();

        virtual void SetParent( THStock * thstock );

        // never called, the contained object are called directly
        //virtual std::vector<std::string> MakeStringForStatusBar( int px, int py ) const;

        // re-implement IndicatorObjectStock function
        virtual void AddToVecObject ( AbstractObjectStock * obj );


        // used ?? seems not, in base ??
        virtual unsigned int GetSize() const { return vec_object.size(); }
        virtual void Resize( unsigned int new_size);

        // cannot make protected, because protected in Abstract
        virtual void GetExtrema( double & min, double & max ) const ;
        virtual void SetValues( UInt_t bin, std::vector<double> values,
                                Double_t xmin, Double_t xmax, time_t date, UInt_t opt_value = 0 );

        //if ListObjectStock should run this one
        virtual void ClearObjectStock();

        virtual Int_t DistancetoPrimitive(Int_t px, Int_t py, AbstractObjectStock** obj);
        // because pure virtual in Abstract
        virtual int DistancetoPoint(int /*px*/, int /*py*/, double & /*yvalue*/, int /*bin*/ = -1) const
        { std::cout << "CollectionObjectStock::DistancetoPoint never called " << std::endl; return 9999; }

        virtual void Paint( const Option_t* = "");
        virtual void SetObjectStock( ListDataStockBase * ldata, CommonXAxis *fcommon_xaxis_th, Hparam_stock_t & Hparam_stock );

    ClassDef( CollectionObjectStock, 1 );
};


#endif // _OBJECTSTOCK_H_