Tools.h

浏览该文件的文档.

/************************************************************************
* @file Tools.h
*
* @brief    工具方法类
*
* @details  工具方法类
*
* @author wukx
*
* @version  v1.0
*
* @date  2016.9.29
*
* @license 北京华科软科技有限公司
*
*************************************************************************/
 
#ifndef BIMHOMEBASE_TOOLS_H
#define BIMHOMEBASE_TOOLS_H
 
#ifndef BH_GLOBAL_H
#include <BHGlobal.h>
#endif
#include <functional>
#include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#include <string>
#include <boost_signals2.hpp>
#include <QString>
 
#ifndef M_PI
#define M_PI       3.14159265358979323846
#endif
 
// ----------------------------------------------------------------------------
 
namespace Base
{
 
    template <class T>
    struct iotaGen
    {
    public:
        iotaGen(T v) : n(v) {}
 
        T operator()() { return n++; }
 
    private:
        T n;
    };
 
    // ----------------------------------------------------------------------------
    template <class T>
    class manipulator
    {
        T i_; 
        std::ostream& (*f_)(std::ostream&, T); 
 
    public:
        manipulator(std::ostream& (*f)(std::ostream&, T), T i) : i_(i), f_(f) {}
 
        friend std::ostream& operator<<(std::ostream& os, manipulator m)
        {
            return m.f_(os, m.i_);
        }
    };
 
    inline std::ostream& tabsN(std::ostream& os, int n)
    {
        for (int i = 0; i < n; i++)
            os << "\t";
        return os;
    }
 
    inline std::ostream& blanksN(std::ostream& os, int n)
    {
        for (int i = 0; i < n; i++)
            os << " ";
        return os;
    }
 
    inline manipulator<int> tabs(int n)
    {
        return manipulator<int>(&tabsN, n);
    }
 
    inline manipulator<int> blanks(int n)
    {
        return manipulator<int>(&blanksN, n);
    }
 
    // ----------------------------------------------------------------------------
    template<class T>
    inline T clamp(T num, T lower, T upper)
    {
        return std::max<T>(std::min<T>(upper, num), lower);
    }
 
    template<class T>
    inline T sgn(T t)
    {
        if (t == 0)
            return T(0);
        else
            return (t > 0) ? T(1) : T(-1);
    }
 
    template<class T>
    inline T toRadians(T d)
    {
        return static_cast<T>((d * M_PI) / 180.0);
    }
 
    template<class T>
    inline T toDegrees(T r)
    {
        return static_cast<T>((r / M_PI) * 180.0);
    }
 
    template<class T>
    inline T fmod(T numerator, T denominator)
    {
        T modulo = std::fmod(numerator, denominator);
        return (modulo >= T(0)) ? modulo : modulo + denominator;
    }
 
    // ----------------------------------------------------------------------------
    class BaseExport StopWatch
    {
    public:
        StopWatch();
 
        ~StopWatch();
 
        void start();
 
        int restart();
 
        int elapsed();
 
        std::string toString(int ms) const;
 
    private:
        struct Private;     
        Private* d;         
    };
 
    // ----------------------------------------------------------------------------
    template<typename Flag = bool>
    struct FlagToggler
    {
        Flag& flag;    
        bool toggled;  
 
        FlagToggler(Flag& _flag)
            : flag(_flag), toggled(true)
        {
            flag = !flag;
        }
 
        FlagToggler(Flag& _flag, Flag check)
            : flag(_flag), toggled(check == _flag)
        {
            if (toggled)
                flag = !flag;
        }
 
        ~FlagToggler()
        {
            if (toggled)
                flag = !flag;
        }
    };
 
    // ----------------------------------------------------------------------------
 
    template<typename Status, class Object>
    class ObjectStatusLocker
    {
    public:
        ObjectStatusLocker(Status s, Object* o, bool value = true) : status(s), obj(o)
        {
            old_value = obj->testStatus(status); // 保存原始状态
            obj->setStatus(status, value);       // 设置新状态
        }
 
        ~ObjectStatusLocker()
        {
            obj->setStatus(status, old_value); // 恢复原始状态
        }
 
    private:
        Status status;    
        Object* obj;      
        bool old_value;   
    };
 
    // ----------------------------------------------------------------------------
 
    class StateLocker
    {
    public:
        StateLocker(bool& flag, bool value = true) : lock(flag)
        {
            old_value = lock; // 保存原始状态
            lock = value;     // 设置新状态
        }
 
        ~StateLocker()
        {
            lock = old_value; // 恢复原始状态
        }
 
    private:
        bool& lock;     
        bool old_value; 
    };
 
    // ----------------------------------------------------------------------------
 
    template<typename T>
    class BitsetLocker
    {
    public:
        BitsetLocker(T& flags, std::size_t flag, bool value = true)
            : flags(flags), flag(flag)
        {
            oldValue = flags.test(flag); // 保存原始状态
            flags.set(flag, value);      // 设置新状态
        }
 
        ~BitsetLocker()
        {
            flags.set(flag, oldValue); // 恢复原始状态
        }
 
    private:
        T& flags;      
        std::size_t flag; 
        bool oldValue;    
    };
 
    // ----------------------------------------------------------------------------
 
    class ConnectionBlocker {
        typedef boost::signals2::connection Connection;
        typedef boost::signals2::shared_connection_block ConnectionBlock;
        ConnectionBlock blocker; 
 
    public:
        ConnectionBlocker(Connection& c) : blocker(c) {}
 
        ~ConnectionBlocker() {}
    };
 
 
    // ----------------------------------------------------------------------------
 
    struct BaseExport Tools
    {
        static std::string getUniqueName(const std::string& baseName, const std::vector<std::string>& names, int d = 0);
 
        static std::string addNumber(const std::string& name, unsigned int number, int d = 0);
 
        static std::string getIdentifier(const std::string& str);
 
        static std::string getIdentifierSupportChinese(const std::string& str);
 
        static std::wstring widen(const std::string& str);
 
        static std::string narrow(const std::wstring& str);
 
        static std::string escapedUnicodeFromUtf8(const char* s);
 
        static std::string escapedUnicodeToUtf8(const std::string& s);
 
        static QString escapeEncodeString(const QString& s);
 
        static std::string escapeEncodeString(const std::string& s);
 
        static QString escapeEncodeFilename(const QString& s);
 
        static std::string escapeEncodeFilename(const std::string& s);
 
        static bool fileIsOrNotExist(const QString& path, const QString& fileName, const QString& suffix);
 
        static QStringList getPathAllFilesName(const QString& path, const QString& suffix);
 
        static QString getUniqueFilesNameInPath(const QString& path, const QString& fileName, const QString& suffix);
 
        static inline std::string toStdString(const QString& s)
        {
            QByteArray tmp = s.toUtf8();
            return std::string(tmp.constData(), static_cast<size_t>(tmp.size()));
        }
 
        static inline QString fromStdString(const std::string& s)
        {
            return QString::fromUtf8(s.c_str(), static_cast<int>(s.size()));
        }
    };
} // namespace Base
 
#endif // BIMHOMEBASE_TOOLS_H