AbstractObjectStock.h

Go to the documentation of this file.

#ifndef _ABSTRACTOBJECTSTOCK_H_
#define _ABSTRACTOBJECTSTOCK_H_

// seems to affect many others, even THIstPainterStock and others !! should be in *.cxx
// boring affects as well controller ! by Canvas, THStock ??
//#undef DEBUG

#include <iostream>
// seems Option_t is a type declared inside
#include "Rtypes.h"
#include <TObject.h>
#include <TAttLine.h>

#include "../../utils/Indicator.h"
#include "../Hparam_stock.h"

class ListDataStockBase;
class CommonXAxis;
class THStock;

// need typedef from DataStock, to delete interface clear now. Here allow access for SetObjectStock
//#include "ListObjectStock.h"
//typedef double type_value_data;

// Strange behaviour for inheriting function in protected
// Should check in book, what s the best to use
// try different way in ObjectStock with GetExtrema,SetValues, can add other GetDate
// \todo make clear derivative of protected function

// TObject important for general function,
// cannot avoid for function gPad->SetSelected( Object * )
// would need to rewrite ( short function ) TPad SetSelected, TCanvas SetSelected
// polymorphisme, easy to reuse, logic to derive from TObject but limited to ROOT
class AbstractObjectStock : public TObject
{
    protected :

        // called for DistanceX, what's the best ??
        // called for Finalize drawing of ObjectLine ? no only CommonXAxis
        // not for DistancetoPoint THStock call the object
        THStock *fParentTHStock;

        bool kPaint;

    public :

        AbstractObjectStock ();
        virtual ~AbstractObjectStock() {};
        // should have the same return, but not if pure virtual
        virtual std::string GetNameObject() const = 0;
        // not necessary yet, only factory set the name
        //virtual std::string SetNameObject() const = 0;

        virtual THStock * GetParent () const { return fParentTHStock;}
        virtual void SetParent ( THStock *thstock ) {fParentTHStock = thstock;}

        virtual void SetToPaint( bool k ) { kPaint = k;}
        virtual bool ToPaint() const { return kPaint;}


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

        // When THStock must contain AbstractObjectStock *
        // needed for THStock::UpdateStock, need the initial size, really ??
        virtual unsigned int GetSize() const {return 0;}
        virtual void Resize( unsigned int /*new_size*/ ) {std::cout << "AbstractObjectStock::Resize to overide !" << std::endl;}
        //virtual void Resize( unsigned int /*new_size*/ ) = 0;

        // ccould be protected, but problem with derived CandleStock ??
        // force double here
        virtual void SetValues( unsigned int bin, std::vector<double> values, double xmin, double ymax, time_t date, unsigned int opt_value = 0) = 0;
        virtual void GetExtrema( double & /*min*/, double & /*max*/ ) const = 0;

        // if virtual, need implemented by Candle and Bar, otherwise Candle is abstract !
        virtual void SetObjectStock( ListDataStockBase * /*ldata*/, CommonXAxis */*fcommon_xaxis_th*/, Hparam_stock_t & /*Hparam_stock*/ ) {} //= 0;
        // to make virtual
        virtual void ClearObjectStock() = 0; //{std::cout << "AbstractObjectStock::ClearObjectStock to overide !" << std::endl;} //= 0;


        // fully implemented in derived class
        virtual Int_t DistancetoPrimitive( int /*px*/, int /*py*/, AbstractObjectStock** /*obj*/) = 0;//const = 0;

        virtual int DistancetoPoint(int /*px*/, int /*py*/, double & /*y_value*/, int bin = -1) const = 0; //{return 9999;}

        virtual void Paint( const Option_t* = "") = 0;

        virtual void SetLineColorObject(Color_t /*lcolor*/) {
                std::cout << "SetLineColorObject abstract !" << std::endl;
        }

    // print a warning during run-time if not dict for cint
    ClassDef(AbstractObjectStock, 1);
};

class IndicatorObjectStock : public AbstractObjectStock, public TAttLine
{
    protected :
        std::string name_indic;

        void ComputeBinRange ( ListDataStockBase *ldata, CommonXAxis *fcommon_xaxis_th, Hparam_stock_t & Hparam_stock,
                        unsigned int & xfirst, unsigned int & xlast, int & shift_left );

    public :
        // base class paint or not by default, not in this construction
        IndicatorObjectStock() : AbstractObjectStock() {}
        IndicatorObjectStock( std::string name) : AbstractObjectStock (), name_indic( name ) {}
        virtual ~IndicatorObjectStock() {}

        // base class provides its own name, could Override GetName() from TObject as well
        // complains for PStockLine, should be overridden
        // ok compiles now, but should be overiddenn any way
        // should work for PStockLine, Collection not sure or add something
        virtual std::string GetNameObject() const { return name_indic; }
        // new added never called yet ??
        // ref is not dangerous ?? should not ??
        virtual void SetNameObject( std::string & new_name ) { name_indic = new_name;}

        //should be implemented,, not by List and Collection
        virtual std::vector<std::string> MakeStringForStatusBar( int /*px*/, int /*py*/ ) const {
            std::cout << "IndicatorStock:: MakeString for status bar to override" << std::endl;
            std::vector<std::string> toto; return toto;
        }

        //virtual unsigned int GetSize() const {return 0;}
//        virtual void Resize( unsigned int /*new_size*/ ) {
//            std::cout << "IndicatorObjectStock::Resize to override, do nothing" << std::endl;}

        // only Indicator ?? or in Abstract ?
        // need to loop over a list ( only Indicator )
        // implements abstract function, ok virtual work with ListObjectStock
        virtual void ClearObjectStock() {
#ifdef DEBUG_OBJSTOCK
            std::cout << "\nIndicatorObjectStock::ClearObjectStock SHOULD NOT BE CALLED, to override\n" << std::endl;
#endif
        }

        // implements here, or in derived, array could be in derived class
        // changed unsigned int to void, otherwise return nothing
        // same than base class...not needed or only here, not in base class
        /*virtual unsigned int GetSize() const {
            std::cout << "IndicatorObjectStock::GetSize return 0" << std::endl;
            return 0;}
        */
        //virtual void Resize( Indicator /*indic*/, unsigned int /*new_size*/) {}
        //virtual void Resize( unsigned int /*new_size*/ ) {}

        // who called ?? only Factory with Collection only
        virtual void AddToVecObject ( AbstractObjectStock* /*obj*/) {}

        virtual void SetLineColorObject(Color_t lcolor) {
                std::cout << "SetLineColorObject from IndicatorObjectStock, color " << lcolor << std::endl;
                SetLineColor( lcolor );
        }
        // seems fine, to delete
        //virtual void SetObjectStock( ListDataStockBase * /*ldata*/, CommonXAxis */*fcommon_xaxis_th*/ ) {}
};

#endif