Search  

---

C:/temp/src/j2k/Fred/Error/JErrorController.cpp

Go to the documentation of this file.

#ifndef __J2K__JErrorController_CPP__
#define __J2K__JErrorController_CPP__

//////////////////////////////////////////////////////////////////////
//                                                                  //
//  Notice:                                                         //
//  -------                                                         //
//                                                                  //
//  We can't use JString or any other J2K classes,                  //
//  since we are not sure, where the error occured                  //
//  and so, we can only rely on ourself !                           // 
//  Hoping that this class works well... =)                         //
//                                                                  //
//////////////////////////////////////////////////////////////////////

#include <j2k/Fred/Error/JErrorController.hpp>


  JErrorController::JErrorController()
  {
    array = new JErrorHandler*[ __J2K__MAX_ERROR ];

  //////////////////////////////////////////////////////////////////////
  // Assign to each error the same Error Handler                      //
  // i.e. Print message and quit.                                     //
  //                                                                  //
  // A more evolued version is needed since some error are not fatal  //
  // and should only be advertise or logged into a error.log file,    //
  // and the program should be resume instead.                        //
  //////////////////////////////////////////////////////////////////////
    register int i = 0;
    defaultHandler = new JErrorHandler();

    for( ; i < __J2K__MAX_ERROR; i++ ) {
      array[ i ] = defaultHandler;
    }
  }

  JErrorController::~JErrorController() 
  {
    // Optimization compiler will surely use a register.
    register int i = 0;
    for( ; i < __J2K__MAX_ERROR; i++ ) {
        if ( array[i] != defaultHandler ) {
          delete array[ i ];  // Delete each node of the array
        }                     // Each JErrorHandler will delete
    }                         // the linked-list using cascade deletion.
    delete   defaultHandler;
    delete[] array;
  }

  //////////////////////////////////////////////////////////////////////
  // Someone has a problem with a known error                         //
  // and call us to resolve it !                                      //
  //////////////////////////////////////////////////////////////////////
  void JErrorController::call( 
    JErrorLevel level, int no, const char* errmsg,
                       int line,  const char* file )
  {
    register int n = (int)no;

    if ( n < 0 ) { n += __J2K__QB_OFFSET; }
    if ( EAGAIN       == 35     &&  n == 35    ) { n =  11; }
    if ( ENAMETOOLONG == 63     &&  n == 63    ) { n =  78; }

#ifndef _WIN32
    if ( EWOULDBLOCK  == 35     &&  n == 35    ) { n =  11; }
    if ( EALREADY     == 37     &&  n == 37    ) { n = 149; }
    if ( EALREADY     == EBUSY  &&  n == EBUSY ) { n =  16; }
    if ( ELOOP        == 62     &&  n == 62    ) { n =  90; }
    if ( ESTALE       == 70     &&  n == 70    ) { n = 151; }
    if ( EREMOTE      == 71     &&  n == 71    ) { n =  66; }
    if ( EOPNOTSUPP   == 103    &&  n == 103   ) { n = 122; }
    if ( ESTALE       == 122    &&  n == 122   ) { n = 151; }
#endif

    array[ n ]->elem( level, (JErrorNo)n, errmsg, line, file );
  }

  //////////////////////////////////////////////////////////////////////
  // Someone needs some specific handler for an error number          //
  // from now until it's removed.                                     //
  // The new error handler is added to the JErrorNo                   //
  // top of single Linked-List for that error number.                 //
  // The second argument is the static error handler                  //
  // that will be call if that error happen.                          //
  //////////////////////////////////////////////////////////////////////
  void JErrorController::add( 
    JErrorNo no, void (*fn)( MC_JErrorHandlerArg ), short id 
  )
  {
    // Optimization compiler will surely use a register.
    register int n = (int)no;
    JErrorHandler* newHandler = new JErrorHandler( fn, array[ n ], id );
    array[ n ] = newHandler;
  }

  //////////////////////////////////////////////////////////////////////
  // Someone doesn't need anymore                                     //
  // some specific handler for an error number.                       //
  // The new error handler is now removed from the                    //
  // top of single Linked-List for that error number.                 //
  //////////////////////////////////////////////////////////////////////
  void JErrorController::remove( JErrorNo no )
  {
    // Optimization compiler will surely use a register.
    register int n = (int)no;
    JErrorHandler* temp = array[n]->next;

      // Else temp gets deleted too.
      array[n]->next = NULL;
  
      if ( array[n] != defaultHandler ) {
        delete array[n];
      }
    array[n] = temp;
  }

  short JErrorController::getID( JErrorNo no ) 
  {
    register int n = (int)no;
    JErrorHandler* temp = array[n];

    if ( temp == NULL ) return -1;

    return temp->id;
  }

#endif

---