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 <unistd.h>
#include <sys/time.h>
#include <queue>
#include <ostream>
#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 <omnithread.h>
//---------------------------------------------------------------------------
class UniSetActivator;
class UniSetManager;

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

        // Функции объявленные в 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() 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);
        }

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

            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( unsigned int s )
            {
                if( s>=0 )
                    SizeOfMessageQueue = s;
            }

            inline unsigned int getMaxSizeOfMessageQueue()
            { return SizeOfMessageQueue; }

            void setMaxCountRemoveOfMessage( unsigned int m )
            {
                if( m >=0 )
                    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;
            UniSetManager* mymngr; 

            void setThreadPriority( int p );

    private:

            friend class UniSetManager;
            friend class UniSetActivator;
            friend class ThreadCreator<UniSetObject>;
            inline pid_t getMsgPID()
            {
                return msgpid;
            }

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

            void init_object();

            pid_t msgpid; // pid потока обработки сообщений
            bool reg;
            std::atomic_bool active;

            bool threadcreate;
            UniSetTimer* tmr;
            UniSetTypes::ObjectId myid;
            CORBA::Object_var oref;
            ThreadCreator<UniSetObject>* thr;

            MessagesQueue queueMsg;

            UniSetTypes::uniset_rwmutex qmutex;

            mutable UniSetTypes::uniset_rwmutex refmutex;

            unsigned int SizeOfMessageQueue;
            unsigned int MaxCountRemoveOfMessage;

            // статистическая информация 
            unsigned long stMaxQueueMessages;    /*<! Максимальное число сообщений хранившихся в очереди */
            unsigned long stCountOfQueueFull;     
};
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------