booltype.h

Go to the documentation of this file.

#ifndef BOOLTYPE_H
 
#define BOOLTYPE_H
 
#include <string>
#include <string.h>
 
#define BOOL_T_LEN 2048
 
class bool_t
{
public:
        bool_t(bool f = true);
 
        bool_t(const char *pStr);
 
        bool_t(const std::string &err);
 
        bool_t(const bool_t &b);
 
        bool_t &operator=(const bool_t &b);
 
        std::string getErrorString() const;
 
        operator bool() const;
 
        bool success() const;
private:
        void strncpy(const char *pSrc);
        void setErrorString(const std::string &err);
        void setErrorString(const char *pStr);
 
        char m_errorString[BOOL_T_LEN];
        static char s_defaultErrMsg[];
        static char s_defaultSuccessMsg[];
};
 
inline bool_t::bool_t(bool f)
{
        if (f)
                m_errorString[0] = 0;
        else
                setErrorString(s_defaultErrMsg);
}
 
inline bool_t::bool_t(const char *pStr)
{
        setErrorString(pStr);
}
 
inline bool_t::bool_t(const std::string &err)
{
        setErrorString(err);
}
 
inline void bool_t::strncpy(const char *pSrc)
{
#ifndef WIN32
        ::strncpy(m_errorString, pSrc, BOOL_T_LEN);
#else
        strncpy_s(m_errorString, BOOL_T_LEN, pSrc, _TRUNCATE);
#endif // !WIN32
        m_errorString[BOOL_T_LEN-1] = 0;
}
 
inline bool_t::bool_t(const bool_t &b)
{
        if (b.m_errorString[0] == 0) // No error
                m_errorString[0] = 0;
        else
                strncpy(b.m_errorString);
}
 
inline void bool_t::setErrorString(const std::string &s)
{
        setErrorString(s.c_str());
}
 
inline void bool_t::setErrorString(const char *pStr)
{
        if (pStr == 0 || pStr[0] == 0)
                strncpy(s_defaultErrMsg);
        else
                strncpy(pStr);
}
 
inline bool_t &bool_t::operator=(const bool_t &b)
{
        if (b.m_errorString[0] == 0) // No error
                m_errorString[0] = 0;
        else
                strncpy(b.m_errorString);
 
        return *this;
}
 
inline std::string bool_t::getErrorString() const
{
        if (m_errorString[0] == 0)
                return s_defaultSuccessMsg;
        return m_errorString;
}
 
inline bool_t::operator bool() const
{
        return success();
}
 
inline bool bool_t::success() const
{
        return (m_errorString[0] == 0);
}
 
#endif // BOOLTYPE_H