NS-3 based Named Data Networking (NDN) simulator
ndnSIM 2.3: NDN, CCN, CCNx, content centric networks
API Documentation
control-parameters.cpp
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
22 #include "control-parameters.hpp"
23 #include "encoding/tlv-nfd.hpp"
25 #include "util/concepts.hpp"
26 
27 namespace ndn {
28 namespace nfd {
29 
30 //BOOST_CONCEPT_ASSERT((boost::EqualityComparable<ControlParameters>));
31 BOOST_CONCEPT_ASSERT((WireEncodable<ControlParameters>));
32 BOOST_CONCEPT_ASSERT((WireDecodable<ControlParameters>));
33 static_assert(std::is_base_of<tlv::Error, ControlParameters::Error>::value,
34  "ControlParameters::Error must inherit from tlv::Error");
35 
37  : m_hasFields(CONTROL_PARAMETER_UBOUND)
38 {
39 }
40 
42  : m_hasFields(CONTROL_PARAMETER_UBOUND)
43 {
44  wireDecode(block);
45 }
46 
47 template<encoding::Tag TAG>
48 size_t
50 {
51  size_t totalLength = 0;
52 
53  if (this->hasFacePersistency()) {
54  totalLength += prependNonNegativeIntegerBlock(encoder,
55  tlv::nfd::FacePersistency, m_facePersistency);
56  }
57  if (this->hasExpirationPeriod()) {
58  totalLength += prependNonNegativeIntegerBlock(encoder,
59  tlv::nfd::ExpirationPeriod, m_expirationPeriod.count());
60  }
61  if (this->hasStrategy()) {
62  totalLength += prependNestedBlock(encoder, tlv::nfd::Strategy, m_strategy);
63  }
64  if (this->hasMask()) {
65  totalLength += prependNonNegativeIntegerBlock(encoder, tlv::nfd::Mask, m_mask);
66  }
67  if (this->hasFlags()) {
68  totalLength += prependNonNegativeIntegerBlock(encoder, tlv::nfd::Flags, m_flags);
69  }
70  if (this->hasCost()) {
71  totalLength += prependNonNegativeIntegerBlock(encoder, tlv::nfd::Cost, m_cost);
72  }
73  if (this->hasOrigin()) {
74  totalLength += prependNonNegativeIntegerBlock(encoder, tlv::nfd::Origin, m_origin);
75  }
76  if (this->hasLocalControlFeature()) {
77  totalLength += prependNonNegativeIntegerBlock(encoder,
78  tlv::nfd::LocalControlFeature, m_localControlFeature);
79  }
80  if (this->hasUri()) {
81  size_t valLength = encoder.prependByteArray(
82  reinterpret_cast<const uint8_t*>(m_uri.c_str()), m_uri.size());
83  totalLength += valLength;
84  totalLength += encoder.prependVarNumber(valLength);
85  totalLength += encoder.prependVarNumber(tlv::nfd::Uri);
86  }
87  if (this->hasFaceId()) {
88  totalLength += prependNonNegativeIntegerBlock(encoder, tlv::nfd::FaceId, m_faceId);
89  }
90  if (this->hasName()) {
91  totalLength += m_name.wireEncode(encoder);
92  }
93 
94  totalLength += encoder.prependVarNumber(totalLength);
95  totalLength += encoder.prependVarNumber(tlv::nfd::ControlParameters);
96  return totalLength;
97 }
98 
99 template size_t
100 ControlParameters::wireEncode<encoding::EncoderTag>(EncodingImpl<encoding::EncoderTag>&) const;
101 
102 template size_t
103 ControlParameters::wireEncode<encoding::EstimatorTag>(EncodingImpl<encoding::EstimatorTag>&) const;
104 
105 Block
107 {
108  if (m_wire.hasWire())
109  return m_wire;
110 
111  EncodingEstimator estimator;
112  size_t estimatedSize = wireEncode(estimator);
113 
114  EncodingBuffer buffer(estimatedSize, 0);
115  wireEncode(buffer);
116 
117  m_wire = buffer.block();
118  return m_wire;
119 }
120 
121 void
123 {
124  if (block.type() != tlv::nfd::ControlParameters) {
125  BOOST_THROW_EXCEPTION(Error("Expecting TLV-TYPE ControlParameters"));
126  }
127  m_wire = block;
128  m_wire.parse();
130 
131  val = m_wire.find(tlv::Name);
132  m_hasFields[CONTROL_PARAMETER_NAME] = val != m_wire.elements_end();
133  if (this->hasName()) {
134  m_name.wireDecode(*val);
135  }
136 
137  val = m_wire.find(tlv::nfd::FaceId);
138  m_hasFields[CONTROL_PARAMETER_FACE_ID] = val != m_wire.elements_end();
139  if (this->hasFaceId()) {
140  m_faceId = static_cast<uint64_t>(readNonNegativeInteger(*val));
141  }
142 
143  val = m_wire.find(tlv::nfd::Uri);
144  m_hasFields[CONTROL_PARAMETER_URI] = val != m_wire.elements_end();
145  if (this->hasUri()) {
146  m_uri.assign(reinterpret_cast<const char*>(val->value()), val->value_size());
147  }
148 
149  val = m_wire.find(tlv::nfd::LocalControlFeature);
150  m_hasFields[CONTROL_PARAMETER_LOCAL_CONTROL_FEATURE] = val != m_wire.elements_end();
151  if (this->hasLocalControlFeature()) {
152  m_localControlFeature = static_cast<LocalControlFeature>(readNonNegativeInteger(*val));
153  }
154 
155  val = m_wire.find(tlv::nfd::Origin);
156  m_hasFields[CONTROL_PARAMETER_ORIGIN] = val != m_wire.elements_end();
157  if (this->hasOrigin()) {
158  m_origin = static_cast<uint64_t>(readNonNegativeInteger(*val));
159  }
160 
161  val = m_wire.find(tlv::nfd::Cost);
162  m_hasFields[CONTROL_PARAMETER_COST] = val != m_wire.elements_end();
163  if (this->hasCost()) {
164  m_cost = static_cast<uint64_t>(readNonNegativeInteger(*val));
165  }
166 
167  val = m_wire.find(tlv::nfd::Flags);
168  m_hasFields[CONTROL_PARAMETER_FLAGS] = val != m_wire.elements_end();
169  if (this->hasFlags()) {
170  m_flags = static_cast<uint64_t>(readNonNegativeInteger(*val));
171  }
172 
173  val = m_wire.find(tlv::nfd::Mask);
174  m_hasFields[CONTROL_PARAMETER_MASK] = val != m_wire.elements_end();
175  if (this->hasMask()) {
176  m_mask = static_cast<uint64_t>(readNonNegativeInteger(*val));
177  }
178 
179  val = m_wire.find(tlv::nfd::Strategy);
180  m_hasFields[CONTROL_PARAMETER_STRATEGY] = val != m_wire.elements_end();
181  if (this->hasStrategy()) {
182  val->parse();
183  if (val->elements().empty()) {
184  BOOST_THROW_EXCEPTION(Error("Expecting Strategy/Name"));
185  }
186  else {
187  m_strategy.wireDecode(*val->elements_begin());
188  }
189  }
190 
191  val = m_wire.find(tlv::nfd::ExpirationPeriod);
192  m_hasFields[CONTROL_PARAMETER_EXPIRATION_PERIOD] = val != m_wire.elements_end();
193  if (this->hasExpirationPeriod()) {
194  m_expirationPeriod = time::milliseconds(readNonNegativeInteger(*val));
195  }
196 
197  val = m_wire.find(tlv::nfd::FacePersistency);
198  m_hasFields[CONTROL_PARAMETER_FACE_PERSISTENCY] = val != m_wire.elements_end();
199  if (this->hasFacePersistency()) {
200  m_facePersistency = static_cast<FacePersistency>(readNonNegativeInteger(*val));
201  }
202 }
203 
204 bool
206 {
207  if (bit >= 64) {
208  BOOST_THROW_EXCEPTION(std::out_of_range("bit must be within range [0, 64)"));
209  }
210 
211  if (!hasMask()) {
212  return false;
213  }
214 
215  return getMask() & (1 << bit);
216 }
217 
218 bool
220 {
221  if (bit >= 64) {
222  BOOST_THROW_EXCEPTION(std::out_of_range("bit must be within range [0, 64)"));
223  }
224 
225  if (!hasFlags()) {
226  return false;
227  }
228 
229  return getFlags() & (1 << bit);
230 }
231 
233 ControlParameters::setFlagBit(size_t bit, bool value, bool wantMask/* = true*/)
234 {
235  if (bit >= 64) {
236  BOOST_THROW_EXCEPTION(std::out_of_range("bit must be within range [0, 64)"));
237  }
238 
239  uint64_t flags = hasFlags() ? getFlags() : 0;
240  if (value) {
241  flags |= (1 << bit);
242  }
243  else {
244  flags &= ~(1 << bit);
245  }
246  setFlags(flags);
247 
248  if (wantMask) {
249  uint64_t mask = hasMask() ? getMask() : 0;
250  mask |= (1 << bit);
251  setMask(mask);
252  }
253 
254  return *this;
255 }
256 
259 {
260  if (bit >= 64) {
261  BOOST_THROW_EXCEPTION(std::out_of_range("bit must be within range [0, 64)"));
262  }
263 
264  uint64_t mask = hasMask() ? getMask() : 0;
265  mask &= ~(1 << bit);
266  if (mask == 0) {
267  unsetMask();
268  unsetFlags();
269  }
270  else {
271  setMask(mask);
272  }
273 
274  return *this;
275 }
276 
277 std::ostream&
278 operator<<(std::ostream& os, const ControlParameters& parameters)
279 {
280  os << "ControlParameters(";
281 
282  if (parameters.hasName()) {
283  os << "Name: " << parameters.getName() << ", ";
284  }
285 
286  if (parameters.hasFaceId()) {
287  os << "FaceId: " << parameters.getFaceId() << ", ";
288  }
289 
290  if (parameters.hasUri()) {
291  os << "Uri: " << parameters.getUri() << ", ";
292  }
293 
294  if (parameters.hasLocalControlFeature()) {
295  os << "LocalControlFeature: " << parameters.getLocalControlFeature() << ", ";
296  }
297 
298  if (parameters.hasOrigin()) {
299  os << "Origin: " << parameters.getOrigin() << ", ";
300  }
301 
302  if (parameters.hasCost()) {
303  os << "Cost: " << parameters.getCost() << ", ";
304  }
305 
306  if (parameters.hasFlags()) {
307  std::ios_base::fmtflags osFlags = os.flags();
308  os << "Flags: " << std::showbase << std::hex << parameters.getFlags() << ", ";
309  os.flags(osFlags);
310  }
311 
312  if (parameters.hasMask()) {
313  std::ios_base::fmtflags osFlags = os.flags();
314  os << "Mask: " << std::showbase << std::hex << parameters.getMask() << ", ";
315  os.flags(osFlags);
316  }
317 
318  if (parameters.hasStrategy()) {
319  os << "Strategy: " << parameters.getStrategy() << ", ";
320  }
321 
322  if (parameters.hasExpirationPeriod()) {
323  os << "ExpirationPeriod: " << parameters.getExpirationPeriod() << ", ";
324  }
325 
326  if (parameters.hasFacePersistency()) {
327  os << "FacePersistency: " << parameters.getFacePersistency() << ", ";
328  }
329 
330  os << ")";
331  return os;
332 }
333 
334 } // namespace nfd
335 } // namespace ndn
bool hasWire() const
Check if the Block has fully encoded wire.
Definition: block.cpp:471
virtual void wireDecode(const Block &wire) final
Copyright (c) 2011-2015 Regents of the University of California.
size_t prependNonNegativeIntegerBlock(EncodingImpl< TAG > &encoder, uint32_t type, uint64_t value)
Helper to prepend TLV block type type containing non-negative integer value.
represents parameters in a ControlCommand request or response
EncodingImpl< EstimatorTag > EncodingEstimator
element_const_iterator elements_end() const
Definition: block.cpp:595
size_t prependNestedBlock(EncodingImpl< TAG > &encoder, uint32_t type, const U &value)
Prepend a TLV block of type type with WireEncodable value as a value.
void parse() const
Parse wire buffer into subblocks.
Definition: block.cpp:322
ControlParameters & setFlags(uint64_t flags)
ControlParameters & unsetMask()
Class representing a wire element of NDN-TLV packet format.
Definition: block.hpp:43
ControlParameters & unsetFlags()
uint64_t readNonNegativeInteger(const Block &block)
Helper to read a non-negative integer from a block.
ControlParameters & unsetFlagBit(size_t bit)
disable a bit in Mask
FacePersistency getFacePersistency() const
virtual Block wireEncode() const final
EncodingImpl< EncoderTag > EncodingBuffer
Copyright (c) 2011-2015 Regents of the University of California.
Definition: ndn-common.hpp:40
element_const_iterator find(uint32_t type) const
Definition: block.cpp:420
element_container::const_iterator element_const_iterator
Definition: block.hpp:48
std::ostream & operator<<(std::ostream &os, FaceScope faceScope)
bool hasFlagBit(size_t bit) const
const std::string & getUri() const
const time::milliseconds & getExpirationPeriod() const
size_t wireEncode(EncodingImpl< TAG > &encoder) const
Fast encoding or block size estimation.
Definition: name.cpp:122
bool getFlagBit(size_t bit) const
void wireDecode(const Block &wire)
Definition: name.cpp:161
LocalControlFeature getLocalControlFeature() const
a concept check for TLV abstraction with .wireEncode method
Definition: concepts.hpp:34
const Name & getStrategy() const
ControlParameters & setMask(uint64_t mask)
a concept check for TLV abstraction with .wireDecode method and constructible from Block ...
Definition: concepts.hpp:70
ControlParameters & setFlagBit(size_t bit, bool value, bool wantMask=true)
set a bit in Flags
uint32_t type() const
Definition: block.hpp:324