UniSetTypes.h

См. документацию.

/* This file is part of the UniSet project
 * Copyright (c) 2002-2005 Free Software Foundation, Inc.
 * Copyright (c) 2002 Pavel Vainerman
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
#ifndef UniSetTypes_H_
#define UniSetTypes_H_
// --------------------------------------------------------------------------
#include <memory>
#include <cstdlib>
#include <cstdio>
#include <string>
#include <list>
#include <vector>
#include <limits>
#include <ostream>
#include <unistd.h>

#include <omniORB4/CORBA.h>
#include "UniSetTypes_i.hh"
#include "IOController_i.hh"
#include "Mutex.h"
#include "UniXML.h"
// -----------------------------------------------------------------------------------------
inline void msleep( unsigned int m )
{
    usleep(m * 1000);
}

namespace UniSetTypes
{
    class Configuration;
    // ---------------------------------------------------------------
    // Вспомогательные типы данных и константы

    const ObjectId DefaultObjectId = -1;    
    const ThresholdId DefaultThresholdId = -1;      
    const ThresholdId DefaultTimerId = -1;      
    const ObjectId AdminID = -2; 
    typedef unsigned long KeyType;    
    inline static KeyType key( const UniSetTypes::ObjectId id, const UniSetTypes::ObjectId node )
    {
        return KeyType((id * node) + (id + 2 * node));
    }

    inline static KeyType key( const IOController_i::SensorInfo& si )
    {
        return key(si.id, si.node);
    }

    typedef std::list<std::string> ListObjectName;    
    typedef ObjectId SysId;
    typedef CORBA::Object_ptr ObjectPtr;    
    typedef CORBA::Object_var ObjectVar;    
    UniversalIO::IOType getIOType( const std::string& s );
    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     
    };

    static const long ChannelBreakValue = std::numeric_limits<long>::max();

    class IDList
    {
        public:

            IDList( std::vector<std::string>& v );
            IDList( std::vector<std::string>&& v );
            IDList();
            ~IDList();

            void add( ObjectId id );
            void del( ObjectId id );

            inline int size() const
            {
                return lst.size();
            }
            inline bool empty() const
            {
                return lst.empty();
            }

            std::list<ObjectId> getList();

            // за освобождение выделеной памяти
            // отвечает вызывающий!
            IDSeq* getIDSeq() const;

            //
            ObjectId getFirst() const;
            ObjectId node;    // узел, на котором находятся датчики

        private:
            std::list<ObjectId> lst;
    };

    struct ObjectInfo
    {
        ObjectInfo():
            id(DefaultObjectId),
            repName(""), textName(""), data(0) {}

        ObjectId id;        
        std::string repName;      
        std::string textName;     
        void* data;

        inline bool operator < ( const ObjectInfo& o ) const
        {
            return (id < o.id);
        }
    };

    typedef std::list<NodeInfo> ListOfNode;

    const char BadSymbols[] = {'.', '/'};

    // ---------------------------------------------------------------
    // Различные преобразования

    int uni_atoi( const char* str );
    inline int uni_atoi( const std::string& str )
    {
        return uni_atoi(str.c_str());
    }

    char* uni_strdup( const std::string& src );

    std::string timeToString(time_t tm = time(0), const std::string& brk = ":"); 
    std::string dateToString(time_t tm = time(0), const std::string& brk = "/"); 
    IDList explode( const std::string& str, char sep = ',' );
    std::vector<std::string> explode_str( const std::string& str, char sep = ',' );

    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<UniSetTypes::Configuration> conf = nullptr );


    std::list<UniSetTypes::ConsumerInfo> getObjectsList( const std::string& s, std::shared_ptr<UniSetTypes::Configuration> conf = nullptr );

    bool is_digit( const std::string& s );

    // ---------------------------------------------------------------
    // Работа с командной строкой

    inline std::string getArgParam( const std::string& name,
                                    int _argc, const char* const* _argv,
                                    const std::string& defval = "" )
    {
        for( int i = 1; i < (_argc - 1) ; i++ )
        {
            if( name == _argv[i] )
                return _argv[i + 1];
        }

        return defval;
    }

    inline int getArgInt( const std::string& name,
                          int _argc, const char* const* _argv,
                          const std::string defval = "" )
    {
        return uni_atoi(getArgParam(name, _argc, _argv, defval));
    }

    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 );

    // установка значения в нужный диапазон
    long setinregion(long raw, long rawMin, long rawMax);
    // установка значения вне диапазона
    long setoutregion(long raw, long rawMin, long rawMax);

    // ---------------------------------------------------------------
    // Всякие helper-ы

    bool file_exist( const std::string& filename );

    // Проверка 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 = "" );

    template<typename InputIterator,
             typename OutputIterator,
             typename Predicate>
    OutputIterator copy_if(InputIterator begin,
                           InputIterator end,
                           OutputIterator destBegin,
                           Predicate p)
    {
        while( begin != end)
        {
            if( p(*begin) ) &destBegin++ = *begin;

            ++begin;
        }

        return destBegin;
    }
    // -----------------------------------------------------------------------------
}

// Варварский запрет на использование atoi вместо uni_atoi..
// #define atoi atoi##_Do_not_use_atoi_function_directly_Use_getIntProp90,_getArgInt_or_uni_atoi

// -----------------------------------------------------------------------------------------
#endif