// $Source: /usr/local/SimSoft/SoftShop/NewSimC/Messung.h,v $
// $Revision: 1.14 $
// $Author: baum $
// $Date: 2001/11/29 15:52:23 $
//
// Login name of the user who locked the revision
// $Locker:  $
// Tag name used to checkout the file
// $Name: Release-20 $
// State assigned to revision
// $State: Exp $
//
//
// $Log: Messung.h,v $
// Revision 1.14  2001/11/29 15:52:23  baum
// -In Kalender.cpp und Kalender.h Handsteuerung eingebaut
//

#ifndef _MESSUNG_H
#define _MESSUNG_H    1

#include <iostream.h>

#include "SimTime.h"
#include "DynArray.h"

#ifdef _MESSUNG_CPP
#  undef _impexp
#  define _impexp __declspec(dllexport)
#elif defined BUILD_NEWSIMC_DLL
#  undef _impexp
#  define _impexp 
#else
#  undef _impexp
#  define _impexp __declspec(dllimport)
#endif

#if defined __GNUC__ || defined __hpux
#  undef _impexp
#  define _impexp
#endif

//================================================================== 
//		Klassen-Header
//		fuer class Erfassung 
//================================================================== 

class _impexp Erfassung {
  public:
    virtual void erfassen  (const double& zahl) = 0;
    virtual void reset     () = 0;
    virtual void compress  () = 0;

  
    const   double& Min    () const;
    virtual double  Mittel () const = 0;
    const   double& Max    () const;

    virtual ostream& print (ostream&) const = 0;
  
  protected:
    Erfassung (double summe, double minimum, double maximum);
    virtual ~Erfassung ();

    double ObjSum;
    double ObjMin;
    double ObjMax;

  private:
    Erfassung ();
    Erfassung (const Erfassung&);
    const Erfassung& operator = (const Erfassung&);
};

inline ostream& operator << (ostream& o, const Erfassung& e) {
  return e.print (o);
}

//==================================================================
//		Klassen-Header
//		fuer class Register
//==================================================================

class _impexp Register : public Erfassung {
  public:
    Register ();
    ~Register ();

    virtual void erfassen (const double& wert);
    virtual void reset    ();
    virtual void compress ();

    virtual double Mittel  () const;

    double         StdAbweichung () const;
    double         Varianz () const;
    unsigned       Anzahl  () const;

    virtual ostream& print (ostream&) const;

  private:
    Register (const Register&);
    Register& operator = (const Register&);

    unsigned ObjAnzahl;
    double ObjQuadSum;
};

inline ostream& operator << (ostream& o, const Register& r) {
  return r.print (o);
}

//==================================================================
//		Klassen-Header
//		fuer class Geschichte
//==================================================================

class _impexp Geschichte : public Erfassung {
  public:
    Geschichte ();
    ~Geschichte ();

    virtual void erfassen (const double& neustatus);
    virtual void reset    ();
    virtual void compress ();

    virtual double Mittel () const;

    virtual ostream& print (ostream&) const;

  private:
    Geschichte (const Geschichte& g);
    const Geschichte& operator = (const Geschichte& g);

    SimTime ObjStartzeit;
    SimTime ObjWechselzeit;

    double ObjStatus;
};

inline ostream& operator << (ostream& o, const Geschichte& g) {
  return g.print (o);
}

//==================================================================
//		Klassen-Header
//		fuer Histogramm
//==================================================================

class _impexp HistoKlasse {
  public:
    const double&   Grenze () const;
    const unsigned& Inhalt () const;

  private:
    HistoKlasse (const double& grenze);
    ~HistoKlasse ();

    double   ObjGrenze;
    unsigned ObjInhalt;

    HistoKlasse ();
    HistoKlasse (const HistoKlasse& hk);
    const HistoKlasse& operator = (const HistoKlasse& hk);

  // friends
    friend class Histogramm;

};

class _impexp Histogramm {
  public :
    Histogramm (unsigned klassenAnzahl, const double& startWert,
                const double& schrittWeite);
    ~Histogramm ();

    void erfassen (const double& wert);

    const double&                StartWert () const;
    const DynArray<HistoKlasse>& Klassen   () const;

    ostream& print (ostream& ostrm) const;

  private:
    Histogramm ();
    Histogramm (const Histogramm&);
    Histogramm& operator = (const Histogramm&);

    double ObjStartWert;
    DynArray<HistoKlasse> ObjKlassen;
};

inline ostream& operator << (ostream& o, const Histogramm& h) {
  return h.print (o);
}

#endif // !_MESSUNG_H
