Base.h

Go to the documentation of this file.

/*****************************************************************************
 $RCSfile: Base.h,v $ --- $Date: 2006/07/19 13:21:43 $ --- $Revision: 1.2 $
 *****************************************************************************
 PREPROCESSOR DIRECTIVES
 *****************************************************************************/

 #ifndef CALC_BASE_H
 #define CALC_BASE_H

/*****************************************************************************
 INCLUDE FILES
 *****************************************************************************/

 #include <cmath>
 #include <iostream>

/*****************************************************************************
 NAMESPACE IDENTIFICATIONS
 *****************************************************************************/

 namespace calc {

/*****************************************************************************
 Err CLASS
 *****************************************************************************/


 class Err {

 public:

 // Member Functions

    int getIndex(void) const {return iErr;}
    const char *getClass(void) const {return sCls;}
    const char *getDescription(void) const {return sDsc;}
    const char *getLibrary(void) const {return LIB_NAME;}
    const char *getNamespace(void) const {return LIB_NSPACE;}

 // Related Functions

    friend std::ostream& operator<<(std::ostream& ostr, const Err& er)
       {ostr<<er.LIB_NAME<<" Error ("<<er.LIB_NSPACE<<"::"<<er.sCls;
          ostr<<" - #"<<er.iErr<<") - "<<er.sDsc; return ostr;}

 // Data Members

    static const char *const LIB_NAME;
    static const char *const LIB_NSPACE;
    static const char *const DEF_MESSAGE;
    static const char *const DEF_CLASS;

 protected:

 // Constructors

    Err(void) {iErr=0; sCls=DEF_CLASS; sDsc=DEF_MESSAGE;}
    Err(int indErr, const char *strCls, const char *strDsc)
       {iErr=indErr; sCls=strCls; sDsc=strDsc;}
    Err(const Err &er) {iErr=er.iErr; sCls=er.sCls; sDsc=er.sDsc;}
   ~Err(void) {}

 // Member Functions

    bool setError(int indErr)
       {if(indErr<0) return true; iErr=indErr; return false;}
    bool setError(const char* strCls, const char* strDsc)
       {if((!strCls)||(!strDsc)) return true; sCls=strCls; sDsc=strDsc; return false;}
    bool setError(int indErr, const char *strCls, const char *strDsc)
       {if((indErr<0)||(!strCls)||(!strDsc)) return true;
          iErr=indErr; sCls=strCls; sDsc=strDsc; return false;}

 private:

 // Data Members

    int         iErr;       
    const char *sCls;       
    const char *sDsc;       
 };

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

 const char *const calc::Err::LIB_NAME="CalcLib";
 const char *const calc::Err::LIB_NSPACE="calc"; 
 const char *const calc::Err::DEF_MESSAGE="execution error"; 
 const char *const calc::Err::DEF_CLASS="????"; 

/*****************************************************************************
 Base CLASS
 *****************************************************************************/

 class Base {

 public:

 // Member Enumerations

    enum BOUND {
     LO=0     , 
     HI       , 
     BOUND_CNT, 
    };

 // Member Functions

    bool isInit(void) const {return (!nogo);}

    static const double PI;

 protected:

 // Constructors

    Base(void) {nogo=true;}
    Base(const Base &ca) {nogo=ca.nogo;}
    ~Base(void) {}

 // Member Functions

    virtual void varInit (void)=0;

    template<typename T>
    static void swap(T &x1, T &x2)
       {const T sto=x1; x1=x2; x2=sto;}
    template<typename T>
    static T abs(const T &x)
       {return (x<(T)(0)?(-x):(x));}
    template<typename T>
    static T* memCopy(T* aDst, const T* aSrc, int nCnt)
       {if((aDst)&&(aSrc))
           for(int iCnt=0; iCnt<nCnt; iCnt++) aDst[iCnt]=aSrc[iCnt];
        return aDst;}
    template<typename T>
    static bool memComp(const T* arr1, const T* arr2, int nCnt)
       {if((!arr1)||(!arr2)||(nCnt<=0)) return true;
        for(int iCnt=0; iCnt<nCnt; iCnt++) if(arr1[iCnt]!=arr2[iCnt]) return true;
        return false;}
    template<typename T>
    static bool memSet(T* arr, int x, int nCnt)
       {if((arr)&&(nCnt>0)) {
           const T xSet=(T)(x);
           for(int iCnt=0; iCnt<nCnt; iCnt++) arr[iCnt]=xSet;
        }
        return arr;}

 // Data Members

    bool nogo;
 };}

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

 const double calc::Base::PI=3.141592653589793238462643;

/*****************************************************************************
 PREPROCESSOR DIRECTIVES
 *****************************************************************************/

 #endif

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

---