// $Source: /usr/local/SimSoft/Sfx3D/src/gsl/prozess.h,v $
// $Revision: 1.2 $
// $Author: baum $
// $Date: 2001/11/29 15:18:09 $
//
// Login name of the user who locked the revision
// $Locker:  $
// Tag name used to checkout the file
// $Name:  $
// State assigned to revision
// $State: Exp $
//
//
// $Log: prozess.h,v $
// Revision 1.2  2001/11/29 15:18:09  baum
// -Realzeitsteuerung eingebaut
// -Handsteuerung eingebaut
//

#ifndef _PROZESS_H
#define _PROZESS_H     1

#include "Zufall.h"

#include "Token.h"

#ifdef _PROZESS_CPP
#  undef _impexp
#  define _impexp __declspec(dllexport)
#elif defined BUILD_MAIN_DLL
#  undef _impexp
#  define _impexp 
#else
#  undef _impexp
#  define _impexp __declspec(dllimport)
#endif

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

//---------------------------------------------------------
// class typProzess
//---------------------------------------------------------

class _impexp typProzess {
  public:
    virtual ~typProzess ();

    enum typ { ANKUNFT  = 1,
               STOERUNG = 2,
               PRG      = 3 };
    unsigned Nummer    () const;
    unsigned Typ       () const;
    unsigned Betrifft  () const;
    bool     isStopped () const;

    void stop ();
    void go   ();

    virtual void     lesen     (InputFile& file)    = 0;
    virtual ostream& schreiben (ostream& ostrm) const;

  protected:
    unsigned ObjBetrifft;

    typProzess (unsigned nr, unsigned typ);

  private:
    // declared, but not defined
    typProzess ();
    typProzess (const typProzess&);
    const typProzess& operator = (const typProzess&);

    enum status { STOP, GO };
    unsigned ObjNummer;
    unsigned ObjTyp;
    unsigned ObjStatusFlag;

}; // typProzess

//---------------------------------------------------------
// Klasse typAnkunftsProzess
//---------------------------------------------------------

class _impexp typAnkunftsProzess : public typProzess {
  public:
    typAnkunftsProzess (unsigned nr);
    virtual ~typAnkunftsProzess ();

    double ZufAbstand ();
    int    ZufMenge   ();

    virtual void     lesen     (InputFile& file);
    virtual ostream& schreiben (ostream& ostrm) const;

  private:
    // declared, but not defined
    typAnkunftsProzess ();
    typAnkunftsProzess (const typAnkunftsProzess&);
    const typAnkunftsProzess& operator = (const typAnkunftsProzess&);

    Verteilung *ObjAbstand;
    Verteilung *ObjMenge;

}; // typAnkunftsProzess

//---------------------------------------------------------
// Klasse typStoerProzess
//---------------------------------------------------------

class _impexp typStoerProzess : public typProzess {
  public:
    typStoerProzess (unsigned nr);
    virtual ~typStoerProzess ();

    double ZufAbstand ();
    double ZufDauer   ();

    virtual void     lesen     (InputFile& file);
    virtual ostream& schreiben (ostream& ostrm) const;

  private:
    // declared, but not defined
    typStoerProzess ();
    typStoerProzess (const typStoerProzess&);
    const typStoerProzess& operator = (const typStoerProzess&);

    Verteilung *ObjAbstand;
    Verteilung *ObjDauer;

}; // typStoerProzess

//---------------------------------------------------------
// Klasse typPRGProzess
//---------------------------------------------------------

class _impexp typPRGProzess : public typProzess {
  public:
    typPRGProzess (unsigned nr);
    typPRGProzess (unsigned nr, int Art, float v1_min, float v1_mittel, float v1_max, int v1_start, float v2_min, float v2_mittel, float v2_max, int v2_start);
    virtual ~typPRGProzess ();

    double ZufV1 ();
    double ZufV2 ();

    virtual void     lesen     (InputFile& file);
    virtual ostream& schreiben (ostream& ostrm) const;

  private:
    // declared, but not defined
    typPRGProzess ();
    typPRGProzess (const typPRGProzess&);
    const typPRGProzess& operator = (const typPRGProzess&);

    Verteilung *ObjV1;
    Verteilung *ObjV2;

}; // typPRGProzess

#endif /* _PROZESS_H */
