UniSetObject.h

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

/* This file is part of the UniSet project
 * Copyright (c) 2002 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 UniSetObject_H_
#define UniSetObject_H_
//--------------------------------------------------------------------------
#include <condition_variable>
#include <thread>
#include <mutex>
#include <atomic>
#include <unistd.h>
#include <sys/time.h>
#include <queue>
#include <ostream>
#include <memory>
#include <string>
#include <list>

#include "UniSetTypes.h"
#include "MessageType.h"
#include "PassiveTimer.h"
#include "Exceptions.h"
#include "UInterface.h"
#include "UniSetObject_i.hh"
#include "ThreadCreator.h"
#include "LT_Object.h"

//---------------------------------------------------------------------------
//#include <omnithread.h>
//---------------------------------------------------------------------------
class UniSetActivator;
class UniSetManager;

//---------------------------------------------------------------------------
class UniSetObject;
typedef std::list< std::shared_ptr<UniSetObject> > ObjectsList;     
//---------------------------------------------------------------------------
class UniSetObject:
    public std::enable_shared_from_this<UniSetObject>,
    public POA_UniSetObject_i,
    public LT_Object
{
    public:
        UniSetObject(const std::string& name, const std::string& section);
        UniSetObject(UniSetTypes::ObjectId id);
        UniSetObject();
        virtual ~UniSetObject();

        std::shared_ptr<UniSetObject> get_ptr()
        {
            return shared_from_this();
        }

        // Функции объявленные в IDL
        virtual CORBA::Boolean exist() override;

        virtual UniSetTypes::ObjectId getId() override
        {
            return myid;
        }
        inline const UniSetTypes::ObjectId getId() const
        {
            return myid;
        }
        inline std::string getName()
        {
            return myname;
        }

        virtual UniSetTypes::ObjectType getType() override
        {
            return UniSetTypes::ObjectType("UniSetObject");
        }
        virtual UniSetTypes::SimpleInfo* getInfo( ::CORBA::Long userparam = 0 ) override;
        friend std::ostream& operator<<(std::ostream& os, UniSetObject& obj );

        virtual void push( const UniSetTypes::TransportMessage& msg ) override;

        inline UniSetTypes::ObjectPtr getRef() const
        {
            UniSetTypes::uniset_rwmutex_rlock lock(refmutex);
            return (UniSetTypes::ObjectPtr)CORBA::Object::_duplicate(oref);
        }

        virtual timeout_t askTimer( UniSetTypes::TimerId timerid, timeout_t timeMS, clock_t ticks = -1,
                                    UniSetTypes::Message::Priority p = UniSetTypes::Message::High ) override;

    protected:
        virtual void processingMessage( UniSetTypes::VoidMessage* msg );
        virtual void sysCommand( const UniSetTypes::SystemMessage* sm ) {}
        virtual void sensorInfo( const UniSetTypes::SensorMessage* sm ) {}
        virtual void timerInfo( const UniSetTypes::TimerMessage* tm ) {}

        bool receiveMessage( UniSetTypes::VoidMessage& vm );

        unsigned int countMessages();

        void termWaiting();

        std::shared_ptr<UInterface> ui; 
        std::string myname;
        std::string section;

        virtual bool deactivateObject()
        {
            return true;
        }
        virtual bool activateObject()
        {
            return true;
        }

        inline void thread(bool create)
        {
            threadcreate = create;
        }
        inline void offThread()
        {
            threadcreate = false;
        }
        inline void onThread()
        {
            threadcreate = true;
        }

        virtual void callback();

        virtual void sigterm( int signo );

        inline void terminate()
        {
            deactivate();
        }

        virtual bool waitMessage(UniSetTypes::VoidMessage& msg, timeout_t timeMS = UniSetTimer::WaitUpTime);

        void setID(UniSetTypes::ObjectId id);

        void setMaxSizeOfMessageQueue( size_t s )
        {
            SizeOfMessageQueue = s;
        }

        inline unsigned int getMaxSizeOfMessageQueue()
        {
            return SizeOfMessageQueue;
        }

        void setMaxCountRemoveOfMessage( size_t m )
        {
            MaxCountRemoveOfMessage = m;
        }

        inline unsigned int getMaxCountRemoveOfMessage()
        {
            return MaxCountRemoveOfMessage;
        }


        // функция определения приоритетного сообщения для обработки
        struct PriorVMsgCompare:
            public std::binary_function<UniSetTypes::VoidMessage, UniSetTypes::VoidMessage, bool>
        {
            bool operator()(const UniSetTypes::VoidMessage& lhs,
                            const UniSetTypes::VoidMessage& rhs) const;
        };
        typedef std::priority_queue<UniSetTypes::VoidMessage, std::vector<UniSetTypes::VoidMessage>, PriorVMsgCompare> MessagesQueue;


        virtual void cleanMsgQueue( MessagesQueue& q );

        inline bool isActive()
        {
            return active;
        }
        inline void setActive( bool set )
        {
            active = set;
        }

        UniSetTypes::VoidMessage msg;
        std::weak_ptr<UniSetManager> mymngr;

        void setThreadPriority( int p );

    private:

        friend class UniSetManager;
        friend class UniSetActivator;

        inline pid_t getMsgPID()
        {
            return msgpid;
        }

        void work();
        bool init( const std::weak_ptr<UniSetManager>& om );
        bool deactivate();
        bool activate();
        /* регистрация в репозитории объектов */
        void registered();
        /* удаление ссылки из репозитория объектов     */
        void unregister();

        void init_object();

        pid_t msgpid; // pid потока обработки сообщений
        bool regOK = { false };
        std::atomic_bool active;

        bool threadcreate;
        std::shared_ptr<UniSetTimer> tmr;
        UniSetTypes::ObjectId myid;
        CORBA::Object_var oref;

        std::shared_ptr< ThreadCreator<UniSetObject> > thr;

        MessagesQueue queueMsg;

        UniSetTypes::uniset_rwmutex qmutex;

        mutable UniSetTypes::uniset_rwmutex refmutex;

        size_t SizeOfMessageQueue;
        size_t MaxCountRemoveOfMessage;

        // статистическая информация
        size_t stMaxQueueMessages;    /*<! Максимальное число сообщений хранившихся в очереди */
        size_t stCountOfQueueFull;    
        std::atomic_bool a_working;
        std::mutex    m_working;
        std::condition_variable cv_working;
        //            timeout_t workingTerminateTimeout; /*!< время ожидания завершения потока */
};
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------