CPPUtils.h

Go to the documentation of this file.

//- ****************************************************************************
//- 
//- Copyright 2009 Sandia Corporation. Under the terms of Contract
//- DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
//- retains certain rights in this software.
//- 
//- BSD Open Source License.
//- All rights reserved.
//- 
//- Redistribution and use in source and binary forms, with or without
//- modification, are permitted provided that the following conditions are met:
//- 
//-    * Redistributions of source code must retain the above copyright notice,
//-      this list of conditions and the following disclaimer.
//-    * Redistributions in binary form must reproduce the above copyright
//-      notice, this list of conditions and the following disclaimer in the
//-      documentation and/or other materials provided with the distribution.
//-    * Neither the name of Sandia National Laboratories nor the names of its
//-      contributors may be used to endorse or promote products derived from
//-      this software without specific prior written permission.
//- 
//- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
//- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
//- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
//- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
//- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
//- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
//- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
//- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//- POSSIBILITY OF SUCH DAMAGE.
//-
//- ****************************************************************************
 
#ifndef CPPUTILS_OBJECT_H
#define CPPUTILS_OBJECT_H
 
// **** _SYSTEM INCLUDES_ ******************************************************
 
#include "CPPGlobals.h"
#include <fstream>
 
// **** # Defines **************************************************************
 
// use standard library objects
using namespace std;
 
//--------------------------
 
// **** _LOCAL INCLUDES_ *******************************************************
 
// **** _BEGIN GEOTESS NAMESPACE_ **********************************************
 
namespace geotess {
 
// **** _GLOBAL_REFERENCES_ ****************************************************
 
// **** _FORWARD REFERENCES_ ***************************************************
 
// **** _CLASS DEFINITION_ *****************************************************
 
class GEOTESS_EXP_IMP CPPUtils
{
private:
 
    CPPUtils(const CPPUtils& bs) {};
 
    CPPUtils&                   operator=(const CPPUtils& bs) { return *this; };
 
public:
 
    CPPUtils() {};
 
    virtual                     ~CPPUtils() {};
 
    static  string      class_name() { return "CPPUtils"; };
 
    virtual int             class_size() const
    { return (int) sizeof(CPPUtils); };
 
    static const string getOpSys();
 
    static string           stringReplaceAll(const string& sf, const string& sr,
            const string& s);
 
    static void             removeEOL(string& s);
 
    static void addPathSeparator(string& path);
 
    static string insertPathSeparator(const string& dir, const string& name);
 
    static void removePathSeparator(string& path);
 
    static string           itos(int i, const string& frmt = "%d");
    static string           ltos(LONG_INT l, const string& frmt = "%llu");
    static string           ftos(float f, const string& frmt = "%.6f");
    static string           dtos(double d, const string& frmt = "%.14f");
    static string           btos(bool b);
 
    static int              stoi(const string& i, const string& frmt = "%d");
    static LONG_INT             stol(const string& i64, const string& frmt = "%llu");
    static float            stof(const string& f, const string& frmt = "%f");
    static double           stod(const string& d, const string& frmt = "%lf");
    static bool             stob(const string& b);
 
    static string           trim(const string& str,
            const string& delim = " \t");
    static string           trimLeft(const string& str,
            const string& delim = " \t");
    static string           trimRight(const string& str,
            const string& delim = " \t");
 
    static void             getProperties(const string& str,
            map<string, string>& props);
 
    static bool             getProperty(const map<string, string>& props,
            const string& tag, string& value);
 
    static void             tokenizeString(const string& str, const string& delim,
            vector<string>& tokens);
 
    static string           lowercase_string(const string& str);
    static string           uppercase_string(const string& str);
 
    template <typename T>
    static void             minmax(const vector<T>& v, T& mn, T& mx);
 
    static double           toDegrees(double a);
 
    static double           toRadians(double a);
 
    template <typename T>
    static T**              new2DArrayOfArrays(int ni, int nj)
    {
        T** a = new T* [ni];
        for (int i = 0; i < ni; ++i)
            a[i] = new T [nj];
        return a;
    }
 
    template <typename T>
    static T**              new2DArray(int ni, int nj)
    {
        T** a = new T* [ni];
        a[0] = new T [ni*nj];
        for (int i=1; i<ni; ++i) a[i] = &a[0][i*nj];
        return a;
    }
 
    template <typename T>
    static T***             new3DArray(int ni, int nj, int nk)
    {
        T*** a  = new T** [ni];
        a[0]    = new T*  [ni*nj];
        a[0][0] = new T   [ni*nj*nk];
        for (int i = 0; i < ni; ++i)
        {
            a[i] = &a[0][i*nj];
            for (int j = 0; j < nj; ++j)
                a[i][j] = &a[0][0][(i*nj + j)*nk];
        }
 
        return a;
    }
 
    template <typename T>
    static void             delete2DArray(T**& a);
 
    template <typename T>
    static void             delete2DArrayOfArrays(T**& a, int ni)
    {
        if (a)
        {
            for (int i = 0; i < ni; ++i) delete [] a[i];
            delete [] a;
            a = NULL;
        }
    }
 
    template <typename T>
    static void             delete3DArray(T***& a);
 
    template <typename T>
    static void             resetArray(int n, T* array, T val)
    {
        for (int i = 0; i < n; ++i) array[i] = val;
    }
 
    template <typename T>
    static T* copyArray(T* a, int n)
    {
        T* copy = new T[n];
        for (int i=0; i<n; ++i)
            copy[i] = a[i];
        return copy;
    }
 
    static bool             isBigEndian();
 
    static  bool            isint(const string& i);
 
    static const int    SBOL;
    static const int    SBYT;
    static const int    SSHT;
    static const int    SINT;
    static const int    SLNG;
    static const int    SFLT;
    static const int    SDBL;
 
    static  char const FILE_SEP;
 
    static  string const NEWLINE;
 
    static bool fileExists(const string& fileName)
    {
        fstream f;
 
        f.open(fileName.c_str(), ios::in);
        if (f.is_open())
        {
            f.close();
            return true;
        }
        return false;
    }
 
}; // End class CPPUtils
 
// **** _INLINE FUNCTION IMPLEMENTATIONS_ **************************************
 
inline double CPPUtils::toDegrees(double a)
{
    return RAD_TO_DEG * a;
}
 
inline double CPPUtils::toRadians(double a)
{
    return DEG_TO_RAD * a;
}
 
template <typename T>
inline void CPPUtils::delete2DArray(T**& a)
{
    if (a)
    {
        delete [] a[0];
        delete [] a;
        a = NULL;
    }
}
 
template <typename T>
inline void CPPUtils::delete3DArray(T***& a)
{
    if (a)
    {
        delete [] a[0][0];
        delete [] a[0];
        delete [] a;
        a = NULL;
    }
}
 
inline void CPPUtils::removeEOL(string& s)
{
    if (s.size() && (s[s.length() - 1] == '\n'))    s.erase(s.length() - 1);
    if (s.size() && (s[s.length() - 1] == '\r'))    s.erase(s.length() - 1);
}
 
inline void CPPUtils::removePathSeparator(string& s)
{
    if (s.size() && (s[s.length() - 1] == CPPUtils::FILE_SEP))  s.erase(s.length() - 1);
}
 
inline void CPPUtils::addPathSeparator(string& s)
{
    if ( s.find_last_of(CPPUtils::FILE_SEP) != s.length() - 1 )
        s += CPPUtils::FILE_SEP;
}
 
inline string CPPUtils::insertPathSeparator(const string& dir, const string& name)
{
 
    string path = dir;
 
    while (path.size() && (path[path.length() - 1] == CPPUtils::FILE_SEP))
        path.erase(path.length() - 1, 1);
    
    if (path.length() > 0)
        path = path+CPPUtils::FILE_SEP;
 
    string nm = name;
    while (nm.size() && (nm[0] == CPPUtils::FILE_SEP))
        nm.erase((unsigned)0, 1);
 
    return path+nm;
}
 
template <typename T>
void CPPUtils::minmax(const vector<T>& v, T& mn, T& mx)
{
    // exit without modification if v is empty
 
    if (v.size())
    {
        // assign mx and mn to first entry
 
        mx = mn = v[0];
 
        // adjust mx and mn based on remaining entries
 
        for (int i = 1; i < v.size(); i++)
        {
            if (mn > v[i]) mn = v[i];
            if (mx < v[i]) mx = v[i];
        }
    }
}
 
} // end namespace geotess
 
#endif  // CPPUTILS_OBJECT_H