1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
// **********************************************************************
//
// Copyright (c) 2003-2016 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;
ICE_DEFINE_PTR(ObjectAdapterIPtr, ObjectAdapterI);
class ObjectAdapterI : public EnableSharedFromThis<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 ObjectPrxPtr add(const ObjectPtr&, const Identity&);
virtual ObjectPrxPtr addFacet(const ObjectPtr&, const Identity&, const std::string&);
virtual ObjectPrxPtr addWithUUID(const ObjectPtr&);
virtual ObjectPrxPtr 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 ObjectPrxPtr&) 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 ObjectPrxPtr createProxy(const Identity&) const;
virtual ObjectPrxPtr createDirectProxy(const Identity&) const;
virtual ObjectPrxPtr createIndirectProxy(const Identity&) const;
virtual void setLocator(const LocatorPrxPtr&);
virtual Ice::LocatorPrxPtr getLocator() const;
virtual void refreshPublishedEndpoints();
virtual EndpointSeq getEndpoints() const;
virtual EndpointSeq getPublishedEndpoints() const;
bool isLocal(const ObjectPrxPtr&) const;
void flushAsyncBatchRequests(const IceInternal::CommunicatorFlushBatchAsyncPtr&);
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; }
ObjectAdapterI(const IceInternal::InstancePtr&, const CommunicatorPtr&,
const IceInternal::ObjectAdapterFactoryPtr&, const std::string&, bool);
virtual ~ObjectAdapterI();
private:
void initialize(const RouterPrxPtr&);
friend class IceInternal::ObjectAdapterFactory;
ObjectPrxPtr newProxy(const Identity&, const std::string&) const;
ObjectPrxPtr newDirectProxy(const Identity&, const std::string&) const;
ObjectPrxPtr 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::ObjectPrxPtr&);
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;
size_t _messageSizeMax;
};
}
#endif
|
