---

Event.h

//   -*- C++ -*-
/*****************************************************************************
 *
 *   |_|_|_  |_|_    |_    |_|_|_  |_                C O M M U N I C A T I O N
 * |_        |_  |_  |_  |_        |_                          N E T W O R K S
 * |_        |_  |_  |_  |_        |_                                C L A S S
 *   |_|_|_  |_    |_|_    |_|_|_  |_|_|_|_                      L I B R A R Y
 *
 * $Id: Event.h,v 1.5 2002/02/01 08:46:04 spee Exp $
 *
 * CNClass: CNEvent --- Generic event
 *
 *****************************************************************************
 * Copyright (C) 1992-2002   Communication Networks
 *                           Aachen University of Technology
 *                           D-52056 Aachen
 *                           Germany
 *                           Email: cncl-adm@comnets.rwth-aachen.de
 *****************************************************************************
 * This file is part of the CN class library. All files marked with
 * this header are free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.  This library 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 Library General Public
 * License for more details.  You should have received a copy of the GNU
 * Library General Public License along with this library; if not, write
 * to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
 * USA.
 *****************************************************************************/

#ifndef __Event_h
#define __Event_h


#include <CNCL/Class.h>
#include <CNCL/Param.h>
#include <CNCL/DLObject.h>              // Base class
#include <CNCL/SimTime.h>

#include <stddef.h>

extern CNClassDesc CN_EVENT;            // CNClass CNEvent description



class CNEventHandler;


typedef unsigned long CNEventID;                // Type of CNEvent::ev_id



class CNEvent : public CNDLObject
{
    friend class CNEventList;
    friend class CNEventBaseSched;
    friend class CNEventScheduler;
    friend class CNEventHeapSched;
    friend class CNEventHIterator;
    
  private:

    enum { default_max_events=100 };

  public:
    unsigned long get_max_events();
    static void set_max_events(unsigned long n);

  public:
    int priority()             const        { return ev_prio; }
    int get_priority()         const        { return ev_prio; }
    void priority(int prio)                 { ev_prio=prio;   }
    void set_priority(int prio)             { ev_prio=prio;   }

    int type()                 const        { return ev_type;   }
    int get_type()             const        { return ev_type;   }
    void type(int new_type)                 { ev_type=new_type; }  
    void set_type(int new_type)             { ev_type=new_type; }

    CNSimTime scheduled()      const        { return ev_scheduled; }
    CNSimTime get_scheduled()  const        { return ev_scheduled; }
    void scheduled(const CNSimTime new_scheduled)
                                            { ev_scheduled = new_scheduled; }
    void set_scheduled(const CNSimTime new_scheduled)
                                            { ev_scheduled = new_scheduled; }

    CNSimTime issued()         const        { return ev_issued; }
    CNSimTime get_issued()     const        { return ev_issued; }

    CNEventHandler *to()       const        { return ev_to; }
    CNEventHandler *get_to()   const        { return ev_to; }
    void to(CNEventHandler *new_to)         { ev_to=new_to; }
    void set_to(CNEventHandler *new_to)     { ev_to=new_to; }

    CNEventHandler *from()     const        { return ev_from; }
    CNEventHandler *get_from() const        { return ev_from; }
    void from(CNEventHandler *new_from)     { ev_from=new_from; }
    void set_from(CNEventHandler *new_from) { ev_from=new_from; }

    CNObject *object()         const        { return ev_obj; }
    CNObject *get_object()     const        { return ev_obj; }
    void object(CNObject *obj)              { ev_obj=obj; }
    void set_object(CNObject *obj)          { ev_obj=obj; }

    CNEventID id()             const        { return ev_id; }
    CNEventID get_id()         const        { return ev_id; }

    static void *operator new(size_t);
    static void  operator delete(void *);

    static void reset_pool();
    
    inline bool after(CNEvent* ev);

  private:
    static CNEvent *pool;
    static unsigned long pool_size;
    static unsigned long next_free;     

    CNEventID ev_id;                    
    int ev_prio;
    int ev_type;
    CNSimTime ev_issued;        
    CNSimTime ev_scheduled;
    CNEventHandler *ev_to;
    CNEventHandler *ev_from;
    CNObject *ev_obj;           

    static CNEventID id_sequencer;      // Sequencer for event IDs

    void issued(const CNSimTime t)     { ev_issued=t; }
    void set_issued(const CNSimTime t) { ev_issued=t; }

    /****** Constructors ******************************************************/
  public:
    CNEvent();
    CNEvent(CNParam *param);
    CNEvent(int new_type);
    CNEvent(int new_type, const CNSimTime t, int new_prio=0);
    CNEvent(int new_type, CNEventHandler *new_to, const CNSimTime t,
            CNObject *new_object=NIL, int new_prio=0);
    CNEvent(int new_type, CNEventHandler *new_from, CNEventHandler *new_to,
            const CNSimTime t, CNObject *new_object=NIL, int new_prio=0);
    CNEvent(int new_type, CNEventHandler *new_to,
            CNObject *new_object=NIL, int new_prio=0);

protected:
    ~CNEvent() {}

    /****** Member functions required by CNCL *********************************/
public:
    virtual CNClassDesc class_desc() const      // CNClass description
    {
        return CN_EVENT;
    };
            
    virtual bool is_a(CNClassDesc desc) const
    {
        return desc == CN_EVENT ? TRUE : CNDLObject::is_a(desc);
    };
        
    static CNEvent *cast_from_object(CNObject *obj)
    {
#   ifdef NO_TYPE_CHECK
        return (CNEvent *)obj;
#   else
        return (CNEvent *)( !obj || obj->is_a(CN_EVENT)
               ? obj : fatal_type(obj->class_desc(), CN_EVENT) );
#   endif
    }
    
    static CNObject *new_object(CNParam *param = NIL)
    { return param ? new CNEvent(param) : new CNEvent; }
    
    virtual void print(ostream &strm = cout) const;
    virtual void dump (ostream &strm = cout) const;
};


/* Comparison used by HeapEventScheduler */
inline bool CNEvent::after(CNEvent* e2)
{
    bool flag = FALSE;
    
    if      (ev_scheduled > e2->ev_scheduled) flag = TRUE;
    else if (ev_scheduled < e2->ev_scheduled) ;
    else if (ev_prio      > e2->ev_prio     ) flag = TRUE;
    else if (ev_prio      < e2->ev_prio     ) ;
    else if (ev_id        > e2->ev_id       ) flag = TRUE;
    return flag;
};

#endif 

---