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 "UniversalInterface.h"
#include "UniSetObject_i.hh"
#include "ThreadCreator.h"

//---------------------------------------------------------------------------
//#include <omnithread.h>
//---------------------------------------------------------------------------
class ObjectsActivator;
class ObjectsManager;

//---------------------------------------------------------------------------
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();
        virtual char* getName(){return (char*)myname.c_str();}
        virtual UniSetTypes::ObjectId getId(){ return myid; }
        virtual UniSetTypes::ObjectType getType() { return UniSetTypes::getObjectType("UniSetObject"); }
        virtual UniSetTypes::SimpleInfo* getInfo();
        friend std::ostream& operator<<(std::ostream& os, UniSetObject& obj );

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

        inline UniSetTypes::ObjectPtr getRef()
        {
            UniSetTypes::uniset_mutex_lock lock(refmutex, 300);
            return (UniSetTypes::ObjectPtr)CORBA::Object::_duplicate(oref);
        }

    protected:
            virtual void processingMessage(UniSetTypes::VoidMessage *msg);

            bool receiveMessage(UniSetTypes::VoidMessage& vm);
    
            unsigned int countMessages();
                
            void termWaiting();

            UniversalInterface ui; 
            std::string myname;
            std::string section;

            virtual bool disactivateObject(){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(){ disactivate(); }

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


            void setRecvMutexTimeout( unsigned long msec );
            inline unsigned long getRecvMutexTimeout(){ return recvMutexTimeout; }
            
            void setPushMutexTimeout( unsigned long msec );
            unsigned long getPushMutexTimeout(){ return pushMutexTimeout; }

            bool isActive();
            void setActive( bool set );

            UniSetTypes::VoidMessage msg;   
            ObjectsManager* mymngr; 

            void setThreadPriority( int p );
            
    private:

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

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

            void init_object();

            pid_t msgpid; // pid потока обработки сообщений
            bool reg;
            bool active;
            UniSetTypes::uniset_mutex act_mutex;
            bool threadcreate;
            UniSetTimer* tmr;
            UniSetTypes::ObjectId myid;
            CORBA::Object_var oref;
            ThreadCreator<UniSetObject>* thr;

            MessagesQueue queueMsg;

            UniSetTypes::uniset_mutex qmutex;

            UniSetTypes::uniset_mutex refmutex;

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