OLD | NEW |
(Empty) | |
| 1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */ |
| 2 /* |
| 3 * Copyright (c) 2009 University of Pennsylvania |
| 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 |
| 19 #include "dhash-message.h" |
| 20 #include "dhash-object.h" |
| 21 #include "ns3/log.h" |
| 22 |
| 23 |
| 24 namespace ns3 { |
| 25 |
| 26 NS_LOG_COMPONENT_DEFINE("DHashMessage"); |
| 27 |
| 28 NS_OBJECT_ENSURE_REGISTERED (DHashMessage); |
| 29 NS_OBJECT_ENSURE_REGISTERED (DHashHeader); |
| 30 |
| 31 DHashHeader::DHashHeader () |
| 32 {} |
| 33 |
| 34 DHashHeader::~DHashHeader () |
| 35 {} |
| 36 |
| 37 TypeId |
| 38 DHashHeader::GetTypeId (void) |
| 39 { |
| 40 static TypeId tid = TypeId ("ns3::DHashHeader") |
| 41 .SetParent<Header> () |
| 42 .AddConstructor<DHashHeader> () |
| 43 ; |
| 44 return tid; |
| 45 } |
| 46 |
| 47 TypeId |
| 48 DHashHeader::GetInstanceTypeId (void) const |
| 49 { |
| 50 return GetTypeId (); |
| 51 } |
| 52 |
| 53 uint32_t |
| 54 DHashHeader::GetSerializedSize (void) const |
| 55 { |
| 56 uint32_t size = sizeof (uint32_t); |
| 57 return size; |
| 58 } |
| 59 |
| 60 void |
| 61 DHashHeader::Print (std::ostream &os) const |
| 62 { |
| 63 os << "Length: " << m_length; |
| 64 } |
| 65 |
| 66 void |
| 67 DHashHeader::Serialize (Buffer::Iterator start) const |
| 68 { |
| 69 Buffer::Iterator i = start; |
| 70 i.WriteHtonU32 (m_length); |
| 71 } |
| 72 |
| 73 uint32_t |
| 74 DHashHeader::Deserialize (Buffer::Iterator start) |
| 75 { |
| 76 uint32_t size; |
| 77 Buffer::Iterator i = start; |
| 78 m_length = i.ReadNtohU32 (); |
| 79 size = sizeof (uint32_t); |
| 80 return size; |
| 81 } |
| 82 |
| 83 DHashMessage::DHashMessage () |
| 84 { |
| 85 } |
| 86 |
| 87 DHashMessage::~DHashMessage () |
| 88 {} |
| 89 |
| 90 TypeId |
| 91 DHashMessage::GetTypeId (void) |
| 92 { |
| 93 static TypeId tid = TypeId ("ns3::DHashMessage") |
| 94 .SetParent<Header> () |
| 95 .AddConstructor<DHashMessage> () |
| 96 ; |
| 97 return tid; |
| 98 } |
| 99 |
| 100 TypeId |
| 101 DHashMessage::GetInstanceTypeId (void) const |
| 102 { |
| 103 return GetTypeId (); |
| 104 } |
| 105 |
| 106 uint32_t |
| 107 DHashMessage::GetSerializedSize (void) const |
| 108 { |
| 109 uint32_t size = sizeof (uint8_t) + sizeof (uint32_t); |
| 110 switch (m_messageType) |
| 111 { |
| 112 case STORE_REQ: |
| 113 size += m_message.storeReq.GetSerializedSize (); |
| 114 break; |
| 115 case STORE_RSP: |
| 116 size += m_message.storeRsp.GetSerializedSize (); |
| 117 break; |
| 118 case RETRIEVE_REQ: |
| 119 size += m_message.retrieveReq.GetSerializedSize (); |
| 120 break; |
| 121 case RETRIEVE_RSP: |
| 122 size += m_message.retrieveRsp.GetSerializedSize (); |
| 123 break; |
| 124 default: |
| 125 NS_ASSERT (false); |
| 126 } |
| 127 return size; |
| 128 } |
| 129 |
| 130 void |
| 131 DHashMessage::Print (std::ostream &os) const |
| 132 { |
| 133 os << "\n***DHashMessage Dump***\n"; |
| 134 os << "Header:: \n"; |
| 135 os << "MessageType: " << m_messageType<<"\n"; |
| 136 os << "TransactionId: " << m_transactionId<<"\n"; |
| 137 os << "Payload:: \n"; |
| 138 switch (m_messageType) |
| 139 { |
| 140 case STORE_REQ: |
| 141 m_message.storeReq.Print (os); |
| 142 break; |
| 143 case STORE_RSP: |
| 144 m_message.storeRsp.Print (os); |
| 145 break; |
| 146 case RETRIEVE_REQ: |
| 147 m_message.retrieveReq.Print (os); |
| 148 break; |
| 149 case RETRIEVE_RSP: |
| 150 m_message.retrieveRsp.Print (os); |
| 151 break; |
| 152 default: |
| 153 break; |
| 154 } |
| 155 os << "\n***End Of Message***\n"; |
| 156 } |
| 157 |
| 158 void |
| 159 DHashMessage::Serialize (Buffer::Iterator start) const |
| 160 { |
| 161 Buffer::Iterator i = start; |
| 162 i.WriteU8 (m_messageType); |
| 163 i.WriteHtonU32 (m_transactionId); |
| 164 |
| 165 switch (m_messageType) |
| 166 { |
| 167 case STORE_REQ: |
| 168 m_message.storeReq.Serialize (i); |
| 169 break; |
| 170 case STORE_RSP: |
| 171 m_message.storeRsp.Serialize (i); |
| 172 break; |
| 173 case RETRIEVE_REQ: |
| 174 m_message.retrieveReq.Serialize (i); |
| 175 break; |
| 176 case RETRIEVE_RSP: |
| 177 m_message.retrieveRsp.Serialize (i); |
| 178 break; |
| 179 default: |
| 180 NS_ASSERT (false); |
| 181 } |
| 182 } |
| 183 |
| 184 uint32_t |
| 185 DHashMessage::Deserialize (Buffer::Iterator start) |
| 186 { |
| 187 uint32_t size; |
| 188 Buffer::Iterator i = start; |
| 189 m_messageType = (MessageType) i.ReadU8 (); |
| 190 m_transactionId = i.ReadNtohU32 (); |
| 191 |
| 192 size = sizeof (uint8_t) + sizeof (uint32_t); |
| 193 |
| 194 switch (m_messageType) |
| 195 { |
| 196 case STORE_REQ: |
| 197 size += m_message.storeReq.Deserialize (i); |
| 198 break; |
| 199 case STORE_RSP: |
| 200 size += m_message.storeRsp.Deserialize (i); |
| 201 break; |
| 202 case RETRIEVE_REQ: |
| 203 size += m_message.retrieveReq.Deserialize (i); |
| 204 break; |
| 205 case RETRIEVE_RSP: |
| 206 size += m_message.retrieveRsp.Deserialize (i); |
| 207 break; |
| 208 default: |
| 209 NS_ASSERT (false); |
| 210 } |
| 211 return size; |
| 212 } |
| 213 |
| 214 /* Message Payloads */ |
| 215 |
| 216 |
| 217 /* STORE_REQ */ |
| 218 uint32_t |
| 219 DHashMessage::StoreReq::GetSerializedSize (void) const |
| 220 { |
| 221 uint32_t size; |
| 222 size = dHashObject->GetSerializedSize(); |
| 223 return size;· |
| 224 } |
| 225 |
| 226 void |
| 227 DHashMessage::StoreReq::Print (std::ostream &os) const |
| 228 { |
| 229 os << "StoreReq: \n"; |
| 230 os << "DHash Object Dump: " << dHashObject; |
| 231 } |
| 232 |
| 233 void |
| 234 DHashMessage::StoreReq::Serialize (Buffer::Iterator &start) const |
| 235 { |
| 236 dHashObject->Serialize(start); |
| 237 } |
| 238 |
| 239 uint32_t |
| 240 DHashMessage::StoreReq::Deserialize (Buffer::Iterator &start) |
| 241 { |
| 242 dHashObject = Create<DHashObject> (); |
| 243 dHashObject->Deserialize(start); |
| 244 return GetSerializedSize(); |
| 245 } |
| 246 |
| 247 /* STORE_RSP */ |
| 248 uint32_t |
| 249 DHashMessage::StoreRsp::GetSerializedSize (void) const |
| 250 { |
| 251 uint32_t size; |
| 252 size = sizeof(uint8_t) + objectIdentifier->GetSerializedSize() ; |
| 253 return size;· |
| 254 } |
| 255 |
| 256 void |
| 257 DHashMessage::StoreRsp::Print (std::ostream &os) const |
| 258 { |
| 259 os << "StoreRsp: \n"; |
| 260 os << "Status: \n" << statusTag; |
| 261 os << "Object Identifier: " << objectIdentifier; |
| 262 } |
| 263 |
| 264 void |
| 265 DHashMessage::StoreRsp::Serialize (Buffer::Iterator &start) const |
| 266 { |
| 267 start.WriteU8 (statusTag); |
| 268 objectIdentifier -> Serialize(start); |
| 269 } |
| 270 |
| 271 uint32_t |
| 272 DHashMessage::StoreRsp::Deserialize (Buffer::Iterator &start) |
| 273 { |
| 274 statusTag = (Status) start.ReadU8(); |
| 275 objectIdentifier = Create<ChordIdentifier> (); |
| 276 objectIdentifier -> Deserialize(start); |
| 277 return GetSerializedSize(); |
| 278 } |
| 279 |
| 280 /* RETRIEVE_REQ */ |
| 281 uint32_t |
| 282 DHashMessage::RetrieveReq::GetSerializedSize (void) const |
| 283 { |
| 284 uint32_t size; |
| 285 size = objectIdentifier->GetSerializedSize(); |
| 286 return size;· |
| 287 } |
| 288 |
| 289 void |
| 290 DHashMessage::RetrieveReq::Print (std::ostream &os) const |
| 291 { |
| 292 os << "RetrieveReq: \n"; |
| 293 os << "Object Identifier: " << objectIdentifier; |
| 294 } |
| 295 |
| 296 void |
| 297 DHashMessage::RetrieveReq::Serialize (Buffer::Iterator &start) const |
| 298 { |
| 299 objectIdentifier->Serialize(start); |
| 300 } |
| 301 |
| 302 uint32_t |
| 303 DHashMessage::RetrieveReq::Deserialize (Buffer::Iterator &start) |
| 304 { |
| 305 objectIdentifier = Create<ChordIdentifier> (); |
| 306 objectIdentifier->Deserialize(start); |
| 307 return GetSerializedSize(); |
| 308 } |
| 309 |
| 310 /* STORE_RSP */ |
| 311 uint32_t |
| 312 DHashMessage::RetrieveRsp::GetSerializedSize (void) const |
| 313 { |
| 314 uint32_t size; |
| 315 size = sizeof(uint8_t); |
| 316 if (statusTag == DHashMessage::OBJECT_FOUND) |
| 317 { |
| 318 size = size + dHashObject->GetSerializedSize(); |
| 319 } |
| 320 return size;· |
| 321 } |
| 322 |
| 323 void |
| 324 DHashMessage::RetrieveRsp::Print (std::ostream &os) const |
| 325 { |
| 326 os << "RetrieveRsp: \n"; |
| 327 os << "Status: \n" << statusTag; |
| 328 os << "Object Dump: " << dHashObject; |
| 329 } |
| 330 |
| 331 void |
| 332 DHashMessage::RetrieveRsp::Serialize (Buffer::Iterator &start) const |
| 333 { |
| 334 start.WriteU8 (statusTag); |
| 335 if (statusTag == DHashMessage::OBJECT_FOUND) |
| 336 { |
| 337 dHashObject->Serialize (start); |
| 338 } |
| 339 } |
| 340 |
| 341 uint32_t |
| 342 DHashMessage::RetrieveRsp::Deserialize (Buffer::Iterator &start) |
| 343 { |
| 344 statusTag = (Status) start.ReadU8(); |
| 345 if (statusTag == DHashMessage::OBJECT_FOUND) |
| 346 { |
| 347 dHashObject = Create<DHashObject> (); |
| 348 dHashObject -> Deserialize(start); |
| 349 } |
| 350 return GetSerializedSize(); |
| 351 } |
| 352 |
| 353 } //namespace ns3 |
OLD | NEW |