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
|
// **********************************************************************
//
// Copyright (c) 2003
// ZeroC, Inc.
// Billerica, MA, USA
//
// All Rights Reserved.
//
// Ice is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License version 2 as published by
// the Free Software Foundation.
//
// **********************************************************************
#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/Exception.h>
#include <Ice/EndpointF.h>
#include <Ice/LocatorInfoF.h>
#include <Ice/ThreadPoolF.h>
#include <Ice/Process.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();
virtual CommunicatorPtr getCommunicator();
virtual void activate();
virtual void hold();
virtual void waitForHold();
virtual void deactivate();
virtual void waitForDeactivate();
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 remove(const Identity&);
virtual void removeFacet(const Identity&, const std::string&);
virtual ObjectPtr find(const Identity&);
virtual ObjectPtr findFacet(const Identity&, const std::string&);
virtual ObjectPtr findByProxy(const ObjectPrx&);
virtual void addServantLocator(const ServantLocatorPtr&, const std::string&);
virtual ServantLocatorPtr findServantLocator(const std::string&);
virtual ObjectPrx createProxy(const Identity&);
virtual ObjectPrx createDirectProxy(const Identity&);
virtual ObjectPrx createReverseProxy(const Identity&);
virtual void addRouter(const RouterPrx&);
virtual void setLocator(const LocatorPrx&);
virtual LocatorPrx getLocator();
bool isLocal(const ObjectPrx&) const;
std::list<IceInternal::ConnectionPtr> getIncomingConnections() const;
void flushBatchRequests();
void incDirectCount();
void decDirectCount();
IceInternal::ThreadPoolPtr getThreadPool() const;
IceInternal::ServantManagerPtr getServantManager() const;
private:
ObjectAdapterI(const IceInternal::InstancePtr&, const CommunicatorPtr&, const std::string&);
virtual ~ObjectAdapterI();
friend class IceInternal::ObjectAdapterFactory;
ObjectPrx newProxy(const Identity&) const;
ObjectPrx newDirectProxy(const Identity&) const;
void checkForDeactivation() const;
static void checkIdentity(const Identity&);
bool _deactivated;
IceInternal::InstancePtr _instance;
CommunicatorPtr _communicator;
IceInternal::ThreadPoolPtr _threadPool;
IceInternal::ServantManagerPtr _servantManager;
bool _printAdapterReadyDone;
const std::string _name;
const std::string _id;
std::vector<IceInternal::IncomingConnectionFactoryPtr> _incomingConnectionFactories;
std::vector<IceInternal::EndpointPtr> _routerEndpoints;
IceInternal::LocatorInfoPtr _locatorInfo;
int _directCount; // The number of direct proxies dispatching on this object adapter.
bool _waitForDeactivate;
class ProcessI : public Process
{
public:
ProcessI(const CommunicatorPtr&);
virtual void shutdown(const Current&);
private:
CommunicatorPtr _communicator;
};
};
}
#endif
|
