omHelper.h

Go to the documentation of this file.

 
// Copyright (c) 2013-2015 OpenM++
// This code is licensed under the MIT license (see LICENSE.txt for details)
 
#ifndef OM_H_HELPER_H
#define OM_H_HELPER_H
 
#include <algorithm>
#include <cstring>
#include <ctime>
#include <chrono>
#include <functional>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <stdexcept>
#include <thread>
#include <iomanip>
#include <sstream>
#include <climits>
#include <vector>
#include <cstdarg>
 
// define max size of file path
#ifdef PATH_MAX
    #define OM_PATH_MAX (FILENAME_MAX < PATH_MAX ? FILENAME_MAX : PATH_MAX)
#endif
#ifndef OM_PATH_MAX
    #ifdef _MAX_PATH
        #define OM_PATH_MAX (FILENAME_MAX < _MAX_PATH ? FILENAME_MAX : _MAX_PATH)
    #else
        #define OM_PATH_MAX (FILENAME_MAX < 4096 ? FILENAME_MAX : 4096)
    #endif 
#endif 
 
#define OM_STRLEN_MAX           INT_MAX 
#define OM_STR_DB_MAX           32000   
#define OM_CODE_DB_MAX          32      
#define OM_NAME_DB_MAX          255     
#define OM_DESCR_DB_MAX         255     
#define OM_OPTION_DB_MAX        32000   
#define OM_SQL_EXPR_DB_MAX      2048    
#define OM_MAX_BUILTIN_TYPE_ID  100     
#define OM_STATE_SAVE_TIME 1811L        
#define OM_STATE_BEAT_TIME 1823L        
namespace openm
{
    extern void toLower(std::string & io_str, const std::locale & i_locale = std::locale(""));
 
    extern void toLower(char * io_str, const std::locale & i_locale = std::locale(""));
 
    extern void toUpper(std::string & io_str, const std::locale & i_locale = std::locale(""));
 
    extern void toUpper(char * io_str, const std::locale & i_locale = std::locale(""));
 
    extern int compareNoCase(const char * i_left, const char * i_right, size_t i_length = 0);
 
    extern bool equalNoCase(const char * i_left, const char * i_right, size_t i_length = 0);
 
    extern bool startWithNoCase(const std::string & i_str, const char * i_start);
 
    extern bool endWithNoCase(const std::string & i_str, const char * i_end);
 
    extern std::string trimLeft(const std::string & i_str, const std::locale & i_locale = std::locale(""));
 
    extern std::string trimRight(const std::string & i_str, const std::locale & i_locale = std::locale(""));
 
    extern std::string trim(const std::string & i_str, const std::locale & i_locale = std::locale(""));
 
    extern void blankCrLf(std::string & io_str);
 
    extern const std::string toQuoted(const std::string & i_str, char i_quote = '\'');
 
    extern const std::string toUnQuoted(const std::string & i_str, char i_quote = '\'', const std::locale & i_locale = std::locale(""));
 
    extern const std::string toString(double i_val);
 
    extern const std::string toAlphaNumeric(const std::string & i_str, int i_maxSize = 0);
 
    extern const std::string cleanPathChars(const std::string & i_str, int i_maxSize = 0);
 
    extern const std::string replaceAll(const std::string & i_src, const char * i_oldValue, const char * i_newValue);
 
    extern bool isBoolType(const char * i_typeName);
 
    extern bool isStringType(const char * i_typeName);
 
    extern bool isBigIntType(const char * i_typeName);
 
    extern bool isIntType(const char * i_typeName, int i_typeId);
 
    extern bool isBuiltInType(int i_typeId);
 
    extern bool isFloatType(const char * i_typeName);
 
    extern bool isTimeType(const char * i_typeName);
 
    extern bool isIntValid(const char* i_value);
 
    extern bool isFloatValid(const char* i_value);
 
    extern bool isBoolTrue(const char* i_str);
 
    extern bool isBoolValid(const char* i_str);
 
    extern int boolStringToInt(const char * i_value);
 
    ptrdiff_t memCopyTo(uint8_t * io_dst, ptrdiff_t i_offset, const void * i_src, size_t i_size);
 
    extern const std::string makeDateTime(const std::chrono::system_clock::time_point & i_time);
 
    extern const std::string makeTimeStamp(const std::chrono::system_clock::time_point & i_time);
 
    extern const std::string toDateTimeString(const std::string & i_timestamp);
 
    extern void formatTo(size_t i_size, char * io_buffer, const char * i_format, va_list io_args);
 
    extern std::string formatToString(const char * i_format, ...);
 
    extern const char * elliptString(const char * i_src, size_t i_size, char * io_buffer);
 
    extern const std::string normalizeLanguageName(const std::string & i_srcLanguage);
 
    extern const std::list<std::string> splitLanguageName(const std::string & i_srcLanguage);
 
    extern std::list<std::string> splitCsv(
        const std::string & i_values, const char * i_delimiters = ",", bool i_isUnquote = false, char i_quote = '\''
    );
 
    extern void splitCsv(
        const std::string & i_values,
        std::list<std::string> & io_resultLst,
        const char * i_delimiters = ",", 
        bool i_isUnquote = false, 
        char i_quote = '\'', 
        const std::locale & i_locale = std::locale(""));
 
    struct LessNoCase
    {
        bool operator() (const std::string & i_left, const std::string & i_right) const
        {
            return compareNoCase(i_left.c_str(), i_right.c_str()) < 0;
        }
    };
 
    typedef std::map<std::string, std::string, LessNoCase> NoCaseMap;
 
    typedef std::set<std::string, LessNoCase> NoCaseSet;
 
    struct IRowBase
    {
        virtual ~IRowBase(void) noexcept = 0;
    };
 
    typedef std::unique_ptr<IRowBase> IRowBaseUptr;
 
    typedef std::vector<IRowBaseUptr> IRowBaseVec;
 
    typedef std::list<IRowBaseUptr> IRowBaseList;
 
    struct IFinalState
    {
        virtual ~IFinalState(void) noexcept = 0;
 
        virtual bool isFinal(void) = 0;
 
        virtual bool isError(void) = 0;
    };
 
    template <class ResourceHolder>
    class exit_guard
    {
    public:
 
        typedef void(ResourceHolder::*CleanupHandler)(void);
 
        exit_guard(ResourceHolder * const i_holder, CleanupHandler i_cleanupFnc) :
            isHold(false),
            holder(i_holder),
            cleanup(i_cleanupFnc)
        { }
 
        ~exit_guard(void) noexcept
        {
            try {
                if (!isHold) (holder->*cleanup)();
            }
            catch (...) { }
        }
 
        void hold(void) noexcept { isHold = true; }
 
    private:
        bool isHold;                    // if true then hold resource
        ResourceHolder * const holder;  // resource holder class
        CleanupHandler cleanup;         // resource release method
 
    private:
        exit_guard(const exit_guard & i_guard) = delete;
        exit_guard & operator=(const exit_guard & i_guard) = delete;
    };
}
 
#endif  // OM_H_HELPER_H