Assertion.h

/*
 * Assertion.h - design-by-contract, assertions.
 *
 * This file is part of the Rulbus Device Class Library (RDCL).
 *
 * Copyright (C) 2003-2004, Leiden University.
 *
 * This library is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * The 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.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with mngdriver; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * $Id: Assertion.h 2 2004-10-12 11:54:15Z moene $
 */

#ifndef __ASSERTION_H
#define __ASSERTION_H

#ifndef __IN_COMMON_H
   #error assertion.h is included by common.h only.
#endif

#include <iosfwd>       // for std::ostream
#include <stdexcept>    // for std::exception

#define LOCATION __FILE__, __LINE__

#if DEBUG & DFLAG_REQUIRE
   #define require(exp)           \
      if (!(exp))                 \
         throw Rulbus::RequireException( _T(#exp), LOCATION )

   #define require_e(exp, ecxpt)  \
      if (!(exp))                 \
         throw excpt
#else
   #define require(exp)
   #define require_e(exp)
#endif // DEBUG & DFLAG_REQUIRE

#if DEBUG & DFLAG_ENSURE
   #define ensure(exp)          \
      if (!(exp))               \
         throw Rulbus::EnsureException( _T(#exp), LOCATION )

   #define ensure_e(exp, ecxpt) \
      if (!(exp))               \
         throw excpt
#else
   #define ensure(exp)
   #define ensure_e(exp, ecxpt)
#endif // DEBUG & DFLAG_ENSURE

#if DEBUG & DFLAG_NEVER_GET_HERE
   #define NEVER_GET_HERE  throw Rulbus::NeverGetHereException( LOCATION )
#else
   #define NEVER_GET_HERE
#endif

#define BASE_INVARIANT( base )  base::invariant()


namespace Rulbus
{
   DECLARE_CLASS( Assertion );                  
   DECLARE_CLASS( DbcException );               
   DECLARE_CLASS( RequireException );           
   DECLARE_CLASS( EnsureException );            
   DECLARE_CLASS( AssertException );            
   DECLARE_CLASS( NeverGetHereException );      

   class Assertion : public StdException
   {
   public:

      Assertion( CharCptr aReason, CharCptr aFile, int aLine );

      Assertion( AssertionCref rhs );

      virtual ~Assertion();


      AssertionRef operator=( AssertionCref rhs );

      bool operator==( AssertionCref rhs );


      virtual CharCptr what() const;

      String  reason() const;
      String  file() const;
      int     line() const;


   protected:
      String  theReason;    
      String  theFile;      
      int     theLine;      
   };

   inline Assertion::Assertion( CharCptr aReason, CharCptr aFile, int aLine ):
      theReason( aReason ), theFile( aFile ), theLine( aLine )
   {
      ; // do nothing
   }

   inline Assertion::Assertion( AssertionCref rhs ):
      theReason( rhs.theReason ), theFile( rhs.theFile ), theLine( rhs.theLine )
   {
      ; // do nothing
   }

   inline Assertion::~Assertion()
   {
      ; // do nothing
   }

   inline AssertionRef Assertion::operator=( AssertionCref rhs )
   {
      if( this != &rhs )
      {
         theReason = rhs.theReason;
         theFile = rhs.theFile;
         theLine = rhs.theLine;
      }
      else
      {
         ;  // do nothing
      }

      return *this;
   }

   inline bool Assertion::operator==( AssertionCref rhs )
   {
      return theReason == rhs.reason() &&
             theFile   == rhs.file()   &&
             theLine   == rhs.line();
   }

   inline String Assertion::reason() const
   {
      return theReason;
   }

   inline String Assertion::file() const
   {
      return theFile;
   }

   inline int Assertion::line() const
   {
      return theLine;
   }

   inline CharCptr Assertion::what() const
   {
      return reason().c_str();
   }

   class DbcException : public Assertion
   {
   public:
      enum Type
      {
         REQUIRE,
         ENSURE,
         ASSERT,
         NEVERGETHERE,
      };


      DbcException( Type aType, CharCptr aDescription, CharCptr aExpression, CharCptr aFile, int aLine );

      DbcException( DbcExceptionCref rhs );

      virtual ~DbcException();


      DbcExceptionRef operator=( DbcExceptionCref rhs );

      bool operator==( DbcExceptionCref rhs );


      virtual CharCptr what() const;

      Type    type() const;
      String  description() const;


   private:
      Type    theType;                  
      String  theDescription;           
      mutable String theMessage;        
   };

   inline DbcException::DbcException( DbcException::Type aType, CharCptr aDescription, CharCptr aExpression, CharCptr aFile, int aLine ):
      Assertion( aExpression, aFile, aLine ), theType( aType ), theDescription( aDescription )
   {
      ; // do nothing
   }

   inline DbcException::DbcException( DbcExceptionCref rhs ):
      Assertion( rhs ), theType( rhs.type() ), theDescription( rhs.description() )
   {
      ; // do nothing
   }

   inline DbcException::~DbcException()
   {
      ; // do nothing
   }

   inline DbcExceptionRef DbcException::operator=( DbcExceptionCref rhs )
   {
      if( this != &rhs )
      {
         (void) Assertion::operator=( rhs );
         theType = rhs.type();
         theDescription = rhs.description();
      }
      else
      {
         ;  // do nothing
      }

      return *this;
   }

   inline bool DbcException::operator==( DbcExceptionCref rhs )
   {
      return Assertion::operator==( rhs ) &&
                         type() == rhs.type() &&
                  description() == rhs.description();
   }

   inline DbcException::Type DbcException::type() const
   {
      return theType;
   }

   inline String DbcException::description() const
   {
      return theDescription;
   }

   class RequireException : public DbcException
   {
   public:
      RequireException( CharCptr aExpression, CharCptr aFile, int aLine ) :
         DbcException( REQUIRE, "require", aExpression, aFile, aLine ) { ; }
   };

   class EnsureException : public DbcException
   {
   public:
      EnsureException( CharCptr aExpression, CharCptr aFile, int aLine ) :
         DbcException( ENSURE, "promised", aExpression, aFile, aLine ) { ; }
   };

   class AssertException : public DbcException
   {
   public:
      AssertException( CharCptr aExpression, CharCptr aFile, int aLine ) :
         DbcException( ASSERT, "assert", aExpression, aFile, aLine ) { ; }
   };

   class NeverGetHereException : public DbcException
   {
   public:
      NeverGetHereException( CharCptr aFile, int aLine ) :
         DbcException( NEVERGETHERE, "shall never get here", "", aFile, aLine ) { ; }
   };

} // namespace Rulbus

std::ostream& operator<<( std::ostream& stream, Rulbus::StdExceptionCref rhs );

#endif  // __ASSERTION_H

/*
 * end of file
 */

---