Tools.cpp

Go to the documentation of this file.

//$Id: Tools.cpp,v 1.8 2006/05/05 15:45:51 fmachefe Exp $
//------------------------------------------------------------------------------
//
//  Package    : Tools
//
//  Description:
//
//  Author(s)  : F. Machefert -
//  Date       : 16 January 2004
//
//------------------------------------------------------------------------------

#ifndef __FCT_CPP_
#define __FCT_CPP_

// Include
#include <stdlib.h>
#include <iostream>
#include <string>
#include <math.h>

#ifdef _WIN32
#include <windows.h>
#endif

//#include <ncurses.h>
#include <unistd.h>

// CAT include files
#include "Application.h"
#include "Options.h"

// local
#include "Tools.h"

Application *gApp;

void setApplication( Application *cat){
  gApp = cat;  
}

Application* application( ){
  return gApp;
}

std::string itos(int i){    
  char val[20];
  sprintf(val,"%d",i);
  std::string str(val);
  return str;
}

std::string ftos(float f){  
  char val[20];
  sprintf(val,"%f",f);
  std::string str(val);
  return str;
}

std::string dtos(double d){ 
  char val[20];
  sprintf(val,"%f",d);
  std::string str(val);
  return str;
}

std::string btos(std::vector<bool> bits){   
  int i=bits.size()-1;
  std::string output;
  while(i>=0){
    output+=itos(bits[i]);
    i--;
  } 
  return output;
}   

std::vector<bool> itob(int val,int nbit){
  int i=nbit-1; 
  int power; 
  std::vector<bool> bits(nbit);
  //    int limit=1<<(nbit-1);
  //int vsat=(val<limit)?val:int(limit-1); //saturation
  int vsat=val;
  while(i>=0){
    power=1<<i;
    bits[i]=(vsat/power==1);
    vsat=vsat%power;
    i--;
  }
  return bits;
}

int stoi(std::string value){    
  const unsigned int codage=2;
  int result=0;
  char h[codage]={'0','1'};
  const unsigned int size=value.size();
  const char* word=value.c_str();
  unsigned int pos=0;
  while (pos<size){
    bool isSeen=false;
    for (unsigned int j=0; j<codage && !isSeen; j++){
      if (h[j]==word[pos]){
    result+=int(j*pow(2.,(int)(size-pos-1)));
    isSeen=true;
      }
    }
    pos++;
  }
  return result;
}

double toDouble(std::string s){
    // do not use a reference, since we're going to modify this string
    // If you do not care about ',' or '.' in your string use a 
    // reference instead.
    size_t found = s.find(",");
    if(found != std::string::npos)
        s[found]='.'; // Change ',' to '.'
    return atof(s.c_str());
}

//=============================================================================
// 
//=============================================================================
StatusCode checkCmd( std::string format , commands instruction , vars &varlist) {
  int size = instruction.size();
  if ( size<=0 ){
    return StatusCode::FAILURE;
  }

  // line is empty
  if ( format.empty() ||  std::string::npos==format.find_first_not_of(' ') ) {
    return StatusCode::FAILURE;
  }

  // split the format in a vector of strings 
  // decode the main command
  std::string line = std::string (format, 
                  format.find_first_not_of(' ') , 
                  format.size());
  std::vector<std::string> cmd;
  std::string separator(1,' ');
  unsigned int ipos = line.find( separator );
  cmd.push_back ( std::string( line, 0, ipos ) );
  if ( 0!=std::string ( line , 0 , ipos ).compare(instruction[0]) ){
    application()->info(std::string ( line , 0 , ipos )+" "+instruction[0],"");
    return StatusCode::FAILURE;
  }

  unsigned int pos ;

  std::string str = line;
  while ( ipos!=std::string::npos ){
    std::string tmp = std::string (str, ipos , str.size());
    str = tmp;
    pos=str.find_first_not_of( ' ' );    
    if ( pos == std::string::npos ) {      
      break;
    }
    std::string arg;
    ipos = str.find(separator,pos);
  
    if (ipos==std::string::npos){
      arg =  std::string(str , pos );
    }
    else {
      arg = std::string(str , pos, ipos - 1);
    }
    cmd.push_back(arg);
  }

  // check parameter number
  if ( instruction.size() != cmd.size() ){
    application()->info("wrong number of parameter. a enelver !!!!","");
    return StatusCode::FAILURE;
  }
  // no parameter
  if ( 1==cmd.size() ){
    return StatusCode::SUCCESS;
  }
  // decode the format
  for (unsigned int index = 1; index < cmd.size() ; ++index){
    // int ?
    if ( 0==cmd[index].compare("%i") || 0==cmd[index].compare("%I") ){
      if ( !isInt ( instruction[index].c_str() ) ) {
    application()->warning("We expect an integer parameter ["+instruction[index]+"]","checkCmd");
    return StatusCode::FAILURE;
      }
      varlist.push_back ( var( atoi(instruction[index].c_str()) ) );
    }
    // float ?
    if ( 0==cmd[index].compare("%f") || 0==cmd[index].compare("%F") ){
      if ( !isFloat ( instruction[index].c_str() ) ) {
    application()->warning("We expect a float parameter ["+instruction[index]+"]","checkCmd");
    return StatusCode::FAILURE;
      }
      varlist.push_back( var ( atof(instruction[index].c_str()) ) );
    }
  }
  return StatusCode::SUCCESS;
}
//=============================================================================
// 
//=============================================================================
bool isFloat( const char* chain ) {
  const char *pChain = chain;
  while (*pChain!='\0') {
    if ( *pChain!='0' && *pChain!='1' && *pChain!='2' && *pChain!='3' &&
     *pChain!='4' && *pChain!='5' && *pChain!='6' && *pChain!='7' &&
     *pChain!='8' && *pChain!='9' && *pChain!='+' && *pChain!='-' &&
     *pChain!='.' ){
      return false;
    }
    pChain++;
  }
  return true;
} 

//=============================================================================
// 
//=============================================================================
bool isInt( const char* chain ) {
  const char *pChain = chain;  
  bool first = true;
  while (*pChain!='\0') {
    if ( ( *pChain<'0' || *pChain>'9' ) ){
      application()->info(chain,"");
      if ( !first || *pChain!='-' ){ 
    return false;
      }
    }
    first = false;
    pChain++;
  }
  return true;
} 

//=============================================================================
// 
//=============================================================================
bool askSvc( std::string  msg ){
  /*
  AskPrinter asker = application() -> options() -> askPrinter ();
  return asker ( msg);
  */
  return false;
}

bool graphSvc( ){
  //  GraphPrinter graph = application() -> options() -> graphPrinter ();
  //  return graph ( );
  return false;
}

//=============================================================================
// 
//=============================================================================
std::string inputSvc( std::string  msg ){
  /*
  InputSvc inp = application() -> options() -> inputSvc ();
  return inp ( msg );
  */
  return std::string("not implemented.");
}


//=========================================================================
//  
//=========================================================================
void wait( int n )
{
  application()->verbose("wait for "+itos(n)+" ms.","Tools::wait");
#ifdef WIN32
  Sleep( n );
#else
  usleep( 1000 * n );
#endif
}


#endif