开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
edge.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：19k
源码类别：

通讯编程

开发平台：

Visual C++

edge.cc：源码内容
  1. /*
  2.  * Copyright (c) 1991,1993 Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  * This product includes software developed by the Computer Systems
  16.  * Engineering Group at Lawrence Berkeley Laboratory.
  17.  * 4. Neither the name of the University nor of the Laboratory may be used
  18.  *    to endorse or promote products derived from this software without
  19.  *    specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  *
  33.  * @(#) $Header: /cvsroot/nsnam/nam-1/edge.cc,v 1.54 2003/10/11 22:56:49 xuanc Exp $ (LBL)
  34.  */
  37. #include <tclcl.h>
  39. #include "config.h"
  40. #include "sincos.h"
  42. #include "edge.h"
  43. #include "queuehandle.h"
  44. #include "node.h"
  45. #include "packet.h"
  46. #include "view.h"
  47. #include "netview.h"
  48. #include "psview.h"
  49. #include "transform.h"
  50. #include "paint.h"
  51. #include "monitor.h"
  52. #include "agent.h"
  53. #include "lossmodel.h"
  55. //----------------------------------------------------------------------
  56. //  Wrapper for tcl creation of Edges (links) 
  57. //----------------------------------------------------------------------
  58. static class EdgeClass : public TclClass {
  59. public:
  60.   EdgeClass() : TclClass("Edge") {} 
  62.   TclObject * create(int argc, const char*const* argv) {
  63.     // set <Edge> [new Node node_id type size]
  64.     Edge * edge;
  65.     double bandwidth, delay, length, angle, label_size;
  66.     bandwidth = strtod(argv[4], NULL);
  67.     delay  = strtod(argv[5], NULL);
  68.     length = strtod(argv[6], NULL);
  69.     angle = strtod(argv[7], NULL);
  70.     label_size = strtod(argv[8], NULL);
  72.     edge = new Edge(label_size, bandwidth, delay, length, angle);
  73.     return edge;
  74.   }
  75. } class_edge;
  77. //----------------------------------------------------------------------
  78. // Edge::Edge(double ps, double bw, double delay,
  79. //            double length, double angle)
  80. //    - Creates an edge that is not attached to any nodes.
  81. //      Used by nam editor when loading in an existing enam file.
  82. //    - With this constructor, the nodes need to be added 
  83. //      to this edge using Edge::attachNodes() 
  84. //----------------------------------------------------------------------
  85. Edge::Edge(double ps, double bw, double delay,
  86.            double length, double angle) :
  87.   Animation(0,0) {
  89.   psize_ = ps;
  90.   angle_ = angle;
  91.   bandwidth_ = bw;
  92.   delay_ = delay;
  93.   length_ = length;
  94.   state_ = UP;
  96.   paint_ = Paint::instance()->thick();
  97.   
  98.   setupDefaults(); 
  99. }
  103. //----------------------------------------------------------------------
  104. // Edge::Edge(Node* src, Node* dst, double ps, double bw,
  105. //            double delay, double length, double angle)
  106. //   - creates an edge which is a one way network link
  107. //   - the edge is automaticall attached to nodes src and dst
  108. //----------------------------------------------------------------------
  109. Edge::Edge(Node * src, Node * dst, double ps, double bw,
  110.            double _delay, double length, double angle) :
  111.   Animation(0,0),
  112.   psize_(ps),
  113.   angle_(angle),
  114.   bandwidth_(bw),
  115.   delay_(_delay),
  116.   length_(length) {
  118.   setupDefaults();
  120.   src_ = src->num();
  121.   dst_ = dst->num();
  122.   start_ = src;
  123.   neighbor_ = dst;
  125.   paint_ = Paint::instance()->thick();
  126.   if (length_ == 0) {
  127.     length_ = delay_;
  128.   }
  130. }
  132. //----------------------------------------------------------------------
  133. // Edge::Edge(Node* src, Node* dst, double ps, double bw,
  134. //            double delay, double length, double angle, int ws)
  135. //   - creates an edge for wireless 
  136. //----------------------------------------------------------------------
  137. Edge::Edge(Node* src, Node* dst, double ps,
  138.      double bw, double _delay, double length, double angle, int ws) :
  139.   Animation(0,0),
  140.   psize_(ps),
  141.   angle_(angle),
  142.   bandwidth_(bw),
  143.   delay_(_delay),
  144.   length_(length),
  145.   wireless_(ws) 
  146. {
  147.   setupDefaults();
  149.   src_ = src->num();
  150.   dst_ = dst->num();
  151.   start_ = src;
  152.   neighbor_ = dst;
  154.   paint_ = Paint::instance()->thick();
  155.   if (length_ == 0) {
  156.     length_ = delay_;
  157.   }
  158. }
  160. //----------------------------------------------------------------------
  161. // void
  162. // Edge::setupDefaults()
  163. //----------------------------------------------------------------------
  164. void
  165. Edge::setupDefaults() {
  166. x0_ = 0.0;
  167. y0_ = 0.0;
  168. state_ = UP;
  169. packets_ = NULL;
  170. no_of_packets_ = 0;
  171. last_packet_ = NULL;
  172. marked_ = 0;
  173. visible_ = 1;
  174. dlabel_ = NULL;
  175. dcolor_ = NULL;
  176. direction_ = 0;
  177. used_ = 0;
  179. // Set initial (x0,y0), (x1,y1) so that they reflect the current 
  180. // angle. This enables netmodel to share the same placeEdge() and
  181. // placeAgent() with AutoNetModel.
  182. SINCOSPI(angle_, &x1_, &y1_);
  184. lossmodel_ = NULL;
  185. queue_handle_ = NULL;
  186. }
  188. //----------------------------------------------------------------------
  189. //----------------------------------------------------------------------
  190. Edge::~Edge() {
  191.   if (queue_handle_) {
  192.     delete queue_handle_;
  193.   }
  194. }
  196. //----------------------------------------------------------------------
  197. // void
  198. // Edge::attachNodes(Node * source, Node * destination)
  199. //----------------------------------------------------------------------
  200. void
  201. Edge::attachNodes(Node * source, Node * destination) {
  202.   src_ = source->num();
  203.   dst_ = destination->num();
  204.   start_ = source;
  205.   neighbor_ = destination;
  207.   if (length_ == 0) {
  208.     length_ = delay_;
  209.   }
  210.   start_->add_link(this);
  211. }
  214. //----------------------------------------------------------------------
  215. // void
  216. // Edge::addLossModel(LossModel * lossmodel)
  217. //----------------------------------------------------------------------
  218. void
  219. Edge::addLossModel(LossModel * lossmodel) {
  220. if (!lossmodel_) {
  221. lossmodel_ = lossmodel;
  222. lossmodel_->attachTo(this);
  223. lossmodel_->place();
  224. }
  225. }
  227. //----------------------------------------------------------------------
  228. //----------------------------------------------------------------------
  229. LossModel * 
  230. Edge::getLossModel() {
  231. return lossmodel_;
  232. }
  234. //----------------------------------------------------------------------
  235. //----------------------------------------------------------------------
  236. void
  237. Edge::clearLossModel() {
  238. // Delete previous loss model if it exists
  239. if (lossmodel_) {
  240. lossmodel_ = NULL;
  241. }
  242. }
  244. //----------------------------------------------------------------------
  245. //----------------------------------------------------------------------
  246. void
  247. Edge::addQueueHandle(QueueHandle * q_handle) {
  248. queue_handle_ = q_handle;
  249. queue_handle_->place();
  250. }
  253. //----------------------------------------------------------------------
  254. //----------------------------------------------------------------------
  255. float Edge::distance(float x, float y) const 
  256. {
  257. // TODO: Look it up when back home...
  258. matrix_.imap(x, y);
  259. return y;
  260. }
  262. //----------------------------------------------------------------------
  263. // inline double
  264. // Edge::delay() const
  265. //   - delay_ is stored in milliseconds
  266. //   - this function returns the delay in seconds
  267. //
  268. //   - look at tcl/netModel.tcl layout_link and layout_lan
  269. //     for the conversion to milliseconds
  270. //
  271. //   - delay_ is kept in milliseconds so that Edge::info()
  272. //     is displayed in millseconds and so that delay can be
  273. //     entered in milliseconds by the nam editor
  274. //
  275. //----------------------------------------------------------------------
  276. double
  277. Edge::delay() const {
  278. return (delay_/1000.0);
  279. } 
  281. void Edge::init_color(const char *clr)
  282. {
  283. color(clr);
  284.         dcolor(clr);
  285. oldPaint_ = paint_;
  286. }
  288. void Edge::set_down(char *color)
  289. {
  290. // If current color is down, don't change it again.
  291. // Assuming only one down color. User can change this behavior
  292. // by adding tcl code for link-up and link-down events.
  293. if (state_ == UP) {
  294. int pno = Paint::instance()->lookup(color, 3);
  295. oldPaint_ = paint_;
  296. paint_ = pno;
  297. state_ = DOWN;
  298. }
  299. }
  301. void Edge::set_up()
  302. {
  303. if (state_ == DOWN) {
  304. state_ = UP;
  305. toggle_color();
  306. }
  307. }
  309. void Edge::place(double x0, double y0, double x1, double y1)
  310. {
  311. x0_ = x0;
  312. y0_ = y0;
  313. x1_ = x1;
  314. y1_ = y1;
  316. double dx = x1 - x0;
  317. double dy = y1 - y0;
  318. /*XXX*/
  319. // delay should not be equal to edge's position
  320. // delay_ = sqrt(dx * dx + dy * dy);
  321. matrix_.clear();
  322. matrix_.rotate((180 / M_PI) * atan2(dy, dx));
  323. matrix_.translate(x0, y0);
  325.   if (x1>x0) {
  326.   bb_.xmin = x0; bb_.xmax = x1;
  327. } else {
  328.   bb_.xmin = x1; bb_.xmax = x0;
  329.   }
  330.   if (y1>y0) {
  331.   bb_.ymin = y0; bb_.ymax = y1;
  332.   } else {
  333.   bb_.ymin = y1; bb_.ymax = y0;
  334.   }
  335. eb_.xmin = -0.1 * start_->size();
  336. eb_.xmax = sqrt(dx*dx+dy*dy) + 0.1*neighbor_->size(); 
  337. eb_.ymin = -0.1 * start_->size();
  338.   eb_.ymax = 0.1 * start_->size();
  340. if (queue_handle_) {
  341.   queue_handle_->place();
  342. }
  343. if (lossmodel_) {
  344. lossmodel_->place();
  345. }
  346. }
  348. void Edge::AddPacket(Packet *p)
  349. {
  350. p->next(packets_);
  351. if (packets_!=NULL)
  352. packets_->prev(p);
  353. p->prev(NULL);
  354. packets_=p;
  355. if (last_packet_==NULL)
  356. last_packet_=p;
  357. no_of_packets_++;
  358. #define PARANOID
  359. #ifdef PARANOID
  360. int ctr=0;
  361. for(Packet *tp=packets_;tp!=NULL;tp=tp->next()) {
  362. ctr++;
  363. if (ctr>no_of_packets_) 
  364. abort();
  365. }
  366. if (last_packet_->next()!=NULL) 
  367. abort();
  368. #ifdef DEBUG
  369. printf("AddPacket: %d->%d OKn", src_, dst_);
  370. #endif
  371. #endif
  372. #undef PARANOID
  373. }
  375. void Edge::arrive_packet(Packet *p, double atime)
  376. {
  377. /*Trigger any arrival event at the node*/
  378. neighbor_->arrive_packet(p, this, atime);
  379. }
  381. void Edge::DeletePacket(Packet *p)
  382. {
  383. /*Trigger any deletion event at the node*/
  384. if (neighbor_)  neighbor_->delete_packet(p);
  385. else return ;
  387. no_of_packets_--;
  388. if (last_packet_==p) {
  389. /*Normal case - it's the last packet*/
  390. last_packet_ = p->prev();
  391. if (packets_!=p)
  392. p->prev()->next(NULL);
  393. else
  394. packets_=NULL;
  395. } else {
  396. /*Abnormal case - need to search the list*/
  397. Packet *tp;
  398. tp=packets_;
  399. while((tp!=p)&&(tp!=NULL)) {
  400. tp=tp->next();
  401. }
  402. if (tp==p) {
  403. if (tp==packets_)
  404. /*it was the first packet*/
  405. packets_=tp->next();
  406. else
  407. tp->prev()->next(tp->next());
  408. if (tp==last_packet_) {
  409. /*this shouldn't ever happen*/
  410. fprintf(stderr, "**it happenedn");
  411. last_packet_=tp->prev();
  412. } else
  413. tp->next()->prev(tp->prev());
  414. }
  415. }
  416. #define PARANOID
  417. #ifdef PARANOID
  418. int ctr=0;
  419. for(Packet *tp=packets_;tp!=NULL;tp=tp->next()) {
  420. ctr++;
  421. if (ctr>no_of_packets_) abort();
  422. }
  423. if ((last_packet_!=NULL)&&(last_packet_->next()!=NULL)) abort();
  424. #ifdef DEBUG
  425. printf("DeletePacket: %d->%d OKn", src_, dst_);
  426. #endif
  427. #endif
  428. #undef PARANOID
  429. }
  431. void Edge::dlabel(const char* name)
  432. {
  433.         if (name[0] == 0) {
  434.                 if (dlabel_) {
  435.                         delete []dlabel_;
  436.                         dlabel_ = 0;
  437.                 }
  438.                 return;
  439.         }
  441.         if (dlabel_)
  442.                 delete []dlabel_;
  443.         dlabel_ = new char[strlen(name) + 1];
  444.         strcpy(dlabel_, name);
  445. }
  447. void Edge::dcolor(const char* name)
  448. {
  449.   if (name[0] == 0) {
  450.     if (dcolor_) {
  451.                         delete []dcolor_;
  452.                         dcolor_ = 0;
  453.     }
  454.                 return;
  455.   }
  457.         if (dcolor_)
  458.                 delete []dcolor_;
  459.         dcolor_ = new char[strlen(name) + 1];
  460.         strcpy(dcolor_, name);
  461. }
  463. void Edge::direction(const char* name)
  464. {
  465. if (name[0] == 0) {
  466. if (direction_)  
  467. direction_ = 0;
  468. return;
  469. }
  470.         if (!strcmp(name, "SOUTH"))          direction_ = 1;
  471.         else if (!strcmp(name, "NORTH"))     direction_ = 2;
  472.         else if (!strcmp(name, "EAST"))      direction_ = 3;
  473.         else if (!strcmp(name, "WEST"))      direction_ = 4;
  474.         else                                 direction_ = 2;
  475. }
  477. void Edge::draw(View* view, double now) {
  478.   if (visible()) {
  479.    view->line(x0_, y0_, x1_, y1_, paint_);
  480. }
  481. if (monitor_!=NULL)
  482.   monitor_->draw(view, (x0_+x1_)/2, (y0_+y1_)/2);
  484.         if (dlabel_ == 0) 
  485. return;
  486. // Draw dynamic label
  487. switch (direction_) {
  488. case 0:
  489. view->string((x0_+x1_)/2.0, (y0_+y1_)/2.0+psize_*1.5, 
  490.      psize_*2.3, dlabel_, direction_, dcolor_);
  491. break;
  492. case 1:
  493. view->string((x0_+x1_)/2.0, (y0_+y1_)/2.0-psize_*1.5, 
  494.      psize_*2.3, dlabel_, direction_, dcolor_);
  495. break;
  496. case 2:
  497. view->string((x0_+x1_)/2.0, (y0_+y1_)/2.0+psize_*1.5, 
  498.      psize_*2.3, dlabel_, direction_, dcolor_);
  499. break;
  500. case 3:
  501. view->string((x0_+x1_)/2.0-psize_*1.5, (y0_+y1_)/2.0, 
  502.      psize_*2.3, dlabel_, direction_, dcolor_);
  503. break;
  504. case 4:
  505. view->string((x0_+x1_)/2.0+psize_*1.5, (y0_+y1_)/2.0, 
  506.      psize_*2.3, dlabel_, direction_, dcolor_);
  507. break;
  508. default:
  509. view->string((x0_+x1_)/2.0, (y0_+y1_)/2.0+psize_*1.5, 
  510.      psize_*2.3, dlabel_, direction_, dcolor_);
  511. break;
  512. }
  513. }
  515. void Edge::reset(double)
  516. {
  517. // paint_ = Paint::instance()->thick();
  518. no_of_packets_=0;
  519. packets_=NULL;
  520. last_packet_=NULL;
  521. }
  523. int Edge::inside(double, float px, float py) const
  524. {
  525. // matrix_.imap(px, py);
  526. // return eb_.inside(px, py);
  527. return inside(px, py);
  528. }
  530. int Edge::inside(float px, float py) const
  531. {
  532. matrix_.imap(px, py);
  533. return eb_.inside(px, py);
  534. }
  536. const char* Edge::info() const
  537. {
  538. static char text[128];
  539. sprintf(text, "Link: %d<->%dn  Bandwidth: %g Mbits/secn  Delay: %g msn",
  540. src_, dst_, bandwidth_, delay_);
  541. return (text);
  542. }
  544. const char* Edge::property() {
  545.   rgb *color;
  546.   color=Paint::instance()->paint_to_rgb(paint_);
  547.  
  548.   static char text[256];
  549.   char *p;
  550.  
  551.   // object type and id
  552.   p = text;
  553.   if (!wireless_) {
  554.     sprintf(text, "{"Link %d-%d" title title "Link %d-%d"} ", 
  555.     src_, dst_, src_, dst_);
  556.   } else {
  557.     sprintf(text, "{"Wireless Link %d-%d" title title "Wireless Link %d-%d"} ", 
  558.     src_, dst_, src_, dst_);
  559.   }
  561.   p = &text[strlen(text)];
  562.   sprintf(p, "{Color color_ color %s} ", color->colorname); // color & value
  564.   // label
  565.   p = &text[strlen(text)];
  566.   if (dlabel_) {
  567.     sprintf(p, "{Label dlabel_ text %s} ", dlabel_); 
  568.   } else {
  569.     sprintf(p, "{Label dlabel_ text  } "); 
  570.   }
  571.   
  572.   //p = &text[strlen(text)];
  573.   //sprintf(p, "{LABEL-DIRECTION %d} ", direction_); // label-direction $ value
  574.   
  575.   // Link Bandwidth
  576.   p = &text[strlen(text)];
  577.   sprintf(p, "{"Bandwidth (Mbits per second)" bandwidth_ text %-f} ", bandwidth_);
  579.   // Link Delay
  580.   p = &text[strlen(text)];
  581.   sprintf(p, "{"Delay (ms)" delay_ text %-f} ", delay_);
  583.   return(text);
  584. }
  586. const char* Edge::getname() const
  587. {
  588. static char text[128];
  589. sprintf(text, "l %d %d",
  590. src_, dst_);
  591. return (text);
  592. }
  594. void Edge::monitor(Monitor *m, double /*now*/, char *result, int /*len*/)
  595. {
  596. monitor_=m;
  597. sprintf(result, "link %d-%d:n bw: %g Mbits/secn delay: %g ms",
  598. src_, dst_, bandwidth_, delay_);
  599. return;
  600. }
  602. int Edge::save(FILE *file)
  603. {
  604. rgb *color;
  605. color=Paint::instance()->paint_to_rgb(paint_);
  606. char state[10];
  607. double angle,length;
  608. float dx,dy;
  609. //Edges in the tracefile are bidirectional, so don't need to save
  610. //both unidirectional edges
  611. if (src_>dst_) return 0;
  613. if (state_==UP)
  614. strcpy(state, " -S UP");
  615. else if (state_==DOWN)
  616. strcpy(state, " -S DOWN");
  617. else
  618. state[0]='';
  619. if (angle_<0)
  620. angle=180*(angle_+2*M_PI)/M_PI;
  621. else
  622. angle=180*(angle_/M_PI);
  623. dx=x0_-x1_;
  624. dy=y0_-y1_;
  625. length=sqrt(dx*dx+dy*dy);
  626. //  printf("%d->%d, angle=%f (%fdeg)n", src_, dst_, angle_, angle);
  627. fprintf(file, "l -t * -s %d -d %d -r %f -D %f -c %s -o %.1fdeg -l %f%sn", 
  628. src_, dst_, bandwidth_, delay_, color->colorname,angle, length, state);
  629. return 0;
  630. }
  632. int Edge::saveAsEnam(FILE *file)
  633. {
  634. rgb *color;
  635. color=Paint::instance()->paint_to_rgb(paint_);
  636. char state[10];
  637. double angle,length;
  638. float dx,dy;
  639. // XXX Should never set edge size outside scale_estimate()!!!!
  640. //    psize_ = 25.0;
  642. // Edges in the tracefile are bidirectional, so don't need to save
  643. // both unidirectional edges
  644. if (src_>dst_) return 0; 
  645.  
  646. if (state_==UP)
  647. strcpy(state, " -S UP");
  648. else if (state_==DOWN)
  649. strcpy(state, " -S DOWN");
  650. else
  651. state[0]='';
  652. if (angle_<0)
  653. angle=180*(angle_+2*M_PI)/M_PI;
  654. else
  655. angle=180*(angle_/M_PI);
  656. dx=x0_-x1_;
  657. dy=y0_-y1_;
  658. length=sqrt(dx*dx+dy*dy);
  659. //  printf("%d->%d, angle=%f (%fdeg)n", src_, dst_, angle_, angle);
  660. fprintf(file, "##l -t * -s %d -d %d -r %f -D %f -c %s -o %.1fdeg -l %f%s -b %sn",
  661. src_, dst_, bandwidth_, delay_, color->colorname,angle, length, state, dlabel_);
  662. return 0;
  663. }
  665. //----------------------------------------------------------------------
  666. // int
  667. // Edge::writeNsScript(FILE *file)
  668. //   - Edges in the tracefile are bidirectional, so don't need to save
  669. //     both unidirectional edges
  670. //----------------------------------------------------------------------
  671. int
  672. Edge::writeNsScript(FILE *file) {
  673.   rgb *color;
  674.   double angle,length;
  675.   float dx,dy;
  677.   color = Paint::instance()->paint_to_rgb(paint_); 
  679.   if (angle_ < 0) { 
  680.      angle = 180 * (angle_ + 2 * M_PI) / M_PI;
  681.    } else {
  682.      angle = 180 * (angle_ / M_PI);
  683.    }
  684.    dx = x0_ - x1_;
  685.    dy = y0_ - y1_;
  686.    length = sqrt(dx * dx + dy * dy);
  688.    // Create the link
  689.    if (queue_handle_) {
  690.      //fprintf(file, "$ns simplex-link $node(%d) $node(%d) %f %f DropTailn",
  691.      fprintf(file, "$ns simplex-link $node(%d) $node(%d) %fMb %fms %sn",
  692.                     src_, dst_, bandwidth_, delay_, queue_handle_->name());
  693.    } else {
  694.      fprintf(file, "$ns simplex-link $node(%d) $node(%d) %fMb %fms DropTailn",
  695.                     src_, dst_, bandwidth_, delay_);
  696.    }
  698.    // Add a packet queue
  699.    fprintf(file, "$ns simplex-link-op $node(%d) $node(%d) queuePos 0.5n",
  700.                   src_, dst_);
  702.    // Set different options for the link
  703.    // - Color
  704.    fprintf(file, "$ns simplex-link-op $node(%d) $node(%d) color %sn",
  705.                   src_, dst_, color->colorname);
  706.    // - Orientation
  707.    fprintf(file, "$ns simplex-link-op $node(%d) $node(%d) orient %.1fdegn",
  708.                   src_, dst_, angle);
  709.    
  710.    if (dlabel_){
  711.      // - label
  712.      fprintf(file, "$ns simplex-link-op $node(%d) $node(%d) label %sn",
  713.                     src_, dst_, dlabel_);
  714.    }
  716.    if (direction_!=0) {
  717.      // - label orientation
  718.      fprintf(file, "$ns simplex-link-op $node(%d) $node(%d) label-at %dn",
  719.                     src_, dst_, direction_);
  720.    }
  722.    if (queue_handle_) {
  723.      queue_handle_->writeNsScript(file);
  724.    }
  726.    fprintf(file, "n");
  728.   return 0;
  729. }