ACE/ACEXML/common/SAXExceptions.cpp

   1 // -*- C++ -*-
   2
   3 #include "ACEXML/common/SAXExceptions.h"
   4 #include "ace/Log_Msg.h"
   5 #include "ace/ACE.h"
   6 #include "ace/OS_Memory.h"
   7 #include "ace/OS_NS_string.h"
   8
   9 const ACEXML_Char * ACEXML_SAXException::exception_name_ = ACE_TEXT ("ACEXML_SAXException");
  10
  11 const ACEXML_Char ACEXML_SAXNotSupportedException::exception_name_[] = ACE_TEXT ("ACEXML_SAXNotSupportedException");
  12
  13 const ACEXML_Char ACEXML_SAXNotRecognizedException::exception_name_[] = ACE_TEXT ("ACEXML_SAXNotRecognizedException");
  14
  15 const ACEXML_Char ACEXML_SAXParseException::exception_name_[] = ACE_TEXT ("ACEXML_SAXParseException");
  16
  17 #if !defined (__ACEXML_INLINE__)
  18 # include "ACEXML/common/SAXExceptions.inl"
  19 #endif /* __ACEXML_INLINE__ */
  20
  21 ACEXML_SAXException::ACEXML_SAXException ()
  22   : message_ (0)
  23 {
  24 }
  25
  26 ACEXML_SAXException::ACEXML_SAXException (const ACEXML_Char *msg)
  27   : message_ (ACE::strnew (msg))
  28 {
  29 }
  30
  31 ACEXML_SAXException::ACEXML_SAXException (const ACEXML_SAXException &ex)
  32   : ACEXML_Exception (ex),
  33     message_ (ACE::strnew (ex.message_))
  34
  35 {
  36 }
  37
  38 ACEXML_SAXException&
  39 ACEXML_SAXException::operator= (const ACEXML_SAXException& src)
  40 {
  41   if (this != &src)
  42     {
  43       ACE::strdelete (this->message_);
  44       this->message_ = ACE::strnew (src.message_);
  45     }
  46
  47   return *this;
  48 }
  49
  50 ACEXML_SAXException*
  51 ACEXML_SAXException::_downcast (ACEXML_Exception* ex)
  52 {
  53   return dynamic_cast<ACEXML_SAXException*> (ex);
  54 }
  55
  56 ACEXML_SAXException::~ACEXML_SAXException ()
  57 {
  58   ACE::strdelete (this->message_);
  59 }
  60
  61 ACEXML_Exception *
  62 ACEXML_SAXException::duplicate () const
  63 {
  64   ACEXML_Exception *tmp;
  65   ACE_NEW_RETURN (tmp, ACEXML_SAXException (*this), 0);
  66   return tmp;
  67 }
  68
  69 int
  70 ACEXML_SAXException::is_a (const ACEXML_Char *name)
  71 {
  72   return ACE_OS::strcmp (ACEXML_SAXException::exception_name_, name) == 0
  73     || this->ACEXML_Exception::is_a (name);
  74 }
  75
  76 void
  77 ACEXML_SAXException::print () const
  78 {
  79   ACE_ERROR ((LM_ERROR,
  80               ACE_TEXT ("ACEXML: (%P|%t) %s: %s\n"),
  81               this->exception_name_, this->message()));
  82 }
  83
  84 ACEXML_SAXNotSupportedException::ACEXML_SAXNotSupportedException ()
  85 {
  86 }
  87
  88 ACEXML_SAXNotSupportedException::ACEXML_SAXNotSupportedException (const ACEXML_SAXNotSupportedException &ex)
  89   : ACEXML_SAXException (ex)
  90 {
  91 }
  92
  93 ACEXML_SAXNotSupportedException&
  94 ACEXML_SAXNotSupportedException::operator= (const
  95                                             ACEXML_SAXNotSupportedException &ex)
  96 {
  97   this->ACEXML_SAXException::operator= (ex);
  98   return *this;
  99 }
 100
 101 ACEXML_SAXNotSupportedException*
 102 ACEXML_SAXNotSupportedException::_downcast (ACEXML_Exception* ex)
 103 {
 104   return dynamic_cast<ACEXML_SAXNotSupportedException*> (ex);
 105 }
 106
 107 ACEXML_SAXNotSupportedException::ACEXML_SAXNotSupportedException (const ACEXML_Char* msg)
 108   : ACEXML_SAXException (msg)
 109 {
 110 }
 111
 112 ACEXML_SAXNotSupportedException::~ACEXML_SAXNotSupportedException ()
 113 {
 114 }
 115
 116
 117 ACEXML_Exception *
 118 ACEXML_SAXNotSupportedException::duplicate () const
 119 {
 120   ACEXML_Exception *tmp;
 121   ACE_NEW_RETURN (tmp, ACEXML_SAXNotSupportedException (*this), 0);
 122   return tmp;
 123 }
 124
 125 int
 126 ACEXML_SAXNotSupportedException::is_a (const ACEXML_Char *name)
 127 {
 128   return ACE_OS::strcmp (ACEXML_SAXNotSupportedException::exception_name_,
 129                          name) == 0
 130     || this->ACEXML_SAXException::is_a (name);
 131 }
 132
 133 void
 134 ACEXML_SAXNotSupportedException::print () const
 135 {
 136   ACE_DEBUG ((LM_ERROR,
 137               ACE_TEXT ("ACEXML: (%P|%t) %s: %s\n"),
 138               this->exception_name_, this->message()));
 139 }
 140
 141 ACEXML_SAXNotRecognizedException::ACEXML_SAXNotRecognizedException ()
 142 {
 143 }
 144
 145 ACEXML_SAXNotRecognizedException::ACEXML_SAXNotRecognizedException (const ACEXML_Char *msg)
 146   : ACEXML_SAXException (msg)
 147 {
 148 }
 149
 150 ACEXML_SAXNotRecognizedException::ACEXML_SAXNotRecognizedException (const ACEXML_SAXNotRecognizedException &ex)
 151   : ACEXML_SAXException (ex)
 152 {
 153 }
 154
 155 ACEXML_SAXNotRecognizedException&
 156 ACEXML_SAXNotRecognizedException::operator= (const ACEXML_SAXNotRecognizedException &ex)
 157 {
 158   this->ACEXML_SAXException::operator= (ex);
 159   return *this;
 160 }
 161
 162 ACEXML_SAXNotRecognizedException*
 163 ACEXML_SAXNotRecognizedException::_downcast (ACEXML_Exception* ex)
 164 {
 165   return dynamic_cast<ACEXML_SAXNotRecognizedException*> (ex);
 166 }
 167
 168 ACEXML_SAXNotRecognizedException::~ACEXML_SAXNotRecognizedException ()
 169 {
 170 }
 171
 172 ACEXML_Exception *
 173 ACEXML_SAXNotRecognizedException::duplicate () const
 174 {
 175   ACEXML_Exception *tmp;
 176   ACE_NEW_RETURN (tmp, ACEXML_SAXNotRecognizedException (*this), 0);
 177   return tmp;
 178 }
 179
 180 int
 181 ACEXML_SAXNotRecognizedException::is_a (const ACEXML_Char *name)
 182 {
 183   return ACE_OS::strcmp (ACEXML_SAXNotRecognizedException::exception_name_,
 184                          name) == 0
 185     || this->ACEXML_SAXException::is_a (name);
 186 }
 187
 188 void
 189 ACEXML_SAXNotRecognizedException::print () const
 190 {
 191   ACE_DEBUG ((LM_ERROR,
 192               ACE_TEXT ("ACEXML: (%P|%t) %s: %s\n"),
 193               this->exception_name_, this->message()));
 194 }
 195
 196 ACEXML_SAXParseException::ACEXML_SAXParseException ()
 197 {
 198 }
 199
 200 ACEXML_SAXParseException::ACEXML_SAXParseException (const ACEXML_Char *msg)
 201   : ACEXML_SAXException (msg)
 202 {
 203 }
 204
 205 ACEXML_SAXParseException::ACEXML_SAXParseException (const ACEXML_SAXParseException &ex)
 206   : ACEXML_SAXException (ex)
 207 {
 208 }
 209
 210 ACEXML_SAXParseException&
 211 ACEXML_SAXParseException::operator= (const ACEXML_SAXParseException &ex)
 212 {
 213   this->ACEXML_SAXException::operator= (ex);
 214   return *this;
 215 }
 216
 217 ACEXML_SAXParseException*
 218 ACEXML_SAXParseException::_downcast (ACEXML_Exception* ex)
 219 {
 220   return dynamic_cast<ACEXML_SAXParseException*> (ex);
 221 }
 222
 223 ACEXML_SAXParseException::~ACEXML_SAXParseException ()
 224 {
 225 }
 226
 227 ACEXML_Exception *
 228 ACEXML_SAXParseException::duplicate () const
 229 {
 230   ACEXML_Exception *tmp;
 231   ACE_NEW_RETURN (tmp, ACEXML_SAXParseException (*this), 0);
 232   return tmp;
 233 }
 234
 235 int
 236 ACEXML_SAXParseException::is_a (const ACEXML_Char *name)
 237 {
 238   return ACE_OS::strcmp (ACEXML_SAXParseException::exception_name_,
 239                          name) == 0
 240     || this->ACEXML_SAXException::is_a (name);
 241 }
 242
 243 void
 244 ACEXML_SAXParseException::print () const
 245 {
 246   ACE_ERROR ((LM_ERROR,
 247               ACE_TEXT ("ACEXML: (%P|%t) %s: %s\n"),
 248                         this->exception_name_, this->message()));
 249 }