TAO/tao/Messaging/ExceptionHolder_i.cpp

   1 // -*- C++ -*-
   2 #include "tao/Messaging/ExceptionHolder_i.h"
   3
   4 #include "tao/Messaging/Messaging.h"
   5 #include "tao/Exception_Data.h"
   6 #include "tao/CDR.h"
   7
   8 #include <memory>
   9
  10 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  11
  12 namespace TAO
  13 {
  14   ExceptionHolder::ExceptionHolder () :
  15     data_ (0),
  16     count_ (0),
  17     char_translator_ (0),
  18     wchar_translator_ (0)
  19   {
  20   }
  21
  22   ExceptionHolder::ExceptionHolder (
  23       ::CORBA::Boolean is_system_exception,
  24       ::CORBA::Boolean byte_order,
  25       const ::CORBA::OctetSeq &marshaled_exception,
  26       ::TAO::Exception_Data* data,
  27       ::CORBA::ULong exceptions_count,
  28       ACE_Char_Codeset_Translator *char_translator,
  29       ACE_WChar_Codeset_Translator *wchar_translator) :
  30         ::OBV_Messaging::ExceptionHolder (is_system_exception, byte_order, marshaled_exception),
  31         data_ (data),
  32         count_ (exceptions_count),
  33         char_translator_ (char_translator),
  34         wchar_translator_ (wchar_translator)
  35   {
  36   }
  37
  38   ExceptionHolder::~ExceptionHolder ()
  39   {
  40   }
  41
  42   void
  43   ExceptionHolder::set_exception_data (::TAO::Exception_Data* data,
  44                                        ::CORBA::ULong exceptions_count)
  45   {
  46     this->data_ = data;
  47     this->count_ = exceptions_count;
  48   }
  49
  50   void ExceptionHolder::raise_exception ()
  51     {
  52       TAO_InputCDR _tao_in ((const char*) this->marshaled_exception ().get_buffer (),
  53                             this->marshaled_exception ().length (),
  54                             this->byte_order ());
  55
  56       _tao_in.char_translator (this->char_translator_);
  57       _tao_in.wchar_translator (this->wchar_translator_);
  58
  59       CORBA::String_var type_id;
  60
  61       if (!(_tao_in >> type_id.inout ()))
  62         {
  63           // Could not demarshal the exception id, raise a local
  64           // CORBA::MARSHAL
  65           throw ::CORBA::MARSHAL (TAO::VMCID, CORBA::COMPLETED_YES);
  66         }
  67
  68       if (this->is_system_exception ())
  69         {
  70           CORBA::ULong minor = 0;
  71           CORBA::ULong completion = 0;
  72           if (!(_tao_in >> minor) ||
  73               !(_tao_in >> completion))
  74             {
  75               throw ::CORBA::MARSHAL (TAO::VMCID, CORBA::COMPLETED_MAYBE);
  76             }
  77
  78           CORBA::SystemException* exception =
  79             TAO::create_system_exception (type_id.in ());
  80
  81           if (!exception)
  82             {
  83               // @@ We should raise a CORBA::NO_MEMORY, but we ran out
  84               //    of memory already. We need a pre-allocated, TSS,
  85               //    CORBA::NO_MEMORY instance
  86               ACE_NEW (exception, CORBA::UNKNOWN);
  87             }
  88           exception->minor (minor);
  89           exception->completed (CORBA::CompletionStatus (completion));
  90
  91           // Raise the exception.
  92           std::unique_ptr<CORBA::SystemException> e_ptr(exception);
  93           exception->_raise ();
  94
  95           return;
  96         }
  97
  98       // Match the exception interface repository id with the
  99       // exception in the exception list.
 100       // This is important to decode the exception.
 101       for (CORBA::ULong i = 0; i != this->count_; ++i)
 102         {
 103           if (ACE_OS::strcmp (type_id.in (), this->data_[i].id) != 0)
 104             continue;
 105
 106           CORBA::Exception * const exception = this->data_[i].alloc ();
 107
 108           if (exception == 0)
 109             {
 110               throw ::CORBA::NO_MEMORY (TAO::VMCID, CORBA::COMPLETED_YES);
 111             }
 112           else
 113             {
 114               exception->_tao_decode (_tao_in);
 115             }
 116
 117           // Raise the exception.
 118           std::unique_ptr<CORBA::Exception> e_ptr (exception);
 119           exception->_raise ();
 120
 121           return;
 122         }
 123
 124       // If we couldn't find the right exception, report it as
 125       // CORBA::UNKNOWN.
 126
 127       // @@ It would seem like if the remote exception is a
 128       //    UserException we can assume that the request was
 129       //    completed.
 130       throw ::CORBA::UNKNOWN (TAO::VMCID, CORBA::COMPLETED_YES);
 131     }
 132
 133   void ExceptionHolder::raise_exception_with_list (
 134       const ::Dynamic::ExceptionList &)
 135     {
 136       // todo convert exceptionlist to something we can really use.
 137       this->raise_exception ();
 138     }
 139
 140   CORBA::ValueBase*
 141   ExceptionHolder::_copy_value ()
 142   {
 143     TAO::ExceptionHolder* ret_val = 0;
 144     ACE_NEW_THROW_EX (ret_val,
 145                       ExceptionHolder,
 146                       CORBA::NO_MEMORY ());
 147
 148     // @todo According to the latest corba spec we should be able to
 149     // pass this to the ExceptionHolder constructor but the TAO_IDL
 150     // compiler doesn't seem to generate this.
 151     ret_val->is_system_exception (this->is_system_exception ());
 152     ret_val->byte_order (this->byte_order ());
 153     ret_val->marshaled_exception (this->marshaled_exception ());
 154
 155     return ret_val;
 156   }
 157
 158   CORBA::ValueBase *
 159   ExceptionHolderFactory::create_for_unmarshal ()
 160   {
 161     TAO::ExceptionHolder* ret_val = 0;
 162     ACE_NEW_THROW_EX (ret_val,
 163                       ExceptionHolder,
 164                       CORBA::NO_MEMORY ());
 165     return ret_val;
 166   }
 167 }
 168
 169 TAO_END_VERSIONED_NAMESPACE_DECL
 170