34 #ifndef HPP_CORBASERVER_SERVANT_BASE_HH 35 #define HPP_CORBASERVER_SERVANT_BASE_HH 41 namespace corbaServer {
73 #define SERVANT_BASE_TYPEDEFS(idlObj, hppObj) \ 75 using ::hpp::corbaServer::AbstractServantBase<hppObj>::server_; \ 79 typedef _Storage Storage; \ 80 typedef idlObj Object; \ 81 typedef idlObj##_ptr Object_ptr; \ 82 typedef idlObj##_var Object_var; \ 83 typedef ::hpp::corbaServer::ServantBase<hppObj, _Storage> _ServantBase; \ 84 using _ServantBase::get; \ 85 using _ServantBase::getT; \ 86 using _ServantBase::getS 101 template <
typename T>
109 virtual TShPtr_t
get()
const = 0;
119 template <
typename T,
typename _Storage>
130 virtual TShPtr_t
get()
const {
131 TWkPtr_t wk((StorageElementWkPtr_t)wrappedObject_);
139 StorageElementShPtr_t
getT()
const {
140 StorageElementWkPtr_t wk((StorageElementWkPtr_t)wrappedObject_);
148 const Storage&
getS()
const {
return wrappedObject_; }
162 persistantStorage(
false);
165 PortableServer::Servant servant =
166 dynamic_cast<PortableServer::Servant
>(
this);
168 throw Error(
"The object was deleted. I could not delete the servant.");
169 this->server_->removeServant(servant);
171 PortableServer::ObjectId_var objectId =
172 this->server_->poa()->servant_to_id(servant);
173 this->server_->poa()->deactivate_object(objectId.in());
179 persistantStorage(
true);
185 void objectExpired()
const {
187 PortableServer::Servant servant =
188 dynamic_cast<PortableServer::Servant
>(
const_cast<ServantBase*
>(
this));
190 throw Error(
"The object was deleted. I could not delete the servant.");
191 this->server_->removeServant(servant);
193 PortableServer::ObjectId_var objectId =
194 this->server_->poa()->servant_to_id(servant);
195 this->server_->poa()->deactivate_object(objectId.in());
196 throw Error(
"The object has been deleted. I delete the servant.");
217 template <
typename T,
typename Base>
225 operator shared_ptr<T>()
const {
return element.lock(); }
226 operator weak_ptr<T>()
const {
return element; }
231 operator bool()
const {
return use_count() > 0; }
234 typedef PortableServer::Servant_var<PortableServer::ServantBase>
237 template <
typename S,
typename P>
240 PortableServer::Servant s = server->
poa()->reference_to_servant(p);
241 if (s == NULL)
throw Error(
"The servant is not located here");
242 return dynamic_cast<S*
>(s);
247 template <
typename T,
typename P>
250 if (s.in() == NULL)
throw Error(
"The servant is not located here");
263 template <
typename P,
typename S>
266 S* servant =
dynamic_cast<S*
>(server->
getServant(servantKey));
267 if (servant != NULL) {
269 return servant->_this();
272 PortableServer::Servant_var<S> d(s);
274 PortableServer::ObjectId_var servantId = server->
poa()->activate_object(d);
284 template <
typename U,
typename V,
template <
typename>
class StorageTpl>
285 struct storage_cast_impl {
286 static StorageTpl<U> run(
const StorageTpl<V>& o) {
287 return o.template cast<U>();
292 template <
typename U,
typename V>
293 struct storage_cast_impl<U, V, shared_ptr> {
294 static shared_ptr<U> run(
const shared_ptr<V>& o) {
295 return dynamic_pointer_cast<U>(o);
300 template <
typename U,
typename V>
301 struct storage_cast_impl<U, V, weak_ptr> {
302 static weak_ptr<U> run(
const weak_ptr<V>& o) {
303 return dynamic_pointer_cast<U>(o.lock());
310 template <
typename U,
typename V,
template <
typename>
class StorageTpl>
311 static StorageTpl<U> storage_cast(
const StorageTpl<V>& o) {
312 return details::storage_cast_impl<U, V, StorageTpl>::run(o);
317 template <
typename T,
typename P>
320 if (s.in() == NULL)
throw Error(
"The servant is not located here");
324 if (asb == NULL)
throw Error(
"Not an object of the correct type.");
325 auto ret = storage_cast<T>(asb->
get());
326 if (!ret)
throw Error(
"Object is not of the correct type.");
333 template <
typename ServantBaseType>
336 typedef typename ServantBaseType::Storage
Storage;
341 virtual Object_var servant(
Server* server,
const Storage& obj) = 0;
352 template <
typename ServantBaseType,
typename ServantType>
361 typedef typename ServantType::Storage
Storage;
362 Storage u = storage_cast<
typename Storage::element_type>(o);
364 if (u.use_count() > 0)
365 ret = makeServant<Object_var>(s,
new ServantType(s, u));
370 template <
typename ServantBaseType>
373 template <
typename ServantBaseType>
375 typedef std::vector<ServantFactoryBase<ServantBaseType>*>
vector_t;
376 typedef typename vector_t::iterator iterator;
378 vector_t& vec = objectDowncasts<ServantBaseType>();
380 for (iterator _obj = vec.begin(); _obj != vec.end(); ++_obj) {
381 if (d >= (*_obj)->depth()) {
382 vec.insert(_obj,
object);
386 vec.push_back(
object);
391 template <
typename ServantBaseType,
typename ReturnType>
393 Server* server,
const typename ServantBaseType::Storage& t) {
394 typedef typename ServantBaseType::Object_var BaseObject_var;
395 typedef typename ReturnType::Object_var Object_var;
396 BaseObject_var servant;
397 assert(CORBA::Object_Helper::is_nil(servant.in()));
399 typedef std::vector<ServantFactoryBase<ServantBaseType>*>
vector_t;
400 typedef typename vector_t::iterator iterator;
402 vector_t& vec = objectDowncasts<ServantBaseType>();
403 for (iterator _obj = vec.begin(); _obj != vec.end(); ++_obj) {
404 servant = (*_obj)->servant(server, t);
405 if (!CORBA::Object_Helper::is_nil(servant.in())) {
407 return Object_var(ReturnType::Object::_narrow(servant._retn()));
413 template <
typename ServantBaseType>
415 Server* server,
const typename ServantBaseType::Storage& t) {
418 typedef typename ServantBaseType::Object_var Object_var;
420 assert(CORBA::Object_Helper::is_nil(servant.in()));
422 typedef std::vector<ServantFactoryBase<ServantBaseType>*>
vector_t;
423 typedef typename vector_t::iterator iterator;
425 vector_t& vec = objectDowncasts<ServantBaseType>();
426 for (iterator _obj = vec.begin(); _obj != vec.end(); ++_obj) {
427 servant = (*_obj)->servant(server, t);
428 if (!CORBA::Object_Helper::is_nil(servant.in()))
break;
434 template <
typename OutType,
typename InnerBaseType,
435 typename InnerType = InnerBaseType>
441 template <
typename InContainer>
443 std::size_t len = std::distance(input.begin(), input.end());
444 OutType* seq =
new OutType();
445 seq->length((CORBA::ULong)len);
448 typename InContainer::const_iterator it = input.begin();
449 while (it != input.end()) {
450 (*seq)[(CORBA::ULong)i] =
451 makeServantDownCast<InnerBaseType, InnerType>(wrappedObject_, *it)
472 #define HPP_CORBASERVER_ADD_DOWNCAST_OBJECT(ServantType, BaseServantType, \ 474 struct HPP_CORE_DLLAPI __InitializerClass_##ServantType { \ 475 __InitializerClass_##ServantType() { \ 476 ::hpp::corbaServer::addDowncastObjects<BaseServantType>( \ 477 new ::hpp::corbaServer::ServantFactory<BaseServantType, \ 478 ServantType>(depth)); \ 481 HPP_CORBASERVER_DLLLOCAL __InitializerClass_##ServantType \ 482 __instance_##ServantType; 484 #endif // HPP_CORBASERVER_SERVANT_BASE_HH Definition: servant-base.hh:120
auto reference_to_object(Server *server, const P &p)
Definition: servant-base.hh:318
PortableServer::Servant_var< PortableServer::ServantBase > ServantBase_var
Definition: servant-base.hh:235
std::vector< ServantFactoryBase< ServantBaseType > * > & objectDowncasts()
ServantFactory(const size_type &depth)
Definition: servant-base.hh:357
Definition: servant-base.hh:353
ServantBaseType::Object_var Object_var
Definition: servant-base.hh:337
Implement CORBA interface ``Obstacle''.
Definition: basic-server.hh:35
AbstractServantBase(Server *server)
Definition: servant-base.hh:114
weak_ptr< typename Storage::element_type > StorageElementWkPtr_t
Definition: servant-base.hh:125
AbstractServantBase< T > * reference_to_servant_base(Server *server, const P &p)
Definition: servant-base.hh:248
T element_type
Definition: servant-base.hh:230
ptr_t element
Definition: servant-base.hh:222
size_type depth() const
Definition: servant-base.hh:346
Abstract class used to avoid duplication of the servants.
Definition: servant-base.hh:92
PortableServer::Servant_var< S > reference_to_servant(Server *server, const P &p)
Definition: servant-base.hh:238
virtual TShPtr_t get() const =0
void addServantKeyAndServant(ServantKey servantKey, PortableServer::Servant servant)
Server * server_
Definition: servant-base.hh:116
Corba exception travelling through the Corba channel.
Definition: common.idl:26
Storage wrappedObject_
Definition: servant-base.hh:182
Definition: servant-base.hh:218
OutType * operator()(const InContainer &input)
Definition: servant-base.hh:442
bool persistantStorage() const
See persistantStorage(bool)
Definition: servant-base.hh:159
Definition: servant-base.hh:334
void addDowncastObjects(ServantFactoryBase< ServantBaseType > *const object)
Definition: servant-base.hh:374
pinocchio::vector_t vector_t
Definition: fwd.hh:112
const Storage & getS() const
Definition: servant-base.hh:148
ReturnType::Object_var makeServantDownCast(Server *server, const typename ServantBaseType::Storage &t)
Definition: servant-base.hh:392
PortableServer::POA_var poa()
Definition: server.hh:110
ServantBase(Server *server, const Storage &_s)
Definition: servant-base.hh:177
P makeServant(Server *server, S *s)
Definition: servant-base.hh:264
Server * wrappedObject_
Definition: servant-base.hh:437
AbstractStorage(const ptr_t &_element)
Definition: servant-base.hh:224
ServantBaseType::Object_var Object_var
Definition: servant-base.hh:354
virtual ~ServantBase()
Definition: servant-base.hh:128
vectorToSeqServant(Server *_s)
Definition: servant-base.hh:439
Definition: servant-base.hh:436
virtual Object_var servant(Server *s, const StorageBase &o)
Definition: servant-base.hh:360
weak_ptr< T > ptr_t
Definition: servant-base.hh:220
ServantBaseType::Storage StorageBase
Definition: servant-base.hh:355
Implementation of Hpp module Corba server.
Definition: server.hh:77
virtual Server::ServantKey getServantKey() const
Definition: servant-base.hh:111
PortableServer::Servant getServant(ServantKey servantKey) const
shared_ptr< typename Storage::element_type > StorageElementShPtr_t
Definition: servant-base.hh:126
Definition: servant-base.hh:102
void persistantStorage(bool persistant)
Set to true if the servant should take ownership of this object.
Definition: servant-base.hh:151
void * ServantKey
Definition: server.hh:157
Definition: servant-base.hh:89
shared_ptr< T > TShPtr_t
Definition: servant-base.hh:106
_Storage Storage
Definition: servant-base.hh:122
StorageElementShPtr_t getT() const
Definition: servant-base.hh:139
_CORBA_MODULE hpp _CORBA_MODULE_BEG _CORBA_MODULE core_idl _CORBA_MODULE_BEG typedef ::CORBA::ULongLong size_t
Definition: paths-idl.hh:75
void deleteThis()
Definition: servant-base.hh:161
weak_ptr< T > TWkPtr_t
Definition: servant-base.hh:107
ServantBaseType::Storage Storage
Definition: servant-base.hh:336
long use_count() const
Definition: servant-base.hh:227
pinocchio::size_type size_type
Definition: fwd.hh:115
virtual ~AbstractServantBase()
Definition: servant-base.hh:104
ServantFactoryBase(const size_type &depth)
Definition: servant-base.hh:339