StockManager.cpp

Go to the documentation of this file.

#include "StockManager.h"

#include "TCPServer.h"
#include "SMSubject.h"
#include "Stock.h"
#include "ListDataStock.h"

// strange needed for TimeScale operator<<, otherwise does not compile
// happens because boost libraries ??
using namespace TimeScale;

// should make a namespace, this variable should not be called anyway
// could be in constructor / getInstance ??
// cannot make a namespace ?? unamed to try, should make test ...
bool StockManager::status_sm = false;
StockManager* StockManager::fstockmanager = 0; //NULL;
// to get a default value ?? not only, needed because static
std::string StockManager::fpath = ".";

TCPServer * StockManager::ftcp = 0;
SMSubject * StockManager::fsubject = 0;


StockManager::~StockManager () 
{
 for (it_stock it_s = vec_stock.begin(); it_s != vec_stock.end(); it_s++)
     delete(*it_s);

 vec_stock.clear();
 status_sm = false;
 DesactivateServer();
 ftcp = 0;
 fstockmanager = 0;
#ifdef DEBUG_CPP
 std::cout << "Destructor StockManager" << std::endl;
#endif
}

StockManager* StockManager::getInstance( std::string new_path )
{
 if (status_sm) {
#ifdef DEBUG_CPP
    std::cout << "return already created fstockmanager " << fstockmanager << std::endl;
#endif

 } else {
    fstockmanager = new StockManager();
    status_sm = true;
    // stupid ?? no it is static...
    //StockManager::fpath = new_path;
    fpath = new_path;
#ifdef DEBUG_CPP
    std::cout << "new StockManager::getInstance set fpath " << fpath << std::endl;
#endif
    //by default server, but inactive ??
    //easy no server
    ftcp = 0;
    // by default observer pattern active
    fsubject = new SMSubject();
 }

 return fstockmanager;
}

void StockManager::killInstance()
{
 if (!status_sm) {
    //return fstockmanager;
#ifdef DEBUG_CPP
    std::cout << " StockManager::killInstance, but has not been run, nothing to do " << std::endl;
#endif
    return;
   }
 else {
#ifdef DEBUG_CPP
    std::cout << "Entry StockManager::killInstance( )" << std::endl;
#endif
    fpath.clear();
    delete ( fstockmanager );
    fstockmanager = 0;
    delete ( fsubject );
    fsubject = 0;

    // Should be in calling function, link ftcp to delete anyway
    if ( ftcp ) {
        //ftcp->StopServer(); //not necessary for valgrind
        delete ftcp;
        ftcp = 0;
    }
    // cannot call without object...
    //StockManager::DesactivateServer();

    status_sm = false;
 }
 return;
}

// cannot call erase with const iterator, try two version, need to not be const as well
StockManager::it_stock StockManager::GetItStock ( const std::string& namestock )
{
#ifdef DEBUG_CPP
  std::cout << "Entry StockManager::GetItStock namestock " << namestock << std::endl;
#endif

  it_stock it_s;
  for ( it_s = vec_stock.begin(); it_s != vec_stock.end(); it_s++) {
      std::cout << (*it_s)->GetName() << std::endl;
      if ( (*it_s)->GetName() == namestock )
          return it_s;
  }
  return it_s;
}

StockManager::cit_stock StockManager::GetItStock ( const std::string& namestock ) const
{
#ifdef DEBUG_CPP
  std::cout << "Entry StockManager::GetItStock namestock " << namestock << std::endl;
#endif

  cit_stock it_s;
  for ( it_s = vec_stock.cbegin(); it_s != vec_stock.cend(); it_s++) {
      std::cout << (*it_s)->GetName() << std::endl;
      if ( (*it_s)->GetName() == namestock )
          return it_s;
  }
  return it_s;
}


// do not check if already existing, private ok
void StockManager::InsertVec_Stock ( Stock * stock )
{
 //add to vector list of StockManager
 vec_stock.push_back( stock );
}


bool StockManager::ActivateServer()
{
#ifdef DEBUG_CPP
        std::cout << "Entry StockManager::ActivateServer()" << std::endl;
#endif

  if ( ftcp == 0 ) {
      std::cout << "Will create a new TCPServer" << std::endl;
      //ftcp = new TCPServer( this, 9998 );
      
  } else
      std::cout << "StockManager::ActivateServer already activated" << std::endl;
  
  return true;
}

bool StockManager::DesactivateServer()
{
#ifdef DEBUG_CPP
        std::cout << "Entry StockManager::DesactivateServer()" << std::endl;
#endif
  // commented, but still double free, nothing to see it was garbage
  // still something missing
  if ( ftcp != 0 ) {
          std::cout << "Will delete the TCPServer " << std::endl;
      delete ftcp;
      ftcp = 0;  
  } else  
      std::cout << "StockManager::DesactivateServer was not activated !" << std::endl;

  return true;
}

// Called by TCPServer, which sends the new data by string.
//
//  Problem, how to notify GUI from here:
//    - A ( optional ) pointer to GUI or MainGUIController, strong coupling GUI and ROOT classes.
//    - A mediator pattern : Mediator_gui, need only class Mediator;
//           StockManager refer to Mediator only and call mediator->StockUpdated( option )
//           // mediator need GUI/MainController.h in//cpp, so coupling again
//           Mediator has a pointer to GUI or MainGUIController and call gui->Update( option )
//
//    - An observer pattern : ++ more decoupling, run-time registration.
//                            -- complex, need class to derive from Subject and Observer
//            Powerfull, but necessary here ???
//            Can try to use only the necessary part of it, but maybe later need a full implementation
//            see template approach for Observer http://accu.org/index.php/journals/308
//
//            Seems the best solution, if general could be applied with gui_app or other...,
//            whenever StockManager needs to send a signal ( after any computation in fact, good for threading )
//            StockManager is Subject/Observable
//            gui is an Observer it must register to be informed, easy because StockManager is singleton !
//
//    - Just need derivation for decoupling ?? and/or registration ?? so full pattern !
//            can optional in this way, not a bad idea !
//            alternative StockManager has an object Subject/Observable and send to this object the update
//
//   link to observer pattern :
//   http://www.oodesign.com/observer-pattern.html
//   see template approach for Observer http://accu.org/index.php/journals/308
//
void StockManager::SendDatadCSV( const std::string& message ) throw (StockException)
{
#ifdef DEBUG_CPP
  std::cout << "StockManager::SendDatadCSV message " << message << std::endl;
#endif
  
  std::string namestock;
  std::vector<std::string> line_split, messages_str;
  time_t tmp_date;
  SimpleData sp_data, sp_vol;
  Stock * stock;

  ListDataStockBase *list_dcsv;
  //ldata_volume *list_single;
  ListDataStockBase *list_single, *list_single_vol;

  // split message by comma
  Utils::splitline ( message, ",", line_split );

  // Nothing to delete here, can exit without problem
  // check size after split , always 4 for instantaneous data
  if ( line_split.size() != 4 )
          throw StockException( namestock, "StockManager::SendDatadCSV missing field in message : "+message);

  // Extract namestock
  namestock = line_split[0];

  // Extract date
  tmp_date = Utils::StringToTime_t( line_split[1] );
  if ( tmp_date == Utils::ERROR_StrToTime ) {
          throw StockException( namestock, "StockManager::SendDatadCSV error in parsing date from TCPServer message : "+message);
  }


  // If value is missing set value to 0, no exception generated. better to test the size
  sp_data.SetData( tmp_date, Utils::fromString<type_value_data>(line_split[2]) );
  sp_vol.SetData( tmp_date, Utils::fromString<type_value_data>(line_split[3]) );

  sp_data.PrintData( 3 );
  sp_vol.PrintData( 3 );

  // to check exists !
  it_stock it = GetItStock ( namestock );

  if ( it != vec_stock.end() ) {
      //std::cout << "found it_stock " << std::endl;
      // Get the stock and the list
      stock = *it;

      // no need to test if use stock AddListDataToMap, no need to load list_dcsv ??
      // test, because do not want to create a new entry in stock
      list_dcsv = stock->GetListData( ETime::INST, Indicator::StockInst );
      if ( list_dcsv == 0 ) {
#ifdef DEBUG_CPP
          std::cout << "namestock " << namestock << " not loaded return " << std::endl;
#endif
          return;
      }

      // update the list, tricky directly, better to create a list_single
      list_single = new ldata_volume( "StockInst", ETime::INST, 1 );
      // here only one, no problem of order
      list_single->AddData( sp_data );
      // get dates from the data
      list_single->SetDates();

      // general function to call, maybe general call from Stock is better, safer...
      // need to test if delete, should be always called
      if ( stock->AddListDataToMap( ETime::INST, list_single ) == 1 ) {
          delete list_single; list_single = 0;
      }
      //same for volume
      list_single_vol =  new ldata_volume( "Volume", ETime::INST, 1 );
      list_single_vol->AddData( sp_vol );
      list_single_vol->SetDates();
      // need to test if need to be deleted
      if ( stock->AddListDataToMap( ETime::INST, list_single_vol ) == 1 ) {
          delete list_single_vol; list_single_vol = 0;
      }

#ifdef DEBUG_CPP
      std::cout << "\nEnd AddListDataToMap, so need to update" << std::endl;
#endif
      // better in Stock. independent, will call UpdateAllTimeScale
      // should assure than related indicator are updated
      // a different thread may be good here, or even before.
      stock->Updated ( ETime::INST );

      // if threaded here wait for the end join ??

      // can broadcast to observers than data changed
      // need to add argument... namestock / TimeScale ??
      // if threaded update, should wait the update is done
#ifdef DEBUG_CPP
      fstockmanager->PrintMap();
#endif
      // add data about the update
      // all indicators have been update, frame_name is possible
      // ok only dcsv updated, but influence all, even DAY, WEEK, MONTH...
      // namestock is needed
      messages_str.push_back("update_dcsv"); //action
      messages_str.push_back(namestock);
      fstockmanager->GetSubject()->Updated( messages_str );

  // by default do not create a new stock if not already loaded, maybe easily changed
  // Should be exception ?? not realyy
  } else {
#ifdef DEBUG_CPP
      std::cout << " it_stock not found ! return !" << std::endl;
#endif
      return;
  }
  return; 
}

//keep only name for getting Stock, this stock will contain all variant: time and indicator.
Stock * StockManager::Find( const std::string & namestock ) const
{
  cit_stock it_s;
  for (it_s = vec_stock.cbegin(); it_s != vec_stock.cend(); it_s++) {
          if ( (*it_s)->GetName() == namestock )
                  return *it_s;
  }
#ifdef DEBUG_CPP
 std::cout << "StockManager did not find " << namestock << std::endl;
#endif
 return nullptr;
}

// here only GetListData throw exception
ListDataStockBase * StockManager::GetListData ( const std::string& fullname ) const throw(StockException)
{
#ifdef DEBUG_CPP
  std::cout << "Entry in StockManager::GetListData " << fullname << std::endl;
#endif

  Stock *stock= nullptr;
  ListDataStockBase* listdata = nullptr;

  stock = Find ( FullName::GetNameStock( fullname ) );
  //std::cout << "pointer stock " << stock << std::endl;
  if ( stock ) {
      //std::cout << "found stock" << std::endl;
      //std::cout << FullName::GetTimeScale( fullname ) << " " << FullName::GetShortName( fullname ) << std::endl;
      listdata = stock->GetListData ( FullName::GetTimeScale( fullname ), FullName::GetShortName( fullname ) );
      // throw exception now ?? to check !
      //if ( listdata )
      //std::cout << "StockManager::GetListData ldata size " << listdata->GetSize() << std::endl;
      return listdata;
  }

  // Find does not send exception, but GetListData will do
  // want a stock exception send from here ?? makes sense
#ifdef DEBUG_CPP
  std::cout << "\n\tNot found in StockManager::GetListData return 0" << std::endl;
#endif
  return nullptr;
}

// not reference for namestock, test "CAC40" need to cast char * to std::string
Stock * StockManager::Load ( const std::string namestock , const ETime& tmscl, const Indicator& indic,
                std::vector< int > param, Utils::firstlast_dates dates ) throw(StockException)
{
  //if error in reading, we can delete the newly added stock, else keep existing (if DAY is ok, but dcsv is missing)
  // why not to be sure it is correct ?
  bool new_added = false;
  Stock * stock;

  // from Stock, not really logic, separate indic param or use short_name ?? redundant
  std::string short_name = ShortName::MakeShortName( indic, param);
  std::cout << "\n timescale " << tmscl;

#ifdef DEBUG_CPP
  std::cout << "\n\tStockManager::Load name " << namestock << " short_name " << short_name << std::endl;
  // do not compile here ??
  //std::cout << "\n timescale " << tmscl;
  //std::cout << " fpath " << fpath << std::endl;
  std::cout << " first date " << dates.first << " last_date " << dates.last << std :: endl;
#endif

  stock = Find ( namestock );

  // it does not exist, create a new one
  if ( !stock ) {
#ifdef DEBUG_CPP
     std::cout << "Stock " << namestock << " not loaded, Make a new stock and insert in Vec" << std::endl;
#endif
     stock = new Stock ( namestock, namestock, fpath );
     InsertVec_Stock ( stock );
     new_added = true;
     //std::cout << "StockManager after InsertVec_Stock size " << vec_stock.size() << std::endl;
  }
#ifdef DEBUG_CPP
  else
    std::cout << "Stock " << namestock << " already exists in StockManager" << std::endl;
#endif

  // Test if the indicator is already loaded
  if ( stock->CheckLoaded ( tmscl, short_name ) ) {
     //std::cout << "StockManager::Load Data for stock " << namestock << " data " << tmscl << " " << short_name << " already loaded " << std::endl;
     return stock;
  }
  //std::cout << " StockManager::Load Need to create and load a new ListDataStock " << tmscl << " " << short_name << std::endl;

  // here catch, because nay need to delete the stock object
  try {
      stock->LoadListData ( tmscl, indic, param, dates );
      // here wait for StockException get the Error file but downgrad !!
      // it receives a FileError or TALibError or other...
      // to check
  } catch ( const StockException & e ) {
#ifdef DEBUG_CPP
      std::cout << "\nStockManager got a StockException" << std::endl;
      std::cout << "with message " << e.what() << std::endl;
      std::cout << "will rethrow" << std::endl;
#endif
      // clean before throwing the error
      if ( new_added ) {
#ifdef DEBUG_CPP
           std::cout << "Delete local copy of stock in StockManager::Load" << std::endl;
#endif
           DeleteStock ( namestock );
      }
      // rethrow the StockException
      throw;
  }
  //stock->PrintMap();
#ifdef DEBUG_CPP
  std::cout << "\tStockManager::Load  retour of Stock::LoadListData " << std::endl; //<< retour << "\n" << std::endl;
#endif

  return stock;
}

// used from GUI, inserting a new stock
// should check if already exists, not done in InsertVec_Stock
// convenient function, allow to create the stock, check dates (like in GUI)
// what so ever and insert after,
// how to report error ? status ? exception ? exception is better
int StockManager::AddStock ( Stock *stock ) //throw (StockException)
{
  // to check if already in vec_stock
#ifdef DEBUG_CPP
  std::cout << "Entry AddStock name " << stock->GetName() << std::endl;
  std::cout << "Stock name " << stock->GetName() << std::endl;
#endif
  std::string stockname = stock->GetName();
  // works, what to do
  Stock *prev_stock = Find( stockname );

  // if not existing create a new one
  if ( prev_stock == nullptr ) {
#ifdef DEBUG_CPP
          std::cout << "Stock did not exist, insert it as a new one " << std::endl;
#endif
          InsertVec_Stock ( stock );
          return 0;
  } else {
          //throw( StockException( stockname, "Error in StockManager::AddStock, the stock already exists: "+stockname+" !!") );
          prev_stock->MergeStock( stock, true );
  }
  return 0;
}

// All delete are mainly wrapper to Stock delete function
// Should check if Stock is empty, and then delete Stock
// Except for StockCSV/dCSV, may stay in memory from GUI because loaded by default

// check if stock is empty and delete it, fname is fullname
void StockManager::DeleteListData( const std::string & fname )
{
#ifdef DEBUG_CPP
  std::cout << " StockManager::DeleteListData " << fname << std::endl;
#endif
  std::string namestock = FullName::GetNameStock( fname );
  ETime tmscl = FullName::GetTimeScale ( fname );
  std::string shortname = FullName::GetShortName( fname );

  Stock *stock = Find ( namestock );

  // checks if map entry is valid, case double delete is fine for DeleteListData
  if ( stock )
          // case double delete is fine as well inside
      stock->DeleteListData( tmscl, shortname );
  else {
#ifdef DEBUG_CPP
      std::cout << "ERROR ?? StockManager::DeleteListData do not find stock, error ?? " << namestock << std::endl;
#endif
      return;
  }

#ifdef DEBUG_CPP
  std::cout << " StockManager::DeleteListData namestock " << stock->GetName(); //<< std::endl;
  std::cout << " shortname " << shortname << std::endl;
  std::cout << "stock after find " << stock << std::endl;
  //stock->PrintMapChrono();
#endif

  // if stock is empty delete it
#ifdef DEBUG_CPP
  std::cout << " Stock->Empty() " << stock->IsEmpty() << std::endl;
  //stock->PrintMapChrono();
#endif
  if ( stock->IsEmpty() ) {
      std::cout << " StockManager has an empty Stock " << stock->GetName() << std::endl;

      it_stock it_s = GetItStock ( namestock );
      if ( it_s == vec_stock.end() ) {
          std::cout << "Get last entry, stock has not been found in vec_stock, ERROR !! " << std::endl;
      }
      // delete entry in vector and object
      vec_stock.erase ( it_s );
      delete (stock);
      stock = 0;
  }
  //stock->PrintMap();
  //PrintMap();
}


void StockManager::DeleteAllListDataFromFrame ( const std::string& frame_name )
{
  std::cout << " StockManager::DeleteListDataFromFrame with frame_name " << frame_name << std::endl;
  std::string namestock = FrameName::GetNameStock( frame_name );
  ETime tmscl = FrameName::GetTimeScale( frame_name );
  DeleteAllListDataFromTimeScale ( namestock, tmscl );
}

void StockManager::DeleteAllListDataFromTimeScale ( const std::string& namestock, const ETime& tmscl)
{
#ifdef DEBUG_CPP
  std::cout << "Entry StockManager::DeleteAllListData from Timescale " << namestock << " tmscl " << tmscl << std::endl;
#endif

  //Could be replaced by iterator GetItStock
  Stock *stock = Find ( namestock );

  if ( stock == 0 ) {
#ifdef DEBUG_CPP
      std::cout << " Stock not found in StockManager::DeleteAllListData" << std::endl;
#endif
      return;
  }
  // call Stock function, check if map entry has to be deleted
  stock->DeleteAllListData ( tmscl );

  //check if vector stock need to be deleted
  //std::cout << "stock->IsEmpty() " << stock->IsEmpty() << std::endl;
  //stock->PrintMap();

  if ( stock->IsEmpty() ) {
#ifdef DEBUG_CPP
      std::cout << " StockManager has an empty Stock " << stock->GetName() << std::endl;
#endif

      it_stock it_s;
      it_s = GetItStock ( namestock );
      if ( it_s == vec_stock.end() ) {
          std::cout << "ERROR ! Get last entry, stock has not been found in vec_stock !!" << std::endl;
      }
      vec_stock.erase ( it_s );
      delete (stock);
      stock = 0;
  } else {
      std::cout << "ERROR in StockManager::DeleteAllListData, stock is not empty " << std::endl;
  }

}

void StockManager::DeleteStock ( std::string namestock )
{
  it_stock it_s;
  // with it_stock, not needed
  //Stock *stock = Find ( namestock );
 std::cout << "StockManager::DeleteStock " << namestock << std::endl;
 //std::cout << "StockManager::DeleteStock size of vec_stock " << vec_stock.size() << std::endl;

 for (it_s = vec_stock.begin(); it_s != vec_stock.end(); it_s++) {
      //std::cout << "loop over iterator" << std::endl;
      if ( (*it_s)->GetName() == namestock ) {
        // delete the map in Stock
        delete ( *it_s );
        //can remove from map here, because break
        vec_stock.erase ( it_s );
        //break;
        return;
      }
     // check if not found, not working here, never reach end()
     //if ( it_s == vec_stock.end() ) {
     //   std::cout << "Stock no found" << std::endl;
     //   return;
     //}
 //end loop for
 }

 // if here, stock not found
 std::cout << "\n\tStockManager::DeleteStock Stock no found" << namestock << "\n" << std::endl;
}

void StockManager::PrintMap() 
{
 std::cout << "===================\n\tShowMap Manager Stock" << std::endl;
 std::cout << "Size of StockManager " << vec_stock.size() << "\n" << std::endl;

 // printMap for each Stock
 for ( it_stock it_s = vec_stock.begin(); it_s != vec_stock.end(); it_s++) 
 {
     std::cout << "name stock " << (*it_s)->GetName() ; // << std::endl;
     std::cout << " symbol stock " << (*it_s)->GetSymbol() << std::endl;

     (*it_s)->PrintMapChrono();
 }

}