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
|
// **********************************************************************
//
// Copyright (c) 2003-2007 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_H
#define ICE_OBJECT_H
#include <IceUtil/Mutex.h>
#include <Ice/GCShared.h>
#include <Ice/ObjectF.h>
#include <Ice/ProxyF.h>
#include <Ice/IncomingAsyncF.h>
#include <Ice/Current.h>
#include <Ice/StreamF.h>
namespace IceInternal
{
class Incoming;
class BasicStream;
enum DispatchStatus
{
DispatchOK,
DispatchUserException,
DispatchObjectNotExist,
DispatchFacetNotExist,
DispatchOperationNotExist,
DispatchUnknownLocalException,
DispatchUnknownUserException,
DispatchUnknownException,
DispatchAsync // "Pseudo dispatch status", used internally only to indicate async dispatch.
};
}
namespace Ice
{
//
// No virtual inheritance from IceUtil::GCShared is required. This
// used to be virtual inheritance from IceUtil::Shared, because we
// could derive multiple times from IceUtil::Shared, such as deriving
// a servant class from both Ice::Object and IceUtil::Thread. However,
// we never derive from IceUtil::GCShared more than once.
//
class ICE_API Object : public IceInternal::GCShared
{
public:
virtual bool operator==(const Object&) const;
virtual bool operator!=(const Object&) const;
virtual bool operator<(const Object&) const;
virtual Int ice_hash() const;
virtual bool ice_isA(const std::string&, const Current& = Current()) const;
IceInternal::DispatchStatus ___ice_isA(IceInternal::Incoming&, const Current&);
virtual void ice_ping(const Current& = Current()) const;
IceInternal::DispatchStatus ___ice_ping(IceInternal::Incoming&, const Current&);
virtual std::vector< std::string> ice_ids(const Current& = Current()) const;
IceInternal::DispatchStatus ___ice_ids(IceInternal::Incoming&, const Current&);
virtual const std::string& ice_id(const Current& = Current()) const;
IceInternal::DispatchStatus ___ice_id(IceInternal::Incoming&, const Current&);
virtual Int ice_operationAttributes(const std::string&) const;
static const std::string& ice_staticId();
virtual ObjectPtr ice_clone() const;
virtual void ice_preMarshal();
virtual void ice_postUnmarshal();
static std::string __all[];
virtual IceInternal::DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
virtual void __write(IceInternal::BasicStream*) const;
virtual void __read(IceInternal::BasicStream*, bool);
virtual void __write(const OutputStreamPtr&) const;
virtual void __read(const InputStreamPtr&, bool);
virtual void __gcReachable(IceInternal::GCCountMap&) const {}
virtual void __gcClear() {}
protected:
Object() {} // This class is abstract.
virtual ~Object() {}
static void __checkMode(OperationMode, OperationMode);
};
class ICE_API Blobject : virtual public Object
{
public:
// Returns true if ok, false if user exception.
virtual bool ice_invoke(const std::vector<Byte>&, std::vector<Byte>&, const Current&) = 0;
virtual IceInternal::DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
};
class ICE_API BlobjectArray : virtual public Object
{
public:
// Returns true if ok, false if user exception.
virtual bool ice_invoke(const std::pair<const Byte*, const Byte*>&, std::vector<Byte>&, const Current&) = 0;
virtual IceInternal::DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
};
class ICE_API BlobjectAsync : virtual public Object
{
public:
// Returns true if ok, false if user exception.
virtual void ice_invoke_async(const AMD_Object_ice_invokePtr&, const std::vector<Byte>&, const Current&) = 0;
virtual IceInternal::DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
};
class ICE_API BlobjectArrayAsync : virtual public Object
{
public:
// Returns true if ok, false if user exception.
virtual void ice_invoke_async(const AMD_Array_Object_ice_invokePtr&, const std::pair<const Byte*, const Byte*>&,
const Current&) = 0;
virtual IceInternal::DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
};
ICE_API void ice_writeObject(const OutputStreamPtr&, const ObjectPtr&);
ICE_API void ice_readObject(const InputStreamPtr&, ObjectPtr&);
}
#endif
|
