Utils.cpp

Go to the documentation of this file.

#include "Utils.h"

#include <ctime>
#include <cstring>

// for test time zone
/*
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
*/

namespace Utils
{
// better here, just move for test
//std::string PATH_DATA="/home/michael/workspace_kepler/ROOT_application/data";

// if static avoids bug valgrind with Python UpdateFromWeb ? Solve other bug (utils in lib and prog) ?
static std::string PATH_DATA="/home/michael/workspace_kepler/ROOT_application/data";
// set directory for tests, unit-tests
//static const std::string PATH_DATA_TEST="/home/michael/workspace_kepler/ROOT_application/data_test";
//static std::string PATH_DATA="/home/michael/workspace_kepler/ROOT_application/data_test";


//void SetPathData( const std::string& new_path ) {
void SetPathData( std::string new_path ) {
 Utils::PATH_DATA = new_path;
 //PATH_DATA = new_path;
}

std::string GetPathData() {return Utils::PATH_DATA;}

// inline makes sense here ? call in loop, always same array
double fromStreamToDouble( std::iostream& stream, char delim )
{
        char buf_value[31];
        stream.getline( buf_value, 30, delim );
        double t = std::atof(buf_value);
        //std::cout << "fromStreamToDouble value " << t << std::endl;
        return t;
}
// split a string into vectors of string.
// @param delimiters any string
//
void splitline(const std::string& str, const std::string& delimiters , std::vector<std::string>& tokens) {
// Skip delimiters at beginning.
  std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
  // Find first "non-delimiter"
  std::string::size_type pos     = str.find_first_of(delimiters, lastPos);

  while (std::string::npos != pos || std::string::npos != lastPos)
           {
                // Found a token, add it to the vector.
                tokens.push_back(str.substr(lastPos, pos - lastPos));
                // Skip delimiters.  Note the "not_of"
                lastPos = str.find_first_not_of(delimiters, pos);
                // Find next "non-delimiter"
                pos = str.find_first_of(delimiters, lastPos);
           }
}

// ok, working, print correct time
time_t GetTime_tToday()
  {
   time_t tmp_time = 0;
   time_t time_unix = 0;
   // original code, do not account for timezone, was working before modifs ??
   // before modif time is working ... with modifs -2 hours... to check
   tmp_time = time ( &time_unix );
   // localtime takes struct tm
   //tmp_time = localtime( &time_unix );
#ifdef DEBUG_UTIL
   std::cout << "GetTime_tToday get actual date " << tmp_time << std::endl;
#endif
   return tmp_time;
  }


// version C style, no care about timezone, no error valgrind
// strptime return nullptr if error, return an error code
//test C++11 thread-safe version of some functions
time_t StringToTime_t ( const std::string& str_date ) {

#ifdef DEBUG_UTIL
   std::cout << "Entry StringToTimeT str " << str_date << std::endl;
   std::cout << "Size String " << str_date.size() << std::endl;
#endif
   std::string date_string;
   // correct initalization of a structure C-style, solved valgrind error in previous version
   //struct tm date_tm;
   //memset( &date_tm, 0, sizeof(struct tm));
   // -1 important
   struct tm date_tm = {0, 0, 0, 0, 0, 0, 0, 0, -1 , 0, nullptr };

   // format output, C++11 put_time not working yet.
   // Here impose hour is present, maybe add a param as well
   char *p = nullptr;
   // read day and hour
   if ( str_date.size() == 19 ) {
           p = strptime ( str_date.c_str(),"%Y-%m-%d %H:%M:%S", &date_tm );
   // only day to read
   } else if ( str_date.size() == 10 ) {
           p = strptime ( str_date.c_str(),"%Y-%m-%d", &date_tm );
   }
   // if size not good, still nullptr, no need to ckeck
   // return a null pointer if an error occured
   if ( p == nullptr ) { //|| p == 0 ) {
           std::cout << "ERROR strptime " << std::endl;
           return Utils::ERROR_StrToTime; //Error code -105
   }
   return mktime( &date_tm );
}

time_t StringToTime_t ( const char * str ) {

#ifdef DEBUG_UTIL
   std::cout << "Entry StringToTimeT with char* str:" << str << std::endl;
   std::cout << "len of str " << strlen(str) << std::endl;
#endif

   size_t str_len =  strlen(str);
   // -1 important
   struct tm date_tm = {0, 0, 0, 0, 0, 0, 0, 0, -1 , 0, nullptr };

   // format output, C++11 put_time not working yet.
   // Here impose hour is present, maybe add a param as well
   char *p = nullptr;
   // read day and hour
   if ( str_len == 19 ) {
           p = strptime ( str,"%Y-%m-%d %H:%M:%S", &date_tm );
   // only day to read
   } else if ( str_len == 10 ) {
           p = strptime ( str,"%Y-%m-%d", &date_tm );
   }
   // if size not good, still nullptr, no need to ckeck
   // return a null pointer if an error occured
   if ( p == nullptr ) {
           std::cout << "ERROR strptime " << std::endl;
           return Utils::ERROR_StrToTime; //Error code -105
   }
   //std::cout << "return mktime " << mktime( &date_tm ) << std::endl;
   return mktime( &date_tm );
}

// here seems ok, localtime takes timezone into account
std::string Time_tToString ( const time_t& time, const bool b_hour )
{

   std::string date_string;
   char tmp_char[25];
   //tm timeinfo;

   struct tm *date_tm;
   // correct initalization of a structure C-style, not needed if using pointer ??
   // or will be set correctly with localtime function ??
   //memset( &date_tm, 0, sizeof(struct tm));

   // convert time_t to struct tm
   // seems a problem with valgrind, solved in glibc 2.14.1-4 only 2.13-2 available on ordi
   // localtime use info about time zone, time() no, and mktime certainly yes ??
   date_tm = localtime ( &time );

   // format the date
   if ( b_hour )
       strftime(tmp_char,25,"%Y-%m-%d %H:%M:%S",date_tm);
   else
       strftime ( tmp_char, 20,"%Y-%m-%d", date_tm );

   date_string.assign(tmp_char);
   return date_string;
}

 // get back year, month day from the time_unix, if time_unix = 0 get actual date //
 void GetDateYMD( time_t time_unix, int &year, int &month, int &day ) {
#ifdef DEBUG_UTIL
  std::cout << "GetDateYMD " << time_unix << std::endl;
#endif

  struct tm * timeinfo;
  // get time_t
  time_t tmp_time = 0;

  if ( time_unix == 0 ) {
      //std::cout << "get actual date " << std::endl;
      // if 0 get actual time
      tmp_time = time ( &time_unix );
      //std::cout << "get actual date " << tmp_time << std::endl;
  } else {
      //std::cout << "time_unix not null " << time_unix << std::endl;
      tmp_time = time_unix;
  }

  timeinfo = localtime ( &tmp_time );
  year = timeinfo->tm_year + 1900 ;
  month = timeinfo->tm_mon + 1;
  day = timeinfo->tm_mday;
}

// strange error because of timezone, not sure the best
// keep for notes later

// to see std, C++11 with time_point, g++4.8 bug still need strptime anyway
// see DataCSV::ExtractCSV, with different initialization
// new correct H:M:S
time_t StringToTime_t_old ( std::string str_date ) {
    std::string date_string;

    // correct initalization of a structure C-style
    //struct tm date_tm;
    //memset( &date_tm, 0, sizeof(struct tm));

    // used in DataStock::ExtractCSVLine, correct dates time like this, shift for origin
    // Some field specif to GNU; BSD, not in the standard
    // http://www.delorie.com/gnu/docs/glibc/libc_435.html
    /*
     long int tm_gmtoff
     This field describes the time zone that was used to compute this broken-down time value, including any adjustment for daylight saving; it is the number of seconds that you must add to UTC to get local time. You can also think of this as the number of seconds east of UTC. For example, for U.S. Eastern Standard Time, the value is -5*60*60. The tm_gmtoff field is derived from BSD and is a GNU library extension; it is not visible in a strict ISO C environment.

 const char *tm_zone
     This field is the name for the time zone that was used to compute this broken-down time value. Like tm_gmtoff, this field is a BSD and GNU extension, and is not visible in a strict ISO C environment.
    // -1 flag..not available                        ‘tm::tm_gmtoff',const char *tm_zone  ;
    */
    // compile but wrong, -1 Save Day.. important
    //struct tm date_tm = {0, 0, 0, 0, 0, 0, 0, 0 }; //, -1 , 0, nullptr }; //, nullptr};
    //                                              ‘tm::tm_gmtoff',const char *tm_zone  ;
    struct tm date_tm = {0, 0, 0, 0, 0, 0, 0, 0, -1 , 0, nullptr };

    //std::cout << "Entry StringToTimeT str " << str_date << std::endl;
    //strptime ( str_date.c_str(),"%Y-%m-%d", &date_tm );
    strptime ( str_date.c_str(),"%Y-%m-%d %H:%M:%S", &date_tm );

    //std::cout << " year " << date_tm.tm_year << " month " << date_tm.tm_mon << " heure " << date_tm.tm_hour << std::endl;
    //std::cout << " year " << (*date_tm).tm_mon << " heure " << (*date_tm).tm_hour << std::endl;

    // see also, for functions tools
    //http://stackoverflow.com/questions/1217566/general-way-to-manipulate-the-times-between-timezones-in-c?rq=1
     // or for discussion about thread-safe, std::strftime
    // http://kjellkod.wordpress.com/2013/01/22/exploring-c11-part-2-localtime-and-time-again/

    // here works for bug, but valgrind errors(warning in compil) and time now is wrong !
    //http://stackoverflow.com/questions/3660983/c-time-t-problem
    // *** enter in UTC mode
     /*
     char* oldTZ = getenv("TZ");
     //empty
     std::cout << "oldTZ " << oldTZ << std::endl;
     //putenv("TZ=UTC");
     std::string tmp_string="TZ=UTC";
     putenv( const_cast<char *>(tmp_string.c_str()) );
     //_tzset();
     tzset();
     */
     // ***

    // call mktime, says opposite of localtime
    //return mktime( &date_tm );
    time_t ret = mktime( &date_tm );

    // *** Restore previous TZ
     /*
     if(oldTZ == NULL)
     {
         putenv("TZ=");
     }
     else
     {
         char buff[255];
         sprintf(buff,"TZ=%s",oldTZ);
         putenv(buff);
     }*/
     //tmp_string="TZ=Europe/Paris";
     //putenv("TZ=Europe/Paris");
     /*
     tmp_string="TZ=Europe/Paris";
     putenv( const_cast<char *>(tmp_string.c_str()) );
     //_tzset();
     tzset();
     */
     // ***
     return ret;
}


} // end namespace Utils