ssim.h

Go to the documentation of this file.

// -*-C++-*-
//
//  This file is part of SSim, a simple discrete-event simulator.
//  See http://www.inf.usi.ch/carzaniga/ssim/
//  
//  Copyright (C) 1998-2004 University of Colorado
//  Copyright (C) 2012 Antonio Carzaniga
//  
//  Authors: Antonio Carzaniga <[email protected]>
//           See AUTHORS for full details.
//  
//  SSim is free software: you can redistribute it and/or modify it under
//  the terms of the GNU General Public License as published by the Free
//  Software Foundation, either version 3 of the License, or (at your
//  option) any later version.
//  
//  SSim is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//  
//  You should have received a copy of the GNU General Public License
//  along with SSim.  If not, see <http://www.gnu.org/licenses/>.
//
#ifndef _ssim_h
#define _ssim_h

namespace ssim {

extern const char *     Version;

typedef int             ProcessId;

const ProcessId         NULL_PROCESSID = -1;

typedef double          Time;

const Time              INIT_TIME = 0;

class Event {
 public:
                        Event(): refcount(0) {};
    virtual             ~Event() {};

 private:
    mutable unsigned refcount;
    friend class SimImpl;       // this is an opaque implementation class
    friend class Sim;           // these need to be friends to manage refcount
};

class Process {
 public:
    virtual             ~Process() {};

    virtual void        init(void) {};

    virtual void        process_event(const Event * msg) {};

    virtual void        stop(void) {};
};

class ProcessWithPId : public Process {
 public:
    ProcessId           activate() throw();

    ProcessId           pid() const throw();

    ProcessWithPId() throw();

 private:
    ProcessId process_id;
};

class SimErrorHandler {
public:
    virtual ~SimErrorHandler() {}

    virtual void clear() throw() {}

    virtual void handle_busy(ProcessId p, const Event * e) throw() {}

    virtual void handle_terminated(ProcessId p, const Event * e) throw() {}
};

class Sim {
public:
    static ProcessId    create_process(Process *) throw();

    static int          stop_process(ProcessId) throw();
    static void         stop_process() throw();

    static void         clear() throw();

    static void         self_signal_event(const Event * e) throw();

    static void         self_signal_event(const Event * e, Time delay) throw();

    static void         signal_event(ProcessId p, const Event * e) throw();

    static void         signal_event(ProcessId p, const Event * e, Time d) throw();

    static void         advance_delay(Time) throw();
    
    static ProcessId    this_process() throw();

    static Time         clock() throw();
    
    static void         run_simulation();
    static void         stop_simulation() throw();

    static void         set_stop_time(Time t = INIT_TIME) throw();

    static void         set_error_handler(SimErrorHandler *) throw();
};

} // end namespace ssim

#endif /* _ssim_h */