src/Utils/Utils.h

Go to the documentation of this file.

/*
* Copyright (C) 2005 Norman Casagrande
* For informations write to nova77@gmail.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*
*/

#ifndef __UTILS_H
#define __UTILS_H

#include <cstring>
#include <locale>
#include <algorithm>
#include <cctype> // for isspace
#include <sstream>

#include <iostream>

using namespace std;


namespace nor_utils
{

// ----------------------------------------------------------------

struct white_tab : ctype<char>
{
   white_tab(): ctype<char>(init()) {}
   ~white_tab() { if (_rc) delete _rc; } 

   ctype_base::mask const* init()
   {
      _rc = new ctype_base::mask[ctype<char>::table_size];

      // not using fill_n because I don't wanna get bothered by the warning
      // of the VC8 compiler. This does not need to be secured! :P
      for (size_t i = 0; i < ctype<char>::table_size; ++i)
         _rc[i] = ctype_base::mask();

      _rc['\t'] = ctype_base::space;
      _rc['\n'] = ctype_base::space;

      return _rc;
   }

   ctype_base::mask const* get_table() {  return _rc;  }

private:
   ctype_base::mask* _rc; 

};

// ----------------------------------------------------------------

inline void skip_line(istream& inFile, const int nLines = 1)
{
   for (int i = 0; i < nLines; ++i)
      while ( inFile.get() != '\n' && !inFile.eof() );
}

// ----------------------------------------------------------------

inline string addAndCheckExtension(const string& file, const string& extension)
{
   // if file smaller than the extension
   // or
   // if the file has no extension whatsoever
   // then return it with the extension
   if ( file.length() <= extension.length() ||
        file.rfind('.') == string::npos )
      return file + "." + extension;

   // get the extension
   size_t pos = file.rfind('.') + 1;
   string fileExt = file.substr(pos, file.length() - pos);

   if (fileExt == extension)
      return file; // extension is the same. Just return the file name
   else
      return file + "." + extension; // return filename plus extension
}


// ----------------------------------------------------------------

inline string trim(const string& str)
{
   size_t beg, end;

   string::const_iterator fIt = str.begin();
   string::const_reverse_iterator rIt = str.rbegin();

   for (beg = 0; isspace( *(fIt++) ); ++fIt);
   for (end = str.length(); isspace( *(rIt++) ); --end);

   return str.substr(beg, end-beg);  
}

// ----------------------------------------------------------------

// 
inline bool cmp_nocase(const string &s1, const string &s2)
{
   string::const_iterator p1 = s1.begin();
   string::const_iterator p2 = s2.begin();

   if (s1.length() != s2.length())
      return false;

   while (p1 != s1.end() && p2 != s2.end() )
   {
      if (toupper(*p1) != toupper(*p2) )
         return false;

      ++p1;
      ++p2;
   }

   return true;
}

// ----------------------------------------------------------------

inline size_t count_columns(istream& in)
{
   size_t nCols = 0;
   bool inCol = false;
   int c = 0;

   while( !in.eof() )
   {
      c = in.get();

      if ( c == '\n' || c == '\r' )
         break;

      if (isspace(c))
      {
         if (inCol)
            inCol = false;
      }
      else
      {
         if (!inCol)
         {
            inCol = true;
            ++nCols;
         }
      }

   }

   return nCols;
}

// ----------------------------------------------------------------
// ----------------------------------------------------------------

template < typename T1, typename T2, typename Pred >
bool comparePairOnSecond( const pair<T1, T2>& el1, const pair<T1, T2>& el2 )
{ return Pred()(el1.second, el2.second); }


// ----------------------------------------------------------------

template < typename T >
bool is_zero( const T val, const T smallVal = 1E-10 )
{
   if ( val <= smallVal &&
        val >= -smallVal)
      return true;
   else
      return false;
}

// ----------------------------------------------------------------

} // end of namespace nor_utils

#endif // __UTILS_H

---