MiscUtils.h

Go to the documentation of this file.

// Copyright 2014 GSI, Inc. All rights reserved.
//
// a set of general helpers
//
#ifndef _DDS_MISCUTILS_H_
#define _DDS_MISCUTILS_H_

// STD
#include <algorithm>
#include <iostream>
// BOOST
#include <boost/filesystem.hpp>
#include <boost/process.hpp>
#include <boost/program_options/parsers.hpp>

namespace dds::misc
{
    class NONCopyable
    {
      protected:
        NONCopyable()
        {
        }
        ~NONCopyable()
        {
        }

      private:
        NONCopyable(const NONCopyable&);
        const NONCopyable& operator=(const NONCopyable&);
    };

    class NullType
    {
    };
    class auto_setenv
    {
      public:
        auto_setenv()
            : m_unset(false)
        {
        }
        auto_setenv(const std::string& _VarName, const std::string& _NewValue)
            : m_unset(false)
        {
            m_sVarName = _VarName;
            m_sNewValue = _NewValue;

            char* chTmp = getenv(m_sVarName.c_str());
            if (chTmp)
                m_sOldValue = chTmp;
            else
                m_unset = true;
            // TODO: check error code
            setenv(m_sVarName.c_str(), m_sNewValue.c_str(), 1);
        }
        ~auto_setenv()
        {
            unset();
        }

      public:
        void set(const std::string& _VarName, const std::string& _NewValue)
        {
            unset();

            m_sVarName = _VarName;
            m_sNewValue = _NewValue;

            char* chTmp = getenv(m_sVarName.c_str());
            if (chTmp)
                m_sOldValue = chTmp;
            else
                m_unset = true;
            // TODO: check error code
            setenv(m_sVarName.c_str(), m_sNewValue.c_str(), 1);
        }
        void unset()
        {
            if (m_unset)
            {
                m_unset = false;
                unsetenv(m_sVarName.c_str());
                return;
            }

            if (!m_sVarName.empty())
            {
                m_sVarName.clear();
                setenv(m_sVarName.c_str(), m_sOldValue.c_str(), 1);
            }
        }

      private:
        std::string m_sVarName;
        std::string m_sNewValue;
        std::string m_sOldValue;
        bool m_unset;
    };

    template <typename _T>
    _T* smart_append(_T* _pString, const typename _T::value_type _ItemToAdd)
    {
        if (!_pString)
            return _pString;

        if (_pString->empty() || (*_pString)[_pString->size() - 1] != _ItemToAdd)
            _pString->push_back(_ItemToAdd);

        return _pString;
    }

    template <typename _T>
    _T& trim_right(_T* _pString, const typename _T::value_type& _chWhat)
    {
        return _pString->erase(_pString->find_last_not_of(_chWhat) + 1);
    }

    template <typename _T>
    _T& trim_left(_T* _pString, const typename _T::value_type& _chWhat)
    {
        return _pString->erase(0, _pString->find_first_not_of(_chWhat));
    }

    template <typename _T>
    _T& trim(_T* _pString, const typename _T::value_type& _chWhat)
    {
        return trim_right(&trim_left(_pString, _chWhat), _chWhat);
    }

    template <typename _T>
    _T& replace(_T* _pString, const _T& _what, const _T& _with)
    {
        typename _T::size_type pos = 0;
        typename _T::size_type withLen = _with.length();
        typename _T::size_type whatLen = _what.length();
        while ((pos = _pString->find(_what, pos)) != _T::npos)
        {
            _pString->replace(pos, _what.length(), _with);
            if (withLen > whatLen)
                pos += withLen - whatLen + 1;
        }
        return (*_pString);
    }

    // HACK: because of the bug in gcc 3.3 we need to use this nasty ToLower and ToUpper instead of direct calls of
    // tolower (tolower.. is inline in this version
    // of std lib)...
    struct ToLower
    {
        char operator()(char c) const
        {
            return std::tolower(c);
        }
    };
    struct ToUpper
    {
        char operator()(char c) const
        {
            return std::toupper(c);
        }
    };
    struct IsDigit : std::unary_function<int, int>
    {
        int operator()(int c) const
        {
            return std::isdigit(c);
        }
    };

    template <typename _T>
    _T& to_upper(_T& _str)
    {
        std::transform(_str.begin(), _str.end(), _str.begin(), ToUpper());
        return _str;
    }

    template <typename _T>
    _T& to_lower(_T& _str)
    {
        std::transform(_str.begin(), _str.end(), _str.begin(), ToLower());
        return _str;
    }

    struct HumanReadable
    {
        std::uintmax_t size{};

      private:
        friend std::ostream& operator<<(std::ostream& os, HumanReadable hr)
        {
            int i{};
            double mantissa = hr.size;
            for (; mantissa >= 1024.; mantissa /= 1024., ++i)
            {
            }
            mantissa = std::ceil(mantissa * 10.) / 10.;
            os << mantissa << "BKMGTPE"[i];
            return i == 0 ? os : os << "B (" << hr.size << ')';
        }
    };
};     // namespace dds::misc
#endif // _DDS_MISCUTILS_H_