servantlocators.h

Go to the documentation of this file.

// OSB library ********************************************* -*- C++ -*-
/*
  AUTHOR(S): Darryl Kang (dk)
             Huang Yong Feng (hyf)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.25 $

  License
   OSB rating and billing library for communication networks
   Copyright (C) 2004, 2005, 2006  OSB systems

   This file may be distributed and/or modify under the terms of the
   GNU General Public License (GPL) as published by the Free Software
   Foundation which is provided in the file LICENSE.GPL included in the
   packaging of this file.

   The file 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.

   Holders of a OSB Commercial License may use this file under the terms
   and conditions of this commercial license.
 */
#ifndef _SERVANTLOCATORS_H_
#define _SERVANTLOCATORS_H_

// *********************************************************************
// included header files
// + standard includes
#include <map>
#include <list>

// + libraries
#include <tao/PortableServer/Servant_Base.h>
#include <tao/PortableServer/ServantLocatorC.h>
#include <osbid.h>
#include <mutex.h>

// + local headers
#include "exceptionS.h"

// *********************************************************************
// namespace extensions
namespace OSB_CORBA {

    using corba::common::OsbCorbaException;

    class Locators : public virtual PortableServer::ServantLocator
    {
    public:
        typedef std::pair<unsigned long, unsigned long> Key;

    public:                             // static definition
        static const std::string IFC;

        static PortableServer::ObjectId_var keyToOid(
            const Key& key
        );

        static Key makeKey(long k1, long k2 = 0);

        template<typename T>
        static Key makeKey(const OSB_LIB::Id<T>& id)
        {
            return makeKey(id.id());
        }

        template<typename T>
        static Key makeKey(const OSB_LIB::Id2<T>& id)
        {
            return makeKey(id.id1_, id.id2_);
        }

    public:
        // Constructor with optional max. size.
        explicit Locators(unsigned long maxSize = 10000);

        // Destructor: deletes all registered servants.
        ~Locators();

    private:
        Locators(const Locators&);
        Locators& operator=(const Locators&);

    public:
        template<typename T>
        Key regServant(
            const OSB_LIB::Id2<T>&  id,
            PortableServer::Servant servant
        )
        {
            Locators::Key key = Locators::makeKey(id.id1_, id.id2_);
            return registerServant(key, servant);
        }

        template<typename T>
        Key regServant(
            const OSB_LIB::Id<T>&   id,
            PortableServer::Servant servant
        )
        {
            Locators::Key key = Locators::makeKey(id.id());
            return registerServant(key, servant);
        }

        Key regServant(
            PortableServer::Servant servant
        );

        template<typename T>
        Key regServantInc(
            const OSB_LIB::Id<T>&   id,
            PortableServer::Servant servant
        )
        {
            unsigned long c = increaseCounter();
            Locators::Key key = Locators::makeKey(id.id(), c);
            return registerServant(key, servant);
        }

        Key regServantInc(
            PortableServer::Servant servant
        );

        void unregServant(
            const Key& key,
                  bool destroy
        );

        PortableServer::Servant find(
            const Key&    key,
            unsigned long oid
        );

        PortableServer::Servant find(const Key& key);

        template<typename T>
        PortableServer::Servant find(
            const OSB_LIB::Id<T>& id
        )
        {
            return find(makeKey(id));
        }

        template<typename T>
        PortableServer::Servant find(
            const OSB_LIB::Id2<T>& id
        )
        {
            return find(makeKey(id));
        }

        virtual PortableServer::Servant preinvoke(
            const PortableServer::ObjectId& oid,
                  PortableServer::POA_ptr   poa,
            const char*                     operation,
                  void* &                   cookie
        ) throw (
            CORBA::SystemException, PortableServer::ForwardRequest
        );

        virtual void postinvoke(
            const PortableServer::ObjectId& oid,
                  PortableServer::POA_ptr   poa,
            const char*                     operation,
                  void*                     cookie,
                  PortableServer::Servant   servant
        ) throw (CORBA::SystemException);

    private:
        Key registerServant(
            Key                     key,
            PortableServer::Servant servant
        );

        unsigned long increaseCounter();

        CORBA::Boolean isEqual(
            const Key&    key,
            unsigned long oid
        );

        Key oidToKey(
            const PortableServer::ObjectId& oid
        ) throw (OsbCorbaException);

    private:
        typedef OSB_LIB::RwGuard RwGuard;
        RwGuard readlock();
        RwGuard writelock();

    private:
        typedef std::list<Key> EvictorQueue;

        typedef std::map<Key, PortableServer::Servant> ActiveObjectMap;

        OSB_LIB::RwMutex mutex_;

        unsigned long maxSize_;
        unsigned long count_;
        // ! Flag the locator is inside the destrctor.
        bool inDtor_;
        EvictorQueue evictorQ_;
        ActiveObjectMap servantMap_;
    };                                  // class Locators
}                                       // namespace OSB_CORBA
#endif                                  // #ifndef _SERVANTLOCATORS_H_

---