UniSetTypes.h

/*
 * Copyright (c) 2015 Pavel Vainerman.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, version 2.1.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Lesser Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
#ifndef UniSetTypes_H_
#define UniSetTypes_H_
// --------------------------------------------------------------------------
#include <memory>
#include <cstdlib>
#include <cstdio>
#include <string>
#include <list>
#include <vector>
#include <limits>
#include <ostream>
#include <chrono>
#include <thread>
#include <regex>
 
#include <omniORB4/CORBA.h>
#include "UniSetTypes_i.hh"
#include "IOController_i.hh"
#include "Mutex.h"
#include "UniXML.h"
#include "PassiveTimer.h" // for typedef timeout_t
// -----------------------------------------------------------------------------------------
inline void msleep( uniset::timeout_t m )
{
    std::this_thread::sleep_for(std::chrono::milliseconds(m));
}
 
namespace uniset
{
    class Configuration;
    // ---------------------------------------------------------------
    // Вспомогательные типы данных и константы
 
    const char BadSymbols[] = {'.', '/'};
 
    char checkBadSymbols(const std::string& str);
 
    std::string BadSymbolsToStr();
 
 
    /* hash32("DefaultObjectId") = 122387491 */
    const ObjectId DefaultObjectId = -1;    
    const ThresholdId DefaultThresholdId = -1;      
    const ThresholdId DefaultTimerId = -1;      
    const ObjectId AdminID = -2; 
    typedef uint64_t KeyType;    
    KeyType key( const uniset::ObjectId id, const uniset::ObjectId node );
    KeyType key( const IOController_i::SensorInfo& si );
 
    uint64_t hash64( const std::string& str ) noexcept;
    uint64_t hash64( const char* buf, size_t sz ) noexcept;
    uint32_t hash32( const std::string& str ) noexcept;
    uint32_t hash32( const char* buf, size_t sz ) noexcept;
 
    typedef std::list<std::string> ListObjectName;    
    typedef CORBA::Object_ptr ObjectPtr;    
    typedef CORBA::Object_var ObjectVar;    
    UniversalIO::IOType getIOType( const std::string& s ) noexcept;
    std::string iotype2str( const UniversalIO::IOType& t ) noexcept;
    std::ostream& operator<<( std::ostream& os, const UniversalIO::IOType t );
    std::ostream& operator<<( std::ostream& os, const IONotifyController_i::ThresholdInfo& ti );
    std::ostream& operator<<( std::ostream& os, const IOController_i::ShortIOInfo& s );
    std::ostream& operator<<( std::ostream& os, const IONotifyController_i::ThresholdState& s);
 
    enum LampCommand
    {
        lmpOFF      = 0,    
        lmpON       = 1,    
        lmpBLINK    = 2,    
        lmpBLINK2   = 3,    
        lmpBLINK3   = 4     
    };
 
    const long ChannelBreakValue = std::numeric_limits<long>::max();
 
    class IDList
    {
        public:
 
            IDList( const std::vector<std::string>& v );
#if __cplusplus >= 201703L
        IDList( const std::vector<std::string_view>& v );
#endif
            IDList();
            ~IDList();
 
            void add( ObjectId id );
            void del( ObjectId id );
 
            inline size_t size() const noexcept
            {
                return lst.size();
            }
            inline bool empty() const noexcept
            {
                return lst.empty();
            }
 
            std::list<ObjectId> getList() const noexcept;
            const std::list<ObjectId>& ref() const noexcept;
 
            // за освобождение выделенной памяти
            // отвечает вызывающий!
            IDSeq* getIDSeq() const;
 
            //
            ObjectId getFirst() const noexcept;
            ObjectId node;    // узел, на котором находятся датчики
 
        private:
            std::list<ObjectId> lst;
    };
 
    struct ObjectInfo
    {
        ObjectId id = { DefaultObjectId };    
        std::string repName = { "" };      
        std::string textName = { "" };     
        std::string name = { "" };     
        xmlNode* xmlnode = { nullptr };
 
        inline bool operator < ( const ObjectInfo& o ) const
        {
            return (id < o.id);
        }
    };
 
    typedef std::list<NodeInfo> ListOfNode;
 
    // ---------------------------------------------------------------
    // Различные преобразования
 
    int uni_atoi( const char* str ) noexcept;
    int uni_atoi( const std::string& str ) noexcept;
#if __cplusplus >= 201703L
    int uni_atoi_sv( std::string_view str ) noexcept;
#endif
 
    char* uni_strdup( const std::string& src );
 
    std::string timeToString(time_t tm = time(0), const std::string& brk = ":") noexcept; 
    std::string dateToString(time_t tm = time(0), const std::string& brk = "/") noexcept; 
    struct timeval to_timeval( const std::chrono::system_clock::duration& d ); 
    struct timespec to_timespec( const std::chrono::system_clock::duration& d ); 
    struct timespec now_to_timespec(); 
    uniset::Timespec_var to_uniset_timespec( const std::chrono::system_clock::duration& d );
    uniset::Timespec_var now_to_uniset_timespec(); 
    int64_t timespec_to_nanosec( const struct timespec& tm );
 
    IDList explode( const std::string& str, char sep = ',' );
    std::vector<std::string> explode_str( const std::string& str, char sep = ',' );
#if __cplusplus >= 201703L
    IDList split_by_id( std::string_view str, char sep = ',' );
    std::vector<std::string_view> split_sv( std::string_view str, char sep = ',' );
#endif
 
    struct ParamSInfo
    {
        IOController_i::SensorInfo si;
        long val;
        std::string fname; // fullname id@node or id
    };
 
    std::list<ParamSInfo> getSInfoList( const std::string& s, std::shared_ptr<uniset::Configuration> conf = nullptr );
 
    uniset::ParamSInfo parseSInfo( const std::string& s, std::shared_ptr<uniset::Configuration> conf = nullptr );
#if __cplusplus >= 201703L
    std::list<ParamSInfo> getSInfoList_sv( std::string_view s, std::shared_ptr<uniset::Configuration> conf = nullptr );
    uniset::ParamSInfo parseSInfo_sv( std::string_view s, std::shared_ptr<uniset::Configuration> conf = nullptr );
#endif
    std::list<uniset::ConsumerInfo> getObjectsList( const std::string& s, std::shared_ptr<uniset::Configuration> conf = nullptr );
 
    bool is_digit( const std::string& s ) noexcept;
#if __cplusplus >= 201703L
    bool is_digit_sv( std::string_view s ) noexcept;
#endif
 
    std::string replace_all( const std::string& src, const std::string& from, const std::string& to );
    // ---------------------------------------------------------------
    // Работа с командной строкой
 
    inline std::string getArgParam( const std::string& name,
                                    int _argc, const char* const* _argv,
                                    const std::string& defval = "" ) noexcept
    {
        for( int i = 1; i < (_argc - 1) ; i++ )
        {
            if( name == _argv[i] )
                return _argv[i + 1];
        }
 
        return defval;
    }
 
    inline std::string getArg2Param(const std::string& name,
                                    int _argc, const char* const* _argv,
                                    const std::string& defval, const std::string& defval2 = "") noexcept
    {
        std::string s(uniset::getArgParam(name, _argc, _argv, ""));
 
        if( !s.empty() )
            return s;
 
        if( !defval.empty() )
            return defval;
 
        return defval2;
    }
 
    inline int getArgInt( const std::string& name,
                          int _argc, const char* const* _argv,
                          const std::string& defval = "" ) noexcept
    {
        return uni_atoi(getArgParam(name, _argc, _argv, defval));
    }
 
    inline int getArgPInt( const std::string& name,
                           int _argc, const char* const* _argv,
                           const std::string& strdefval, int defval ) noexcept
    {
        std::string param = uniset::getArgParam(name, _argc, _argv, strdefval);
 
        if( param.empty() && strdefval.empty() )
            return defval;
 
        return uniset::uni_atoi(param);
    }
 
 
    inline int findArgParam( const std::string& name, int _argc, const char* const* _argv )
    {
        for( int i = 1; i < _argc; i++ )
        {
            if( name == _argv[i] )
                return i;
        }
 
        return -1;
    }
 
    // ---------------------------------------------------------------
    // Калибровка
 
    std::ostream& operator<<( std::ostream& os, const IOController_i::CalibrateInfo& c );
 
    // Функции калибровки значений
    // raw      - преобразуемое значение
    // rawMin   - минимальная граница исходного диапазона
    // rawMax   - максимальная граница исходного диапазона
    // calMin   - минимальная граница калиброванного диапазона
    // calMin   - минимальная граница калиброванного диапазона
    // limit    - обрезать итоговое значение по границам
    float fcalibrate(float raw, float rawMin, float rawMax, float calMin, float calMax, bool limit = true );
    long lcalibrate(long raw, long rawMin, long rawMax, long calMin, long calMax, bool limit = true );
    double dcalibrate(double raw, double rawMin, double rawMax, double calMin, double calMax, bool limit = true );
 
    // установка значения в нужный диапазон
    long setinregion(long raw, long rawMin, long rawMax);
    // установка значения вне диапазона
    long setoutregion(long raw, long rawMin, long rawMax);
 
    // ---------------------------------------------------------------
    // Всякие helper-ы
 
    bool file_exist( const std::string& filename );
    bool directory_exist( const std::string& path );
    bool create_directory( const std::string& path, bool with_parents = true );
 
    // Проверка xml-узла на соответствие <...f_prop="f_val">,
    // если не задано f_val, то проверяется, что просто f_prop!=""
    bool check_filter( UniXML::iterator& it, const std::string& f_prop, const std::string& f_val = "" ) noexcept;
    bool check_filter_re( UniXML::iterator& it, const std::string& f_prop, const std::regex& re ) noexcept;
 
    bool containsIgnoreCase( const std::string& text, const std::string& pattern ) noexcept;
 
    // RAII для флагов форматирования ostream..
    class ios_fmt_restorer
    {
        public:
            ios_fmt_restorer( std::ostream& s ):
                os(s), f(nullptr)
            {
                f.copyfmt(s);
            }
 
            ~ios_fmt_restorer()
            {
                os.copyfmt(f);
            }
 
            ios_fmt_restorer( const ios_fmt_restorer& ) = delete;
            ios_fmt_restorer& operator=( const ios_fmt_restorer& ) = delete;
 
        private:
            std::ostream& os;
            std::ios f;
    };
 
    // -----------------------------------------------------------------------------------------
} // end of namespace uniset
// -----------------------------------------------------------------------------------------
    inline bool operator==(const struct timespec &r1, const struct timespec &r2)
    {
        return (r1.tv_sec == r2.tv_sec && r1.tv_nsec == r2.tv_nsec);
    }
    inline bool operator!=(const struct timespec &r1, const struct timespec &r2)
    {
        return !(operator==(r1, r2));
    }
#endif