ListObjectStock.h

Go to the documentation of this file.

#ifndef _LISTOBJECTSTOCK_H_
#define _LISTOBJECTSTOCK_H_

#include <vector>
// need gPad for drawing, really needed only function SetObjectStock
// which can be combined in IndicatorObjectStock
// #include <TPad.h>

#include "ObjectStock.h"
#include "../../src_cpp/ListDataStock.h"
#include "../CommonXAxis.h"

template < class T >
class ListObjectStock : public IndicatorObjectStock
{
    private :
        typedef T type_obj;
        std::vector<type_obj> vec_object;

    public :
        ListObjectStock();
        ListObjectStock( std::string name ) : IndicatorObjectStock( name ) {}
        // really needed ??, will resize
        //ListObjectStock ( Indicator indic, UInt_t size,  const char * name_contained = "", bool ref0 = false );
        ListObjectStock ( unsigned int size, std::string name_contained = std::string(), bool ref0 = false );
        virtual ~ListObjectStock();

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

        virtual void GetExtrema( double & min, double & max ) const;

        virtual void AddToVecObject ( T * obj) { vec_object.push_back( *obj );}

        // no function get values ??
        virtual void SetValues( UInt_t bin, std::vector<type_value_data> values,
                                Double_t xmin, Double_t xmax, time_t date, UInt_t opt_value = 0 );

        // specific implementation
        virtual void ClearObjectStock();

        virtual int DistancetoPrimitive(int px, int py, AbstractObjectStock** obj);// const;
        virtual int DistancetoPoint(int px, int py, double &yvalue, int bin = -1) const;
        // try new method,, if work delete previous, not convenient distance dependent of the scale !
        //virtual Int_t DistancetoPoint( double value_x, double value_y, unsigned int bin, double & y_value);

        //to be overloaded, event, px, py
        // never moved, just need to be selected
        //virtual void ExecuteEvent(Int_t, Int_t, Int_t ) {}  /*std::cout << "ListObjectStock ExecuteEvent()" << std::endl;*/

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



template < class T >
ListObjectStock<T> :: ListObjectStock() : IndicatorObjectStock()
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Entry default Constructor ListObjectStock" << std::endl;
#endif
}

// default: name = "", ref0 = false
template< class T >
ListObjectStock<T>::ListObjectStock( unsigned int size, std::string name_contained, bool ref0 )
    : IndicatorObjectStock ( name_contained )
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "Entry Constructor ListObjectStock size " << size << std::endl;
    std::cout << "name_contained " << name_contained << std::endl;
    //std::cout << "Indicator label " << indic.label() << std::endl;
    std::cout << "ref0 " << ref0 << std::endl;
#endif

    for ( unsigned int i=0; i < size; i++ ) {
        vec_object.push_back( type_obj() );
    }
}

template< class T >
ListObjectStock<T>::~ListObjectStock()
{
#ifdef DEBUG_OBJSTOCK
 std::cout << "Destructor ListObjectStock" << std::endl;
#endif
 // crash in deleting the object, object is contained, properly destroyed when ListDataStock is deleted
 //      for ( unsigned int i=0; i< vec_object.size(); ++i ) {
 //              delete &(vec_object[i]);
 //      }
 //vec_object.erase();

 // take out from the list, and destroy the object
 vec_object.clear();

#ifdef DEBUG_OBJSTOCK
 std::cout << "size vec_object " << vec_object.size() << std::endl;
#endif
}


// could be in indicator object stock
// cannot simply loop over all, need a Hparam_stock for futur, and check for its own specificity ( shift_left )
template< class T >
void ListObjectStock<T>::GetExtrema( double & min, double & max ) const
{
#ifdef DEBUG_OBJSTOCK
   std::cout << "Entry ListObjectStock::GetExtrema " << std::endl;
#endif

   // local and true min, max
   double lmin, lmax;
   double tmin, tmax;
   tmin = 10e6;
   tmax = -10e6;
   lmin = tmin;
   lmax = tmax;

   // use info painted, only the painted object are accounted
   // save lots of code
   for ( unsigned int i = 0; i <  vec_object.size(); i++ ) {
       //std::cout << "object i " << i << " ToPaint() " << vec_object[i].ToPaint() << std::endl;

       if ( vec_object[i].ToPaint() ) {
         vec_object[i].GetExtrema( lmin, lmax );
         if ( lmin < tmin ) tmin = lmin;
         if ( lmax > tmax ) tmax = lmax;
       }
   }

   min = tmin;
   max = tmax;
#ifdef DEBUG_OBJSTOCK
   std::cout << "will return extrema min/max " << min << " " << max << std::endl;
#endif
}

// send function to candle and bar
template < class T >
void ListObjectStock<T>::ClearObjectStock()
{
#ifdef DEBUG_OBJSTOCK
 std::cout << " Entry ListObjectStock::ClearObjectStock(), clear all object size " <<  vec_object.size() << std::endl;
#endif

    for ( unsigned int i = 0; i < vec_object.size(); i++ ) {
        // for Candle and Bars set kPaint to false, only
        vec_object[i].ClearObjectStock();
    }
}

//come from update, new size is always more data, may need to extend later ( if want to delete data )
template < class T >
void ListObjectStock<T>::Resize( unsigned int new_size )
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "ListObjectStock::Resize new_size " << new_size << std::endl;
#endif
    // seems to work !!
    //const char * default_name = GetNameObject().c_str();
    for ( unsigned int i = 0; i < new_size; ++i ) {
        vec_object.push_back( type_obj() );
     }
}

template < class T >
int ListObjectStock<T>::DistancetoPrimitive(int px, int py, AbstractObjectStock** obj) //const
{
#ifdef DEBUG_OBJSTOCK
   std::cout << "Entry ListObjectStock::DistancetoPrimitive " << std::endl;
   std::cout << "broadcast the function to all elements " << std::endl;
#endif
  Int_t dist = 9999;
  Int_t dist_objstock;
  // added because of declaration. but not used
  AbstractObjectStock *tmp_obj;

  //ListObjectStock always contains same kind of ObjectStock Bar or Candle (PStockLine ?? choice)
  for ( unsigned int i = 0; i < vec_object.size(); ++i ) {
      // candle or bar do not set the object in the function
      dist_objstock = vec_object[i].DistancetoPrimitive( px, py, &(tmp_obj) );

      if ( dist_objstock <= dist ) {
          dist = dist_objstock;
          *obj = &(vec_object[i]);
          // could stop if 0
          //std::cout << "set obj_tmp " << *obj << " " << (*obj)->ClassName() << " dist " << dist << std::endl;
       }
   }
  return dist;
}

template < class T >
int ListObjectStock<T>::DistancetoPoint(int px, int py, double & yvalue, int bin ) const
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Entry ListObjectStock::DistancetoPoint get bin_entry " << bin << std::endl;
#endif

  int dist = 9999;
  // because always nochronologic order when painting
  int bin_entry = vec_object.size() - bin;

  //std::cout << "ListObjectStock::DistancetoPoint bin_entry " << std::endl;
  dist = (vec_object[ bin_entry ]).DistancetoPoint( px, py, yvalue );

  //std::cout << "return from ListObjectStock::DistancetoPoint dist " << dist_objstock << "yvalue " << yvalue << std::endl;
  return dist;
}

template < class T >
void ListObjectStock<T>::SetValues( UInt_t bin, std::vector<type_value_data> values,
     Double_t xmin, Double_t xmax, time_t date, UInt_t opt_value  )
{
/*
#ifdef DEBUG_OBJSTOCK
  std::cout << " Entry ListObjectStock SetValues bin " << bin << " opt_value " << opt_value << std::endl;
#endif
*/
  vec_object[bin].SetValues( bin, values, xmin, xmax, date, opt_value );

  // assumption: if set values, will be to paint
  vec_object[bin].SetToPaint( true );
}

template < class T >
void ListObjectStock<T>::Paint( const Option_t* option )
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "Entry ListObjectStock::Paint" << std::endl;
#endif

    for ( unsigned int i = 0; i < vec_object.size(); i++ ) {

        if ( vec_object[i].ToPaint() )
            vec_object[i].Paint( option );
    }
}

template < class T >
void ListObjectStock<T>::SetObjectStock( ListDataStockBase * ldata, CommonXAxis *fcommon_xaxis_th, Hparam_stock_t & Hparam_stock )
{
/*
#ifdef DEBUG_OBJSTOCK
   std::cout << "\n\tEntry ListObjectStock::SetObjectStock " << std::endl;
   //std::cout << " Hparam_stock.xlast not modified here " << Hparam_stock.xlast << std::endl;
   std::cout << " Always identical to fcommon_axis->GetLast() " << fcommon_xaxis_th->GetLast() << std::endl;
   // std::cout << "gPad->GetName() " << gPad->GetName() << std::endl;
   // ok this is the TPadStock 1 created
   // std::cout << "gPad " << gPad << std::endl;
#endif
*/
   std::vector<type_value_data> values;
   double xmin,xmax;

   unsigned int xfirst, xlast;
   int shift_left;
   unsigned int size_data = ldata->GetSize();

   ComputeBinRange( ldata, fcommon_xaxis_th, Hparam_stock, xfirst, xlast, shift_left );
   //std::cout << "After ComputeBinRange xfirst/xlast " << xfirst << " " << xlast << std::endl;

   for ( unsigned int bin = xlast; bin >= xfirst; bin -- ) {
       //std::cout << "bin " << bin << " " << size_data - bin + shift_left << std::endl;
       values=ldata->NoChronologicAt( size_data - bin + shift_left ).GetValues();

       // x are the same !!
       //xmin = gPad->XtoPad( fcommon_xaxis_th->GetXAxis()->GetBinLowEdge(bin) );
       //xmax = gPad->XtoPad( fcommon_xaxis_th->GetXAxis()->GetBinUpEdge(bin) );
       xmin = fcommon_xaxis_th->GetXAxis()->GetBinLowEdge(bin);
       xmax = fcommon_xaxis_th->GetXAxis()->GetBinUpEdge(bin);
       //std::cout << "xmin " << xmin << " " << fcommon_xaxis_th->GetXAxis()->GetBinLowEdge(bin) << std::endl;

       // modfiy slightly for candle and Bar
       // should be in Candle and Bar !
       xmin += (xmax-xmin)*0.1;
       xmax -= (xmax-xmin)*0.1;

       // set values for each bin
       SetValues ( size_data - bin + shift_left, values, xmin, xmax,
           ldata->NoChronologicAt( size_data-bin+shift_left).GetDate() );
   }
}


#endif /* _LISTOBJECTSTOCK_H_ */