TAO/tao/PortableServer/SUpcall_commands.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    SUpcall_commands.h
   6  *
   7  *  @author  Marcel Smit <msmit@remedy.nl>
   8  *
   9  * @brief Upcall command exection classes for static skeleton methods
  10  *
  11  * This file contains the classes needed to perform an upcall command for
  12  * the following static methods, defined in Servant_Base.h
  13  * - _is_a_skel
  14  * - _non_existent_skel
  15  * - _component_skel
  16  * - _repository_id_skel
  17  * - _interface_skel
  18  */
  19 //=============================================================================
  20
  21 #ifndef TAO_SUPCALL_COMMANDS_H
  22 #define TAO_SUPCALL_COMMANDS_H
  23
  24 #include /**/ "ace/pre.h"
  25
  26 #include "tao/PortableServer/Upcall_Command.h"
  27
  28 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  29 # pragma once
  30 #endif /* ACE_LACKS_PRAGMA_ONCE */
  31
  32 #include "tao/PortableServer/Upcall_Wrapper.h"
  33 #include "tao/operation_details.h"
  34
  35 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  36
  37 /**
  38  * @class _is_a_thru_poa_Upcall_Command
  39  *
  40  * @brief Execution class for _is_a_skel.
  41  */
  42 class _is_a_thru_poa_Upcall_Command
  43   : public TAO::Upcall_Command
  44 {
  45 public:
  46   inline _is_a_thru_poa_Upcall_Command (
  47     TAO_ServantBase * servant,
  48     TAO_Operation_Details const * operation_details,
  49     TAO::Argument * const args[])
  50     : servant_ (servant)
  51     , operation_details_ (operation_details)
  52     , args_ (args)
  53   {}
  54
  55   virtual void execute ();
  56
  57 private:
  58   TAO_ServantBase * const servant_;
  59   TAO_Operation_Details const * const operation_details_;
  60   TAO::Argument * const * const args_;
  61 };
  62
  63 /**
  64  * @class _is_a_Upcall_Command
  65  *
  66  * @brief Execution class for _is_a_skel when through POA option is used.
  67  */
  68 class _is_a_Upcall_Command
  69   : public TAO::Upcall_Command
  70 {
  71 public:
  72   inline _is_a_Upcall_Command (
  73     TAO_ServantBase * servant,
  74     TAO::Argument * const args[])
  75     : servant_ (servant)
  76     , args_ (args)
  77   {
  78   }
  79
  80   virtual void execute ();
  81
  82 private:
  83   TAO_ServantBase * const servant_;
  84   TAO::Argument * const * const args_;
  85 };
  86
  87
  88 /**
  89  * @class _non_existent_thru_poa_Upcall_Command
  90  *
  91  * @brief Execution class for _non_existent_skel.
  92  */
  93 #if (TAO_HAS_MINIMUM_CORBA == 0)
  94 class _non_existent_thru_poa_Upcall_Command
  95   : public TAO::Upcall_Command
  96 {
  97 public:
  98   inline _non_existent_thru_poa_Upcall_Command (
  99     TAO_ServantBase * servant,
 100     TAO_Operation_Details const * operation_details,
 101     TAO::Argument * const args[])
 102     : servant_ (servant)
 103     , operation_details_ (operation_details)
 104     , args_ (args)
 105   {
 106   }
 107
 108   virtual void execute ();
 109 private:
 110   TAO_ServantBase * const servant_;
 111   TAO_Operation_Details const * const operation_details_;
 112   TAO::Argument * const * const args_;
 113 };
 114
 115 /**
 116  * @class _non_existent_Upcall_Command
 117  *
 118  * @brief Execution class for _non_existent_skel when through POA option is used.
 119  */
 120 class _non_existent_Upcall_Command
 121   : public TAO::Upcall_Command
 122 {
 123 public:
 124   inline _non_existent_Upcall_Command (
 125     TAO_ServantBase * servant,
 126     TAO::Argument * const args[])
 127     : servant_ (servant)
 128     , args_ (args)
 129   {
 130   }
 131
 132   virtual void execute ();
 133
 134 private:
 135   TAO_ServantBase * const servant_;
 136   TAO::Argument * const * const args_;
 137 };
 138
 139
 140 # if !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
 141 /**
 142  * @class _get_component_thru_poa_Upcall_Command
 143  *
 144  * @brief Execution class for _component_skel.
 145  */
 146 class _get_component_thru_poa_Upcall_Command
 147   : public TAO::Upcall_Command
 148 {
 149 public:
 150   inline _get_component_thru_poa_Upcall_Command (
 151     TAO_ServantBase * servant,
 152     TAO_Operation_Details const * operation_details,
 153     TAO::Argument * const args[])
 154     : servant_ (servant)
 155     , operation_details_ (operation_details)
 156     , args_ (args)
 157   {
 158   }
 159
 160   virtual void execute ();
 161
 162 private:
 163   TAO_ServantBase * const servant_;
 164   TAO_Operation_Details const * const operation_details_;
 165   TAO::Argument * const * const args_;
 166 };
 167
 168 /**
 169  * @class _get_component_Upcall_Command
 170  *
 171  * @brief Execution class for _get_component when through POA option is used.
 172  */
 173 class _get_component_Upcall_Command
 174   : public TAO::Upcall_Command
 175 {
 176 public:
 177   inline _get_component_Upcall_Command (
 178     TAO_ServantBase * servant,
 179     TAO::Argument * const args[])
 180     : servant_ (servant)
 181       , args_ (args)
 182   {
 183   }
 184
 185   virtual void execute ();
 186
 187 private:
 188   TAO_ServantBase * const servant_;
 189   TAO::Argument * const * const args_;
 190 };
 191 # endif /* !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO) */
 192
 193 /**
 194  * @class _repository_id_thru_poa_Upcall_Command
 195  *
 196  * @brief Execution class for _repository_id_skel
 197  */
 198 class _repository_id_thru_poa_Upcall_Command
 199   : public TAO::Upcall_Command
 200 {
 201 public:
 202   inline _repository_id_thru_poa_Upcall_Command (
 203     TAO_ServantBase * servant,
 204     TAO_Operation_Details const * operation_details,
 205     TAO::Argument * const args[])
 206     : servant_ (servant)
 207     , operation_details_ (operation_details)
 208     , args_ (args)
 209   {
 210   }
 211
 212   virtual void execute ();
 213
 214 private:
 215   TAO_ServantBase * const servant_;
 216   TAO_Operation_Details const * const operation_details_;
 217   TAO::Argument * const * const args_;
 218 };
 219
 220 /**
 221  * @class _repository_id_Upcall_Command
 222  *
 223  * @brief Execution class for _repository_id when through POA option is used.
 224  */
 225 class _repository_id_Upcall_Command
 226   : public TAO::Upcall_Command
 227 {
 228 public:
 229   inline _repository_id_Upcall_Command (
 230     TAO_ServantBase * servant,
 231     TAO::Argument * const args[])
 232     : servant_ (servant)
 233     , args_ (args)
 234   {
 235   }
 236
 237   virtual void execute ();
 238
 239 private:
 240   TAO_ServantBase * const servant_;
 241   TAO::Argument * const * const args_;
 242 };
 243
 244 #endif /* TAO_HAS_MINIMUM_CORBA */
 245
 246 TAO_END_VERSIONED_NAMESPACE_DECL
 247
 248 #include /**/ "ace/post.h"
 249
 250 #endif /* TAO_SUPCALL_COMMANDS_H */