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

    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();
            ~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(0),textName(0),data(0){}

        ObjectId id;        
        char* repName;        
        char* 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());
    }

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

    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