StreamIOError.h

/*
    This software is Copyright by the Board of Trustees of Michigan
    State University (c) Copyright 2005.

    You may use this software under the terms of the GNU public license
    (GPL).  The terms of this license are described at:

     http://www.gnu.org/licenses/gpl.txt

     Author:
             Ron Fox
         NSCL
         Michigan State University
         East Lansing, MI 48824-1321
*/

// Class: CStreamIOError                     //ANSI C++
//
// Encapsulates error conditions on an ios
// derived object as an exception.
// Note that objects of this type carry with them
// a reference to the stream on which the condition
// was detected.  This reference may become invalid
//  if the exception propagates up the call stack
//  far enough to cause the stream to be destroyed.
//  I would have ideally liked to carry a copy of the stream,
//  however far too few ios derived classes are derived
//  from ***_withassign to make this practical.
//
// Author:
//     Ron Fox
//     NSCL
//     Michigan State University
//     East Lansing, MI 48824-1321
//     mailto: fox@nscl.msu.edu
// 
// (c) Copyright NSCL 1999, All rights reserved StreamIOError.h
//

#ifndef STREAMIOERROR_H  //Required for current class
#define STREAMIOERROR_H

                               //Required for base classes
#ifndef EXCEPTION_H
#include "Exception.h"
#endif

#include <string>
     

class CStreamIOError  : public CException        
{       
public:             // Data types;
  typedef enum _IoStreamConditions {
    EndFile,
    BadSet,
    FailSet
  } IoStreamConditions;

private:  
  IoStreamConditions m_eReason; //Reason for the throw
  std::ios&               m_rStream; //Reference to stream <may be invalid>
  char               m_sReasonText[1000]; // Reason for failure built here.
  static  const char**      m_svErrorMessages; //Pointer to error message table.      


public:

  CStreamIOError(IoStreamConditions eReason,
         const  char* pDoing, std::ios& rStream) :
    CException(pDoing),
    m_eReason(eReason),
    m_rStream(rStream)
  {}

  CStreamIOError(IoStreamConditions eReason,
      const std::string&  rDoing, std::ios& rStream) :
    CException(rDoing),
    m_eReason(eReason),
    m_rStream(rStream)
  {}
    
         
   ~ CStreamIOError ( )  // Destructor 
  { }  
  
   //Copy constructor 

  CStreamIOError (const CStreamIOError& aCStreamIOError )   : 
    CException (aCStreamIOError),
    m_eReason(aCStreamIOError.m_eReason),
    m_rStream(aCStreamIOError.m_rStream)
  { 
  }                                     

   // Operator= Assignment Operator 
  //  The existence of reference member data inhibits this
  //  operator:
  //
private:
  CStreamIOError& operator= (const CStreamIOError& aCStreamIOError);
public:
 
   //Operator== Equality Operator 
  // We'll have to compare references by comparing their
  // addresses:
  //
  int operator== (const CStreamIOError& aCStreamIOError) const  {
    return ( CException::operator==(aCStreamIOError)              &&
         (m_eReason  == aCStreamIOError.m_eReason)             &&
         (&m_rStream == &aCStreamIOError.m_rStream)
         );
  }
  int operator!=(const CStreamIOError& aCStreamIOError) const  {
    return !(this->operator==(aCStreamIOError));
  }
    
// Selectors:

public:

  IoStreamConditions getReason() const
  { 
    return m_eReason;
  }
  std::ios& getStream()
  { 
    return m_rStream;
  }
                       
  const char* getErrorMessage() const; // Return just error msg.

                       
// Mutators:

protected:

  void setReason (const IoStreamConditions am_eReason)
  { 
    m_eReason = am_eReason;
  }
                       
public:

 virtual   const char* ReasonText ()    const;
 virtual   int ReasonCode ()    const;
 

};

#endif