zeroc-ice 3.6b1

data/ext/ice/cpp/src/Ice/ObjectAdapterI.h

@@ -0,0 +1,155 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_OBJECT_ADAPTER_I_H
+#define ICE_OBJECT_ADAPTER_I_H
+
+#include <IceUtil/Shared.h>
+#include <IceUtil/RecMutex.h>
+#include <IceUtil/Monitor.h>
+#include <Ice/ObjectAdapter.h>
+#include <Ice/InstanceF.h>
+#include <Ice/ObjectAdapterFactoryF.h>
+#include <Ice/CommunicatorF.h>
+#include <Ice/ConnectionFactoryF.h>
+#include <Ice/ServantManagerF.h>
+#include <Ice/ProxyF.h>
+#include <Ice/ObjectF.h>
+#include <Ice/RouterInfoF.h>
+#include <Ice/EndpointIF.h>
+#include <Ice/LocatorInfoF.h>
+#include <Ice/ThreadPoolF.h>
+#include <Ice/OutgoingAsyncF.h>
+#include <Ice/Exception.h>
+#include <Ice/BuiltinSequences.h>
+#include <Ice/Proxy.h>
+#include <Ice/ACM.h>
+#include <list>
+
+namespace Ice
+{
+
+class ObjectAdapterI;
+typedef IceUtil::Handle<ObjectAdapterI> ObjectAdapterIPtr;
+
+class ObjectAdapterI : public ObjectAdapter, public IceUtil::Monitor<IceUtil::RecMutex>
+{
+public:
+
+    virtual std::string getName() const;
+
+    virtual CommunicatorPtr getCommunicator() const;
+
+    virtual void activate();
+    virtual void hold();
+    virtual void waitForHold();
+    virtual void deactivate();
+    virtual void waitForDeactivate();
+    virtual bool isDeactivated() const;
+    virtual void destroy();
+
+    virtual ObjectPrx add(const ObjectPtr&, const Identity&);
+    virtual ObjectPrx addFacet(const ObjectPtr&, const Identity&, const std::string&);
+    virtual ObjectPrx addWithUUID(const ObjectPtr&);
+    virtual ObjectPrx addFacetWithUUID(const ObjectPtr&, const std::string&);
+    virtual void addDefaultServant(const ObjectPtr&, const std::string&);
+    virtual ObjectPtr remove(const Identity&);
+    virtual ObjectPtr removeFacet(const Identity&, const std::string&);
+    virtual FacetMap removeAllFacets(const Identity&);
+    virtual ObjectPtr removeDefaultServant(const std::string&);
+    virtual ObjectPtr find(const Identity&) const;
+    virtual ObjectPtr findFacet(const Identity&, const std::string&) const;
+    virtual FacetMap findAllFacets(const Identity&) const;
+    virtual ObjectPtr findByProxy(const ObjectPrx&) const;
+    virtual ObjectPtr findDefaultServant(const std::string&) const;
+
+
+    virtual void addServantLocator(const ServantLocatorPtr&, const std::string&);
+    virtual ServantLocatorPtr removeServantLocator(const std::string&);
+    virtual ServantLocatorPtr findServantLocator(const std::string&) const;
+
+    virtual ObjectPrx createProxy(const Identity&) const;
+    virtual ObjectPrx createDirectProxy(const Identity&) const;
+    virtual ObjectPrx createIndirectProxy(const Identity&) const;
+
+    virtual void setLocator(const LocatorPrx&);
+    virtual Ice::LocatorPrx getLocator() const;
+    virtual void refreshPublishedEndpoints();
+
+    virtual EndpointSeq getEndpoints() const;
+    virtual EndpointSeq getPublishedEndpoints() const;
+    
+    bool isLocal(const ObjectPrx&) const;
+
+    void flushAsyncBatchRequests(const IceInternal::CommunicatorFlushBatchPtr&);
+
+    void updateConnectionObservers();
+    void updateThreadObservers();
+
+    void incDirectCount();
+    void decDirectCount();
+
+    IceInternal::ThreadPoolPtr getThreadPool() const;
+    IceInternal::ServantManagerPtr getServantManager() const;
+    IceInternal::ACMConfig getACM() const;
+    size_t messageSizeMax() const { return _messageSizeMax; }
+
+private:
+
+    ObjectAdapterI(const IceInternal::InstancePtr&, const CommunicatorPtr&, 
+                   const IceInternal::ObjectAdapterFactoryPtr&, const std::string&, bool);
+    virtual ~ObjectAdapterI();
+    void initialize(const RouterPrx&);
+    friend class IceInternal::ObjectAdapterFactory;
+    
+    ObjectPrx newProxy(const Identity&, const std::string&) const;
+    ObjectPrx newDirectProxy(const Identity&, const std::string&) const;
+    ObjectPrx newIndirectProxy(const Identity&, const std::string&, const std::string&) const;
+    void checkForDeactivation() const;
+    std::vector<IceInternal::EndpointIPtr> parseEndpoints(const std::string&, bool) const;
+    std::vector<IceInternal::EndpointIPtr> parsePublishedEndpoints();
+    void updateLocatorRegistry(const IceInternal::LocatorInfoPtr&, const Ice::ObjectPrx&, bool);
+    bool filterProperties(Ice::StringSeq&);
+
+    enum State
+    {
+        StateUninitialized,
+        StateHeld,
+        StateActivating,
+        StateActive,
+        StateDeactivating,
+        StateDeactivated,
+        StateDestroying,
+        StateDestroyed
+    };
+    State _state;
+    IceInternal::InstancePtr _instance;
+    CommunicatorPtr _communicator;
+    IceInternal::ObjectAdapterFactoryPtr _objectAdapterFactory;
+    IceInternal::ThreadPoolPtr _threadPool;
+    IceInternal::ACMConfig _acm;
+    IceInternal::ServantManagerPtr _servantManager;
+    const std::string _name;
+    const std::string _id;
+    const std::string _replicaGroupId;
+    IceInternal::ReferencePtr _reference;
+    std::vector<IceInternal::IncomingConnectionFactoryPtr> _incomingConnectionFactories;
+    std::vector<IceInternal::EndpointIPtr> _routerEndpoints;
+    IceInternal::RouterInfoPtr _routerInfo;
+    std::vector<IceInternal::EndpointIPtr> _publishedEndpoints;
+    IceInternal::LocatorInfoPtr _locatorInfo;
+    int _directCount; // The number of direct proxies dispatching on this object adapter.
+    bool _noConfig;
+    Identity _processId;
+    size_t _messageSizeMax;
+};
+
+}
+
+#endif

data/ext/ice/cpp/src/Ice/ObjectFactory.cpp

@@ -0,0 +1,41 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+//
+// Ice version 3.6b
+//
+// <auto-generated>
+//
+// Generated from file `ObjectFactory.ice'
+//
+// Warning: do not edit this file.
+//
+// </auto-generated>
+//
+
+#ifndef ICE_API_EXPORTS
+#   define ICE_API_EXPORTS
+#endif
+#include <Ice/ObjectFactory.h>
+#include <IceUtil/PushDisableWarnings.h>
+#include <Ice/BasicStream.h>
+#include <IceUtil/Iterator.h>
+#include <IceUtil/PopDisableWarnings.h>
+
+#ifndef ICE_IGNORE_VERSION
+#   if ICE_INT_VERSION  != 30651
+#       error Ice version mismatch: an exact match is required for beta generated code
+#   endif
+#endif
+
+namespace
+{
+
+}
+
+ICE_DECLSPEC_EXPORT ::Ice::LocalObject* Ice::upCast(::Ice::ObjectFactory* p) { return p; }

data/ext/ice/cpp/src/Ice/ObjectFactoryF.cpp

@@ -0,0 +1,38 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+//
+// Ice version 3.6b
+//
+// <auto-generated>
+//
+// Generated from file `ObjectFactoryF.ice'
+//
+// Warning: do not edit this file.
+//
+// </auto-generated>
+//
+
+#ifndef ICE_API_EXPORTS
+#   define ICE_API_EXPORTS
+#endif
+#include <Ice/ObjectFactoryF.h>
+#include <IceUtil/PushDisableWarnings.h>
+#include <IceUtil/Iterator.h>
+#include <IceUtil/PopDisableWarnings.h>
+
+#ifndef ICE_IGNORE_VERSION
+#   if ICE_INT_VERSION  != 30651
+#       error Ice version mismatch: an exact match is required for beta generated code
+#   endif
+#endif
+
+namespace
+{
+
+}

data/ext/ice/cpp/src/Ice/ObjectFactoryManager.cpp

@@ -0,0 +1,140 @@
+
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#include <Ice/ObjectFactoryManager.h>
+#include <Ice/ObjectFactory.h>
+#include <Ice/Functional.h>
+#include <Ice/LocalException.h>
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+IceUtil::Shared* IceInternal::upCast(ObjectFactoryManager* p) { return p; }
+
+void
+IceInternal::ObjectFactoryManager::add(const ObjectFactoryPtr& factory, const string& id)
+{
+    IceUtil::Mutex::Lock sync(*this);
+
+    if((_factoryMapHint != _factoryMap.end() && _factoryMapHint->first == id)
+       || _factoryMap.find(id) != _factoryMap.end())
+    {
+        AlreadyRegisteredException ex(__FILE__, __LINE__);
+        ex.kindOfObject = "object factory";
+        ex.id = id;
+        throw ex;
+    }
+
+    _factoryMapHint = _factoryMap.insert(_factoryMapHint, pair<const string, ObjectFactoryPtr>(id, factory));
+}
+
+void
+IceInternal::ObjectFactoryManager::remove(const string& id)
+{
+    ObjectFactoryPtr factory = 0;
+    {
+        IceUtil::Mutex::Lock sync(*this);
+        
+        FactoryMap::iterator p = _factoryMap.end();
+        if(_factoryMapHint != _factoryMap.end())
+        {
+            if(_factoryMapHint->first == id)
+            {
+                p = _factoryMapHint;
+            }
+        }
+        
+        if(p == _factoryMap.end())
+        {
+            p = _factoryMap.find(id);
+            if(p == _factoryMap.end())
+            {
+                NotRegisteredException ex(__FILE__, __LINE__);
+                ex.kindOfObject = "object factory";
+                ex.id = id;
+                throw ex;
+            }
+        }
+        assert(p != _factoryMap.end());
+        
+        factory = p->second;
+        
+        if(p == _factoryMapHint)
+        {
+            _factoryMap.erase(p++);
+            _factoryMapHint = p;
+        }
+        else
+        {
+            _factoryMap.erase(p);
+        }
+    }
+    
+    //
+    // Destroy outside the lock
+    //
+    assert(factory != 0);
+    factory->destroy();
+}
+
+ObjectFactoryPtr
+IceInternal::ObjectFactoryManager::find(const string& id) const
+{
+    IceUtil::Mutex::Lock sync(*this);
+   
+    FactoryMap& factoryMap = const_cast<FactoryMap&>(_factoryMap);
+
+    FactoryMap::iterator p = factoryMap.end();
+    if(_factoryMapHint != factoryMap.end())
+    {
+        if(_factoryMapHint->first == id)
+        {
+            p = _factoryMapHint;
+        }
+    }
+    
+    if(p == factoryMap.end())
+    {
+        p = factoryMap.find(id);
+    }
+    
+    if(p != factoryMap.end())
+    {
+        _factoryMapHint = p;
+        return p->second;
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+IceInternal::ObjectFactoryManager::ObjectFactoryManager() :
+    _factoryMapHint(_factoryMap.end())
+{
+}
+
+void
+IceInternal::ObjectFactoryManager::destroy()
+{
+    FactoryMap oldMap;
+    {
+        IceUtil::Mutex::Lock sync(*this);
+        oldMap.swap(_factoryMap);
+        _factoryMapHint = _factoryMap.end();
+    }
+
+    //
+    // Destroy all outside lock
+    //
+    for_each(oldMap.begin(), oldMap.end(),
+             Ice::secondVoidMemFun<const string, ObjectFactory>(&ObjectFactory::destroy));
+}

data/ext/ice/cpp/src/Ice/ObjectFactoryManager.h

@@ -0,0 +1,43 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_OBJECT_FACTORY_MANAGER_H
+#define ICE_OBJECT_FACTORY_MANAGER_H
+
+#include <IceUtil/Shared.h>
+#include <IceUtil/Mutex.h>
+#include <Ice/ObjectFactoryManagerF.h>
+#include <Ice/ObjectFactoryF.h>
+
+namespace IceInternal
+{
+
+class ObjectFactoryManager : public ::IceUtil::Shared, public ::IceUtil::Mutex
+{
+public:
+
+    void add(const ::Ice::ObjectFactoryPtr&, const std::string&);
+    void remove(const std::string&);
+    ::Ice::ObjectFactoryPtr find(const std::string&) const;
+
+    typedef std::map<std::string, ::Ice::ObjectFactoryPtr> FactoryMap;
+
+private:
+
+    ObjectFactoryManager();
+    void destroy();
+    friend class Instance;
+
+    FactoryMap _factoryMap;
+    mutable FactoryMap::iterator _factoryMapHint;
+};
+
+}
+
+#endif

data/ext/ice/cpp/src/Ice/ObserverHelper.cpp

@@ -0,0 +1,84 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#include <Ice/ObserverHelper.h>
+#include <Ice/Reference.h>
+#include <Ice/Instance.h>
+#include <Ice/Proxy.h>
+
+using namespace std;
+using namespace Ice;
+using namespace Ice::Instrumentation;
+
+namespace
+{
+
+Ice::Context emptyCtx;
+
+}
+
+IceInternal::InvocationObserver::InvocationObserver(IceProxy::Ice::Object* proxy, const string& op, const Context* ctx)
+{
+    const CommunicatorObserverPtr& obsv = proxy->__reference()->getInstance()->initializationData().observer;
+    if(!obsv)
+    {
+        return;
+    }
+
+    if(ctx)
+    {
+        attach(obsv->getInvocationObserver(proxy, op, *ctx));
+    }
+    else
+    {
+        attach(obsv->getInvocationObserver(proxy, op, emptyCtx));
+    }
+}
+
+IceInternal::InvocationObserver::InvocationObserver(IceInternal::Instance* instance, const string& op)
+{
+    const CommunicatorObserverPtr& obsv = instance->initializationData().observer;
+    if(!obsv)
+    {
+        return;
+    }
+
+    attach(obsv->getInvocationObserver(0, op, emptyCtx));
+}
+
+void
+IceInternal::InvocationObserver::attach(IceProxy::Ice::Object* proxy, const string& op, const Context* ctx)
+{
+    const CommunicatorObserverPtr& obsv = proxy->__reference()->getInstance()->initializationData().observer;
+    if(!obsv)
+    {
+        return;
+    }
+
+    if(ctx)
+    {
+        attach(obsv->getInvocationObserver(proxy, op, *ctx));
+    }
+    else
+    {
+        attach(obsv->getInvocationObserver(proxy, op, emptyCtx));
+    }
+}
+
+void
+IceInternal::InvocationObserver::attach(IceInternal::Instance* instance, const string& op)
+{
+    const CommunicatorObserverPtr& obsv = instance->initializationData().observer;
+    if(!obsv)
+    {
+        return;
+    }
+
+    attach(obsv->getInvocationObserver(0, op, emptyCtx));
+}