libs/EDoc/PropogatingException.cpp

Go to the documentation of this file.

/*******************************************************************************

   Copyright (C) 2007 by Brendon Costa

   This library is free software; you can redistribute it and/or modify 
   it under the terms of the "LGPL Like" License defined in the file COPYING 
   that should have been distributed along with this source.

   This library is distributed in the hope that it will be useful, 
   but WITHOUT ANY WARRANTY; without even the implied warranty of 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

   You should have received a copy of the "LGPL Like" License 
   along with this library; see the file COPYING. if not, it can be 
   obtained from the EDoc++ website: 
   http://edoc.sourceforge.net/license.html

*******************************************************************************/
#include "config.h"

#include "EDoc/PropogatingException.h"
#include "EDoc/Exception.h"
#include "EDoc/Function.h"
#include "EDoc/exceptions.h"
#include "EDoc/utils.h"
#include "EDoc/PStack.h"
#include "EDoc/StackRef.h"
#include "EDoc/Type.h"
#include "EDoc/Dictionary.h"

namespace EDoc
{
   //===========================================================================
   PropogatingException::PropogatingException(Dictionary& dict_in, 
         Exception* exception_in,
         FunctionLoc& func_in) :
      
      DictionarySpecific(&dict_in),
      exception(exception_in),
      func(func_in),
      possible(func_in.possible),
      visible(true),
      orig_subst(false)
   {
   }
   //===========================================================================
   PropogatingException::PropogatingException(Dictionary* dict_in) :
      DictionarySpecific(dict_in),
      exception(NULL),
      func(NULL),
      possible(false),
      visible(true),
      orig_subst(false)
   {
   }
   //===========================================================================
   PropogatingException::PropogatingException(
         const PropogatingException& right) :
   
      DictionarySpecific(&right.dict),
      exception(right.exception),
      func(right.func),
      rethrows(right.rethrows),
      possible(right.possible),
      visible(right.visible),
      orig_subst(right.orig_subst)
   {
      // Cant copy propogating exception objects across dictionary boundaries.
      EDOC_ASSERT(&exception->dict == &dict, "");
   }
   //===========================================================================
   PropogatingException& PropogatingException::operator=(
      const PropogatingException& right)
   {
      if (this == &right)
      {
         return *this;
      }
      
      // Cant copy propogating exception objects across dictionary boundaries.
      EDOC_ASSERT(&dict == &right.dict, "");
      
      exception = right.exception;
      func = right.func;
      rethrows = right.rethrows;
      possible = right.possible;
      visible = right.visible;
      orig_subst = right.orig_subst;
      return *this;
   }
   //===========================================================================
   void PropogatingException::Validate(PStack& stack, 
      const Dictionary& dict_in) const
   {
      StackRef ref(stack, this);
      if (!ref)
      {
         return;
      }
      
      EDOC_ASSERT(&dict == &dict_in, "");
      
      exception->Validate(stack, dict_in);
      func.Validate(stack, dict_in);
      EDOC_FOREACH_CONST(ExcepPList, it, rethrows)
      {
         (*it)->Validate(stack, dict_in);
         EDOC_ASSERT((*it)->type.value->GetDeclaredName() == "...", "");
      }

      if (orig_subst)
      {
         EDOC_ASSERT(exception->type.value->GetDeclaredName() == "....", "");
      }

      // If it was constructed from a "Possible" function call then it is
      // mandatory that it also be defined as possible. It may however be that
      // it was constructed from a non-possible function call but propogated up
      // as a possible exception so it is not necessary that if func.possible is
      // false that this.possible will be false.
      if (func.possible)
      {
         EDOC_ASSERT(possible, "");
      }
   }
   //===========================================================================
   bool PropogatingException::operator==(
      const PropogatingException& right) const
   {
      // NOTE: Does not look at the rethrow list for equality.
      
      // @@@Brendon Performing pointer equality.
      return (exception == right.exception) && (func == right.func);
   }
   //===========================================================================
   size_t PropogatingException::ReplaceReferences(PStack& stack, void* remove, 
      void* replace)
   {
      size_t count = 0;
      if (!stack.Push(this))
      {
         return count;
      }

      count += exception->ReplaceReferences(stack, remove, replace);
      count += func.ReplaceReferences(stack, remove, replace);
      
      EDOC_FOREACH_CONST(ExcepPList, it, rethrows)
      {
         count += (*it)->ReplaceReferences(stack, remove, replace);
      }
      
      return count;
   }
   //===========================================================================
   std::ostream& PropogatingException::Print(std::ostream& out, 
      std::string prefix) const
   {
      out << prefix << "Propogating Exception Type: " 
          << exception->type.value->GetKeyName() << std::endl;
      out << prefix << "{" << std::endl;

      // Display the original Exception object.
      exception->Print(out, prefix + INDENT_STR + "Exception: ");
      
      // Display the function location.
      func.Print(out, prefix + INDENT_STR + "FunctionLoc: ");

      EDOC_FOREACH_CONST(ExcepPList, it, rethrows)
      {
         out << prefix << INDENT_STR << "Rethrown line: " 
             << (*it)->type.loc.line << std::endl;
      }
      
      out << prefix << "}" << std::endl;
      
      return out;
   }
   //===========================================================================
   bool PropogatingException::IsVisible() const
   {
      return visible && exception->visible && exception->type.value->visible;
   }
   //===========================================================================
}

---