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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
// -*- C++ -*-
//=============================================================================
/**
* @file Servant_var.h
*
* $Id$
*
* @author Jody Hagins <jody@atdesk.com>
* @author Carlos O'Ryan <coryan@atdesk.com>
*/
//=============================================================================
#ifndef TAO_PORTABLESERVER_SERVANT_VAR_H
#define TAO_PORTABLESERVER_SERVANT_VAR_H
#include /**/ "ace/pre.h"
#include "ace/config-all.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#include "tao/orbconf.h"
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
namespace PortableServer
{
/**
* @class Servant_var
*
* @brief Provides a type safe counted reference to servants.
*
* @author Jody Hagins
*
* @todo Life would be much easier if _add_ref() and _remove_ref() had
* throw specs of "throw ()", that can be hidden in static
* methods though.
*/
template<class T>
class Servant_var
{
public:
typedef T servant_type;
/// Constructor. Assumes ownership of @c p.
Servant_var (T * p = 0);
/// Copy constructor. Adds reference to @c rhs.
Servant_var (Servant_var<T> const & rhs);
/// Assignment operator. Adds reference to @c rhs.
Servant_var<T> & operator= (Servant_var<T> const & rhs);
/// Destructor. Removes a reference from the underlying object,
/// possibly destroying it.
/**
* This destructor doesn't throw exceptions.
*/
~Servant_var (void) /* throw () */;
/// Assignment operator. Assumes ownership of @c p.
Servant_var<T> & operator= (T * p);
/**
@@ Ciju:
The below member templates was commented out because:
1. gcc 2.95 doesn't support them.
2. Sun cc 5.8 member templates support is buggy (Bug Id: 6463114).
Once these have been fixed a decision can be made regards
uncommenting them. My own openion is that they shouldn't be used
since making implicit constructors, member templates, you could
potentially get an unwanted conversion where one was unwarranted.
*/
/*
# if !defined(ACE_LACKS_MEMBER_TEMPLATES)
/// Template member constructor from a pointer that will implicitly
/// cast to type T. Assumes ownership of @c p.
/// This constructor allows constructs such as:
/// Servant_Base<Base> p(new Derived);
template <class Y>
Servant_var (Y * p);
/// Template member copy constructor from a Servant_var<Y>, where
/// Y can be implicitly cast to type T.
template <class Y>
Servant_var (Servant_var<Y> const & rhs);
/// Template member assignment operator from a Servant_var<Y>, where
/// Y can be implicitly cast to type T.
template <class Y>
Servant_var<T> & operator= (Servant_var<Y> const & rhs);
/// Template member assignment operator from a pointer to Y, where Y
/// can be implicitly cast to type T.
template <class Y>
Servant_var<T> & operator= (Y * p);
# endif / * ACE_LACKS_MEMBER_TEMPLATES * /
*/
/// Smart pointer operator-> provides access to the underlying object.
T const * operator->() const;
/// Smart pointer operator-> provides access to the underlying object.
T * operator->();
/// Dereference the underlying object.
T const & operator*() const;
/// Dereference the underlying object.
T & operator*();
/// Return a void pointer to the underlying object. This allows
/// it to be used in conditional code and tested against 0.
operator void const * () const;
/// As an IN parameter.
T * in() const;
/// As an INOUT parameter.
T *& inout();
/// As an OUT parameter.
T *& out();
/// Return a pointer to the underlying object, and this counted
/// reference will no longer own the object.
T * _retn();
/// Increment the reference count and return the servant.
/**
* It is safe to pass in a null pointer, the pointer is simply
* returned in that case.
*
* @todo We might want to catch all (potential) exceptions in
* _add_ref().
*
* @todo It might be useful to add a _release() method that handles
* any potential exceptions...
*/
static T * _duplicate (T *);
/// Swap the contents of a Servant_var<T> with another
/// Servant_var<T>
/**
* Non-throwing swap operation.
* Often used to implement strong exception safety.
*/
void swap (Servant_var<T> & rhs) /* throw () */;
private:
T * ptr_;
};
/// Compare two Servant_vars for equivalence.
template <class X, class Y>
bool operator==(Servant_var<X> const & x,
Servant_var<Y> const & y);
/// Compare two Servant_vars for non-equivalence.
template <class X, class Y>
bool operator!=(Servant_var<X> const & x,
Servant_var<Y> const & y);
} // namespace PortableServer
TAO_END_VERSIONED_NAMESPACE_DECL
#if defined (__ACE_INLINE__)
# include "tao/PortableServer/Servant_var.inl"
#endif /* __ACE_INLINE__ */
#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
#include "tao/PortableServer/Servant_var.cpp"
#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
#pragma implementation ("tao/PortableServer/Servant_var.cpp")
#endif
#include /**/ "ace/post.h"
#endif /* TAO_PORTABLESERVER_SERVANT_VAR_H */
|
