ACE/protocols/ace/RMCast/Protocol.h

   1 // author    : Boris Kolpackov <boris@kolpackov.net>
   2
   3 #ifndef ACE_RMCAST_PROTOCOL_H
   4 #define ACE_RMCAST_PROTOCOL_H
   5
   6 #include <memory>
   7 #include "ace/Bound_Ptr.h"
   8
   9 #include "ace/Vector_T.h"
  10 #include "ace/Hash_Map_Manager.h"
  11
  12 #include "ace/CDR_Stream.h"
  13 #include "ace/CDR_Size.h"
  14
  15 #include "ace/INET_Addr.h"
  16 #include "ace/Null_Mutex.h"
  17
  18 #include "ace/OS_NS_string.h"
  19 #include "ace/OS_NS_stdlib.h"
  20
  21 #include "Bits.h"
  22
  23 namespace ACE_RMCast
  24 {
  25   // Basic types.
  26   //
  27   typedef ACE_CDR::UShort u16;
  28   typedef ACE_CDR::ULong u32;
  29   typedef ACE_CDR::ULongLong u64;
  30
  31   // Protocol parameters
  32   //
  33   //
  34   unsigned short const max_service_size = 60;  // service profiles (Part, SN,
  35                                                // etc), sizes plus message size.
  36
  37   //
  38   //
  39   //
  40   typedef ACE_INET_Addr Address;
  41
  42   struct AddressHasher
  43   {
  44     unsigned long
  45     operator() (Address const& a) const
  46     {
  47       unsigned long port (a.get_port_number ());
  48       unsigned long ip (a.get_ip_address ());
  49
  50       port <<= sizeof (unsigned long) - sizeof (unsigned short);
  51
  52       return port ^ ip;
  53     }
  54   };
  55
  56   //@@ Provide stream<< (Address const&)
  57   //
  58
  59   typedef ACE_OutputCDR ostream;
  60   typedef ACE_SizeCDR sstream;
  61   typedef ACE_InputCDR istream;
  62
  63   struct Profile;
  64
  65   typedef
  66   ACE_Strong_Bound_Ptr<Profile, Mutex>
  67   Profile_ptr;
  68
  69   struct Profile
  70   {
  71   public:
  72     class Header
  73     {
  74     public:
  75       Header (u16 id, u16 size)
  76           : id_ (id), size_ (size)
  77       {
  78       }
  79
  80       Header (istream& is)
  81       {
  82         (void) (is >> id_ >> size_);
  83       }
  84
  85     public:
  86       u16
  87       id () const
  88       {
  89         return id_;
  90       }
  91
  92       u16
  93       size () const
  94       {
  95         return size_;
  96       }
  97
  98     protected:
  99       void
 100       size (u16 s)
 101       {
 102         size_ = s;
 103       }
 104
 105       friend struct Profile;
 106
 107     private:
 108       u16 id_;
 109       u16 size_;
 110     };
 111
 112   public:
 113     virtual
 114     ~Profile ()
 115     {
 116     }
 117
 118     Profile_ptr
 119     clone ()
 120     {
 121       Profile_ptr p (clone_ ());
 122       return p;
 123     }
 124
 125   protected:
 126     Profile (u16 id)
 127         : header_ (id, 0)
 128     {
 129     }
 130
 131     Profile (Header const& h)
 132         : header_ (h)
 133     {
 134     }
 135
 136     virtual Profile_ptr
 137     clone_ () = 0;
 138
 139   private:
 140     Profile&
 141     operator= (Profile const&) = delete;
 142
 143   public:
 144     u16
 145     id () const
 146     {
 147       return header_.id ();
 148     }
 149
 150     u16
 151     size () const
 152     {
 153       return header_.size ();
 154     }
 155
 156   protected:
 157     void
 158     size (u16 s)
 159     {
 160       header_.size (s);
 161     }
 162
 163     u16
 164     calculate_size ()
 165     {
 166       sstream ss;
 167
 168       serialize_body (ss);
 169
 170       return static_cast<u16> (ss.total_length ());
 171     }
 172
 173   public:
 174     virtual void
 175     serialize_body (ostream&) const = 0;
 176
 177     virtual void
 178     serialize_body (sstream&) const = 0;
 179
 180     friend
 181     ostream&
 182     operator<< (ostream& os, Profile const& p);
 183
 184     friend
 185     sstream&
 186     operator<< (sstream& ss, Profile const& p);
 187
 188   private:
 189     Header header_;
 190   };
 191
 192   inline
 193   ostream&
 194   operator<< (ostream& os, Profile::Header const& hdr)
 195   {
 196     os << hdr.id ();
 197     os << hdr.size ();
 198
 199     return os;
 200   }
 201
 202   inline
 203   sstream&
 204   operator<< (sstream& ss, Profile::Header const& hdr)
 205   {
 206     ss << hdr.id ();
 207     ss << hdr.size ();
 208
 209     return ss;
 210   }
 211
 212   inline
 213   ostream&
 214   operator<< (ostream& os, Profile const& p)
 215   {
 216     os << p.header_;
 217     p.serialize_body (os);
 218
 219     return os;
 220   }
 221
 222   inline
 223   sstream&
 224   operator<< (sstream& ss, Profile const& p)
 225   {
 226     ss << p.header_;
 227     p.serialize_body (ss);
 228
 229     return ss;
 230   }
 231
 232
 233   //
 234   //
 235   //
 236   class Message;
 237
 238   typedef
 239   ACE_Strong_Bound_Ptr<Message, Mutex>
 240   Message_ptr;
 241
 242   class Message
 243   {
 244     typedef
 245     ACE_Hash_Map_Manager<u16, Profile_ptr, ACE_Null_Mutex>
 246     Profiles;
 247
 248   public:
 249     Message ()
 250         : profiles_ (4)
 251     {
 252     }
 253
 254     Message_ptr
 255     clone ()
 256     {
 257       Message_ptr cloned (new Message (*this));
 258       return cloned;
 259     }
 260
 261   protected:
 262     Message (Message const& m)
 263         : profiles_ (4)
 264     {
 265       for (Profiles::const_iterator i (m.profiles_); !i.done (); i.advance ())
 266       {
 267         // Shallow copy of profiles. This implies that profiles are not
 268         // modified as they go up/down the stack.
 269         //
 270         profiles_.bind ((*i).ext_id_, (*i).int_id_);
 271       }
 272     }
 273
 274   private:
 275     Message&
 276     operator= (Message const&);
 277
 278   public:
 279     bool
 280     add (Profile_ptr p)
 281     {
 282       u16 id (p->id ());
 283
 284       if (profiles_.find (id) == 0)
 285       {
 286         return false;
 287       }
 288
 289       profiles_.bind (id, p);
 290
 291       return true;
 292     }
 293
 294     void
 295     replace (Profile_ptr p)
 296     {
 297       profiles_.rebind (p->id (), p);
 298     }
 299
 300     void
 301     remove (u16 id)
 302     {
 303       profiles_.unbind (id);
 304     }
 305
 306     Profile const*
 307     find (u16 id) const
 308     {
 309       Profiles::ENTRY* e = 0;
 310
 311       if (profiles_.find (id, e) == -1) return 0;
 312
 313       return e->int_id_.get ();
 314     }
 315
 316     typedef
 317     Profiles::const_iterator
 318     ProfileIterator;
 319
 320     ProfileIterator
 321     begin () const
 322     {
 323       return ProfileIterator (profiles_);
 324     }
 325
 326   public:
 327     size_t
 328     size () const
 329     {
 330       sstream ss;
 331
 332       u32 s (0);
 333
 334       ss << s;
 335
 336       for (Profiles::const_iterator i (profiles_); !i.done (); i.advance ())
 337       {
 338         ss << *((*i).int_id_);
 339       }
 340
 341       return ss.total_length ();
 342     }
 343
 344     friend
 345     ostream&
 346     operator<< (ostream& os, Message const& m)
 347     {
 348       u32 s (m.size ());
 349
 350       os << s;
 351
 352       for (Profiles::const_iterator i (m.profiles_); !i.done (); i.advance ())
 353       {
 354         os << *((*i).int_id_);
 355       }
 356
 357       return os;
 358     }
 359
 360   private:
 361     Profiles profiles_;
 362   };
 363
 364   typedef ACE_Vector<Message_ptr, ACE_VECTOR_DEFAULT_SIZE> Messages;
 365
 366   //
 367   //
 368   //
 369   struct From;
 370
 371   typedef
 372   ACE_Strong_Bound_Ptr<From, Mutex>
 373   From_ptr;
 374
 375   struct From : Profile
 376   {
 377     static u16 const id;
 378
 379   public:
 380     From (Header const& h, istream& is)
 381         : Profile (h)
 382     {
 383       u32 addr;
 384       u16 port;
 385
 386       is >> addr;
 387       is >> port;
 388
 389       address_ = Address (port, addr);
 390     }
 391
 392     From (Address const& addr)
 393         : Profile (id), address_ (addr)
 394     {
 395       size (calculate_size ());
 396     }
 397
 398     From_ptr
 399     clone ()
 400     {
 401       return From_ptr (clone_ ());
 402     }
 403
 404   protected:
 405     virtual Profile_ptr
 406     clone_ ()
 407     {
 408       Profile_ptr p (new From (*this));
 409       return p;
 410     }
 411
 412     From (From const& from)
 413         : Profile (from),
 414           address_ (from.address_)
 415     {
 416     }
 417
 418   public:
 419     Address const&
 420     address () const
 421     {
 422       return address_;
 423     }
 424
 425   public:
 426     virtual void
 427     serialize_body (ostream& os) const
 428     {
 429       u32 addr (address_.get_ip_address ());
 430       u16 port (address_.get_port_number ());
 431
 432       os << addr;
 433       os << port;
 434     }
 435
 436     virtual void
 437     serialize_body (sstream& ss) const
 438     {
 439       u32 addr (0);
 440       u16 port (0);
 441
 442       ss << addr;
 443       ss << port;
 444     }
 445
 446   private:
 447     Address address_;
 448   };
 449
 450
 451   //
 452   //
 453   //
 454   struct To;
 455
 456   typedef
 457   ACE_Strong_Bound_Ptr<To, Mutex>
 458   To_ptr;
 459
 460   struct To : Profile
 461   {
 462     static u16 const id;
 463
 464   public:
 465     To (Header const& h, istream& is)
 466         : Profile (h)
 467     {
 468       u32 addr;
 469       u16 port;
 470
 471       is >> addr;
 472       is >> port;
 473
 474       address_ = Address (port, addr);
 475     }
 476
 477     To (Address const& addr)
 478         : Profile (id), address_ (addr)
 479     {
 480       size (calculate_size ());
 481     }
 482
 483     To_ptr
 484     clone ()
 485     {
 486       return To_ptr (clone_ ());
 487     }
 488
 489   protected:
 490     virtual Profile_ptr
 491     clone_ ()
 492     {
 493       Profile_ptr p (new To (*this));
 494       return p;
 495     }
 496
 497     To (To const& to)
 498         : Profile (to),
 499           address_ (to.address_)
 500     {
 501     }
 502
 503   public:
 504     Address const&
 505     address () const
 506     {
 507       return address_;
 508     }
 509
 510   public:
 511     virtual void
 512     serialize_body (ostream& os) const
 513     {
 514       u32 addr (address_.get_ip_address ());
 515       u16 port (address_.get_port_number ());
 516
 517       os << addr;
 518       os << port;
 519     }
 520
 521     virtual void
 522     serialize_body (sstream& ss) const
 523     {
 524       u32 addr (0);
 525       u16 port (0);
 526
 527       ss << addr;
 528       ss << port;
 529     }
 530
 531   private:
 532     Address address_;
 533   };
 534
 535
 536   //
 537   //
 538   //
 539   struct Data;
 540
 541   typedef
 542   ACE_Strong_Bound_Ptr<Data, Mutex>
 543   Data_ptr;
 544
 545   struct Data : Profile
 546   {
 547     static u16 const id;
 548
 549   public:
 550     virtual
 551     ~Data ()
 552     {
 553       if (buf_)
 554         operator delete (buf_);
 555     }
 556
 557     Data (Header const& h, istream& is)
 558         : Profile (h),
 559           buf_ (0),
 560           size_ (h.size ()),
 561           capacity_ (size_)
 562     {
 563       if (size_)
 564       {
 565         buf_ = reinterpret_cast<char*> (operator new (capacity_));
 566         is.read_char_array (buf_, size_);
 567       }
 568     }
 569
 570     Data (void const* buf, size_t s, size_t capacity = 0)
 571         : Profile (id),
 572           buf_ (0),
 573           size_ (s),
 574           capacity_ (capacity < size_ ? size_ : capacity)
 575     {
 576       if (size_)
 577       {
 578         buf_ = reinterpret_cast<char*> (operator new (capacity_));
 579         ACE_OS::memcpy (buf_, buf, size_);
 580       }
 581
 582       Profile::size (calculate_size ());
 583     }
 584
 585     Data_ptr
 586     clone ()
 587     {
 588       return Data_ptr (clone_ ());
 589     }
 590
 591   protected:
 592     virtual Profile_ptr
 593     clone_ ()
 594     {
 595       Profile_ptr p (new Data (*this));
 596       return p;
 597     }
 598
 599     Data (Data const& d)
 600         : Profile (d),
 601           buf_ (0),
 602           size_ (d.size_),
 603           capacity_ (d.capacity_)
 604     {
 605       if (size_)
 606       {
 607         buf_ = reinterpret_cast<char*> (operator new (capacity_));
 608         ACE_OS::memcpy (buf_, d.buf_, size_);
 609       }
 610
 611       Profile::size (calculate_size ());
 612     }
 613
 614   public:
 615     char const*
 616     buf () const
 617     {
 618       return buf_;
 619     }
 620
 621     char*
 622     buf ()
 623     {
 624       return buf_;
 625     }
 626
 627     size_t
 628     size () const
 629     {
 630       return size_;
 631     }
 632
 633     void
 634     size (size_t s)
 635     {
 636       if (s > capacity_)
 637         ACE_OS::abort ();
 638
 639       size_ = s;
 640
 641       Profile::size (calculate_size ());
 642     }
 643
 644     size_t
 645     capacity () const
 646     {
 647       return capacity_;
 648     }
 649
 650   public:
 651     virtual void
 652     serialize_body (ostream& os) const
 653     {
 654       os.write_char_array (buf_, size_);
 655     }
 656
 657     virtual void
 658     serialize_body (sstream& ss) const
 659     {
 660       ss.write_char_array (buf_, size_);
 661     }
 662
 663   private:
 664     char* buf_;
 665     size_t size_;
 666     size_t capacity_;
 667   };
 668
 669
 670   //
 671   //
 672   //
 673   struct SN;
 674
 675   typedef
 676   ACE_Strong_Bound_Ptr<SN, Mutex>
 677   SN_ptr;
 678
 679   struct SN : Profile
 680   {
 681     static u16 const id;
 682
 683   public:
 684     SN (Header const& h, istream& is)
 685         : Profile (h)
 686     {
 687       is >> n_;
 688     }
 689
 690     SN (u64 n)
 691         : Profile (id), n_ (n)
 692     {
 693       size (calculate_size ());
 694     }
 695
 696     SN_ptr
 697     clone ()
 698     {
 699       return SN_ptr (clone_ ());
 700     }
 701
 702   protected:
 703     virtual Profile_ptr
 704     clone_ ()
 705     {
 706       Profile_ptr p (new SN (*this));
 707       return p;
 708     }
 709
 710     SN (SN const& sn)
 711         : Profile (sn),
 712           n_ (sn.n_)
 713     {
 714     }
 715
 716   public:
 717     u64
 718     num () const
 719     {
 720       return n_;
 721     }
 722
 723   public:
 724     virtual void
 725     serialize_body (ostream& os) const
 726     {
 727       os << n_;
 728     }
 729
 730     virtual void
 731     serialize_body (sstream& ss) const
 732     {
 733       ss << n_;
 734     }
 735
 736   private:
 737     u64 n_;
 738   };
 739
 740
 741   //
 742   //
 743   //
 744   class NAK;
 745
 746   typedef
 747   ACE_Strong_Bound_Ptr<NAK, Mutex>
 748   NAK_ptr;
 749
 750   class NAK : public Profile
 751   {
 752   public:
 753     static u16 const id;
 754
 755     typedef ACE_Vector<u64, ACE_VECTOR_DEFAULT_SIZE> SerialNumbers;
 756     typedef SerialNumbers::Iterator iterator;
 757
 758     NAK (Header const& h, istream& is)
 759         : Profile (h)
 760     {
 761       u64 sn (0);
 762       u32 addr (0);
 763       u16 port (0);
 764
 765       sstream ss;
 766
 767       ss << sn;
 768       size_t sn_size (ss.total_length ());
 769
 770       ss.reset ();
 771
 772       ss << addr;
 773       ss << port;
 774
 775       size_t addr_size (ss.total_length ());
 776
 777
 778       is >> addr;
 779       is >> port;
 780
 781       // num_of_sns = (size - addr_size) / sn_size
 782       //
 783       for (unsigned long i (0); i < ((h.size () - addr_size) / sn_size); ++i)
 784       {
 785         is >> sn;
 786         sns_.push_back (sn);
 787       }
 788
 789
 790       address_ = Address (port, addr);
 791     }
 792
 793     NAK (Address const& src)
 794         : Profile (id), address_ (src)
 795     {
 796       size (calculate_size ());
 797     }
 798
 799     NAK_ptr
 800     clone ()
 801     {
 802       return NAK_ptr (clone_ ());
 803     }
 804
 805   protected:
 806     virtual Profile_ptr
 807     clone_ ()
 808     {
 809       Profile_ptr p (new NAK (*this));
 810       return p;
 811     }
 812
 813     NAK (NAK const& nak)
 814         : Profile (nak),
 815           address_ (nak.address_),
 816           sns_ (nak.sns_)
 817     {
 818     }
 819
 820   public:
 821     void
 822     add (u64 sn)
 823     {
 824       sns_.push_back (sn);
 825       size (calculate_size ());
 826     }
 827
 828   public:
 829     Address const&
 830     address () const
 831     {
 832       return address_;
 833     }
 834
 835
 836     iterator
 837     begin () /* const */
 838     {
 839       return iterator (sns_);
 840     }
 841
 842     /*
 843     iterator
 844     end ()  const
 845     {
 846       return sns_.end ();
 847     }
 848     */
 849
 850     size_t
 851     count () const
 852     {
 853       return sns_.size ();
 854     }
 855
 856   public:
 857     // Count max number of elements that will fit into NAK profile
 858     // with size <= max_size.
 859     //
 860     static u32
 861     max_count (u32 max_size)
 862     {
 863       u32 n (0);
 864
 865       sstream ss;
 866
 867       Profile::Header hdr (0, 0);
 868       ss << hdr;
 869
 870       u32 addr (0);
 871       u16 port (0);
 872       ss << addr;
 873       ss << port;
 874
 875       while (true)
 876       {
 877         u64 sn (0);
 878         ss << sn;
 879
 880         if (ss.total_length () <= max_size)
 881           ++n;
 882
 883         if (ss.total_length () >= max_size)
 884           break;
 885       }
 886
 887       return n;
 888     }
 889
 890   public:
 891     virtual void
 892     serialize_body (ostream& os) const
 893     {
 894       NAK& this_ = const_cast<NAK&> (*this); // Don't put in ROM.
 895
 896       u32 addr (address_.get_ip_address ());
 897       u16 port (address_.get_port_number ());
 898
 899       os << addr;
 900       os << port;
 901
 902       // Stone age iteration.
 903       //
 904       for (iterator i (this_.begin ()); !i.done (); i.advance ())
 905       {
 906         u64* psn = 0;
 907         i.next (psn);
 908         os << *psn;
 909       }
 910     }
 911
 912     virtual void
 913     serialize_body (sstream& ss) const
 914     {
 915       NAK& this_ = const_cast<NAK&> (*this); // Don't put in ROM.
 916
 917       u32 addr (0);
 918       u16 port (0);
 919
 920       ss << addr;
 921       ss << port;
 922
 923       // Stone age iteration.
 924       //
 925       for (iterator i (this_.begin ()); !i.done (); i.advance ())
 926       {
 927         u64 sn (0);
 928         ss << sn;
 929       }
 930     }
 931
 932   private:
 933     Address address_;
 934     SerialNumbers sns_;
 935   };
 936
 937   //
 938   //
 939   //
 940   struct NRTM;
 941
 942   typedef
 943   ACE_Strong_Bound_Ptr<NRTM, Mutex>
 944   NRTM_ptr;
 945
 946   struct NRTM : Profile
 947   {
 948     static u16 const id;
 949
 950   public:
 951     NRTM (Header const& h, istream& is)
 952         : Profile (h), map_ (10)
 953     {
 954       u32 addr (0);
 955       u16 port (0);
 956       u64 sn (0);
 957
 958       sstream ss;
 959
 960       ss << sn;
 961       ss << addr;
 962       ss << port;
 963
 964       size_t block_size (ss.total_length ());
 965
 966
 967       // num_of_blocks = size / block_size
 968       //
 969       for (size_t i (0); i < (h.size () / block_size); ++i)
 970       {
 971         is >> sn;
 972         is >> addr;
 973         is >> port;
 974
 975         map_.bind (Address (port, addr), sn);
 976       }
 977     }
 978
 979     NRTM ()
 980         : Profile (id), map_ (10)
 981     {
 982       size (calculate_size ());
 983     }
 984
 985     NRTM_ptr
 986     clone ()
 987     {
 988       return NRTM_ptr (clone_ ());
 989     }
 990
 991   protected:
 992     virtual Profile_ptr
 993     clone_ ()
 994     {
 995       Profile_ptr p (new NRTM (*this));
 996       return p;
 997     }
 998
 999     NRTM (NRTM const& nrtm)
1000         : Profile (nrtm)
1001     {
1002       for (Map::const_iterator i (nrtm.map_); !i.done (); i.advance ())
1003       {
1004         map_.bind ((*i).ext_id_, (*i).int_id_);
1005       }
1006     }
1007
1008   public:
1009     void
1010     insert (Address const& addr, u64 sn)
1011     {
1012       map_.bind (addr, sn);
1013
1014       size (calculate_size ());
1015     }
1016
1017     u64
1018     find (Address const& addr) const
1019     {
1020       u64 sn = 0;
1021
1022       if (map_.find (addr, sn) == -1) return 0;
1023
1024       return sn;
1025     }
1026
1027     bool
1028     empty () const
1029     {
1030       return map_.current_size () == 0;
1031     }
1032
1033   public:
1034     // Count max number of elements that will fit into NRTM profile
1035     // with size <= max_size.
1036     //
1037     static u32
1038     max_count (u32 max_size)
1039     {
1040       u32 n (0);
1041
1042       sstream ss;
1043
1044       Profile::Header hdr (0, 0);
1045       ss << hdr;
1046
1047       while (true)
1048       {
1049         u32 addr (0);
1050         u16 port (0);
1051         u64 sn (0);
1052
1053         ss << sn;
1054         ss << addr;
1055         ss << port;
1056
1057         if (ss.total_length () <= max_size)
1058           ++n;
1059
1060         if (ss.total_length () >= max_size)
1061           break;
1062       }
1063
1064       return n;
1065     }
1066
1067   public:
1068     virtual void
1069     serialize_body (ostream& os) const
1070     {
1071       for (Map::const_iterator i (map_), e (map_, 1); i != e; ++i)
1072       {
1073         u32 addr ((*i).ext_id_.get_ip_address ());
1074         u16 port ((*i).ext_id_.get_port_number ());
1075         u64 sn ((*i).int_id_);
1076
1077         os << sn;
1078         os << addr;
1079         os << port;
1080       }
1081     }
1082
1083     virtual void
1084     serialize_body (sstream& ss) const
1085     {
1086       for (Map::const_iterator i (map_), e (map_, 1); i != e; ++i)
1087       {
1088         u32 addr (0);
1089         u16 port (0);
1090         u64 sn (0);
1091
1092         ss << sn;
1093         ss << addr;
1094         ss << port;
1095       }
1096     }
1097
1098   private:
1099     typedef
1100     ACE_Hash_Map_Manager_Ex<Address,
1101                             u64,
1102                             AddressHasher,
1103                             ACE_Equal_To<Address>,
1104                             ACE_Null_Mutex>
1105     Map;
1106
1107     Map map_;
1108   };
1109
1110
1111   //
1112   //
1113   //
1114   struct NoData;
1115
1116   typedef
1117   ACE_Strong_Bound_Ptr<NoData, Mutex>
1118   NoData_ptr;
1119
1120   struct NoData : Profile
1121   {
1122     static u16 const id;
1123
1124   public:
1125     NoData (Header const& h, istream&)
1126         : Profile (h)
1127     {
1128     }
1129
1130     NoData ()
1131         : Profile (id)
1132     {
1133       Profile::size (0);
1134     }
1135
1136     NoData_ptr
1137     clone ()
1138     {
1139       return NoData_ptr (clone_ ());
1140     }
1141
1142   protected:
1143     virtual Profile_ptr
1144     clone_ ()
1145     {
1146       Profile_ptr p (new NoData (*this));
1147       return p;
1148     }
1149
1150     NoData (NoData const& no_data)
1151         : Profile (no_data)
1152     {
1153     }
1154
1155   public:
1156     virtual void
1157     serialize_body (ostream&) const
1158     {
1159     }
1160
1161     virtual void
1162     serialize_body (sstream&) const
1163     {
1164     }
1165   };
1166
1167
1168   //
1169   //
1170   //
1171   struct Part;
1172
1173   typedef
1174   ACE_Strong_Bound_Ptr<Part, Mutex>
1175   Part_ptr;
1176
1177   struct Part : Profile
1178   {
1179     static u16 const id;
1180
1181   public:
1182     Part (Header const& h, istream& is)
1183         : Profile (h)
1184     {
1185       is >> num_;
1186       is >> of_;
1187       is >> total_size_;
1188     }
1189
1190     Part (u32 num, u32 of, u64 total_size)
1191         : Profile (id),
1192           num_ (num),
1193           of_ (of),
1194           total_size_ (total_size)
1195     {
1196       size (calculate_size ());
1197     }
1198
1199     Part_ptr
1200     clone ()
1201     {
1202       return Part_ptr (clone_ ());
1203     }
1204
1205   protected:
1206     virtual Profile_ptr
1207     clone_ ()
1208     {
1209       Profile_ptr p (new Part (*this));
1210       return p;
1211     }
1212
1213     Part (Part const& part)
1214         : Profile (part),
1215           num_ (part.num_),
1216           of_ (part.of_),
1217           total_size_ (part.total_size_)
1218     {
1219     }
1220
1221   public:
1222     u32
1223     num () const
1224     {
1225       return num_;
1226     }
1227
1228     u32
1229     of () const
1230     {
1231       return of_;
1232     }
1233
1234     u64
1235     total_size () const
1236     {
1237       return total_size_;
1238     }
1239
1240   public:
1241     virtual void
1242     serialize_body (ostream& os) const
1243     {
1244       os << num_;
1245       os << of_;
1246       os << total_size_;
1247     }
1248
1249     virtual void
1250     serialize_body (sstream& ss) const
1251     {
1252       ss << num_;
1253       ss << of_;
1254       ss << total_size_;
1255     }
1256
1257
1258   private:
1259     u32 num_;
1260     u32 of_;
1261     u64 total_size_;
1262   };
1263 }
1264
1265 /*
1266 inline
1267 std::ostream&
1268 operator<< (std::ostream& os, ACE_RMCast::Address const& a)
1269 {
1270   char buf[64];
1271   a.addr_to_string (buf, 64, 1);
1272   return os << buf;
1273 }
1274 */
1275
1276 #endif  // ACE_RMCAST_PROTOCOL_H