DataStock.cpp

Go to the documentation of this file.

#include "DataStock.h"

#include <iomanip>
#include <sstream>
#include <cassert>
#include <cstring>
// for limits_numeric
#include <limits>

namespace FDS {

        const int WCOL = 10;
        const int PRECISION = 2;
}


size_t reconstruct_stream_operator( std::iostream &is, char * buf_to_ret )
{
#ifdef DEBUG_DATASTOCK
        std::cout << "Entry reconstruct_stream_operator " << std::endl;
#endif
        // intermediate, contains the rest of the line
        char buf_rest[BDS::BUFFER_STREAM];
        memset ( buf_rest, 0, BDS::BUFFER_STREAM );
        // contains the date
        char buf_date[BDS::BUFFER_DATE];
        memset ( buf_date, 0, BDS::BUFFER_DATE );
        // correct initialization of the C-array in entry
        memset ( buf_to_ret, 0, BDS::BUFFER_STREAM );

        // stop at the end of the stream the first time, or to '!' in a next run
        is.getline( buf_rest, BDS::BUFFER_STREAM, '!' );
        //std::cout << "buf_rest:" << buf_rest << std::endl;

        // check size will be correct, add 3 for terminal characters
        assert( ( strlen(buf_rest) + BDS::BUFFER_DATE + 3 ) < BDS::BUFFER_STREAM );

        // read the date again
        is.seekg(0);
        is.getline(buf_date, BDS::BUFFER_DATE,',');
        //std::cout << "buf_date " << buf_date << std::endl;

        // creates full output: "date , rest ,!", ok works
        strcat( buf_to_ret, buf_date );
        strcat( buf_to_ret, ",");
        strcat( buf_to_ret, buf_rest);
        // null character added by strcat
        strcat(buf_to_ret, ",!");

        size_t len = strlen(buf_to_ret);
        //unsigned int len = strlen(buf_ret);
#ifdef DEBUG_DATASTOCK
        std::cout << "buf_ret: " << buf_to_ret << std::endl;
        std::cout << "return buf_ret length " << len << std::endl;
#endif
        // return the len, used to copy the data into stream
        return len;
}

// default constructor
DataStock::DataStock():date( (time_t) 0) {
#ifdef DEBUG_DATASTOCK
        std::cout << "DataStock default constructor" << std::endl;
#endif
}

DataStock::DataStock(time_t d):date(d) {
#ifdef DEBUG_DATASTOCK
        std::cout << "DataStock constructor with date" << std::endl;
#endif
}

// copy constructor of the base class
// bug here ?? seems not here. where is the problem ???
DataStock::DataStock (const DataStock & rhs) : date( rhs.date )
//DataStock::DataStock (const DataStock & rhs)
{
#ifdef DEBUG_DATASTOCK
        std::cout << "Copy Constructor Base date: " << rhs.date << std::endl;
#endif
  //date = rhs.date;
}

DataStock::DataStock( DataStock&& rhs )
{
#ifdef DEBUG_DATASTOCK
        std::cout << "Move Copy Constructor Base date: " << rhs.date << std::endl;
#endif
  date = rhs.date;
  // reset
  rhs.date = 0;
}

// assignment operator
DataStock& DataStock::operator=( const DataStock& rhs ) 
{
#ifdef DEBUG_DATASTOCK
        std::cout << "DataStock Base Normal assignment " << std::endl;
#endif
  if ( this == &rhs ) {
        return *this;
  }
  // copy member, no memory to free/allocate
  date = rhs.date;
  return *this;
}

// move assignment operator
DataStock& DataStock::operator=( DataStock&& rhs)
{
#ifdef DEBUG_DATASTOCK
        std::cout << "DataStock Base Move assignment " << std::endl;
#endif
  if ( this == &rhs ) {
        return *this;
  }
  // copy
  date = rhs.date;
  // reset 
  rhs.date = 0;
  return *this;
}

// in utils ?? better ?? yes more option ?
// tmp_tm necessary, could be hidden
// should be static as well, 
// used tm because it provides info about the week, necessary for transform
struct tm DataStock::GetDateTm() const {

    //struct tm* localtime(const time_t* timer)
    struct tm *tmp_tm=localtime(&date);
    return *tmp_tm;

    // implementation in DataCSV->ExtractCSV
    //time_t tmp_date;
    // seem important to declare the tabular, and send a pointeur to strptime
    //struct tm tmp_tm = {0, 0, 0, 0, 0, 0, 0, 0, -1, 0, nullptr};
}

// redirect to Utils
std::string DataStock::GetDateString( const bool bhours ) const
{
    // Use Utils::functions, true will include the hour
    std::string date_string = Utils::Time_tToString( date, bhours );
    return date_string;
}

// possible to have a parameter for b_hour
// use string, not C array in this case
void DataStock::helper_operator_write_base(std::ostream& os) const
{
#ifdef DEBUG_DATASTOCK
  std::cout << "DataStock::helper_operator_write_base" << std::endl;
#endif
  // full date 19 characters
  // always 19 characters for the line, or need parameter in object to decide
  os << GetDateString();
}

// must extract date from istream, always first 19 characters, and pass the comma
// do not care about the number of charaters if used string
// unit test with str_in = "2013-01-01 01:01:01 100.00, 200,300,400"; passes before, now check for comma
int DataStock::helper_operator_read_base(std::iostream& ios)
{
#ifdef DEBUG_DATASTOCK
        std::cout << "DataStock::helper_operator_read_base" << std::endl;
#endif

        // more basic, gains a bit in time
        char date_buf[BDS::BUFFER_DATE];
        // istream.get() method does not consume the comma, string method does
        ios.get( date_buf, BDS::BUFFER_DATE, ',');
        // here got 44 the comma, need to pass by a get
        //std::cout << "ios.peek() " << ios.peek() << std::endl;

        // see unit_test other_data_error, ok now test do not pass
        if ( ios.peek() != 44 )
                return 1;
        ios.get();
        // extract time_t
        time_t time = Utils::StringToTime_t( date_buf );

        // or can use string to extract the date
        /*
        std::string str_date;
        // position is increased
        std::getline( ios, str_date, ',' );
        //std::cout << "str_date " << str_date << std::endl;
        time_t time = Utils::StringToTime_t( str_date );
        */

        // can check for error now
        if ( time == Utils::ERROR_StrToTime )
                return 1;
        // parsing date ok
        SetDate ( time );
        // correct processing
        return 0;
}

SimpleData::SimpleData() : DataStock(), value(0.) {
#ifdef DEBUG_DATASTOCK
        std::cout <<"Constructor default SimpleData" << std::endl;
#endif
}

SimpleData::SimpleData(type_value_data ivalue):DataStock(),value(ivalue) {
#ifdef DEBUG_DATASTOCK
        std::cout <<"Constructor SimpleData with value" << std::endl;
#endif
}

SimpleData::SimpleData(time_t d,type_value_data ivalue):DataStock(d),value(ivalue) {
#ifdef DEBUG_DATASTOCK
        std::cout <<"Constructor SimpleData default date and value" << std::endl;
#endif
}

SimpleData::SimpleData( unsigned int /*nb*/ ) : DataStock(),value(0.) {}

//copy constructor
// see comment DataCSV, do not use list init.
SimpleData::SimpleData( const SimpleData & rhs ) : DataStock( rhs )
//,value(rhs.value)
{
#ifdef DEBUG_DATASTOCK
        std::cout <<"Copy Constructor SimpleData" << std::endl;
#endif
  value = rhs.value;
}

// Move copy constructor, certainly need same in base
// do not call the correct move copy
// rvalue considered as lvalue inside the function
SimpleData::SimpleData( SimpleData && rhs ) : DataStock( std::move(rhs) )
{
#ifdef DEBUG_DATASTOCK
        std::cout <<"Move Copy Constructor SimpleData" << std::endl;
#endif
  // copy data
  value = rhs.value;
  // reset origin
  rhs.value = 0;
}

// normal assignment
SimpleData& SimpleData::operator=( const SimpleData& rhs )
{
#ifdef DEBUG_DATASTOCK
        std::cout << "SimpleData Normal assignment " << std::endl;
#endif
  // Check self-assignment
  if ( this == &rhs ) {
        return *this;
  }
  // call base class
  DataStock::operator=( rhs );
  // no memory to delete, copy data, no memory to allocate
  value = rhs.value;
  return *this;
}

// move assignment
SimpleData& SimpleData::operator=( SimpleData&& rhs) 
{
#ifdef DEBUG_DATASTOCK
        std::cout << "SimpleData Move assignment " << std::endl;
#endif
  // Check self-assignment
  if ( this == &rhs ) {
        return *this;
  }
  // call base class, do not call the correct one
  DataStock::operator=( std::move(rhs) );
  // copy data
  value = rhs.value;
  // reset
  rhs.value = 0;
  return *this;
}

std::vector<type_value_data> SimpleData::GetValues() const
{
  std::vector<type_value_data> vec_value;
  vec_value.push_back( value );
  return vec_value;
}

void SimpleData::SetValues( std::vector<type_value_data> & vec) 
{
  assert( vec.size() == 1 );
  value = vec[0];
}

// use when reading dscv file
void SimpleData::ExtractCSVLine(std::vector<std::string> & linecsv) {
    // set date and value
    SetDate( Utils::StringToTime_t( linecsv[0] ) );
    SetValue( Utils::fromString<type_value_data>(linecsv[1]) );
}

// use GetValue() if not virtual, need to cast
bool SimpleData::HasChanged(const DataStock & data_to_check ) const
{
#ifdef DEBUG_CPP
 std::cout << "Entry SimpleData::HasChanged" << std::endl;
 //std::cout << "GetDate() " << GetDate() << std::endl;
 std::cout << "Date of the old data " << GetDate() << std::endl;
 std::cout << "Date of the old data " << GetDateString() << std::endl;
 std::cout << " value old " << GetValue() << std::endl;
 //std::cout << "data_to_check " << data_to_check << std::endl;
 std::cout << "Date of the new data " << data_to_check.GetDate() << std::endl;
 std::cout << "Date of the new data " << data_to_check.GetDateString() << std::endl;
 //std::cout << "new value " << ((SimpleData &)data_to_check).GetValue() << std::endl;
 std::cout << "new value " << static_cast<const SimpleData &>(data_to_check).GetValue() << std::endl;
#endif

 //if same date means that it is an update
 /*
 if ( GetDate() != data_to_check.GetDate() ) {
#ifdef DEBUG_CPP
    std::cout << " SimpleData dates differ, return true " << std::endl;
#endif
     return true;

 // same date, check if the value changed
 } */ 
 //if (  GetValue() != ((SimpleData &)data_to_check).GetValue() ) {
 if (  GetValue() != static_cast<const SimpleData &>(data_to_check).GetValue() ) {
#ifdef DEBUG_CPP
         std::cout << " SimpleData value differ, return true " << std::endl;
#endif
         return true;
 } //else
 return false;
}

// may improve if volume
void SimpleData::PrintData( const unsigned int verbose ) const
{
  // intermediate, sure tellp is correct and set to 0
  std::ostringstream tmp_os;

  if ( verbose == 1 ) {
    std::cout << "PrintData SimpleData " << std::endl;
    std::cout << std::setw(25) <<"date" << std::setw(FDS::WCOL+1) << "value" << std::endl;
  }  
  // use friend operator << with SimpleData
  tmp_os << *this;

  // format of output with header
  if ( verbose == 1 )
          std::cout << "     " << tmp_os.str() << std::endl;
  else
          std::cout << tmp_os.str() << std::endl;

  return;
}

void SimpleData::helper_operator_write(std::ostream &os) const
{
        os << "," << std::setprecision(FDS::PRECISION) << std::setw(FDS::WCOL) << std::fixed  << GetValue();
}

void SimpleData::helper_operator_read(std::iostream &ios)
{
        // set value from the stream, got form the string up to end or first delimiter character
        SetValue( Utils::fromStreamToDouble( ios, ',') );
}


// to have same behaviour than other classes, fill the vector with default values
MultiData::MultiData() : DataStock(), nb_data(1) {
#ifdef DEBUG_DATASTOCK
        std::cout <<"Constructor default MultiData" << std::endl;
#endif
 
 //nb_data = 1;
 // set values with a default 0.
 values.push_back( 0. );
 //values = {0.};
 //values = std::vector<type_value_data>( 1, 0.); //{0.};
 //std::cout << "sizeof values " << sizeof(values) << std::endl; 
 
}

MultiData::MultiData( unsigned int nbdata ) : DataStock(), nb_data(nbdata) {
#ifdef DEBUG_DATASTOCK
        std::cout <<"Constructor MultiData with size: " << nbdata << std::endl;
#endif
 // set values with a default 0.
 //values.push_back( 0. );
 //nb_data = nbdata;
 values = std::vector<type_value_data>( nb_data, 0. );
 //std::cout << "sizeof values " << sizeof(values) << std::endl; 
}

MultiData::MultiData(time_t d, std::vector<type_value_data> ivalues) : 
        DataStock(d), nb_data(ivalues.size()), values(ivalues) {
#ifdef DEBUG_DATASTOCK
        std::cout <<"Constructor MultiData date and values " << std::endl;
#endif
}

// copy constructor, works here with initilizers ??
// here necessary in list, because const ! certainly a strange bug with DataCSV...
MultiData::MultiData( const MultiData & rhs ) : DataStock(rhs), nb_data(rhs.nb_data)
// values(rhs.values)
{
#ifdef DEBUG_DATASTOCK
        std::cout <<"Copy Constructor MultiData" << std::endl;
#endif
  // check const nb_data
  assert ( nb_data == rhs.nb_data );
  assert ( nb_data == rhs.values.size() );
  values = rhs.values;
}

// move copy constructor
MultiData::MultiData( MultiData && rhs ) : DataStock( std::move(rhs) ), nb_data(rhs.nb_data)
{
#ifdef DEBUG_DATASTOCK
        std::cout <<"Move Copy Constructor MultiData" << std::endl;
#endif
  // copy data, cannot optimize here
  //nb_data = rhs.nb_data;
  values = rhs.values;
  // no pointer to modify
  // reset origin
  //rhs.value = 0;
  // clear vector ? NO ! default size is one, set to zero maybe
}


// normal assignment
MultiData& MultiData::operator=( const MultiData& rhs )
{
#ifdef DEBUG_DATASTOCK
  std::cout << "MultiData Normal assignement " << std::endl;
#endif
  // Check self-assignment
  if ( this == &rhs ) {
        return *this;
  }
  // should not happen !
  assert( nb_data == rhs.nb_data );
  assert ( values.size() == rhs.values.size() );

  // call base class
  DataStock::operator=( rhs );
  // copy data, no memory to allocate
  // cannot here because const
  //nb_data = rhs.nb_data;
  values = rhs.values;

  return *this;
}

MultiData& MultiData::operator=( MultiData&& rhs) 
{
#ifdef DEBUG_DATASTOCK
        std::cout << "MultiData Move assignment " << std::endl;
#endif
  // Check self-assignment
  if ( this == &rhs ) {
        return *this;
  }
  // call base class, do not call the correct one
  DataStock::operator=( std::move(rhs) );
  // copy data
  //nb_data = rhs.nb_data;
  values = rhs.values;
  // reset, maybe set to zero
  return *this;
}

// to use stl max algoithm
// limits_
type_value_data MultiData::GetMaximum() const
{
  type_value_data max = -99999;
  std::vector<type_value_data>::const_iterator it;
  
  for ( it = values.begin(); it != values.end(); ++it ) {
      if ( (*it) > max ) max = (*it);
  }
  return max;
}

// to use stl min algorithm
type_value_data MultiData::GetMinimum() const
{
  type_value_data min = 99999;
  std::vector<type_value_data>::const_iterator it;
  for ( it = values.begin(); it != values.end(); ++it ) {
      if ( (*it) < min ) min = (*it);
  }
  return min;
}

// other class fill a vector with their current values
// just need to return a copy, ref possible, more efficient, but not for others classes
// should not matter the return type ?? to test
std::vector<type_value_data> MultiData::GetValues() const
{
  return values;
}

void MultiData::SetValues( std::vector<type_value_data> & vec)
{
  //assert size (nb_data), constant during its life time not a bad idea
  assert ( nb_data == vec.size() );
  assert ( vec.size() == values.size() );
  values = vec;
}

// Check vector of values only
// GetValues is virtual, no need of explicit cast !
bool MultiData::HasChanged( const DataStock & data_to_check ) const
{
  // here can test entry has the correct type
  assert ( nb_data == dynamic_cast<const MultiData &>(data_to_check).nb_data );
  // test also than correct virtual function of MultiData is called
  assert ( nb_data == data_to_check.GetValues().size() );

  // compare the vector directly, return by copy here ?
  if (  GetValues() != data_to_check.GetValues() ) {
#ifdef DEBUG_CPP
         std::cout << " MultiData at least one value differ, return true " << std::endl;
#endif
         return true;
 }
 return false;
}

// certainly much better algo to use
void MultiData::ExtractCSVLine(std::vector<std::string> & linecsv) 
{
    assert( (nb_data + 1) == linecsv.size() );
    time_t tmp_date;
    // could fix the size here
    std::vector<type_value_data> tmp_values;

    // use Utils
    tmp_date = Utils::StringToTime_t( linecsv[0] );

    // copy, swap better
    for ( auto v= linecsv.begin()+1; v != linecsv.end(); ++v ) {
        tmp_values.push_back( Utils::fromString<type_value_data>(*v) );
    }

    SetData(tmp_date,tmp_values);
}

// problem when runing prog > out, tellp is increased in this case, works with output !! ??
// std::cout bound to an other ostream maybe ??
void MultiData::PrintData( const unsigned int verbose ) const
{
  // intermediate, sure tellp is correct and set to 0
  std::ostringstream tmp_os;

  if ( verbose == 1 ) {
      std::cout << "PrintData MultiData " << std::endl;
      std::cout << std::setw(25) <<"date" << std::setw(FDS::WCOL+1) << "values" << std::endl;
  }
  // use operator << with MultiCSV
  tmp_os << *this;
  // can test here

  // format of output with header
  if ( verbose == 1 )
          std::cout << "     " << tmp_os.str() << std::endl;
  else
          std::cout << tmp_os.str() << std::endl;
  return;

}

void MultiData::helper_operator_write(std::ostream &os) const
{
        for ( unsigned int i=0; i< nb_data; ++i) {
            os << "," << std::setprecision(FDS::PRECISION) << std::setw(FDS::WCOL) << std::fixed  << values[i];
        }
}

void MultiData::helper_operator_read(std::iostream &ios)
{
        std::vector<type_value_data> vec_values;
        //vec_values.reserve(4);

        // loop until "," or end line, always 4 here
        for ( unsigned int i=0; i< nb_data; ++i) {
                // only stream and char[] are used inside
                vec_values.push_back( Utils::fromStreamToDouble( ios, ',') );
        }
        SetValues(vec_values);
}


DataCSV::DataCSV(): DataStock(), open(0.),high(0.),low(0.),close(0.)
{
#ifdef DEBUG_DATASTOCK
        std::cout << "Constructor default DataCSV" << std::endl;
#endif
}

DataCSV::DataCSV(time_t d, type_value_data iopen, type_value_data ihigh,
        type_value_data ilow, type_value_data iclose) : 
        DataStock(d), open(iopen),high(ihigh),low(ilow),close(iclose) {
#ifdef DEBUG_DATASTOCK
        std::cout << "Constructor DataCSV with 5 arguements " << std::endl;
#endif
}

DataCSV::DataCSV( unsigned int /*nb*/ ): DataStock(), open(0.),high(0.),low(0.),close(0.) {} 

// copy constructor, must call base copy constructor
// IMPORTANT, Do not work with list initialization !! ??
DataCSV::DataCSV(const DataCSV& rhs): DataStock(rhs)
{
#ifdef DEBUG_DATASTOCK
    std::cout << "copy constructor DataCSV " << std::endl;
#endif
  // copy private member of this class
  open = rhs.open;
  high = rhs.high;
  low = rhs.low;
  close = rhs.close;
}

// move copy constructor
DataCSV::DataCSV( DataCSV && rhs ) : DataStock( std::move(rhs) )
{
#ifdef DEBUG_DATASTOCK
        std::cout <<"Move Copy Constructor DataCSV" << std::endl;
#endif
  // copy data, cannot optimize here
  open = rhs.open;
  high = rhs.high;
  low = rhs.low;
  close = rhs.close;
  // no pointer to modify
  // reset origin
  rhs.open = 0.;
  rhs.high = 0.;
  rhs.low = 0.;
  rhs.close = 0.;
}

// normal assignment
DataCSV& DataCSV::operator=( const DataCSV& rhs )
{
#ifdef DEBUG_DATASTOCK
  std::cout << "DataCSV Normal assignement " << std::endl;
#endif
  // Check self-assignment
  if ( this == &rhs ) {
        return *this;
  }
  // call base class operator=
  DataStock::operator=( rhs );
  // copy data, no memory to free/allocate in this case
  open = rhs.open;
  high = rhs.high;
  low = rhs.low;
  close = rhs.close;
  return *this;
}

// move assignment
DataCSV& DataCSV::operator=( DataCSV&& rhs) 
{
#ifdef DEBUG_DATASTOCK
        std::cout << "DataCSV Move assignment " << std::endl;
#endif
  // Check self-assignment
  if ( this == &rhs ) {
        return *this;
  }
  // call base class, do not call the correct one
  DataStock::operator=( std::move(rhs) );
  // copy data
  open = rhs.open;
  high = rhs.high;
  low = rhs.low;
  close = rhs.close;
  // reset
  rhs.open = 0.;
  rhs.high = 0.;
  rhs.low = 0.;
  rhs.close = 0.;
  return *this;
}

// reset to initial min and max values in particular
// could use maxint minint c++11
// http://en.cppreference.com/w/cpp/types/numeric_limits/max
void DataCSV::Reset()
{
  //low = 100000;
  //high = -100000;
  low = std::numeric_limits<type_value_data>::max();
  high = std::numeric_limits<type_value_data>::min();
  //open=0;
  //close=0;
}

//void DataCSV::SetData(type_value_data o,type_value_data h,type_value_data l,type_value_data c)
void DataCSV::SetValues(const type_value_data iopen, const type_value_data ihigh,
                const type_value_data ilow, const type_value_data iclose)
{
    open = iopen;
    high = ihigh;
    low = ilow;
    close = iclose;
}

void DataCSV::SetData(const time_t d, const type_value_data o,const type_value_data h,
                const type_value_data l,const type_value_data c)
{
    date= d;
    open = o;
    high = h;
    low = l;
    close = c;
}

void DataCSV::SetData( const time_t d, const std::vector<type_value_data> & vec )
{
    date= d;
    open = vec[0];
    high = vec[1];
    low = vec[2];
    close = vec[3];
}

void DataCSV::SetValues( std::vector<type_value_data> & vec )
{
    open = vec[0];
    high = vec[1];
    low = vec[2];
    close = vec[3];
}

std::vector<type_value_data> DataCSV::GetValues() const 
{
  std::vector<type_value_data> vec_value;
  vec_value.push_back( open );
  vec_value.push_back( high );
  vec_value.push_back( low );
  vec_value.push_back( close );
  return vec_value;
}

// to delete anyway
void DataCSV::ExtractCSVLine(std::vector<std::string> & linecsv) 
{
#ifdef DEBUG_CPP
    std::cout << "Extractline DataCSV" << std::endl;
#endif

    // at least 5, maybe volume included in file
    //assert( linecsv.size() >= 5 );

    time_t tmp_date;
    type_value_data tmp_open,tmp_high,tmp_low,tmp_close;
    
    tmp_date = Utils::StringToTime_t( linecsv[0] );
    tmp_open = Utils::fromString<type_value_data> ( linecsv[1] );
    tmp_high = Utils::fromString<type_value_data> ( linecsv[2] );
    tmp_low = Utils::fromString<type_value_data>  ( linecsv[3] );
    tmp_close = Utils::fromString<type_value_data>( linecsv[4] );

    SetData( tmp_date, tmp_open, tmp_high, tmp_low, tmp_close);
}

// call by ListDataStock::AddToList,
// called by Stock::AddListDataToStock, compare if data_to_check is a more recent version than prev_data
// case of a candle if not finished
// test the time, to be sure to compare the same candle
// use DataStock entry, if want to used as pure virtual
// with change of ChronologicAt, which returns the correct type could use explicit DataCSV type..to see later
bool DataCSV::HasChanged( const DataStock & data_to_check ) const
{
#ifdef DEBUG_CPP
 std::cout << "\n\t Entry DataCSV::HasChanged " << std::endl; 
 //std::cout << "Date of the old data " << GetDate() << std::endl;
 std::cout << "Date of the old data " << GetDateString() << std::endl;
 std::cout << "old Close " << GetClose() << std::endl;
 //std::cout << "data_to_check " << data_to_check << std::endl;
 //std::cout << "Date of the new data " << data_to_check.GetDate() << std::endl;
 std::cout << "Date of the new data " << data_to_check.GetDateString() << std::endl;
 std::cout << "new Close " <<  ((DataCSV &)data_to_check).GetClose() << std::endl;
#endif

 // if same date means that it is an update, 
 // already some tests in case of InsertBegin, different tests but similar... never different ?? 
 // test here or before ? better to have same behaviour/logic for all the DataStock
 if ( GetDate() != data_to_check.GetDate() ) {
     std::cout << " date differ so it is a new data, return replace_last false" << std::endl;
     return false;
 // real test, date should be always identical here ??
 } else {
     std::cout << "Same date, check Close " << std::endl;
     // could use dynamic or static cast, maybe use real type in parameter now ?
     if ( GetClose() != ((DataCSV &)data_to_check).GetClose() ) {
     //if ( GetClose() != (data_to_check).GetClose() ) {
         std::cout << " Close differ, real update of the candle, return true " << std::endl;
         return true;
     } else {
         std::cout << " Close identical, mean that is the beginning of a new value, return false " << std::endl;
         return false;
     }
  }
}

void DataCSV::AdditionData(const DataCSV & new_data)
{
    if (new_data.high > high )
        high = new_data.high;
    if (new_data.low < low )
        low = new_data.low;
}

// could assign close by default ? see with algo
// no, will make dependent of the order
void DataCSV::AdditionData( const SimpleData & new_data)
{
    if ( new_data.GetValue() > high )
        high = new_data.GetValue();
    if ( new_data.GetValue() < low )
        low = new_data.GetValue();
}

void DataCSV::PrintData( const unsigned int verbose ) const
{
  // intermediate, sure tellp is correct and set to 0
  std::ostringstream tmp_os;

  if ( verbose == 1 ) {
    std::cout << "PrintData DataCSV"<< std::endl;
    std::cout << std::setw(25) <<"date" << std::setw(FDS::WCOL+1) << "open" <<
        std::setw(FDS::WCOL+1) << "high" << std::setw(FDS::WCOL+1) << "low"  <<
        std::setw(FDS::WCOL+1) << "close " << std::endl;
  }
  // use operator << with DataCSV
  tmp_os << *this;

  //std::cout << tmp_os.str() << std::endl;
  // format of output with header
  if ( verbose == 1 )
          std::cout << "     " << tmp_os.str() << std::endl;
  else
          std::cout << tmp_os.str() << std::endl;

  return;
}

void DataCSV::helper_operator_write(std::ostream &os) const
{
        // format for DataCSV
        os << "," << std::setprecision(FDS::PRECISION) << std::setw(FDS::WCOL) << std::fixed
             << GetOpen() << "," << std::setw(FDS::WCOL) << GetHigh() << ","
             << std::setw(FDS::WCOL) << GetLow() << "," << std::setw(FDS::WCOL) << GetClose();
        //return os;
}

void DataCSV::helper_operator_read(std::iostream &ios)
{
        std::vector<type_value_data> vec_values;
        vec_values.reserve(4);

        // loop until "," or end line, always 4 here
        for ( unsigned int i=0; i< 4; ++i) {
                // only stream and char[] are used inside
                vec_values.push_back( Utils::fromStreamToDouble( ios, ',') );
        }
        SetValues(vec_values);
}


bool operator==( const SimpleData & lhs, const SimpleData & rhs ) {

        return ( ( lhs.date == rhs.date ) &&
             ( lhs.value == rhs.value ) );
}

bool operator==( const MultiData & lhs, const MultiData & rhs ) {

        return ( ( lhs.date == rhs.date ) &&
             ( lhs.values == rhs.values ) );
}

bool operator==( const DataCSV & lhs, const DataCSV & rhs ) {

        return ( ( lhs.date == rhs.date ) &&
             ( lhs.open == rhs.open ) &&
             ( lhs.high == rhs.high ) &&
             ( lhs.low  == rhs.low  ) &&
             ( lhs.close == rhs.close ) );
}




// define only for DataStock base and use polymorphisme on obj
std::ostream& operator<<(std::ostream& os, const DataStock& obj)
{
        // call base for the date only if pos == 0
        if ( os.tellp() == 0 || os.tellp() == -1 )
                obj.helper_operator_write_base( os );

        // call a virtual function
        obj.helper_operator_write( os );

        return os;
}

std::iostream& operator>>(std::iostream& ios, DataStock& obj)
{
        // C buffer to renconstruct the stream, correctly initialized with memset in function
        char buf_ret[BDS::BUFFER_STREAM];
        size_t len_buf;

        // here it is an error, because it means than an object has no data to read, set fail()
        if ( ( (ios.rdstate() & std::iostream::eofbit ) != 0 ) ||
                 ( (ios.rdstate() & std::iostream::failbit) != 0 ) ) {
                std::cout << "DataStock eofbit or fail nothing more to read from the stream, set fail " << std::endl;
                ios.setstate ( std::iostream::failbit);
                return ios;
        }

        // call base to read the date, bytes are consumed, stream position advanced
        if ( obj.helper_operator_read_base( ios ) != 0 ) {
                //std::cout << "Error in parsing date, set fail " << std::endl;
                ios.setstate ( std::iostream::failbit);
                return ios;
        }

        // specific to each object
        obj.helper_operator_read( ios );

        //for all
        // if it is the first call, eof will return true
        // if it is an other will peek '!' and discard unused bytes
        // set eofbit to be sure a potential caller will return directly ( and generate a fail in this case )
        if ( ios.eof() || (ios.peek() == '!') ) {
                ios.setstate ( std::iostream::eofbit);
                return ios;
        }
        // is should point to the resting values before the call
        // if more data, need to reconstruct the stream
        len_buf = reconstruct_stream_operator( ios, buf_ret );

        // write the total array into the stream and pass to the next object
        ios.seekg(0);
        ios.write( buf_ret, len_buf );
        return ios;
}

std::string& operator<<(std::string &line_csv, const DataStock& obj)
{
        std::ostringstream stream;
        // ok, now stream.tellp is increased if line is non empty
        stream << line_csv << obj;
        line_csv = stream.str();
        return line_csv;
}

std::string& operator>>(std::string &line_csv, DataStock& obj)
{
        std::stringstream ss(line_csv);
        ss >> obj;

        // everything done correctly, clear the string
        if ( ss.eof() == true && ss.fail() == false )
                line_csv.clear();
        // error, insure string is not empty
        else
                line_csv = ss.str();

        return line_csv;
}