Stock.cpp

Go to the documentation of this file.

#include "Stock.h"

#include <fstream>
#include <ostream>
// needed for passing stream by parameter, seems really important !
#include <iosfwd>
#include <iomanip>

#include "ListDataStock.h"
// moved here, maybe need other import for other function, more convenient in Stock.h
#include "TAlibAPI.h"
/* include the wrapper to ParserStock, defined in external file
 * because include Python.h makes problem with rootcint */
#include "StockwrapPyParser.cpp"


// old deprecated
Stock::Stock( const std::string iname, const std::string isymbol, const std::string ipath):
      name(iname), symbol(isymbol), path(ipath) {
#ifdef DEBUG_CPP
        std::cout << " Constructor Stock, depreaceated version with symbol " << std::endl;
#endif
        // lazy initialization, created only when calling Compute
        p_talib = nullptr;
}

// constructor, ipath has default value with Utils::PATH_DATA
Stock::Stock( const std::string iname, const std::string ipath ) :
                name(iname), path(ipath) {
        symbol= iname;
        // lazy initialization, created only when calling Compute
        p_talib = nullptr;
}


Stock::~Stock() {
#ifdef DEBUG_CPP
  std::cout << "Default destructor stock" << std::endl;
#endif

  for( it_map it_m = mapTime_ListData.begin(); it_m != mapTime_ListData.end(); ++it_m) {
      for( it_listdata it_l = it_m->second.begin(); it_l != it_m->second.end(); ++it_l) {
          //std::cout << "Delete ListDatatStock " << std::endl;
          delete (*it_l);
      }
  }
  // do not seem necessary, done when exiting, but correct if outside the loop
  mapTime_ListData.clear();
  // not necessary 
  name.clear();
  symbol.clear();
  // nullify the pointer, now with singleton ok, shutdown the library only once
  delete p_talib;
  p_talib = nullptr;
}


// in all GetItList functions check end iterator must be done before
// could return end iterator of the map, easier to check
Stock::cit_listdata Stock::GetItList( Stock::cit_map& it_m, const Indicator& indic, const std::vector<int> & param ) const
{
    cit_listdata it_l;
    std::string full_indic_label = ShortName::MakeShortName( indic, param );
    //std::cout << "Stock::GetItList full_indic_label " << full_indic_label << std::endl;

    return GetItList( it_m, full_indic_label );
}

Stock::cit_listdata Stock::GetItList( Stock::cit_map& it_m, const std::string& sname ) const
{
    cit_listdata it_l;
    // or use find algorithm
    for( it_l = (*it_m).second.begin(); it_l != (*it_m).second.end(); it_l ++) {
        if ( (*it_l)->GetName() == sname ) {
            return it_l;
        }
    }
    return (*it_m).second.end();
}

// version non-const, to be called by non-const function
Stock::it_listdata Stock::GetItList( it_map& it_m, const Indicator& indic, const std::vector<int>& param )
{
        // call only one version
        std::string full_indic_label = ShortName::MakeShortName( indic, param );
        return GetItList( it_m, full_indic_label );
}

Stock::it_listdata Stock::GetItList( it_map& it_m, const std::string& sname )
{
        // here iterator it_m should be checked before
        for( it_listdata it_l = (*it_m).second.begin(); it_l != (*it_m).second.end(); it_l ++) {
            if ( (*it_l)->GetName() == sname ) {
                return it_l;
            }
        }
        return (*it_m).second.end();
}

// only in one place, extract dates and timescale maybe (for check as well)
// made private and static
// suppress ETime & tmscl, not used until now
// version static, can be called by Read_HeaderCSV_static
int Stock::ReadLineHeader( const std::string & line, Utils::firstlast_dates & dates )
{
  std::vector<std::string> line_split;
  Utils::splitline(line," ", line_split);
  // could choose format from the TimeScale, tricky here int
  //tmscl = static_cast<ETime>(( unsigned int) line_split[1]);
  //tmscl = static_cast<ETime>( line_split[1]);

  // for daily data, StringToTime_t return -1/-105 if an error occured (bad format)
  if ( line_split.size() == 4 ) {
      dates.first = Utils::StringToTime_t ( line_split[2] );
      dates.last  = Utils::StringToTime_t ( line_split[3] );
  // for dcsv
  } else if ( line_split.size() == 6 ) {
      dates.first = Utils::StringToTime_t ( line_split[2]+" "+line_split[3] );
      dates.last  = Utils::StringToTime_t ( line_split[4]+" "+line_split[5] );
  }

  // else problem, should not appear
  else {
          std::cout << "ERROR Stock::ReadLineHeader in reading dates, return 1 " << std::endl;
          return 1;
  }

  // -1 possibly a time shift with origin date and locatime ? yes seems, use -105
  if ( dates.first == Utils::ERROR_StrToTime || dates.last == Utils::ERROR_StrToTime ) {
#ifdef DEBUG_CPP
        std::cout << "ERROR Stock::ReadLineHeader from Utils::StringToTime_t, return 1" << std::endl;
#endif
          return 1;
  }

#ifdef DEBUG_CPP
  std::cout << "ReadLineHeader dates " << Utils::Time_tToString( dates.first, true ) << " "
            << Utils::Time_tToString( dates.last, true ) << std::endl;
#endif
  return 0;
}

// advantage of stream, keep previous modificator (fixed, precision), solve bug volume with exponential ??
// include string timescale (DAY) on 5 characters
// include version number, only fixed now
// made static as well
void Stock::WriteLineHeader( const ETime & tmscl, const Utils::firstlast_dates & dates, std::ostringstream & ss_header )
{
        // test to print the name, 5 is max with MONTH,  do not include HH:MM:SS
        if ( tmscl >= ETime::DAY ) {
                        ss_header << "#0.1 " << std::setw(5) << std::left << tmscl << " " << Utils::Time_tToString( dates.first, false )
                                          << " " << Utils::Time_tToString( dates.last, false );
        // need exact time
        } else {
                        ss_header << "#0.1 " << std::setw(5)<< std::left << tmscl << " " << Utils::Time_tToString( dates.first, true )
                                                          << " " << Utils::Time_tToString( dates.last, true );
        }
        return;
}

// private member now, could change the name ReadFileListData or LoadCSVdata, LoadHistoricalData
// Read the correct file ( need infos about dates) try to avoid the default values here
// Call Transform Time if necessary
// return value not used, use exception
void Stock::LoadCSVData(const ETime& tmscl, Utils::firstlast_dates & dates) throw ( StockException )
{
#ifdef DEBUG_CPP
        std::cout << "Stock::LoadCSVData argument tmscl: " << tmscl << std::endl;
#endif
        // test first if the candle is already loaded
    // case INST, indicator is different StockInst
        if ( tmscl == ETime::INST ) {

                // better, more accurate
            if ( CheckLoaded( tmscl, Indicator::StockInst ) && CheckLoaded( tmscl, Indicator::Volume ) ) {
#ifdef DEBUG_CPP
            std::cout << "Indicator::StockInst and Volume for timescale " << tmscl << " is already loaded" << std::endl;
#endif
            return;
        }
    // all other cases, use Candle
        } else {
        if ( CheckLoaded( tmscl, Indicator::StockCSV ) && CheckLoaded( tmscl, Indicator::Volume ) ) {
#ifdef DEBUG_CPP
                std::cout << "Indicator::StockCSV and Volume for timescale " << tmscl << " is already loaded" << std::endl;
#endif
                return;
        }
    }

        // Case read data from a file
        if ( (tmscl == ETime::DAY) or (tmscl == ETime::INST) ) {
#ifdef DEBUG_CPP
                //create ListCSV in Read and fill
                std::cout << " ReadCSV timescale " << tmscl << std::endl;
                //here read all data, by default last_time = 0, could make a first_time to limit the data to load(not implemented)
#endif
                // return is not needed anymore
                try {
                        ReadCSV( tmscl, dates );
            } catch ( const StockFileError & e ) {
#ifdef DEBUG_CPP
                std::cout << "LoadListData catch FileError exception" << std::endl;
                std::cout << "what() " << e.what() << std::endl;
                std::cout << "Will Create a StockFileError " << std::endl;
#endif
                // need to clean some data ?? only inside ReadCSV...
                // rethrow error, already of type StockException
                throw;
            }
            // return here for iteration, before transform_timescale
            return;
        }

        // not DAY or dcsv, need to transform to an other timescale
        if (tmscl > ETime::DAY) {
                //new_tmscl = ETime::DAY;
                // new version check exactly one of mandatory if missing
                // if one is missing, force to read again the file, old list will be "replaced" (first time equal)
                // and it solves the bug
                if ( !CheckLoaded(ETime::DAY, Indicator::StockCSV) ||
                         !CheckLoaded( ETime::DAY, Indicator::Volume)  ) {
                        LoadCSVData( ETime::DAY, dates);
                }
        } else if (tmscl < ETime::DAY) {
                //new_tmscl = ETime::INST;
                if ( !CheckLoaded(ETime::INST, Indicator::StockInst) ||
                         !CheckLoaded( ETime::INST, Indicator::Volume) ) {
                        std::cout << "At least one missing, force to read the file " << std::endl;
                        LoadCSVData( ETime::INST, dates);
                }
        }

        // transform to the timescale, problem if StockCSV or Volume deleted, but not both
        std::cout << "before transform_timescale " << std::endl;
        if ( Transform_TimeScale(tmscl) != 0 ) {
        // message not clear...
                std::cout << "TransformTimeScale problem throw exception " << std::endl;
                throw ( StockException( name, "Error in Transform_TimeScale tmscl") );
    }
        return;
}

// may check before ?
// to delete
void Stock::SetLDataFullName( ListDataStockBase *p_listdata ) const
{
    std::string tmp_string = GetName()+"_"+ GetTimeScaleName( p_listdata->GetTimeScale() ) +
                "_" + p_listdata->GetName();
#ifdef DEBUG_CPP
    std::cout << "Entry Stock::SetLDataFullName " << std::endl;
    std::cout << " tmp_string " << tmp_string << std::endl;
#endif
    p_listdata->SetFullName( tmp_string );
}

// no exception from ListDataStock
// should be used only internally ? now is private
// Swap is done according to ListDataStock_Utils::TransformTimeScale
// dynamic_cast still needed here ?? yes to call TransformTimeScale
int Stock::Transform_TimeScale( const ETime & new_tmscl )
{
#ifdef DEBUG_CPP
    std::cout << "\n\tEntry Transform_TimeScale " << new_tmscl << std::endl;
#endif

    assert( new_tmscl != ETime::DAY);
    assert( new_tmscl != ETime::INST);
    assert( new_tmscl != ETime::not_a_time);

    // output type is known for sure
    ldata_candle *out_csv  = new ldata_candle ("StockCSV", new_tmscl);
    ldata_volume *out_vol = new ldata_volume("Volume", new_tmscl);
    // input volume
    ldata_volume *in_vol;

    // need to load DAY if transform > DAY
    if ( new_tmscl > ETime::DAY) {
#ifdef DEBUG_CPP
        std::cout << " new_tmscl  > DAY " << new_tmscl << std::endl;
#endif
        // cannot avoid dynamic_cast here ?? no or should use Base for all lists
        // volume the same class in both case
        in_vol = dynamic_cast<ldata_volume*>( GetListData(ETime::DAY, Indicator::Volume ));
        if ( in_vol == nullptr ) {
            std::cout << "ERROR in Stock::Transform_TimeScale in dynamic_cast volume " << std::endl;
            return 1;
        }

        ldata_candle *in_csv = dynamic_cast<ldata_candle*>( GetListData(ETime::DAY, Indicator::StockCSV) );
        if ( in_csv == nullptr ) {
            std::cout << "ERROR in Stock::Transform_TimeScale in dynamic_cast candle" << std::endl;
            return 1;
        }
        //std::cout << "Call ListDataStock::TransformTimeScale " << std::endl;
        // make transformation in ListData, correct call done by the argument list
        ListDataStock_Utils::TransformTimeScale ( new_tmscl, *in_csv, *in_vol, *out_csv, *out_vol );

   //else use dcsv, assert to check for bad tmscl
   } else if ( new_tmscl < ETime::DAY) {
#ifdef DEBUG_CPP
        std::cout << " new_tmscl < DAY " << new_tmscl << std::endl;
#endif
        // volume the same class in both case
        in_vol = dynamic_cast<ldata_volume*>( GetListData(ETime::INST, Indicator::Volume ));
        if ( in_vol == nullptr ) {
            std::cout << "ERROR in Stock::Transform_TimeScale in dynamic_cast volume " << std::endl;
            return 1;
        }
        ldata_dcsv *in_dcsv = dynamic_cast<ldata_volume*>( GetListData(ETime::INST, Indicator::StockInst) );
        if ( in_dcsv == nullptr ) {
            std::cout << "ERROR in Stock::Transform_TimeScale in dynamic_cast candle " << std::endl;
            return 1;
        }
        ListDataStock_Utils::TransformTimeScale ( new_tmscl, *in_dcsv, *in_vol, *out_csv, *out_vol );
    }

    // if == 1 update of a previous listdata, need to delete the local pointer
    if ( AddListDataToMap( new_tmscl,out_csv ) == 1 ) {
#ifdef DEBUG_CPP
        std::cout << "return 1 (update) from AddListData, so delete temporary list" << std::endl;
#endif
        delete ( out_csv );
        out_csv = 0;
    }
    if ( AddListDataToMap( new_tmscl,out_vol ) == 1 ) {
#ifdef DEBUG_CPP
        std::cout << "return 1 (update) from AddListData, so delete temporary " << std::endl;
#endif
        delete ( out_vol );
        out_vol = 0;
    }
    return 0;
}

// exception useful here, for log, gui...
// Computation of any TAlib indicator */
// maybe Indicator, param easier. Could check default parameter, now only in GUI.
int Stock::ComputeTA( const ETime & tmscl, const std::string & name_new_indic ) throw(TALibException)
{
#ifdef DEBUG_CPP
    std::cout << "\n\tEntry Stock::ComputeTA, name_new_indic: " << name_new_indic << std::endl;
#endif

    int  new_size;
    int retour=0;
    //get indicator and parameters, here extract parameters from name, could pass correct indicator and param
    //could be a function GetvecParam, better than new indic ??
    std::vector<int> vec_param;
    Indicator new_indic(Indicator::Null);
    new_indic.Set(name_new_indic,vec_param);
    // for exception
    //std::string msg;

    // They could be in TALib and throw appropriate exception
    // This case cannot appear from LoadListData, need a real Indicator
    // From other ?? or delete this test
    // new_indic
    if (new_indic == Indicator::Null || new_indic.nb_output() < 1 ) { // || vec_param.empty() ) { //deleted for AD, no parameter
#ifdef DEBUG_CPP
        std::cout << "\n\t Stock::ComputeTA" << std::endl;
        std::cout << "Error, indicator is null" << std::endl;
        std::cout << "label indicator after extract "<< new_indic.label() << std::endl;
#endif
        std::string msg = "TALibException: Error, indicator is null or nb_output <= 0, label received = "+ Utils::toString(name_new_indic);
        throw ( TALibException( new_indic, vec_param, msg ) );
        //return 1;
    }
    // test the number of parameter is correct
    if ( new_indic.nb_param() != (int)vec_param.size() ) {
#ifdef DEBUG_CPP
        std::cout << "\n\t Stock::ComputeTA" << std::endl;
        std::cout << "Error required number of parameters  "<< new_indic.nb_param() << std::endl;
#endif
        std::string msg = "Error required number of parameters = " + Utils::toString(new_indic.nb_param());
        throw ( TALibException( new_indic, vec_param, msg ) );

    }
    //End of check
#ifdef DEBUG_CPP
    std::cout << new_indic.label() << " will give " << new_indic.nb_output() << " output " << std::endl;
#endif
    assert ( new_indic.nb_output() > 0 );

    // never sure here of its life time, good use of std::unqique_ptr ?
    // now with exception potential more problem with deletion ? deleted before it is copied with release ?
    ListDataStockBase *ldata_base_out;
    //std::unique_ptr< ListDataStockBase> ldata_base_out;


    // kind of factory, see later if needed as separate function
    // creates default SimpleData or MultiData for the output
    switch ( new_indic.nb_output() ) {
        case 1:
                //can create correct type ??
#ifdef DEBUG_CPP
                std::cout << "case : nb_output 1 " << std::endl;
#endif
                ldata_base_out = new ldata_ta_sd( name_new_indic, tmscl );
                //std::unique_ptr< ListDataStockBase > *ldata_base_out = new ldata_ta_sd( name_new_indic, tmscl );
                break;

        // equal or larger than 2
        default:
                ldata_base_out = new ldata_ta_md( name_new_indic, tmscl );
    }

    // ok for the moment send stockCSV with correct timescale, need also volume for momentum !
    // now extend to INST as well
    std::vector< ListDataStockBase *> vec_ldata_in;

    // here may be problem as well, should work with INST as well ! but need dynamic_cast after
    if ( tmscl == ETime::INST )
        vec_ldata_in.push_back( GetListData(tmscl,Indicator::StockInst) );
    else
        vec_ldata_in.push_back( GetListData(tmscl,Indicator::StockCSV) );

    // case where volume is needed
    if ( new_indic == Indicator::AD ) {
#ifdef DEBUG_CPP
        std::cout << " case of AD need the volume in vec_ldata_in " << std::endl;
#endif
        vec_ldata_in.push_back( GetListData(tmscl, Indicator::Volume) );
    }

#ifdef DEBUG_CPP
    std::cout << "ldata_in[0] Name " << vec_ldata_in[0]->GetName() << std::endl;
    std::cout << "ldata_in[0] Size " << vec_ldata_in[0]->GetSize() << std::endl;
    //if ( vec_ldata_in.size() == 2 ) {
    //    std::cout << "Name " << vec_ldata_in[1]->GetName() << std::endl;
    //    std::cout << "Size " << vec_ldata_in[1]->GetSize() << std::endl;
    //}
#endif


    // lazy initialization, assign the pointer if not done and init TAlib
    if ( p_talib == nullptr ) {
#ifdef DEBUG_CPP
        std::cout << "p_talib is null, must initialize the library " << std::endl;
#endif
        p_talib = new TAlibAPI();
    }
#ifdef DEBUG_CPP
    else {
        std::cout << "p_talib is not null, library already initialized " << std::endl;
    }
#endif

    // Treated here, made check, not to do in TAlibAPI
    try {
        retour = p_talib->Compute( tmscl, new_indic, vec_param, vec_ldata_in, ldata_base_out);
#ifdef DEBUG_CPP
    std::cout << "TAlibAPI::Compute retour " << retour << std::endl;
#endif

    } catch ( TALibException & e ) {
        std::cout << "Catch Stock::ComputeTA TALibException " << std::endl;
        std::cout << "what() of TALib " << e.what() << std::endl;
        // throw to the caller or here throw StockException( TALibException ) to write

        // need to delete list_out
        delete ldata_base_out; ldata_base_out = nullptr;
        throw;
    }

    // test not needed anymore if an exception is throw ?
    if ( !retour ) {

        new_size = ldata_base_out->GetSize();
        std::cout << " size new data " << new_size << std::endl;
        //std::cout << "name_new_indic " << name_new_indic << std::endl;

        //certainly need to delete previous and replace by new, default for all indicator recomputed ??
        // may work for update SMA, should be default but may do better...

        // old test, should not be true, except mistake ask 2 times, so check first !,
        // keep as example, and for test, but can delete
        /*
        if ( GetListData( tmscl, name_new_indic ) != 0 ) {
            std::cout << "size old data " << GetListData ( tmscl, name_new_indic ) -> GetSize() << std::endl;
            //default delete previous ListData
            std::cout << "existing ldata pointer " << GetListData( tmscl, name_new_indic ) << std::endl;
            std::cout << "GetName of existing data " << GetListData( tmscl, name_new_indic )->GetName() << std::endl;

            //cannot delete pointer is present in THStock... need to resize, keep same pointer
            //DeleteListData( tmscl, GetListData( tmscl, name_new_indic )->GetName() );
        }*/

        // Set the dates of the new List. Here will apply to all computations.
        ldata_base_out->SetDates();

        // Will insert or replace the indicator, delete if replaced
        // can avoid those tests, should be automatic with smart pointer ?? if unique_ptr.release maybe
        if ( AddListDataToMap ( tmscl, ldata_base_out ) == 1 ) {
#ifdef DEBUG_CPP
            std::cout << " update will delete original list " << std::endl;
#endif
            delete ( ldata_base_out );
            ldata_base_out = nullptr;
        }
    }
    //else return != 0 , error in TALib, not exception for all
    else {
        std::cout << "\n\t retour of TAlib::Compute !=0 Error\n" << std::endl;
        delete ( ldata_base_out );
        ldata_base_out = 0;
        return 1;
    }
#ifdef DEBUG_CPP
    std::cout << "\n\treturn from Stock::ComputeTA no error\n" << std::endl;
#endif
    return 0;
}

bool Stock::CheckLoaded( const ETime& tmscl) const
{
    cit_map it = mapTime_ListData.find( tmscl );
    if ( it==mapTime_ListData.end() )
        return false;

    return true;
}

// need to split in 2, need to be sure first iterator is valid
bool Stock::CheckLoaded( const ETime& tmscl, const Indicator& indic, const std::vector<int>& param ) const
{
    cit_map it_m = mapTime_ListData.find( tmscl );
    if ( it_m == mapTime_ListData.end() ) {
        return false;
    }

    cit_listdata it_l = GetItList( it_m, indic, param );
    if ( it_l == (*it_m).second.end() ) {
        return false;
    }
    return true;
}

bool Stock::CheckLoaded( const ETime& tmscl, const std::string& sname ) const
{
    cit_map it_m = mapTime_ListData.find( tmscl );
    if ( it_m == mapTime_ListData.end() ) {
            return false;
    }

    cit_listdata it_l = GetItList( it_m, sname );
    if ( it_l == (*it_m).second.end() ) {
            return false;
    }
    return true;
}

bool Stock::IsEmpty() const
{
  if ( mapTime_ListData.empty() ) {
#ifdef DEBUG_CPP
      std::cout << " The map of Stock " << name << " Is empty " << std::endl;
#endif
      return true;
  }
  return false;
}

// new, add param in input
// could perform the dynamic cast here ?? from Indicator should be possible ??
// indicator optional, send back StockCSV or StockInst ?
ListDataStockBase* Stock::GetListData( const ETime& tmscl, const Indicator& indic, const std::vector<int> param ) const
{
    // new design, safer, obliged to check in calling
    cit_map it_m = mapTime_ListData.find( tmscl );
    if ( it_m == mapTime_ListData.end() ) {
        return nullptr;
    }
    // map entry exist, search in vector
    cit_listdata it_l = GetItList( it_m, indic, param );
    if ( it_l == (*it_m).second.end() ) {
        return nullptr;
    }
    return *it_l;
}

// if can make the dynamic cast here, call the other function
ListDataStockBase* Stock::GetListData( const ETime& tmscl, const std::string& sname) const
{
    cit_map it_m = mapTime_ListData.find( tmscl );
    if ( it_m == mapTime_ListData.end() ) {
        return nullptr;
    }
    cit_listdata it_l = GetItList( it_m, sname );
    if ( it_l == (*it_m).second.end() ) {
        return nullptr;
    }
    return *it_l;
}

// new version, should be called in all cases
// creates the key timescale if it does not exist and insert the list
//
// 1. if size new data == 0 error with assert
// 2. Get it_map on the timescale, creates it if it does not exist. ok
//
// 3. Check if a previous listdata_old exists, with same shortname as p_listdata
//    - if exists: if StockCSV,Stockdcsv or Volume (Indicator::ToUpdate()) : update with ListDataStock::AddToList
//                 else if TA_Indicator : replace with ListDataStock::Replace, set fullname
//                 return 1 == update
//    else: set fullname, insert directly the pointer p_listdata into map
//    return 0
int Stock::AddListDataToMap( const ETime& tmscl, ListDataStockBase* p_listdata )
{

    std::string sname = p_listdata->GetName();
    unsigned int new_ldata_size = p_listdata->GetSize();
    ListDataStockBase *ldata_old = 0;

    //Add a pointeur to the vector of pointeur on listdata
#ifdef DEBUG_CPP
    std::cout << "\n\t Stock::AddListDataToMap " << tmscl ;
    std::cout << " new list p_listdata->name " << p_listdata->GetName() ;
    std::cout << " new list p_listdata->size " << p_listdata->GetSize() << std::endl;
#endif

    //for real time, AddListDataToMap should be called only if new data to add
    // much better, keep it for test use assert
    if ( new_ldata_size == 0 ) {
        std::cout << "Stock::AddListDataToMap p_listdata size = 0 , return 2, SHOULD NOT APPEAR !!" << std::endl;
        assert ( new_ldata_size !=0 );
        return 2;
    }

    // get iterator on timescale if exists
    //it_map it_m = GetItMap(tmscl);
    it_map it_m = mapTime_ListData.find( tmscl );
    // if tmscl key does not exist, create
    if  ( it_m == mapTime_ListData.end() ) {
#ifdef DEBUG_CPP
        std::cout << "In Map, ETime " << tmscl << " does not exist, create " << std::endl;
#endif
        std::vector < ListDataStockBase* > vec;
        // create a new timescale, with a default empty vector
        mapTime_ListData[tmscl] = vec;
        // used later if insertion
        //it_m = GetItMap( tmscl );
        it_m = mapTime_ListData.find( tmscl );
    }

    // check if listdata already exists, in this case it is an update should return 1
    // could use it_m, faster, clearer
#ifdef DEBUG_CPP
    std::cout << "Check old data with same name " << sname << std::endl;
#endif
    ldata_old = GetListData ( tmscl, sname );

    if ( ldata_old ) {
#ifdef DEBUG_CPP
        std::cout << " Will Update existing ListDataStock " << std::endl;
        std::cout << " name listdata old " << ldata_old->GetName() << std::endl;
#endif
        Indicator indic = ShortName::GetIndicator( ldata_old->GetName() );
        //std::cout << "Get indicator old " << indic.label() << std::endl;

        // Test indicator, could be a function of Indicator::ToReplace, ToCheck...
        // try to update
        if ( ( indic == Indicator::StockCSV ) || ( indic == Indicator::StockInst ) ||
             ( indic == Indicator::Volume ) ) {

#ifdef DEBUG_CPP
            std::cout << "Update Stock or Volume, call AddToList " << std::endl;
#endif
            // all details let to ListDataStock now
            // number of inserted of modified values should be done there
            ldata_old->AddToList ( p_listdata );

        //else indicator to recompute SMA, MACD... by default call ListDataStock->Replace()
        // could update, more efficient, but more tricky... memory effect ...
        // now all recomputed, force to replace all, not want to update like AddToList
        } else {
#ifdef DEBUG_CPP
            std::cout << "Will replace indicator (SMA,MACD...) " << std::endl;
#endif
            // If fullname is missing creates it, could be done once
            if ( p_listdata->GetFullName() == "" ) {
                    //std::cout << "SetFullname " << std::endl;
                    SetLDataFullName ( p_listdata );
            }
            //std::cout << "Check if fullname exist :" << p_listdata->GetFullName() << std::endl;
            ldata_old->Replace( p_listdata );
        }
        // ldata_old exists, an update has been done
#ifdef DEBUG_CPP
        std::cout << "ldata_old exists, an update has been done, return 1" << std::endl;
#endif
        // return 1 == update p_listdata to delete
        return 1;
    } //end if ldata_old

    // else listdata_old does not exist, insert the full list in map
    // and return 0
#ifdef DEBUG_CPP
    std::cout << "ListData does not exist, insert " << std::endl;
    std::cout << "Check if fullname exist to set fullname :" << p_listdata->GetFullName() << std::endl;
#endif
    // could be done once ?
    if ( p_listdata->GetFullName() == "" ) {
        //std::cout << "SetFullname " << std::endl;
        // cannot call ListDataStock method ??
        SetLDataFullName ( p_listdata );
    }
    // add to the map, copy the pointer only
    (*it_m).second.push_back(p_listdata);
    // return 0, new insertion
    return 0;
}

// to_replace, replace existing entry, update maybe later...
// Call AddListDataToMap, follow same logic for insertion and update
void Stock::MergeStock( const Stock *new_stock, bool /*to_replace*/)
{
#ifdef DEBUG_CPP
        std::cout << "Entry MergeStock "  << std::endl;
        std::cout << "this " << this << std::endl;
        std::cout << "new_stock " << new_stock << std::endl;
#endif
        // can get access to private member of new_stock
        //it_listdata it_l_new = new_stock->GetItList(ETime::DAY,"StockCSV");
        const Stock & rnew_stock = (*new_stock);
        int status;

        if ( this == new_stock ) {
#ifdef DEBUG_CPP
                std::cout << "Same pointer ! already updated ? just return...\n" << std::endl;
#endif
                return;
        }

#ifdef DEBUG_CPP
        std::cout << "Different pointer ! Make a copy... " << std::endl;
#endif
        cit_map it_map_new;
        cit_listdata it_list_new;

        for ( it_map_new = rnew_stock.mapTime_ListData.cbegin();
                        it_map_new != rnew_stock.mapTime_ListData.cend();
                        it_map_new++) {

                // print the timescale normally, ok
                ETime tmscl = (*it_map_new).first;
                std::cout << "ETime " << (*it_map_new).first << std::endl;

                // loop over listdata
                for ( it_list_new = (*it_map_new).second.cbegin();
                                it_list_new != (*it_map_new).second.cend();
                                it_list_new++ ) {
#ifdef DEBUG_CPP
                                        std::cout << "fullname list " << (*it_list_new)->GetFullName() << std::endl;
                                        std::cout << "name list " << (*it_list_new)->GetName() << std::endl;
#endif
                                        // use existing interface AddListDataToMap
                                        // case to replace here to improve
                                        status = AddListDataToMap( tmscl, *it_list_new );

#ifdef DEBUG_CPP
                                        if ( status==0 ) {
                                                std::cout <<"status 0: insertion " << std::endl;
                                        } else if (status == 1) {
                                                std::cout <<"status 1: update " << std::endl;
                                        }
#endif
                                } // end loop over vector lists
        } // end loop over key
        return;
}

// use private LoadCSVData to load historical data
// return 0 if correct
// return 1 if already present, just return
//
// wrong to test with ETime::INST
// works fine if Load( M5, Indicator::StockCSV ), so name is wrong, it should be Indicator::StockInst !
//
// If load Indicator, missing parameter, status 0, no exception ?? corrected, throw exception
//
// to load historic data, no need to give the indicator in fact, LoadCSVData guess about the timescale, overload the input
// done
//
// made Indicator default StockCSV (if INST, will overload) done !
// not sure about return value or exception, at the moment only if already loaded return 1
int Stock::LoadListData(const ETime& tmscl, const Indicator& indic, const std::vector<int>& param,
                        Utils::firstlast_dates dates ) throw (StockException)
{
    std::string sname;
    sname = ShortName::MakeShortName( indic, param );

#ifdef DEBUG_CPP
    std::cout << "\n\tEntry Stock::LoadListData ";
    std::cout << "timescale " << tmscl << std::endl;
    std::cout << " indic " << indic.label() << std::endl;
    std::for_each(param.cbegin(),param.cend(),
         [](int value){std::cout << value << " ";} );
    std::cout << "first time " << dates.first << " " << Utils::Time_tToString( dates.first, true ) << std::endl;
    std::cout << "last time " << dates.last << " " << Utils::Time_tToString ( dates.last, true )  << std::endl;
    std::cout << "ShortName " << sname << std::endl;
#endif

    // Check for Indicator::Null
    if ( indic == Indicator::Null ) {
        throw StockException("StockException: LoadListData with indicator Null");
    }

    // already loaded, return 1
    // need to test for the exact indicator as well
    if ( CheckLoaded( tmscl, sname ) ) {
#ifdef DEBUG_CPP
        std::cout << "Indicator " << sname << " Already in Map" << std::endl;
#endif
        return 1;
    }

    // assure StockCSV (Stockdcsv to do) with the correct timescale is loaded in Stock
    // may throw a StockFileError (StockException specific) as well, must be caught by the caller
    // this is done before check of the indicator...
    //
    // here problem if INST Volume is still present, but StockInst deleted.
    // crash  in Stock::TransformTimeScale, ok problem solved now
    LoadCSVData( tmscl, dates );

    // check if this indicator need to be computed by Talib
    if ( indic.NeedToComputeTA() ) {
#ifdef DEBUG_CPP
                std::cout << "LoadListData call ComputeTA " << std::endl;
#endif
                // throw TAlibException if not enough data for instance
                // retour not needed anymore ?
                // if indicator has wrong parameter, return 1, does not throw exception.
                try {
                        ComputeTA( tmscl, sname );
                // expect a TALibException if any problem in this part
                } catch ( const TALibException & e ) {
#ifdef DEBUG_CPP
                        std::cout << "Stock::LoadListData catch TALibException " << std::endl;
                        std::cout << "what() " << e.what() << std::endl;
#endif
                        // rethrow, transform to StockTALibError
                        throw ( StockTALibError( name, TimeScale::GetTimeScaleName(tmscl), e) );
                }
    } // end ComputeTA

#ifdef DEBUG_CPP
    std::cout << "Exit Stock::LoadListDataStock without problem " << std::endl;
    //PrintMapChrono();
#endif
    // all fine, new inserted by default
    return 0;
}


// only call other version
void Stock::DeleteListData( const ETime& tmscl, const Indicator& indic, std::vector<int> param )
{
#ifdef DEBUG_CPP
  std::cout << "Stock::DeleteListData with indic" << indic.label() << " tmscl " << tmscl << std::endl;
  //PrintMapChrono();
#endif

  std::string sname = ShortName::MakeShortName( indic, param );
  DeleteListData( tmscl, sname );
}

// Delete one ListDataStock with shortname
// check if the dictionary TimeScale entry is empty and delete it
void Stock::DeleteListData( const ETime& tmscl, const std::string& sname )
{
#ifdef DEBUG_CPP
  std::cout << "Stock::DeleteListData " << sname << " tmscl " << tmscl << std::endl;
  //PrintMapChrono();
#endif
  
  it_map it_m = mapTime_ListData.find( tmscl );
  // if time does not exist, do nothing
  if ( it_m != mapTime_ListData.end() ) {

          it_listdata it_l = GetItList ( it_m, sname );
          // if name does not exist, do nothing
          if ( it_l != (*it_m).second.end() ) {
                  // delete object ListData
                  delete(*it_l);
                  // erase entry in map value
                  mapTime_ListData[tmscl].erase(it_l);

                  // if size of the vector TimeScale is null, delete completely the entry in map
                  if ( mapTime_ListData[tmscl].size() == 0 ) {
#ifdef DEBUG_CPP
                          std::cout << " size of map with key " << tmscl << " is empty, delete it " << std::endl;
#endif
                          mapTime_ListData.erase ( tmscl );
                  }
          }
  }
}

// Delete all ListData corresponding to a TimeScale, delete entry timescale in map */
void Stock::DeleteAllListData( const ETime & tmscl )
{
    #ifdef DEBUG_CPP
    std::cout << " Entry DeleteAllListData " << tmscl << std::endl;
    #endif

    it_map it_m = mapTime_ListData.find( tmscl );
    // if time does nott exist, return
    if ( it_m == mapTime_ListData.end() )
        return;

    //stl remove-erase-idiom, p 1020, not really applicable here

    // Best way, delete data and then the map reference by erase all
    for ( it_listdata it_l = ((*it_m).second.begin()); it_l != (*it_m).second.end(); it_l++ ) {
#ifdef DEBUG_CPP
          std::cout << (*it_l)->GetName() << std::endl;
#endif
        //if not called, destructor of ListDataStock is not called
        delete ( *it_l );
    }
    // here sure to delete the map entry, should be empty already
    mapTime_ListData[tmscl].clear();
    //(it_m).clear(); //not compile, it is a pair Etime, vector
    // erasing by key directly
    mapTime_ListData.erase ( tmscl );
#ifdef DEBUG_CPP
    std::cout << "Stock::End DeleteAllListData " << std::endl;
    PrintMapChrono();
#endif
}


// book, p 1119, force stream to throw exception
//cout.exceptions(ios::failbit | ios::badbit | ios::eofbit);

// Could be in ListDataStock, and forward the call here. But read only DAY and dcsv....
// read StockCSV and volume
// or StockdCVS and volume
// full implementation of dates now
unsigned int Stock::ReadCSV( const ETime tmscl, Utils::firstlast_dates dates )
    throw ( StockFileError )
{
#ifdef DEBUG_CPP
    std::cout << "\n\tEntry ReadCSV ,timescale " << tmscl << std::endl;
    std::cout << " opt dates first " << dates.first <<" " << Utils::Time_tToString( dates.first, true ) << std::endl;
    std::cout << " opt dates last "  << dates.last << " " << Utils::Time_tToString( dates.last ) << std::endl;
    std::cout << " path data: " << path << std::endl;
#endif

    std::string line;
    std::vector<std::string> line_split;
    // return value
    int new_size = 0;
    // tmp values
    time_t time_tmp;
    // float or double for DataStock values
    type_value_data tmp_vol;
    int count = 0;
    // file input
    std::string filename;
    std::ifstream file;

    // Use base pointer for filling the map
    ListDataStockBase *plist_data;
    ListDataStockBase *plist_volume;

    assert( tmscl != ETime::not_a_time);

    // really needed to split in 2 subdirectories ? more general csv/symbol.timescale.csv
    // better historic/CAC40.csv and historic/CAC40.dcsv is enough (no timescale info) or CAC40.DAY.csv CAC40.dcsv.csv
    // dcsv, changed to INST, clearer Indicator::StockInst (better than dcsv)
    // CAC40.5.csv or CAC40.DAY.csv / CAC40.dcsv.csv

    // all in one directory now
    filename = path + "/historical/"+ name +"."+ TimeScale::GetTimeScaleName(tmscl) + ".csv";
#ifdef DEBUG_CPP
    std::cout << "read filename " << filename << std::endl;
#endif
   
    // force as input, redundant with ifstream ?
    file.open ( filename.c_str(), std::ios_base::in );
    // throw exception if cannot open
    if ( file.fail() ) {
#ifdef DEBUG_EXCEPT
        std::cout << "Stock::ReadCVS Opening failed, will throw exception StockFileError with a FileOpenError " << std::endl;
#endif
        throw StockFileError ( name, TimeScale::GetTimeScaleName(tmscl), Indicator::StockCSV.label(), FileOpenError( filename ) );
    }

    // read the first line: header, check if file empty
    std::getline( file, line );
    // test correct, not empty
    if ( file.fail() ) {
#ifdef DEBUG_CPP
        std::cout << "Get first line failed, throw exception " << std::endl;
#endif
                throw StockFileError ( name, TimeScale::GetTimeScaleName(tmscl), Indicator::StockCSV.label(), FileEmptyError( filename ) );
    }

    // move logic of reading the header in one private method
    Utils::firstlast_dates dates_file;
    // return 0 ok, or or error
    if ( ReadLineHeader( line, dates_file ) ) {
#ifdef DEBUG_CPP
        std::cout << "Error return from ReadLineHeader " << std::endl;
#endif
            // Read Error exception, header is line 1
        throw StockFileError ( name, TimeScale::GetTimeScaleName(tmscl), Indicator::StockCSV.label(),
                        FileReadError( filename, 1 ) );
    }

    // could check date input are valid with dates_file in supplement
    // use data from header if not specified as argument
    if ( dates.first == 0 )
        dates.first = dates_file.first;
    if ( dates.last == 0 )
        dates.last = dates_file.last;
#ifdef DEBUG_CPP
    std::cout << "modified first dates " << Utils::Time_tToString( dates.first, true) << std::endl;
    std::cout << "modified last dates " << Utils::Time_tToString( dates.last, true) << std::endl;
#endif

    // count valid lines with the dates, allow to size correctly the lists
    while (true) {
      // exists std::getline( file, line, delimiter) //avoids splitline
      // or std::istream::getline( char * s, streamsize n, delimiter)
      std::getline( file, line );
      // full test if file.good() {make logic} else if file.eof() {break} else {clear and can get the error}, p1136
      if ( file.eof() )
            break;

      // could read the first 19 characters also (if sure of the format)
      // exists
      Utils::splitline ( line, ",", line_split );
      // return -105 if not correct
      time_tmp = Utils::StringToTime_t( line_split[0] );

          //std::cout << "time_tmp " << Utils::Time_tToString( time_tmp, true ) << std::endl;
      // check with dates
      if ( ( time_tmp >= dates.first ) && ( time_tmp <= dates.last ) )
          ++count;
      line_split.clear();
    }
#ifdef DEBUG_CPP
    std::cout << " count " << count << " lines " << std::endl;
#endif
    // with exception, will get problem if no dates
    // here throw no data to read from file
    if ( count == 0 ) {
#ifdef DEBUG_CPP
        std::cout << "will throw a StockFileError, dates are wrong " << std::endl;
#endif
        // add better nessage, with dates, real input is missing
        std::string msg = "Dates provided give no data \ndates used: " +
                        Utils::Time_tToString(dates.first, true) + " " + Utils::Time_tToString(dates.last, true) +" ";
        // must be a StockFileError !
        throw StockFileError (name, TimeScale::GetTimeScaleName(tmscl), Indicator::StockCSV.label(), FileReadError( filename, msg ) );
    }

    // both are mandatory, not sure why ? becasue eof ?
    file.clear();
    file.seekg(0, std::ios::beg);

    // need polymorphism for data, stack more efficient ?
    DataStock *data = 0;
    // for volume exact type is known for sure
    SimpleData data_volume;

    if ( tmscl == ETime::INST ) {
        // only one value with dcsv
        data = new SimpleData();
        // SimpleData and order given in tydedef
        plist_data = new ldata_dcsv("StockInst", tmscl, count);

    // now read all
    //} else if (tmscl == ETime::DAY) {
    } else if ( tmscl != ETime::not_a_time) {
        data = new DataCSV();
        plist_data = new ldata_candle("StockCSV", tmscl, count);
    }
    //else error timescale, exception
    // always set the volume
    plist_volume = new ldata_volume("Volume", tmscl, count);

    //Reread the file, first line header, do nothing
    getline (file,line);
    //std::cout << "Read line: " << line << std::endl;

    //could add a line number for exception
    //count = 0;
    while ( std::getline(file,line) ) {
        //std::cout << "Read line: " << line << std::endl;

        // new operator<< for data_csv :  data << line
        // not possible yet to combine with data_vol << data_csv << line

        // need to clear line before reuse ! very important !
        // or need to modify function, clear at the entrance ? default behaviour
        Utils::splitline ( line, ",", line_split );

        // data and data stock treated by correct type CSV or dCSV (with simple data)
        // good test for exception here !! for sure !!
        //data->ExtractCSVLine(line_split);
        // new style, error assert in load_list_data_dcsv ! line_split != 2
        // be less specific, >= 2
        //(*data) << line;
        line >> *data;

        // to test, operator not implemented for string, only stringstream at now
        //data_volume << (*data << line );

        // extract time in time_t format
        time_tmp = data->GetDate();
        //std::cout << " time_tmp " << time_tmp << " " << Utils::Time_tToString ( time_tmp, true ) << std::endl;

        // test dates match
        if ( ( time_tmp >= dates.first ) && ( time_tmp <= dates.last ) ) {
            // add the new data_csv
            plist_data->AddData( *data );

            // volume, always last one, trick use previous conversion of date !
            tmp_vol = Utils::fromString<type_value_data>( line_split[line_split.size()-1] );
            // C++11, new conversion function

            // SetData
            data_volume.SetData( data->GetDate(), tmp_vol );
            // add data volume to the list
            plist_volume->AddData( data_volume );
        }
        //break the loop if nothing more to read in CSV ( can be a lot !! )
        else {
            // simple shortcut, because always written non-chronologic
            if ( ( tmscl == ETime::DAY ) && ( time_tmp < dates.first ) ) {
                // if day chronologic, no need to continue to read data
                //if ( time_tmp < dates.first ) {
#ifdef DEBUG_CPP
                std::cout << " \nNo need to read others if DAY, can stop !\n " << std::endl;
#endif
                break;         
            }
        }
        //clear line before reuse ! very important !
        line_split.clear();
    }
    // no more need of object and pointer on data csv, volume on stack
    delete ( data ); data = nullptr;
    // use volume because always filled
    new_size = plist_volume->GetSize();

#ifdef DEBUG_CPP
    std::cout << " size new list volume " << plist_volume->GetSize() << " " << new_size << std::endl;
    std::cout << " should be equal to count " << count << std::endl;
    std::cout << " after loop last date " <<  Utils::Time_tToString ( time_tmp, true ) << std::endl;
#endif
    // maybe too strong here ?
    assert ( new_size==count );

    // case of dates, maybe no new data
    if ( new_size ) {

        // need to setup the correct order here, before Adding data to Map
        // indicates in which order the data have been read, to order accordingly to the Policy
        // if could assign ChronologicAt() = data, maybe not needed, but order is different for CSV and dcsv

        // case dcsv it is chronologic
        if ( tmscl == ETime::INST ) {
                plist_data->Order( EPChrono::CHRONO );
                plist_volume->Order( EPChrono::CHRONO );
         }
        // other non-chrono, but may change later (keep M5,..H1 chrono), just change the reorder
        else {
          plist_data->Order( EPChrono::NO_CHRONO );
          plist_volume->Order ( EPChrono::NO_CHRONO );
        }

        // need better after, case of update..., not bad here setup correctly
        // maybe updated in AddListDataToMap
        // if later read M5, ... should use the header dates, can be different from data
        // maybe too early if update, done in AddListDataToMap() after ?? to check but yes I guess
        // if commented unit-test failed
        plist_data->SetDates();
        plist_volume->SetDates();

        // Append to the map, check if it is an update
        // return 1 is an update, need to delete local p_listdata
        if ( AddListDataToMap( tmscl, plist_data ) == 1 ) {
#ifdef DEBUG_CPP
            std::cout << "AddListDataToMap list_data==1 delete plist_data " << std::endl;
#endif
            delete ( plist_data ); plist_data=0;
        }

        if ( AddListDataToMap ( tmscl,plist_volume ) == 1 ) {
#ifdef DEBUG_CPP
            std::cout << "AddListDataToMap list_volume==1 delete plist_data " << std::endl;
#endif
            delete ( plist_volume ); plist_volume=0;
        }
    // read nothing
    } else {
#ifdef DEBUG_CPP
        std::cout << "ReadCSV new_size==0, Not call AddListDataToMap and return 0" << std::endl;
        std::cout << "and need to delete listdata" << std::endl;
#endif
        delete ( plist_data ); plist_data=0;
        delete ( plist_volume ); plist_volume=0;
        // return 0
        return new_size;
    }
    //not sure the return value is needed, can be used in case of error in dates also
    //used by UpdateAllTimeScale, see UpdateCSVFromFile
#ifdef DEBUG_CPP
    std::cout << "End  ReadCSV, return new_size " << new_size << std::endl;
#endif
    // here new size read, not new size really added by AddListToMap, difficult to get
    PrintMapChrono();
    return new_size;
}

// only write CSV data, may extend later ?? could specialize for tmscl dcsv
// commented, few changes to make it work for dcsv.
// complex with indicator, see later with enum indicator
//int Stock::WriteIndicator(TimeScale tmscl, std::string dir, std::vector<std::string name_indic> list_indic)

// opt_name optional for unit_test, output directory ( tmp can be in the opt_name and replace the dir
// opt_name more general, keep it for writing

// strange behaviour to load the data if not already in memory ? should return 1, nothing done
// deleted this behaviour, was only for tests ?
void Stock::WriteCSV( const ETime tmscl, bool opt_tmp ) const throw (StockException)
{
#ifdef DEBUG_CPP
    std::cout << "\tWriteCSV" << std::endl;
    std::cout << "opt_tmp " << opt_tmp << std::endl; //opt_name "tmp"
#endif

    // file to output
    std::ofstream file;
    std::string filename;
    //for float or double or int or timescale to string
    std::stringstream ss (std::stringstream::in | std::stringstream::out);
    //std::ostream os;
    // for header, could use the same !
    std::ostringstream ss_header;

    assert( tmscl != ETime::not_a_time);

    // default
    if ( opt_tmp == false )
        filename = path + "/historical/"+ name +"."+ TimeScale::GetTimeScaleName(tmscl) + ".csv";
    // for test, output in a different directory to not overwrite
    else
        filename = path + "/historical_tmp/"+ name +"."+ TimeScale::GetTimeScaleName(tmscl) + ".csv";

#ifdef DEBUG_CPP
    std::cout << "write csv filename :" << filename << std::endl;
#endif

    // extend to DAY and INST
    ListDataStockBase *csv;

    // if not in memory, throw StockException
    if ( tmscl == ETime::INST) {
        if ( CheckLoaded( tmscl, Indicator::StockInst ) == false )
                throw StockException( name, "Indicator::StockInst for the timescale " + TimeScale::GetTimeScaleName(tmscl) + " is not loaded");

        csv = GetListData( tmscl, Indicator::StockInst );

    // all other case, CSV data
    } else {
        if ( CheckLoaded( tmscl, Indicator::StockCSV ) == false )
                throw StockException( name, "Indicator::StockCSV for the timescale " + TimeScale::GetTimeScaleName(tmscl) + " is not loaded");

        csv = GetListData( tmscl, Indicator::StockCSV );
    }

    // identical for volume
    ldata_volume *vol = dynamic_cast<ldata_volume *>( GetListData( tmscl, Indicator::Volume ) );

    // this is to put in define debug or assert
    if ( (!csv) or (!vol) ) {
        std::cout << "Error casting in write CSV csv !" << std::endl;
        throw StockException( name, "Error in getting the indicators pointers !!!");
    }

    //file.open ( filename.c_str() ); // default ios_base::out, start at beginning and overwrite the content
    file.open ( filename.c_str(), std::ios_base::out );
    // check correct
    if ( file.fail() ) {
#ifdef DEBUG_EXCEPT
            std::cout << "Stock::WriteCVS Opening failed, will throw exception StockFileError with a FileOpenError " << std::endl;
#endif
            throw StockFileError ( name, TimeScale::GetTimeScaleName(tmscl), Indicator::StockCSV.label(), FileOpenError( filename ) );
    }
    std::cout << "Stock::WriteCSV file opened, " << filename.c_str() << std::endl;

    // create header in stringstream, same for dcsv
    WriteLineHeader( tmscl, csv->GetDates(), ss_header );
    // write to file, line or stream
    file << ss_header.str() << std::endl;

    // NeedToForce the order, use NoChronologicAt() for CSV data, chronological for dcsv
    // INST convenient for python, real time can simply append the data, to keep
    for ( unsigned int i = 0; i < csv->GetSize(); ++i ) {

       // clear content before reuse
        ss.str("");
        // DAY and most non-chronologic
        if ( tmscl > ETime::INST ) {
            // new style with operator for data_csv, works well with stringstream
                //vol->NoChronologicAt(i) >> ( csv->NoChronologicAt(i) >> ss );
                ss << csv->NoChronologicAt(i) << vol->NoChronologicAt(i);

        // only INST, chronologic order
        } else {
            // new style operator <<
                //vol->ChronologicAt(i) >> ( csv->ChronologicAt(i) >> ss );
                ss << csv->ChronologicAt(i) << vol->ChronologicAt(i);
        }
        // write to file and check it is correct
        file << ss.str() << std::endl;
        if ( file.fail() ) {
                std::cout << "\n Failed in writing, big error, disk space ??" << std::endl;
                throw StockFileError( name, FileError ( filename, "Fail in writing into the file ! Disk space error ??") );
        }
        // or check only good at the end ?
    }
#ifdef DEBUG_CPP
    std::cout << "End Stock::WriteCSV" << std::endl;
#endif

    return;
}

// save file without loosing data, main point !
// empty List no point ? UpdateFromFile before or UpdateFromWeb (List at least exists)
//                       UpdateFromServer, same the last data are loaded
// if required, creates a tmp_stock with all data (+new data??) and writes all, tricky to combine ?
//              can read tmp_stock from first to lb->First(), and AddToList( this->List ) (will append, but no need to delete this->List after)
int Stock::SaveCSV ( const ETime tmscl, bool opt_tmp ) const
{
#ifdef DEBUG_CPP
        std::cout << "\n Stock::SaveCSV tmscl " << tmscl << std::endl;
        std::cout << "opt_tmp " << opt_tmp << std::endl;
#endif

        assert( tmscl != ETime::not_a_time);

        ListDataStockBase *lb;
        Utils::firstlast_dates dates_header = Utils::get_fldate_default();

        if ( tmscl == ETime::INST ) {
                lb = GetListData( tmscl, Indicator::StockInst );
        } else {
                lb = GetListData( tmscl, Indicator::StockCSV );
        }

        Read_HeaderCSV( tmscl, dates_header );
        /*
        std::cout << "First Time header " << Utils::Time_tToString( dates_header.first ) << std::endl;
        std::cout << "Last  Time header " << Utils::Time_tToString( dates_header.last ) << std::endl;
        */

        // if loaded in memory, need to be sure all data are present before overwriting the file
        // should be called by UpdateParserFromWeb (DAY)
        // or general before closing (? not really)
        if ( lb == nullptr ) {
                std::cout << "List is not loaded in memory, nothing to do, return -1" << std::endl;
                return -1;
        }

        // else if no new data to add, nothing to do
        // check size ? lb->GetSize() > 0
        /*
        std::cout << "List is loaded in memory " << std::endl;
        std::cout << "GetFirstTime " << Utils::Time_tToString( lb->GetFirstTime(), true ) << std::endl;
        std::cout << "LastUpdate() " << Utils::Time_tToString( lb->LastUpdate(), true ) << std::endl;
        */

        // if header == Last, nothing to do. UpdateFromServer to check (Progress DAY)
        // Progress DAY, need a general check, IsLastDataOver() ? Check with today ? Hour 00:00:00 ?
        if ( dates_header.last == lb->LastUpdate() ) {
#ifdef DEBUG_CPP
                std::cout << "Header is Up to date, return -1" << std::endl;
#endif
                return -1;
        }

        // possible Update, but a sub-range is loaded. but UpdateFromWeb return CANNOT_UPDATE,
        // HERE would need an other parameter, ListDataStock *to_add for this case

        // all in memory just write the data
        // Case UpdateFromWeb with DAY,
        // UpdateFromFile with INST no point, UpdateFromFile with DAY (no point also, file is up to date)
        if ( ( dates_header.first == lb->GetFirstTime() ) &&
                 ( dates_header.last <= lb->LastUpdate() ) ) {
#ifdef DEBUG_CPP
                std::cout << "Ok dates first== && last >, after an update can write and return" << std::endl;
#endif
                WriteCSV( tmscl, opt_tmp );
                return 0;
        }

        // case first data are missing in-memory, need a tmp_stock
        // Case UpdateFromWeb with DAY
        if ( ( dates_header.first < lb->GetFirstTime() ) &&
                 ( dates_header.last < lb->LastUpdate()   ) ) {
#ifdef DEBUG_CPP
                std::cout << "First dates are missing, need a tmp_stock trick ! " << std::endl;
#endif

                int status_ll, status_al;
                // tmp stock, will contain missing and new values
                Stock *tmp_stock = new Stock( name );

                // read only the missing data from file
                dates_header.last = lb->GetFirstTime();

                //Load all first missing data in lb
                if ( tmscl >= ETime::M5 )
                        status_ll = tmp_stock->LoadListData ( tmscl, Indicator::StockCSV, std::vector<int>{}, dates_header );
                else
                        status_ll = tmp_stock->LoadListData ( tmscl, Indicator::StockInst, std::vector<int>{}, dates_header );

                if ( status_ll ) {
                        std::cout << "Error in loading data in tmp_stock, return -1" << std::endl;
                        return -1;
                }
                //std::cout << "Before Adding new data" << std::endl;
                //tmp_stock->PrintMapChrono(1);

                // Update INST or DAY data, sure Order is correct here ?
                if ( tmscl >= ETime::M5 )
                        status_al = tmp_stock->AddListDataToMap( tmscl, GetListData( tmscl, Indicator::StockCSV ) );
                else
                        status_al = tmp_stock->AddListDataToMap( tmscl, GetListData( tmscl, Indicator::StockInst ) );
                /*
                if ( status_al != 1 ) {
                        std::cout << "Stock::SaveCSV expects always an update " << std::endl;
                }*/
                assert (status_al == 1);

                // for all timescale Volume
                status_al = tmp_stock->AddListDataToMap( tmscl, GetListData( tmscl, Indicator::Volume ) );
                /*
                if ( status_al != 1 ) {
                        std::cout << "Stock::SaveCSV expects always an update " << std::endl;
                }*/
                assert (status_al == 1);

                //std::cout << "After Adding new data" << std::endl;
                //tmp_stock->PrintMapChrono(1);
                tmp_stock->WriteCSV( tmscl, opt_tmp );

                // delete tmp_stock after writing all data
                delete tmp_stock; tmp_stock = nullptr;

        }
        return 0;
}

// Read only the first line, and then close the file.
// Could be static, called from outside and send back explicitly all info, to see from GUI
// Made Read_HeaderCSV_static, to replace this function
//
// return value to delete ? now Exception
// ?? optional ifstream, if empty open and close
// To be static need to add the name of the stock (and the path) makes sense ? yes if stock is not needed
// At the moment only called by TransDateBox, now more but all in Stock (wrap construct object only for calling this function)
int Stock::Read_HeaderCSV( ETime tmscl, Utils::firstlast_dates & dates ) const
   throw ( StockFileError )
{
#ifdef DEBUG_CPP
  std::cout << "Read_HeaderCSV version with timescale " << std::endl;
#endif
  std::string filename;
  std::string line;
  
  // all in one directory now
  filename = path + "/historical/"+ name +"."+ TimeScale::GetTimeScaleName(tmscl) + ".csv";
 #ifdef DEBUG_CPP
  std::cout << "read filename " << filename << std::endl;
 #endif

  // default, read normally
  std::ifstream file( filename.c_str() );
  if ( file.fail() ) {
#ifdef DEBUG_EXCEPT
        std::cout << "Opening failed, will create and throw a StockFileError " << std::endl;
#endif
        throw StockFileError ( name, TimeScale::GetTimeScaleName(tmscl), Indicator::StockCSV.label(), FileOpenError ( filename) );
  }
  // maybe a return value or exception ?? to check
  std::getline( file, line );
  // move logic of reading data in one function, can deal with version
  ReadLineHeader( line, dates );
  // file close out of scope
  return 0;
}

// static version for test, use Utils::PATH_DATA may be an argument
int Stock::Read_HeaderCSV_static( std::string namestock, ETime tmscl, Utils::firstlast_dates & dates )
        throw ( StockFileError )
{
#ifdef DEBUG_CPP
  std::cout << "Read_HeaderCSV_static " << std::endl;
#endif
  std::string filename;
  std::string line;

  // all in one directory now
  filename = Utils::GetPathData() + "/historical/"+ namestock +"."+ TimeScale::GetTimeScaleName(tmscl) + ".csv";
 #ifdef DEBUG_CPP
  std::cout << "read filename " << filename << std::endl;
 #endif

  // default, read normally
  std::ifstream file( filename.c_str() );
  if ( file.fail() ) {
#ifdef DEBUG_EXCEPT
        std::cout << "Opening failed, will create and throw a StockFileError " << std::endl;
#endif
        throw StockFileError ( namestock, TimeScale::GetTimeScaleName(tmscl), Indicator::StockCSV.label(), FileOpenError ( filename) );
  }
  // maybe a return value or exception ?? to check
  std::getline( file, line );

  // move logic of reading data in one function, can deal with version
  // need to be static as well
  ReadLineHeader( line, dates );


  // file close out of scope
  return 0;
}


int Stock::UpdateCSV_Inst( std::string namestock, DataStock& inst_value, DataStock& inst_volume, ETime tmscl, bool opt_tmp )
    throw ( StockFileError )
{
        // file to output, open a new file return fail
        std::fstream file;
        // if ofstream open creates a new file
        //std::ofstream file;
        std::string filename;
        std::string line;
        Utils::firstlast_dates dates_header = Utils::get_fldate_default();
        Utils::firstlast_dates dates_data = Utils::get_fldate_default();
        // default false, set to true if fail in opening
        bool new_file = false;
        //for float or double or int or timescale to string, in/out important for formatting (align right !!)
        std::stringstream ss (std::stringstream::in | std::stringstream::out);
        // for header
        std::ostringstream ss_header;

        assert( tmscl != ETime::not_a_time);
        assert( tmscl == ETime::INST );

        // default
        if ( opt_tmp == false )
                filename = Utils::GetPathData() + "/historical/"+ namestock +"."+ TimeScale::GetTimeScaleName(tmscl) + ".csv";
        // for test, output in a different directory to not overwrite
        else
                filename = Utils::GetPathData() + "/historical_tmp/"+ namestock +"."+ TimeScale::GetTimeScaleName(tmscl) + ".csv";

#ifdef DEBUG_CPP
        std::cout << "update csv INST filename :" << filename << std::endl;
#endif

        // open for reading / writing, and will create if necessary.
        file.open ( filename.c_str() );
        if ( !file.is_open() ) {
                // to create a new file, need trunc flag as well
                file.open ( filename.c_str(), std::ios_base::in | std::ios_base::out | std::ios_base::trunc );
                assert ( file.good() == true );
                new_file = true;
        }

        // default dates from the data
        dates_data.first = inst_value.GetDate();
        dates_data.last = inst_value.GetDate();

    // create the file, write header and data
        if ( new_file ) {
                // create header in stringstream, same for dcsv
                WriteLineHeader( tmscl, dates_data, ss_header );
                // write to file, line or stream
                file << ss_header.str() << std::endl;
                // write values
                ss << inst_value << inst_volume << std::endl;
                file << ss.str();

        // append data to file and modify the header
        } else {
                // read the first line: header, check if file empty (should not exist and be empty)
                std::getline( file, line );
                // test correct, not empty
                if ( file.fail() ) {
        #ifdef DEBUG_CPP
                std::cout << "Get first line failed, throw exception " << std::endl;
        #endif
                        throw StockFileError ( namestock, TimeScale::GetTimeScaleName(tmscl), Indicator::StockCSV.label(), FileEmptyError( filename ) );
                }

                // return 0 ok, or error
                if ( ReadLineHeader( line, dates_header ) ) {
#ifdef DEBUG_CPP
                        std::cout << "Error return from ReadLineHeader " << std::endl;
#endif
                    // Read Error exception, header is line 1
                throw StockFileError ( namestock, TimeScale::GetTimeScaleName(tmscl), Indicator::StockCSV.label(),
                        FileReadError( filename, 1 ) );
            }

                // Check no simple mistakes in the update, return -1 if dates are identical
                // Check here on in python ?? python should decide to write or not, but can add simple test
                dates_data.first = dates_header.first;
                if ( dates_header.last > dates_data.last ) {
                        std::cout << "Error Stock::UpdateCSV_Inst dates are wrong " << std::endl;
                        return -1;
                }

                if ( dates_header.last == dates_data.last ) {
                        std::cout << "Warning Stock::UpdateCSV_Inst dates last identical with present in header!!!" << std::endl;
                        return -1;
                }

                // erase header at the beginning of the file
                file.seekg(0, std::ios::beg);
                WriteLineHeader( tmscl, dates_data, ss_header );
                file << ss_header.str();
                // append data at the end of the file
                file.seekg(0, std::ios::end);
                ss.str("");
                ss << inst_value << inst_volume << std::endl;
                file << ss.str();
        }

        return 0;
}

// long int better for python, correct for C++ but not good for internal, changed in wrapper

// indicator not really needed(parameter missing), apply only StockCSV DAY or INST, deleted
//
// may keep an option force to load, convenient for other Updates functions
//
// If only ReadHeader, no point...  call Read_HeaderCSV, but Header may not be up to date
// If can read in memory and in header better
// maybe good point compared to ReaderHeader_CSV, can check in-memory in-file consistency...
//

// This logic applies to SaveTimeScale (saving data to file), not for update
// Check than last date in header < in-memory : Means a sub-part of the list has been loaded.\n
// Cannot make any update !! return 0 ? Could have an explicit Error return, user should know why
// Exception will stop the process
// Same for first date, can update but may he problem to save the file. An other problem for write!

// FILE is up-to-date !!
// Wrong can update from file from the last in-memory ! will read more data that's all !
// Same with first date, will be still missing in-memory, but file is OK.
// It is what the user expects ? Maybe not, but should not done automatically or GUI message before running
//
// last = Header last
// If in memory get last from it
// else If load_list == true load the file, and get date from the data
//
//

// To delete, Read_Header when needed, Load by default ? really useful ?
//time_t Stock::LastCSVUpdate(ETime tmscl, Indicator indic) throw(StockException)
/*
time_t Stock::LastCSVUpdate(ETime tmscl, bool load_list ) throw(StockException)
{
#ifdef DEBUG_CPP
        std::cout << "LastCSVUpdate tmscl " << tmscl << std::endl;
#endif
    //int status;
    time_t last_time = (time_t)0;
    time_t last_time_memory = (time_t)0;

    // should not happen, or correctly return 0
    //assert ( ( (tmscl == ETime::DAY ) || ( tmscl == ETime::INST ) ) == true );
    if ( ( (tmscl == ETime::DAY ) || ( tmscl == ETime::INST ) ) == false ) {
        std::cout << "Error tmscl is not valid " << tmscl << std::endl;
        return 0;
    }

    Utils::firstlast_dates fldates_header;
    //Utils::firstlast_dates fldates_memory_dm = Utils::get_fldate_default();

    try {
        Read_HeaderCSV ( tmscl, fldates_header );
        last_time = fldates_header.last;
    } catch ( StockFileError & e){
        std::cout << "Stock::LastCSVUpdate caught StockFileError " << std::endl;
        //throw StockException( e );
        throw;
    }

    // make indicator here, maybe later extend to other indicators ??
    Indicator indic = Indicator::Null;
    if ( tmscl == ETime::INST )
        indic = Indicator::StockInst;
    else
        indic = Indicator::StockCSV;

    // if data in memory, load_list has no effect
    if ( CheckLoaded( tmscl, indic) ) {
        // date from data member
        //fldates_memory_dm = GetListData( tmscl, indic )->GetDates();
        // use from data rather
        last_time_memory = GetListData( tmscl, indic )->LastUpdate();
        // ok works
        if ( last_time > last_time_memory ) {
                // ok pass existing unit-tests
                std::cout << "\nERROR Stock::LastCSVUpdate last header > last memory, cannot proceed to an update \n" << std::endl;
                //exit(1);
                return 0;
        }
        last_time = last_time_memory;

    // force to load the data in memory
    } else if ( load_list ) {

        try {
                // here date header and memory are identical for sure
            LoadListData(tmscl,indic);
            assert ( last_time == GetListData( tmscl, indic )->LastUpdate() );
            //fldates_memory_dm = GetListData( tmscl, indic )->GetDates();
            last_time = GetListData( tmscl, indic )->LastUpdate();
        } catch (StockException & e) {
            throw;
            // ok, pass existing unit-tests
            if ( last_time != fldates_header.last ) {
                std::cout << "\nERROR Stock::LastCSVUpdate\n" << std::endl;
                exit(1);
            }
        }
    }
    // else do nothing and last from header

#ifdef DEBUG_CPP
    std::cout << "Stock::LastCSVUpdate From header " << Utils::Time_tToString ( fldates_header.last , true ) << std::endl;
    //std::cout << "From memory data member " << Utils::Time_tToString ( fldates_memory_dm.last, true ) << std::endl;
    std::cout << "Stock::LastCSVUpdate From header or memory return last " << Utils::Time_tToString ( last_time, true ) << std::endl;
#endif
    // from header, or if present, in-memory
    return last_time;

    // original implementation, force to load the data
    // if not available yet, load from disk by default ! what we want ??
    if ( !CheckLoaded(tmscl,indic) ) {
        std::cout << "Stock::LastCSVUpdate force to load data tmscl " << GetTimeScaleName(tmscl) << " " << indic.label() << std::endl;
        //status = LoadListData(tmscl,indic);
        // exception not needed, will throw the exception anyway "!
        //try {
        LoadListData(tmscl,indic);
        //} catch (StockException & e) {
        //      throw;
        //}
    }
    //now loaded, keep base and use virtual
    ListDataStockBase *ldata = GetListData( tmscl, indic );
    last_time = ldata->LastUpdate();
#ifdef DEBUG_CPP
    std::cout << "Stock::LastCSVUpdate last_time = " << last_time << std::endl;
#endif
    return last_time;
}
*/


// call by StockManger when a new TCP message has been received
// to Inform than new data have been provided ( Inst now, later can be csv as well )
// Call UpdateAllTimeScale, specifying the data must not been read from file.
// All other indicator update, recomputation similar
void Stock::Updated( const ETime tmscl )
{
#ifdef DEBUG_CPP
  std::cout << "Entry Stock::Updated tmscl " << tmscl << std::endl;
  std::cout << "(TimeScale) dcsv: " <<  ETime::INST << std::endl;
  std::cout << "(TimeScale) M5: " << ETime::M5 << std::endl;
#endif

  assert( tmscl != ETime::not_a_time);

  ETime tmscl_to_update;
  // no used need only the argument
  Utils::firstlast_dates tmp_date= Utils::get_fldate_default();

  if ( tmscl < ETime::DAY ) {

#ifdef DEBUG_CPP
      std::cout << "Need to update all indic between INST and H1" << std::endl;
#endif

      // loop over the timescale and check it is in memory
      for ( unsigned int i= as_uint(ETime::M5); i < as_uint(ETime::DAY); ++i ) {

          // alternative, http://stackoverflow.com/questions/261963/c-iterate-through-an-enum
          tmscl_to_update = static_cast<ETime>( i );//i; //static_cast<ETime>( i );
          std::cout << "tmscl_to_update " << as_uint(tmscl_to_update) << std::endl;

          // test if entry tmscl exists, not working ??
          //if ( GetItMap( tmscl_to_update ) != mapTime_ListData.end() ) {
          if ( mapTime_ListData.find( tmscl_to_update ) != mapTime_ListData.end() ) {
              // update all indicator at this specific timescale
              UpdateAllTimeScale( tmscl_to_update, tmp_date, false );

          } 
          /* else {
              std::cout << "Stock::Updated this indicator is not loaded " << std::endl;
          } */
      }
  } else {
      std::cout << "\n Need to update all indic between DAY and year not implemented yet \n" << std::endl;
  }

}

// Update all ListDataStock of the given TimeScale.
//
// Problem reading of the file by default, not needed if update from TCPServer.
// Need optional argument b_readfile or make a check with the date ( dates may be good ).
// or split in 2 functions but not so clear..
// Advantage in 1 function use b_readfile
//
//
// Both of theses function call LastCSVUpdate:
// If StockCSV and tmscl >= DAY
//   call on UpdateCSVFromParser( "Yahoo" ) and Transform_TimeScale
// StockCSV and tmsc < DAY
//   UpdateCSVFromFile ( Indicator::StockInst, dcsv ) and Transform_TimeScale
//
//
//
// Case StockInst not taken into account: no need ? at least CSV 5mn...
//
//  UpdateCSVFromParser, read header
//    download data from Yahoo from last_day to today, add to ListDataStock and write into file
//
//  UpdateCSVFromFile, only readCSV ( dcsv in this case ).
//    This file is kept up to date only by real time
//
// loop over all the map entry.
// only use python Yahoo_CSV class at the moment.
//
// todo : call to bourso ?? partly done within RealTime ?
// return size of ListData StockCSV, the largest one, not implemented.
//
// b_readfile : allow to check for update from file or from web
//              if false (as used now) only recompute TA indicator in memory, for sure more efficient !
//
// useful to get exception from this call, action from GUI to catch
// maybe more work to get the exception (From PyWrapper), but could create them here

// only called by Updated with b_readfile to false (apply only to Inst up to now)
// ok, go it, it is now used to only recompute TA indicators
// (StockInst updated by Server, DAY updated by direct call to UpdateFromParser) name is wrong ! or use is wrong !
// ReadCSV throw exception, should specify here (rules: no or all)

// maybe not bad to have bool argument: b_update_from_file, b_update_from_web
// if server, normally need UpdateFromWeb only once a DAY, not regularly for DAY
//            got INST value regularly, must recompute TA Indicators
// if no_server : Must UpdateFromFile regularly (INST) (ServerPortfolio running, server not running, no normal)
//                Must UpdateFromWeb only once a DAY (Later can replace server with call to Bourso if ServerPortfolio is not running)
//
// option : b_update_by_server b_server running
// or send the data (INST, DAY?) if server is running (got from the queue)
void Stock::UpdateAllTimeScale( ETime tmscl, Utils::firstlast_dates opt_dates, bool b_readfile )
{
#ifdef DEBUG_CPP
    std::cout << "\n\t Entry Stock::UpdateAllTimeScale: " << tmscl << std::endl;
    std::cout << "opt_dates first/last " << opt_dates.last << std::endl;
#endif

    // get the list of this timescale
    it_map it_m = mapTime_ListData.find( tmscl );
    // still need to test, return only an iterator
    // should be safe here
    /*
    if ( it_m == mapTime_ListData.end() ) {
        std::cout << "GetItMap is at the end in UpdateAllTimeScale, return " << std::endl;
        return; -1 for nothing has been done ?
    }*/

    // key tmscl does not exist, still continue and so can read files ! but next iteraotr will crash !

    // return value of ReadCSV when reading new data (file or Parser_Stock)
    unsigned int new_added_size = 0;
    //by default it is done, false if error or not new data in Stock
    bool recompute = true;
    // return value of Transform_TimeScale
    int status_tt;
    std::string name_indic;
    // make a list, for indicator to recompute (possible OpenMP)
    std::vector< std::string > vec_indic;

    // more useful if set full dates first/last for use with Yahoo, upload from introduction
    // and default value of now.
    if ( opt_dates.last == 0 ) {
        opt_dates.last = time ( NULL );
#ifdef DEBUG_CPP
        std::cout << "opt_date set up to now by call to time(NULL) " << std::endl;
#endif
    }

    // Loop over the ListData, treat StockCSV and Volume first.
    // Store other in vec_indic to recompute after the loop
    for ( it_listdata it_l = it_m->second.begin(); it_l != it_m->second.end() ; it_l++ ) {
        std::cout << " name listdata " << (*it_l)->GetName() << std::endl;
        name_indic = (*it_l)->GetName();

        // indicator present now in listdata as well
        if ( ( name_indic == "StockCSV" ) || ( name_indic == "StockInst") ) {

           // add option here, if already updated do not need to read the file
           // strange here, this function is called only by Updated ? b_readfile is set to false so never used

           // b_server is off, may be possible to update
           // more logic server_off && ServerPortfolio running
           if ( b_readfile ) {

#ifdef DEBUG_CPP
                std::cout << "b_readfile is true " << std::endl;
#endif
                // This should not be called regularly (For DAY), or quick check
                // if server off, can call Bourso to update INST later (case server off,ServerPortfolio not running)
            if ( tmscl >= ETime::DAY ) {
                std::cout << " UpdateCSV, Yahoo, data and volume " << std::endl;
                //call wrapper python, change return new_size of (already added) data, if null, nothing to transform

                // throw a specific exception here, problem with Network, with parsing...
                // not sure very useful call to Web now.
                try {
                    new_added_size = UpdateCSVFromWeb( "Yahoo", opt_dates );
                //} catch ( StockPythonException )
                } catch ( StockException & e ) {
                    std::cout << "Caught an exception " << std::endl;
                    // something to delete ? seems not ?
                    // rethrow
                    throw;
                }

            // If server off, but ServerPortfolio running, can read file regularly (INST)
            // For DAY, same for Progress DAY, consider INST is loaded
            } else {
                std::cout << " Update INST, (Bourso to do?) Read from file *dcsv " << std::endl;
                // first Update_dCSV, to check for the size
                new_added_size = UpdateCSVFromFile ( ETime::INST );
            }

            // strange check, should agree on the retour new_added_size
            // common check
            //if == 0 it is ok, nothing to add, -1 an error
            //if ( ( new_added_size == -1 ) || ( new_added_size == 0 ) ) {
            // UpdateFromFile will throw exception if problem, size 0 means nothing new found
            //       FromWeb return -1, change to return 0, need to implement throw Exceptino
            if ( new_added_size == 0 ) {
                //std::cout << " return Python new_added_size == " << new_added_size << std::endl;
                std::cout << "\n\t UpdateAllTimeScale returned new_added_size == 0" << new_added_size << std::endl;
                recompute = false;
                // better with continue, maybe other set to update, other indicator
                //break; //ok, goes out directly to recompute, but no need to recompute if error
                continue;
            }

           } //end if b_readfile


          // all cases want to recompute the correct TimeScale
          if ( ( tmscl != ETime::DAY ) && ( tmscl != ETime::INST ) ) {
#ifdef DEBUG_CPP
                std::cout << "Will call Transform_TimeScale tmscl= " << tmscl << std::endl;
#endif
                // should make a test, something new ? here or in Transform
                status_tt = Transform_TimeScale(  tmscl );
                // what to do here, no return value, no exception...
                if ( status_tt != 0 ) {
                        std::cout << "\nERROR in Stock::UpdateAllTimeScale in TransformTimeScale !!\n" << std::endl;
                }
          }
        } //end StockCSV or StockInst

        //Volume done with StockCSV or StockInst by default
        else if ( name_indic == "Volume")
            continue;

        //all other indicators, may add case later, to recompute after the update of stock and volume only
        // can be updated by server, so to recompute often (independent of other update before)
        // ca ncheck NeedComputeTA()
        else {
#ifdef DEBUG_CPP
            std::cout << "Add " << name_indic << " to the list of indicator to recompute " << std::endl;
#endif
            vec_indic.push_back( name_indic );
        }

        //} //end if b_readfile

    } //end loop over listdata

#ifdef DEBUG_CPP
    std::cout << "test to recompute other indicators, recompute: " << recompute << std::endl;
    //PrintMapChrono();
#endif

    // main point of the function, Update HistoricalData could be done apart
    if ( recompute ) {
        //loop over the indicator to recompute
        //could be threaded to speed up, TAlib thread-safe, to see later
        for ( unsigned int i=0; i< vec_indic.size(); i++ ) {
            //keep local variable for thread ??
            std::string name_ind;
            Indicator new_indic(Indicator::Null);
            std::vector< int > vec_param;

            name_ind = FullName::GetNameStock( vec_indic[i] );
            //std::cout << "name_ind " << name_ind << std::endl;
            // Set vec_param, just for test...
            new_indic.Set( vec_indic[i], vec_param );
            /*
            if ( vec_param.size() > 0 ) {
              std::cout << " Recompute " <<  name_ind << " indic " << new_indic << " first arg " << vec_param[0] << std::endl;
            }
            */
            std::cout << "ComputeTA to test for exception" << std::endl;
            ComputeTA( tmscl, vec_indic[i] );
            //std::cout << "End ComputeTA" << std::endl;

            //here special AddListDataToMap, need to replace all data,
            // or done in ComputeTA, better
        }
    } //end recompute
}


// Load last data from the filesystem
//  Called by UpdateAllTimescale()
// Call LastCSVUpdate
//  Was used when ServerPortfolio saved INST data to file. To check now with RealTime.
//
// ok for LastCSVUpdate, can get last date from file (with header), or from memory if available.
// in fact, a check in header info could be done before...
//
int Stock::UpdateCSVFromFile( const ETime tmscl )
{
    unsigned int new_size;
    // no need to initialize ? if error in ReadHeaderCSV ?
    Utils::firstlast_dates dates_header;
    // first is set to default, all data
    Utils::firstlast_dates dates_to_load = Utils::get_fldate_default();
    time_t last_in_memory = 0;

#ifdef DEBUG_CPP
    std::cout << "\n\t Entry Stock::UpdateCSVFromFile tmscl " << tmscl << std::endl;
#endif

    // assert for INST / DAY not really needed, may work on other if file exists !
    // throw exception if problem
    Read_HeaderCSV( tmscl, dates_header );
    //dates_to_load.last = dates_header.last;

    // could be avoid if parameter (as before)
    Indicator indic = Indicator::Null;
    if ( tmscl == ETime::INST )
        indic = Indicator::StockInst;
    else
        indic = Indicator::StockCSV;

    // if DAY Progress, may call intermediate rounding or test
    if ( CheckLoaded( tmscl, indic ) ) {
        last_in_memory = GetListData( tmscl, indic )->LastUpdate();
        dates_to_load.first = GetListData( tmscl, indic )->LastUpdate();
    }

    std::cout << "last in memory " << Utils::Time_tToString( last_in_memory, true) << std::endl;
    std::cout << "last header " << Utils::Time_tToString( dates_header.last, true) << std::endl;

    // return if not possible to update, already updated by server
    if ( last_in_memory > dates_header.last )
        return -1;

    // not in memory, read all
    new_size = ReadCSV( tmscl, dates_to_load );

#ifdef DEBUG_CPP
    std::cout << "UpdateCSVFromFile ReadCSV return new_size " << new_size << std::endl;
#endif
    return new_size;
}

// Stupid no point to read here !! already on disk, it is the logic for SaveTimeScale here !

// - if cannot(first or last), we can create a tmp_stock_update, empty, ReadAll, NO need to write(file is updated), Delete tmp
//              retrurn a code to say do not recompute TA in-memory, in-memory not updated, only file
// - if can, just call ReadCSV on this, return new_added data, recomputeTA

// call with opt_dates == update, can add check in ReadCSV
// original, always ReadCSV, even if it was in memory after LastCSVUpdate...
// ReadCSV will now check if new data available


// verbose is send directly to ListDataStock
void Stock::PrintMapChrono( const unsigned int verbose ) const
{
    std::cout << "===================\n\t ShowMap Stock Chrono " <<  GetName() << std::endl;
    std::cout << "Size " << mapTime_ListData.size() << std::endl;
    
    for( cit_map it_m = mapTime_ListData.begin(); it_m != mapTime_ListData.end(); it_m++) {

        std::cout << "timescale: " << it_m->first << std::endl;
        if ( (it_m->second).empty() ) {
            std::cout << "  list data defined and empty" << std::endl;
        }
        else if ( (it_m->second).size() > 0 ) {

            std::cout << "  list data defined, " << (it_m->second).size() << " pointeur on List " << std::endl;
            for( cit_listdata it_l= it_m->second.begin(); it_l !=it_m->second.end(); it_l++) {
                // call ListDataStock function
                std::cout << "\t========================" << std::endl;
                (*it_l)->PrintData( verbose );
            }
        }
        // done in ListDataStock now
        //else
        //    std::cout << "  list data with size == 0 " << std::endl;
    }
    std::cout << "\n" << std::endl;
    return;
}



/*
//before int, need to use !!
WaveletBase* Stock::ComputeWavelet( ETime tmscl ) //, std::string name_new_indic ) same problem as PatternRecognition...
{
    std::cout << "Entry Stock::ComputeWavelet, tmscl  " << tmscl << std::endl;

    //array of array for input, simpler pointer in this case
    double **arraydata_c_in = 0;
    //unsigned int size;

    //need to allocate first pointer first! reason of the bug !!
    arraydata_c_in = new double*[ 1 ];

    //need explicit ??
    //Indicator indic = Indicator::StockCSV;
    //by default get StockCSV, need dynamic_cast ?? why ??
    ListDataStock<DataCSV> *ldata = dynamic_cast< ListDataStock<DataCSV>* >(GetListData(tmscl,Indicator::StockCSV));
    // get close in double ??, need to allocate ??
    ldata->GetCArray( &(arraydata_c_in[0]), "Close");
    std::cout << " ldata->GetSize() " << ldata->GetSize() << std::endl;

    //should split creation, from computation, easier
    Haar *haar = new Haar( &(arraydata_c_in[0][0]), ldata->GetSize() );

    std::cout << " now compute Haar transform size " << haar->GetSize() << std::endl;
    //need size / 2 for recursive function
    //haar->Calc( haar->GetValues(), haar->GetSize()/2 );
    //add new interface
    haar->Transform();

    return haar;
}
*/