Logo Search packages:      
Sourcecode: nam version File versions  Download package

edge.h

/*
 * Copyright (c) 1991,1993 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    This product includes software developed by the Computer Systems
 *    Engineering Group at Lawrence Berkeley Laboratory.
 * 4. Neither the name of the University nor of the Laboratory may be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * @(#) $Header: /cvsroot/nsnam/nam-1/edge.h,v 1.32 2003/10/11 22:56:49 xuanc Exp $ (LBL)
 */

#ifndef nam_edge_h
#define nam_edge_h

#include <math.h>
#include <tclcl.h>
#include "animation.h"
#include "transform.h"

class View;
//class PSView;
class Transform;
class Node;
class Packet;
class Monitor;
class LossModel;
class QueueHandle;

00053 class Edge : public Animation, public TclObject {
public:
      Edge(double ps, double bw, double delay, double length, double angle);
      Edge(Node* src, Node* dst, double ps,
            double bw, double _delay, double length, double angle);
      Edge(Node* src, Node* dst, double ps,
           double bw, double _delay, double length, double angle, int ws);
      ~Edge();

      void attachNodes(Node * source, Node * destination);
      void addLossModel(LossModel * lossmodel);
      LossModel * getLossModel();
      void clearLossModel();

      void addQueueHandle(QueueHandle * q_handle);
      QueueHandle * getQueueHandle() {return queue_handle_;}

      virtual void draw(View*, double);
      virtual void reset(double);

      virtual int classid() const { return ClassEdgeID;}
      virtual float distance(float x, float y) const;

      inline double PacketHeight() const { return (psize_); }
      inline double size() const { return (psize_); }
      inline void size(double s) { psize_ = s; }

      inline int src() const { return (src_); }
      inline int dst() const { return (dst_); }
      Node * getSourceNode() {return start_;}
      Node * getDestinationNode() {return neighbor_;}

      inline int match(int s, int d) const { return (src_ == s && dst_ == d); }
      inline const Transform& transform() const { return (matrix_); }
      // bandwidth_ is converted to bits/sec for txtime calculation see tcl/netModel.tcl
      inline double txtime(int n) const {return (double(n << 3)/(bandwidth_*1000000.0));}
      inline double angle() const { return (angle_); }
      inline double realangle() const {
            return atan2(y1_-y0_, x1_-x0_);
      }
      inline void setAngle(double angle) { angle_ = angle; }
      double delay() const; // link delay is returned in seconds  
      inline double length() const { return (length_); }
      inline double x0() const { return (x0_); }
      inline double y0() const { return (y0_); }
      inline double x() const { return (x0_); }
      inline double y() const { return (y0_); }
      inline int anchor() const { return (anchor_); }
      inline void anchor(int v) { anchor_ = v; }
      inline int visible() const { return (visible_); }
      inline void visible(int v) { visible_ = v; }

      inline Node* neighbor() const { return (neighbor_); }
      inline Node* start() const { return (start_); }
      inline Packet* packets() const { return packets_;}
      inline double reallength() const { 
            return sqrt((x1_-x0_)*(x1_-x0_) + (y1_-y0_)*(y1_-y0_));
      }
      inline void setBW(double bw) { bandwidth_ = bw;}
      inline void setDelay(double dlay) { delay_ = dlay;}
      inline void setLength(double length) { length_ = length;}

      inline void inc_usage() { used_ = used_ + 1;}
      inline void dec_usage() { used_ = used_ - 1;}
      inline int used() const {return used_;}

      /*XXX for debugging only*/
      inline int no_of_packets() const {return no_of_packets_;}

      void init_color(const char *clr);
      void set_down(char *clr);
      void set_up();
      inline int isdown() const { return (state_==DOWN); }

      void place(double, double, double, double);
      virtual void update_bb() {} // Do nothing

      void AddPacket(Packet *);
      void DeletePacket(Packet *);
      void arrive_packet(Packet *, double atime);
      void dlabel(const char* name);
      void direction(const char* name);
      void dcolor(const char* name);

      virtual int inside(double, float, float) const;
      virtual int inside(float, float) const;
      const char* info() const;
      const char* property();
      const char* getname() const;
      void monitor(Monitor *m, double now, char *result, int len);
      inline int marked() const { return (marked_); }
      inline void mark() { marked_ = 1; }
      inline void unmark() { marked_ = 0; }
      int save(FILE *file);
      int saveAsEnam(FILE *file);
      int writeNsScript(FILE *file);

      Edge* next_;


private:
      void setupDefaults();

      int src_, dst_;
      Node* start_;
      Node* neighbor_;

      double x0_, y0_;
      double x1_, y1_;
      double psize_;          /* packet size */
      double angle_;
      double bandwidth_;      // link bandwidth (Mbits/sec) 
      double delay_;          // link delay in milliseconds
      double length_;         /* link length if not related to delay */
      Transform matrix_;      /* rotation matrix for packets */
      int state_;
      BBox eb_;   /* own bounding box in its own coordinate */
                        /* system */
      
      Packet* packets_;       /*newest packet to be added*/
      int no_of_packets_;
      Packet* last_packet_;   /*oldest packet - normally first to arrive*/

      int marked_;
      int visible_;

      char* dlabel_;          /* Label to be drawn beneath the link */
      char* dcolor_;          /* label color */
      int direction_;
      int wireless_;
      int anchor_;
      int used_ ;             /* is the edge currently being used */

      LossModel * lossmodel_;
      QueueHandle * queue_handle_;
};


#endif






Generated by  Doxygen 1.6.0   Back to index