34#ifndef HPP_CORBASERVER_SERVANT_BASE_HH
35#define HPP_CORBASERVER_SERVANT_BASE_HH
41namespace 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
119template <
typename T,
typename _Storage>
165 PortableServer::Servant servant =
166 dynamic_cast<PortableServer::Servant
>(
this);
168 throw Error(
"The object was deleted. I could not delete the servant.");
171 PortableServer::ObjectId_var objectId =
173 this->
server_->
poa()->deactivate_object(objectId.in());
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.");
193 PortableServer::ObjectId_var objectId =
195 this->
server_->
poa()->deactivate_object(objectId.in());
196 throw Error(
"The object has been deleted. I delete the servant.");
217template <
typename T,
typename Base>
225 operator shared_ptr<T>()
const {
return element.lock(); }
226 operator weak_ptr<T>()
const {
return element; }
234typedef PortableServer::Servant_var<PortableServer::ServantBase>
237template <
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);
247template <
typename T,
typename P>
250 if (s.in() == NULL)
throw Error(
"The servant is not located here");
263template <
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);
284template <
typename U,
typename V,
template <
typename>
class StorageTpl>
285struct storage_cast_impl {
286 static StorageTpl<U> run(
const StorageTpl<V>& o) {
287 return o.template cast<U>();
292template <
typename U,
typename V>
293struct 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);
300template <
typename U,
typename V>
301struct 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());
310template <
typename U,
typename V,
template <
typename>
class StorageTpl>
311static StorageTpl<U> storage_cast(
const StorageTpl<V>& o) {
312 return details::storage_cast_impl<U, V, StorageTpl>::run(o);
317template <
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.");
333template <
typename ServantBaseType>
336 typedef typename ServantBaseType::Storage
Storage;
352template <
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));
370template <
typename ServantBaseType>
373template <
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);
391template <
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()));
413template <
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;
434template <
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;
Definition: servant-base.hh:102
weak_ptr< T > TWkPtr_t
Definition: servant-base.hh:107
virtual ~AbstractServantBase()
Definition: servant-base.hh:104
shared_ptr< T > TShPtr_t
Definition: servant-base.hh:106
AbstractServantBase(Server *server)
Definition: servant-base.hh:114
Server * server_
Definition: servant-base.hh:116
virtual TShPtr_t get() const =0
virtual Server::ServantKey getServantKey() const
Definition: servant-base.hh:111
Abstract class used to avoid duplication of the servants.
Definition: servant-base.hh:92
virtual Server::ServantKey getServantKey() const =0
Definition: servant-base.hh:218
long use_count() const
Definition: servant-base.hh:227
weak_ptr< T > ptr_t
Definition: servant-base.hh:220
T element_type
Definition: servant-base.hh:230
ptr_t element
Definition: servant-base.hh:222
AbstractStorage(const ptr_t &_element)
Definition: servant-base.hh:224
Definition: servant-base.hh:120
void deleteThis()
Definition: servant-base.hh:161
bool persistantStorage() const
See persistantStorage(bool)
Definition: servant-base.hh:159
virtual ~ServantBase()
Definition: servant-base.hh:128
const Storage & getS() const
Definition: servant-base.hh:148
_Storage Storage
Definition: servant-base.hh:122
Storage wrappedObject_
Definition: servant-base.hh:182
ServantBase(Server *server, const Storage &_s)
Definition: servant-base.hh:177
weak_ptr< typename Storage::element_type > StorageElementWkPtr_t
Definition: servant-base.hh:125
shared_ptr< typename Storage::element_type > StorageElementShPtr_t
Definition: servant-base.hh:126
void persistantStorage(bool persistant)
Set to true if the servant should take ownership of this object.
Definition: servant-base.hh:151
StorageElementShPtr_t getT() const
Definition: servant-base.hh:139
virtual TShPtr_t get() const
Definition: servant-base.hh:130
Definition: servant-base.hh:334
ServantBaseType::Object_var Object_var
Definition: servant-base.hh:337
size_type depth() const
Definition: servant-base.hh:346
ServantFactoryBase(const size_type &depth)
Definition: servant-base.hh:339
virtual Object_var servant(Server *server, const Storage &obj)=0
ServantBaseType::Storage Storage
Definition: servant-base.hh:336
Implementation of Hpp module Corba server.
Definition: server.hh:77
PortableServer::Servant getServant(ServantKey servantKey) const
void addServantKeyAndServant(ServantKey servantKey, PortableServer::Servant servant)
void removeServant(PortableServer::Servant servant)
PortableServer::POA_var poa()
Definition: server.hh:110
void * ServantKey
Definition: server.hh:157
Corba exception travelling through the Corba channel.
Definition: common.idl:27
ReturnType::Object_var makeServantDownCast(Server *server, const typename ServantBaseType::Storage &t)
Definition: servant-base.hh:392
PortableServer::Servant_var< S > reference_to_servant(Server *server, const P &p)
Definition: servant-base.hh:238
P makeServant(Server *server, S *s)
Definition: servant-base.hh:264
void addDowncastObjects(ServantFactoryBase< ServantBaseType > *const object)
Definition: servant-base.hh:374
PortableServer::Servant_var< PortableServer::ServantBase > ServantBase_var
Definition: servant-base.hh:235
std::vector< ServantFactoryBase< ServantBaseType > * > & objectDowncasts()
auto reference_to_object(Server *server, const P &p)
Definition: servant-base.hh:318
AbstractServantBase< T > * reference_to_servant_base(Server *server, const P &p)
Definition: servant-base.hh:248
pinocchio::vector_t vector_t
Definition: fwd.hh:112
pinocchio::size_type size_type
Definition: fwd.hh:115
Implement CORBA interface `‘Obstacle’'.
Definition: basic-server.hh:35
Definition: servant-base.hh:353
ServantBaseType::Storage StorageBase
Definition: servant-base.hh:355
ServantBaseType::Object_var Object_var
Definition: servant-base.hh:354
ServantFactory(const size_type &depth)
Definition: servant-base.hh:357
virtual Object_var servant(Server *s, const StorageBase &o)
Definition: servant-base.hh:360
Definition: servant-base.hh:89
Definition: servant-base.hh:436
OutType * operator()(const InContainer &input)
Definition: servant-base.hh:442
Server * wrappedObject_
Definition: servant-base.hh:437
vectorToSeqServant(Server *_s)
Definition: servant-base.hh:439