/home/toby/moos-ivp/MOOS-2375-Oct0611/Core/MOOSGenLib/MOOSGenLibGlobalHelper.h

Go to the documentation of this file.

//
//   MOOS - Mission Oriented Operating Suite
//
//   A suit of Applications and Libraries for Mobile Robotics Research
//   Copyright (C) 2001-2005 Massachusetts Institute of Technology and
//   Oxford University.
//
//   This software was written by Paul Newman at MIT 2001-2002 and Oxford
//   University 2003-2005. email: pnewman@robots.ox.ac.uk.
//
//   This file is part of a  MOOS Core Component.
//
//   This program is free software; you can redistribute it and/or
//   modify it under the terms of the GNU General Public License as
//   published by the Free Software Foundation; either version 2 of the
//   License, or (at your option) any later version.
//
//   This program is distributed in the hope that it will be useful,
//   but WITHOUT ANY WARRANTY; without even the implied warranty of
//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
//   General Public License for more details.
//
//   You should have received a copy of the GNU General Public License
//   along with this program; if not, write to the Free Software
//   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
//   02111-1307, USA.
//

#ifndef MOOSGenLibGlobalHelperh
#define MOOSGenLibGlobalHelperh


#ifndef PI
#define PI 3.141592653589
#endif

#include <string>
#include <list>
#include <vector>
#include <sstream>
#include <algorithm>





typedef std::list<std::string> STRING_LIST ;

//find the location of sToken in a string sSource with or without case sensitivity
size_t  MOOSStrFind( const std::string &sSource , const std::string & sToken,bool bInsensitive=false);


//following function finds token = value in a list of such strings
bool MOOSGetValueFromToken(STRING_LIST & sParams,const std::string & sToken,std::string & sVal);

//following functions extract a value from a string containing comma seperated pairs of Token = Val....
//by default case sensitivity on the Token is off. Thus  given two strings S1="X=AbCd" and S2="x=AbCd",
//invoking  MOOSValFromString(s,S1,"x",true) and MOOSValFromString(s,S2,"x",true) with both insert "AbCd" into s
bool MOOSValFromString(std::string & sVal,const std::string & sStr,const std::string & sTk,bool bInsensitive=false);
bool MOOSValFromString(double & dfVal,const std::string & sStr,const std::string & sTk,bool bInsensitive=false);
bool MOOSValFromString(float  &  fVal,const std::string & sStr,const std::string & sTk,bool bInsensitive=false);
bool MOOSValFromString(long   &  nVal,const std::string & sStr,const std::string & sTk,bool bInsensitive=false);
bool MOOSValFromString(int    &  nVal,const std::string & sStr,const std::string & sTk,bool bInsensitive=false);
bool MOOSValFromString(bool   &  bVal,const std::string & sStr,const std::string & sTk,bool bInsensitive=false);
bool MOOSValFromString(unsigned int &  nVal,const std::string & sStr,const std::string & sTk,bool bInsensitive=false);
bool MOOSValFromString(std::vector<double> &dfValVec,int &nRows,int &nCols, const std::string & sStr, const std::string & sToken,bool bInsensitive=false);
bool MOOSValFromString(std::vector<unsigned int> &nValVec, int &nRows, int &nCols, const std::string & sStr, const std::string & sToken,bool bInsensitive=false);
bool MOOSValFromString(long long & nVal, const std::string & sStr,const std::string & sTk,bool bInsensitive=false);

//the following simply parse a MOOSFormated vector [nxm]{a,b,c...}
bool MOOSVectorFromString(const std::string & sStr,std::vector<double> & dfVecVal,int & nRows,int & nCols);
bool MOOSVectorFromString(const std::string & sStr,std::vector<float> & fValVec,int & nRows, int & nCols);
bool MOOSVectorFromString(const std::string & sStr,std::vector<unsigned int> & dfVecVal,int & nRows,int & nCols);

//the following a sim[lpe line extractor from a file possessing an alog format - see Logger documentation
bool GetNextAlogLineByMessageName(std::istream & Input,
                                                                  const std::string & sMessageName,
                                                                  double & dfTime,
                                                                  std::string & sSource,
                                                                  std::string & sPayload);


std::string DoubleVector2String(const std::vector<double> & V);

std::stringstream & Write (std::stringstream & os,const std::vector<double> & Vec);

std::stringstream & Write (std::stringstream & os,const std::vector<int> & Vec);

//the ubiquitous chomp function
std::string MOOSChomp(std::string &sStr, const std::string &sTk=",",bool bInsensitive=false);

void MOOSRemoveChars(std::string & sStr,const std::string & sTok);

void MOOSToUpper(std::string &str);

void MOOSTrimWhiteSpace(std::string & str);

bool MOOSIsNumeric(std::string  str);

bool MOOSStrCmp(std::string s1,std::string s2);

bool MOOSWildCmp(const std::string & sPattern, const std::string & sString ) ;



double GetMOOSSkew();
void SetMOOSSkew(double dfSkew);

double GetMOOSSkew();

bool SetMOOSTimeWarp(double dfWarp);

double GetMOOSTimeWarp();

void MOOSPause(int nMS,bool bApplyTimeWarping = true);

double MOOSTime(bool bApplyTimeWarping=true);

bool SetWin32HighPrecisionTiming(bool bEnable);

double HPMOOSTime(bool bApplyTimeWarping = true);

double MOOSLocalTime(bool bApplyTimeWarping=true);


int     MOOSGetch();


//formatted printing
void MOOSTrace(std::string  Str);

void MOOSTrace(const char *FmtStr,...);

std::string MOOSFormat(const char * FmtStr,...);

void InhibitMOOSTraceInThisThread(bool bInhibit = true);

bool MOOSFail(const char * FmtStr,...);

std::string MOOSGetTimeStampString();

std::string MOOSGetDate();

#define  MOOSHERE  MOOSFormat("File %s Line %d", __FILE__,__LINE__).c_str()

void Progress(double dfPC);


//these are used to let people format string used to control
//actuation (via a Thirdparty task) - one has to question why they are here though..
std::string MOOSThirdPartyActuationString(double * pdfRudder,double * pdfElevator,double * pdfThrust);
std::string MOOSThirdPartyStatusString(std::string sStatusCommand);



double MOOS_ANGLE_WRAP(double dfAng);

double MOOSDeg2Rad(double dfDeg);

double MOOSRad2Deg(double dfRad);

bool MOOSAbsLimit(double & dfVal,double dfLimit);

double MOOSWhiteNoise(double Sigma);

double MOOSNormalInv(double dfArea);

int MOOSDiscreteUniform(int nMin, int nMax);

double MOOSUniformRandom(double dfMin, double dfMax);

template <class T>
const T& MOOSClamp(const T &val, const T &min, const T &max)
{
    if (val < min) return min;
    if (max < val) return max;
    else return val;
}



bool GetDirectoryContents(const std::string & sPath,std::list<std::string> &sContents,bool bFiles= true);

bool MOOSCreateDirectory(const std::string & sDirectory);

bool MOOSFileParts(std::string sFullPath, std::string & sPath,std::string &sFile,std::string & sExtension);






template <class  T > T SwapByteOrder(const T &v)
{
    T r = v;
    char * aR = (char*)&r;
    std::reverse(aR,aR+sizeof(T));
    return r;
}


bool IsLittleEndian();


template<class D> struct static_caster
{
    template<class S> D operator()(S s) const { return static_cast<D> (s); }
};


template<class D> struct dynamic_caster
{
    template<class S> D operator()(S s) const { return dynamic_cast<D> (s); }
};


//adds a token/value pair to end of the supplied string sIn
template <class T>
std::string & MOOSAddValToString(std::string & sIn, const std::string & sTok,const T & Val)
{
    std::stringstream s;
    
    if(!sIn.empty())
                s<<",";
    
    s<<sTok<<"="<<Val;
    
    sIn+=s.str();
    
    return sIn;
}


#ifdef _WIN32
#define UNUSED_PARAMETER(a) a
#else
#define UNUSED_PARAMETER(a)
#endif



#endif