exception.cc
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:4k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. #include "exception.hh"
  19. #ifdef USE_EXECINFO
  20. #include <execinfo.h>
  21. #endif
  22. #include <errno.h>
  23. #include <sstream>
  24. #include <typeinfo>
  25. using std::string;
  26. namespace hadoop {
  27.   /**
  28.    * Create an exception.
  29.    * @param message The message to give to the user.
  30.    * @param reason The exception that caused the new exception.
  31.    */
  32.   Exception::Exception(const string& message,
  33.                        const string& component,
  34.                        const string& location,
  35.                        const Exception* reason
  36.                        ): mMessage(message),
  37.                           mComponent(component),
  38.                           mLocation(location),
  39.                           mReason(reason)
  40.                           
  41.   {
  42. #ifdef USE_EXECINFO
  43.     mCalls = backtrace(mCallStack, sMaxCallStackDepth);
  44. #else
  45.     mCalls = 0;
  46. #endif
  47.   }
  48.   /**
  49.    * Copy the exception.
  50.    * Clones the reason, if there is one.
  51.    */
  52.   Exception::Exception(const Exception& other
  53.                        ): mMessage(other.mMessage), 
  54.                           mComponent(other.mComponent),
  55.                           mLocation(other.mLocation),
  56.                           mCalls(other.mCalls)
  57.   {
  58.     for(int i=0; i < mCalls; ++i) {
  59.       mCallStack[i] = other.mCallStack[i];
  60.     }
  61.     if (other.mReason) {
  62.       mReason = other.mReason->clone();
  63.     } else {
  64.       mReason = NULL;
  65.     }
  66.   }
  67.   Exception::~Exception() throw () {
  68.     delete mReason;
  69.   }
  70.   /**
  71.    * Print all of the information about the exception.
  72.    */
  73.   void Exception::print(std::ostream& stream) const {
  74.     stream << "Exception " << getTypename();
  75.     if (mComponent.size() != 0) {
  76.       stream << " (" << mComponent << ")";
  77.     }
  78.     stream << ": " << mMessage << "n";
  79.     if (mLocation.size() != 0) {
  80.       stream << "  thrown at " << mLocation << "n";
  81.     }
  82. #ifdef USE_EXECINFO
  83.     printCallStack(stream);
  84. #endif
  85.     if (mReason) {
  86.       stream << "caused by: ";
  87.       mReason->print(stream);
  88.     }
  89.     stream.flush();
  90.   }
  91.   /**
  92.    * Result of print() as a string.
  93.    */
  94.   string Exception::toString() const {
  95.     std::ostringstream stream;
  96.     print(stream);
  97.     return stream.str();
  98. }
  99. #ifdef USE_EXECINFO
  100.   /**
  101.    * Print the call stack where the exception was created.
  102.    */
  103.   void Exception::printCallStack(std::ostream& stream) const {
  104.       char ** symbols = backtrace_symbols(mCallStack, mCalls);
  105.       for(int i=0; i < mCalls; ++i) {
  106.         stream << "  ";
  107.         if (i == 0) {
  108.           stream << "at ";
  109.         } else {
  110.           stream << "from ";
  111.         }
  112.         stream << symbols[i] << "n";
  113.       }
  114.       free(symbols);
  115.   }
  116. #endif
  117.   const char* Exception::getTypename() const {
  118.     return "Exception";
  119.   }
  120.   Exception* Exception::clone() const {
  121.     return new Exception(*this);
  122.   }
  123.   IOException::IOException(const string& message,
  124.                          const string& component,
  125.                          const string& location,
  126.                          const Exception* reason
  127.                          ): Exception(message, component, location, reason) 
  128.   {
  129.   }
  130.   const char* IOException::getTypename() const {
  131.     return "IOException";
  132.   }
  133.   IOException* IOException::clone() const {
  134.     return new IOException(*this);
  135.   }
  136. }