A Discrete-Event Network Simulator
API
service-flow.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2007,2008,2009 INRIA, UDcast
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Authors: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
19  * Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
20  * <amine.ismail@UDcast.com>
21  */
22 
23 #include "service-flow.h"
24 #include "service-flow-record.h"
25 #include "ns3/simulator.h"
26 #include "wimax-tlv.h"
27 
28 namespace ns3 {
29 
31 {
32  InitValues ();
33  m_direction = direction;
35  m_record = new ServiceFlowRecord ();
36  m_sfid = 0;
37  m_connection = 0;
38  m_isEnabled = false;
39  m_isMulticast = false;
41 }
42 
44  : m_sfid (0),
45  m_direction (SF_DIRECTION_DOWN),
46  m_type (SF_TYPE_PROVISIONED),
47  m_connection (0),
48  m_isEnabled (false),
49  m_record (new ServiceFlowRecord ())
50 {
51  InitValues ();
52  m_isMulticast = false;
54 
55 }
56 
57 ServiceFlow::ServiceFlow (uint32_t sfid, Direction direction, Ptr<WimaxConnection> connection)
58 {
59  InitValues ();
60  m_record = new ServiceFlowRecord ();
61  m_isEnabled = false;
62  m_connection = connection;
63  m_connection->SetServiceFlow (this);
65  m_direction = direction;
66  m_sfid = sfid;
67  m_isMulticast = false;
69 }
70 
72 {
73  InitValues ();
74  m_connection = 0;
75  m_isEnabled = 0;
76  m_record = new ServiceFlowRecord ();
78  "Invalid TLV");
79 
80  SfVectorTlvValue * param;
81  param = (SfVectorTlvValue*)(tlv.PeekValue ());
82 
83  if (tlv.GetType () == Tlv::UPLINK_SERVICE_FLOW)
84  {
86  }
87  else
88  {
90  }
91 
92  for (std::vector<Tlv*>::const_iterator iter = param->Begin (); iter != param->End (); ++iter)
93  {
94  switch ((*iter)->GetType ())
95  {
97  {
98  m_sfid = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
99  break;
100  }
102  {
103  uint16_t cid = ((U16TlvValue*)((*iter)->PeekValue ()))->GetValue ();
104  m_connection = CreateObject<WimaxConnection> (cid, Cid::TRANSPORT);
105  break;
106  }
108  {
109  m_qosParamSetType = ((U8TlvValue*)((*iter)->PeekValue ()))->GetValue ();
110  break;
111  }
113  {
114  m_trafficPriority = ((U8TlvValue*)((*iter)->PeekValue ()))->GetValue ();
115  break;
116  }
118  {
119  m_maxSustainedTrafficRate = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
120  break;
121  }
123  {
124  m_maxTrafficBurst = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
125  break;
126  }
128  {
129  m_minReservedTrafficRate = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
130  break;
131  }
133  {
134  m_minTolerableTrafficRate = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
135  break;
136  }
138  {
139  m_schedulingType = (ServiceFlow::SchedulingType)((U8TlvValue*)((*iter)->PeekValue ()))->GetValue ();
140  break;
141  }
143  {
144  m_requestTransmissionPolicy = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
145  break;
146  }
148  {
149  m_toleratedJitter = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
150  break;
151  }
153  {
154  m_maximumLatency = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
155  break;
156  }
158  {
159  m_fixedversusVariableSduIndicator = ((U16TlvValue*)((*iter)->PeekValue ()))->GetValue ();
160  break;
161  }
163  {
164  m_csSpecification = (enum CsSpecification)(((U8TlvValue*)((*iter)->PeekValue ()))->GetValue ());
165  break;
166  }
167 
169  {
171  break;
172  }
173 
174  }
175  }
176  m_isMulticast = false;
178 }
179 
181 {
182  if (m_record != 0)
183  {
184  delete m_record;
185  m_record = 0;
186  }
187  m_connection = 0;
188 }
189 
190 void
192 {
193  m_direction = direction;
194 }
195 
198 {
199  return m_direction;
200 }
201 
202 void
204 {
205  m_type = type;
206 }
207 
210 {
211  return m_type;
212 }
213 
214 void
216 {
217  m_connection = connection;
218  m_connection->SetServiceFlow (this);
219 }
220 
223 {
224  return m_connection;
225 }
226 
227 void
229 {
230  m_isEnabled = isEnabled;
231 }
232 
233 bool
235 {
236  return m_isEnabled;
237 }
238 
239 void
241 {
242  m_record = record;
243 }
244 
247 {
248  return m_record;
249 }
250 
253 {
254  if (!m_connection)
255  {
256  return 0;
257  }
258  return m_connection->GetQueue ();
259 }
260 
263 {
264  return m_schedulingType;
265 }
266 
267 bool
269 {
270  if (!m_connection)
271  {
272  return false;
273  }
274  return m_connection->HasPackets ();
275 }
276 
277 bool
279 {
280  if (!m_connection)
281  {
282  return false;
283  }
284  return m_connection->HasPackets (packetType);
285 }
286 
287 void
289 {
290  GenericMacHeader hdr;
291  Time timeStamp;
292  Ptr<Packet> packet;
293  Time currentTime = Simulator::Now ();
294  if (m_connection)
295  {
296  while (m_connection->HasPackets ())
297  {
298  packet = m_connection->GetQueue ()->Peek (hdr, timeStamp);
299 
300  if (currentTime - timeStamp > MilliSeconds (GetMaximumLatency ()))
301  {
302  m_connection->Dequeue ();
303  }
304  else
305  {
306  break;
307  }
308  }
309  }
310 }
311 
312 void
314 {
315 }
316 // ==============================================================================
317 
318 
319 uint32_t
321 {
322  return m_sfid;
323 }
324 uint16_t
326 {
327  if (m_connection == 0)
328  {
329  return 0;
330  }
331  return m_connection->GetCid ().GetIdentifier ();
332 }
333 std::string
335 {
336  return m_serviceClassName;
337 }
338 uint8_t
340 {
341  return m_qosParamSetType;
342 }
343 uint8_t
345 {
346  return m_trafficPriority;
347 }
348 uint32_t
350 {
352 }
353 uint32_t
355 {
356  return m_maxTrafficBurst;
357 }
358 uint32_t
360 {
362 }
363 uint32_t
365 {
367 }
368 enum
370 {
371  return m_schedulingType;
372 }
373 uint32_t
375 {
377 }
378 uint32_t
380 {
381  return m_toleratedJitter;
382 }
383 uint32_t
385 {
386  return m_maximumLatency;
387 }
388 uint8_t
390 {
392 }
393 uint8_t
395 {
396  return m_sduSize;
397 }
398 uint16_t
400 {
401  return m_targetSAID;
402 }
403 uint8_t
405 {
406  return m_arqEnable;
407 }
408 uint16_t
410 {
411  return m_arqWindowSize;
412 }
413 uint16_t
415 {
416  return m_arqRetryTimeoutTx;
417 }
418 uint16_t
420 {
421  return m_arqRetryTimeoutRx;
422 }
423 
424 uint16_t
426 {
427  return m_arqBlockLifeTime;
428 }
429 uint16_t
431 {
432  return m_arqSyncLoss;
433 }
434 uint8_t
436 {
437  return m_arqDeliverInOrder;
438 }
439 uint16_t
441 {
442  return m_arqPurgeTimeout;
443 }
444 uint16_t
446 {
447  return m_arqBlockSize;
448 }
449 enum
451 {
452  return m_csSpecification;
453 }
456 {
458 }
459 uint16_t
461 {
463 }
464 uint16_t
466 {
468 }
469 
470 bool
472 {
473  return m_isMulticast;
474 }
477 {
478  return m_modulationType;
479 }
480 
481 
482 // ==============================================================================
483 
484 void
485 ServiceFlow::SetSfid (uint32_t sfid)
486 {
487  m_sfid = sfid;
488 }
489 void
491 {
492  m_serviceClassName = name;
493 }
494 void
496 {
497  m_qosParamSetType = type;
498 }
499 void
501 {
502  m_trafficPriority = priority;
503 }
504 void
505 ServiceFlow::SetMaxSustainedTrafficRate (uint32_t maxSustainedRate)
506 {
507  m_maxSustainedTrafficRate = maxSustainedRate;
508 }
509 void
510 ServiceFlow::SetMaxTrafficBurst (uint32_t maxTrafficBurst)
511 {
512  m_maxTrafficBurst = maxTrafficBurst;
513 }
514 void
516 {
517  m_minReservedTrafficRate = minResvRate;
518 }
519 void
521 {
522  m_minTolerableTrafficRate = minJitter;
523 }
524 void
526 {
527  m_schedulingType = schedType;
528 }
529 void
531 {
533 }
534 void
536 {
537  m_toleratedJitter = jitter;
538 }
539 void
540 ServiceFlow::SetMaximumLatency (uint32_t MaximumLatency)
541 {
542  m_maximumLatency = MaximumLatency;
543 }
544 void
546 {
547  m_fixedversusVariableSduIndicator = sduIndicator;
548 }
549 void
550 ServiceFlow::SetSduSize (uint8_t sduSize)
551 {
552  m_sduSize = sduSize;
553 }
554 void
555 ServiceFlow::SetTargetSAID (uint16_t targetSaid)
556 {
557  m_targetSAID = targetSaid;
558 }
559 void
560 ServiceFlow::SetArqEnable (uint8_t arqEnable)
561 {
562  m_arqEnable = arqEnable;
563 }
564 void
565 ServiceFlow::SetArqWindowSize (uint16_t arqWindowSize)
566 {
567  m_arqWindowSize = arqWindowSize;
568 }
569 void
571 {
573 }
574 void
576 {
578 }
579 void
581 {
582  m_arqBlockLifeTime = lifeTime;
583 }
584 void
585 ServiceFlow::SetArqSyncLoss (uint16_t syncLoss)
586 {
587  m_arqSyncLoss = syncLoss;
588 }
589 void
591 {
592  m_arqDeliverInOrder = inOrder;
593 }
594 void
596 {
598 }
599 void
601 {
602  m_arqBlockSize = size;
603 }
604 void
606 {
607  m_csSpecification = spec;
608 }
609 void
611 {
612  m_convergenceSublayerParam = csparam;
613 }
614 void
615 ServiceFlow::SetUnsolicitedGrantInterval (uint16_t unsolicitedGrantInterval)
616 {
617  m_unsolicitedGrantInterval = unsolicitedGrantInterval;
618 }
619 void
620 ServiceFlow::SetUnsolicitedPollingInterval (uint16_t unsolicitedPollingInterval)
621 {
622  m_unsolicitedPollingInterval = unsolicitedPollingInterval;
623 }
624 void
625 ServiceFlow::SetIsMulticast (bool isMulticast)
626 {
627  m_isMulticast = isMulticast;
628 }
629 void
631 {
632  m_modulationType = modulationType;
633 }
634 
635 void
637 {
638  m_sfid = 0;
639  m_serviceClassName = "";
640  m_qosParamSetType = 0;
641  m_trafficPriority = 0;
643  m_maxTrafficBurst = 0;
648  m_toleratedJitter = 0;
649  m_maximumLatency = 0;
651  m_sduSize = 0;
652  m_targetSAID = 0;
653  m_arqEnable = 0;
654  m_arqWindowSize = 0;
660  m_arqBlockLifeTime = 0;
661  m_arqSyncLoss = 0;
663  m_arqPurgeTimeout = 0;
664  m_arqBlockSize = 0;
667  m_isMulticast = false;
669 }
670 
671 void
673 {
686  m_sduSize = sf.GetSduSize ();
687  m_targetSAID = sf.GetTargetSAID ();
688  m_arqEnable = sf.GetArqEnable ();
696  m_direction = sf.GetDirection ();
699 }
700 
702 {
703  m_sfid = sf.GetSfid ();
716  m_sduSize = sf.GetSduSize ();
717  m_targetSAID = sf.GetTargetSAID ();
718  m_arqEnable = sf.GetArqEnable ();
726  m_direction = sf.GetDirection ();
727  m_type = sf.GetType ();
728  m_connection = sf.GetConnection ();
729  m_isEnabled = sf.GetIsEnabled ();
730  m_record = new ServiceFlowRecord ();
731  (*m_record) = (*sf.GetRecord ());
734 }
735 
736 ServiceFlow &
738 {
739 
740  m_sfid = o.GetSfid ();
753  m_sduSize = o.GetSduSize ();
755  m_arqEnable = o.GetArqEnable ();
763  m_direction = o.GetDirection ();
764  m_type = o.GetType ();
766  m_isEnabled = o.GetIsEnabled ();
769  if (m_record != 0)
770  {
771  delete m_record;
772  }
773 
774  m_record = new ServiceFlowRecord ();
775 
776  (*m_record) = (*o.GetRecord ());
777  return *this;
778 }
779 
780 char*
782 {
783  switch (m_schedulingType)
784  {
785  case SF_TYPE_UGS:
786  return (char*) "UGS";
787  break;
788  case SF_TYPE_RTPS:
789  return (char*) "rtPS";
790  break;
791  case SF_TYPE_NRTPS:
792  return (char*) "nrtPS";
793  break;
794  case SF_TYPE_BE:
795  return (char*) "BE";
796  break;
797  default:
798  NS_FATAL_ERROR ("Invalid scheduling type");
799  }
800  return 0;
801 }
802 
803 Tlv
804 ServiceFlow::ToTlv (void) const
805 {
806  SfVectorTlvValue tmpSfVector;
807  tmpSfVector.Add (Tlv (SfVectorTlvValue::SFID, 4, U32TlvValue (m_sfid)));
808  tmpSfVector.Add (Tlv (SfVectorTlvValue::CID, 2, U16TlvValue (GetCid ())));
820  1,
822  tmpSfVector.Add (Tlv (SfVectorTlvValue::SDU_Size, 1, U8TlvValue (m_sduSize)));
825  tmpSfVector.Add (m_convergenceSublayerParam.ToTlv ());
827  {
828  return Tlv (Tlv::UPLINK_SERVICE_FLOW, tmpSfVector.GetSerializedSize (), tmpSfVector);
829  }
830  else
831  {
832  return Tlv (Tlv::DOWNLINK_SERVICE_FLOW, tmpSfVector.GetSerializedSize (), tmpSfVector);
833  }
834 }
835 
836 bool
838  Ipv4Address dstAddress,
839  uint16_t srcPort,
840  uint16_t dstPort,
841  uint8_t proto) const
842 {
844  dstAddress,
845  srcPort,
846  dstPort,
847  proto);
848 }
849 } // namespace ns3
void SetArqRetryTimeoutTx(uint16_t timeout)
Set ARQ retry timeout transmit.
uint32_t GetMaxSustainedTrafficRate(void) const
Get max sustained traffic rate.
CsParameters GetConvergenceSublayerParam(void) const
Get convergence sublayer.
HeaderType
Header type enumeration.
ServiceFlow()
default constructor
Definition: service-flow.cc:43
uint16_t m_unsolicitedPollingInterval
unsolicited polling interval
Definition: service-flow.h:582
bool GetIsMulticast(void) const
Get is multicast.
uint16_t GetArqRetryTimeoutRx(void) const
Get ARQ retry timeout receive.
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:102
Tlv ToTlv(void) const
creates a TLV from this service flow
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:73
U16TlvValue class.
Definition: wimax-tlv.h:209
enum WimaxPhy::ModulationType m_modulationType
modulation type
Definition: service-flow.h:588
void SetConnection(Ptr< WimaxConnection > connection)
Set connection.
NS_ASSERT_MSG(false, "Ipv4AddressGenerator::MaskToIndex(): Impossible")
uint16_t GetArqBlockLifeTime(void) const
Get ARQ block lifetime.
uint8_t GetArqDeliverInOrder(void) const
Get ARQ deliver in order.
void SetRequestTransmissionPolicy(uint32_t policy)
Set request transmission policy.
this class implements a structure to manage some parameters and statistics related to a service flow ...
uint16_t m_arqWindowSize
ARQ window size.
Definition: service-flow.h:571
uint16_t GetUnsolicitedGrantInterval(void) const
Get unsolicited grant interval.
uint32_t m_sfid
SFID.
Definition: service-flow.h:555
void SetArqEnable(uint8_t arqEnable)
Set ARQ enable.
SfVectorTlvValue class.
Definition: wimax-tlv.h:328
void SetArqBlockLifeTime(uint16_t lifeTime)
Set ARQ block lifetime.
uint8_t GetSduSize(void) const
Get SDU size.
Ptr< WimaxConnection > m_connection
connection
Definition: service-flow.h:585
uint32_t GetMinTolerableTrafficRate(void) const
Get minimum tolerable traffic rate.
void SetToleratedJitter(uint32_t jitter)
Set tolerated jitter.
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1072
enum CsSpecification m_csSpecification
CS specification.
Definition: service-flow.h:579
uint32_t GetMaximumLatency(void) const
Get maximum latency.
std::string m_serviceClassName
service class name
Definition: service-flow.h:556
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:162
uint8_t GetArqEnable(void) const
Get ARQ enable.
enum WimaxPhy::ModulationType GetModulation(void) const
Get modulation.
uint8_t m_arqDeliverInOrder
ARQ deliver in order.
Definition: service-flow.h:576
Type m_type
type
Definition: service-flow.h:584
uint16_t m_targetSAID
traget SAID
Definition: service-flow.h:569
ns3::Time timeout
uint8_t GetTrafficPriority(void) const
Get traffic priority.
uint16_t GetArqPurgeTimeout(void) const
Get ARQ purge timeout.
virtual uint32_t GetSerializedSize(void) const
Get serialized size in bytes.
Definition: wimax-tlv.cc:251
uint32_t GetSfid(void) const
Get SFID.
uint16_t GetArqBlockSize(void) const
Get ARQ block size.
uint16_t m_arqRetryTimeoutTx
ARQ retry timeout transmit.
Definition: service-flow.h:572
uint8_t m_trafficPriority
traffic priority
Definition: service-flow.h:558
This class implements the Type-Len-Value structure channel encodings as described by "IEEE Standard f...
Definition: wimax-tlv.h:83
void SetSduSize(uint8_t sduSize)
Set SDU size.
void SetMinReservedTrafficRate(uint32_t minResvRate)
Set minimum reserved traffic rate.
bool GetIsEnabled(void) const
Get is enabled flag.
This class implements the Generic mac Header as described by IEEE Standard for Local and metropolitan...
CsSpecification
section 11.13.19.2 CS parameter encoding rules, page 707
Definition: service-flow.h:69
uint32_t m_toleratedJitter
tolerated jitter
Definition: service-flow.h:565
enum ServiceFlow::SchedulingType GetServiceSchedulingType(void) const
Get service scheduling type.
void SetArqSyncLoss(uint16_t syncLoss)
Set ARQ sync loss.
void SetQosParamSetType(uint8_t type)
Set QOS parameter set type.
void InitValues(void)
Initial values.
void Add(const Tlv &val)
Add a TLV.
Definition: wimax-tlv.cc:284
SchedulingType
section 11.13.11 Service flow scheduling type, page 701
Definition: service-flow.h:58
CsParameters class.
Definition: cs-parameters.h:35
Ptr< WimaxConnection > GetConnection(void) const
Can return a null connection is this service flow has not been associated yet to a connection...
char * GetSchedulingTypeStr(void) const
Get scheduling type string.
uint32_t m_maxTrafficBurst
maximum traffic burst
Definition: service-flow.h:560
Direction
Direction enumeration.
Definition: service-flow.h:43
uint16_t GetArqRetryTimeoutTx(void) const
Get ARQ retry timeout transmit.
void SetArqDeliverInOrder(uint8_t inOrder)
Set ARQ deliver in order.
IpcsClassifierRecord GetPacketClassifierRule(void) const
uint32_t GetToleratedJitter(void) const
Get tolerated jitter.
Direction m_direction
direction
Definition: service-flow.h:583
bool m_isMulticast
is multicast?
Definition: service-flow.h:587
uint8_t m_sduSize
SDU size.
Definition: service-flow.h:568
void CleanUpQueue(void)
shall be called only by BS
void CopyParametersFrom(ServiceFlow sf)
Copy parameters from another service flow.
U8TlvValue class.
Definition: wimax-tlv.h:170
void SetUnsolicitedGrantInterval(uint16_t unsolicitedGrantInterval)
Set unsolicied grant interval.
CsParameters m_convergenceSublayerParam
convergence sublayer parameters
Definition: service-flow.h:580
Ptr< WimaxMacQueue > GetQueue(void) const
Get pointer to queue.
uint8_t GetType(void) const
Get type value.
Definition: wimax-tlv.cc:214
uint8_t m_fixedversusVariableSduIndicator
fixed versus variable SDI indicator
Definition: service-flow.h:567
ServiceFlowRecord * GetRecord(void) const
Get service flow record.
uint8_t m_qosParamSetType
QOS parameter type.
Definition: service-flow.h:557
enum CsSpecification GetCsSpecification(void) const
Get CS specification.
void SetMaximumLatency(uint32_t MaximumLatency)
Set maximum latency.
uint32_t m_maxSustainedTrafficRate
maximum sustained traffic rate
Definition: service-flow.h:559
uint16_t GetCid(void) const
Get CID.
uint32_t GetMaxTrafficBurst(void) const
Get max traffic burst.
void SetTargetSAID(uint16_t targetSaid)
Set target SAID.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
void SetConvergenceSublayerParam(CsParameters csparam)
Set convergence sublayer parameters.
bool CheckMatch(Ipv4Address srcAddress, Ipv4Address dstAddress, uint16_t srcPort, uint16_t dstPort, uint8_t proto) const
check if a packets can be used with this classifier
uint32_t GetRequestTransmissionPolicy(void) const
Get request transmission policy.
ServiceFlow & operator=(ServiceFlow const &o)
assignment operator
TlvValue * PeekValue(void)
Peek value.
Definition: wimax-tlv.cc:224
void SetRecord(ServiceFlowRecord *record)
Set service flow record.
uint16_t m_arqPurgeTimeout
ARQ purge timeout.
Definition: service-flow.h:577
This class implements service flows as described by the IEEE-802.16 standard.
Definition: service-flow.h:39
uint32_t GetMinReservedTrafficRate(void) const
Get minimum reserved traffic rate.
std::string GetServiceClassName() const
Get service class name.
enum Type GetType(void) const
Get type of service flow.
uint16_t m_arqRetryTimeoutRx
ARQ retry timeout receive.
Definition: service-flow.h:573
uint16_t m_arqBlockSize
ARQ block size.
Definition: service-flow.h:578
uint16_t GetTargetSAID(void) const
Get target SAID.
static Time Now(void)
Return the current simulation virtual time.
Definition: simulator.cc:193
bool CheckClassifierMatch(Ipv4Address srcAddress, Ipv4Address dstAddress, uint16_t srcPort, uint16_t dstPort, uint8_t proto) const
uint32_t m_maximumLatency
maximum latency
Definition: service-flow.h:566
enum ServiceFlow::SchedulingType m_schedulingType
scheduling type
Definition: service-flow.h:563
uint16_t m_unsolicitedGrantInterval
unsolicited grant interval
Definition: service-flow.h:581
void SetModulation(enum WimaxPhy::ModulationType modulationType)
Set modulation.
void SetMinTolerableTrafficRate(uint32_t minJitter)
Set minimum tolerable traffic rate.
ModulationType
ModulationType enumeration.
Definition: wimax-phy.h:49
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:41
enum ServiceFlow::SchedulingType GetSchedulingType(void) const
Get scheduling type.
void SetDirection(enum Direction direction)
Set direction.
void SetIsEnabled(bool isEnabled)
Set is enabled flag.
uint16_t m_arqSyncLoss
ARQ sync loss.
Definition: service-flow.h:575
void SetType(enum Type type)
Set type of service flow.
void SetUnsolicitedPollingInterval(uint16_t unsolicitedPollingInterval)
Set unsolicited polling interval.
uint16_t m_arqBlockLifeTime
ARQ block life time.
Definition: service-flow.h:574
void SetMaxTrafficBurst(uint32_t maxTrafficBurst)
Set maximum traffic burst.
U32TlvValue class.
Definition: wimax-tlv.h:248
Type
Type enumeration.
Definition: service-flow.h:50
ServiceFlowRecord * m_record
service flow record
Definition: service-flow.h:590
bool m_isEnabled
is enabled?
Definition: service-flow.h:586
void SetFixedversusVariableSduIndicator(uint8_t sduIndicator)
Set fixed versus variable SDU indicator.
void SetSfid(uint32_t sfid)
Set SFID.
uint16_t GetArqSyncLoss(void) const
Get ARQ sync loss.
uint32_t m_minTolerableTrafficRate
minimum tolerable traffic rate
Definition: service-flow.h:562
uint8_t GetFixedversusVariableSduIndicator(void) const
Get fixed versus varaiable SDU indicator.
uint32_t m_requestTransmissionPolicy
request transmission policy
Definition: service-flow.h:564
bool HasPackets(void) const
Check if packets are present.
uint16_t GetArqWindowSize(void) const
Get ARQ retry timeout transmit.
void SetTrafficPriority(uint8_t priority)
Set traffic priority.
void SetCsSpecification(enum CsSpecification spec)
Set CS specification.
void SetMaxSustainedTrafficRate(uint32_t maxSustainedRate)
Set max sustained traffic rate.
void SetServiceClassName(std::string name)
Set service class name.
void SetIsMulticast(bool isMulticast)
Set is multicast.
uint16_t GetUnsolicitedPollingInterval(void) const
Get unsolicited polling interval.
void SetArqRetryTimeoutRx(uint16_t timeout)
Set ARQ retry timeout receive.
Tlv ToTlv(void) const
creates a tlv from the classifier record
uint8_t m_arqEnable
ARQ enable.
Definition: service-flow.h:570
enum Direction GetDirection(void) const
Get direction.
void SetServiceSchedulingType(enum ServiceFlow::SchedulingType schedType)
Set service scheduling type.
uint32_t m_minReservedTrafficRate
minimum reserved traffic rate
Definition: service-flow.h:561
void SetArqPurgeTimeout(uint16_t timeout)
Set ARQ purge timeout.
uint8_t GetQosParamSetType(void) const
Get QOS parameter set type.
void SetArqBlockSize(uint16_t size)
Set ARQ block size.
void PrintQoSParameters(void) const
Print QOS parameters.
void SetArqWindowSize(uint16_t arqWindowSize)
Set ARQ retry timeout transmit.