A Discrete-Event Network Simulator
API
type-id.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2008 INRIA
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  * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
19  */
20 #include "log.h" // NS_ASSERT and NS_LOG
21 #include "hash.h"
22 #include "type-id.h"
23 #include "singleton.h"
24 #include "trace-source-accessor.h"
25 
26 #include <map>
27 #include <vector>
28 #include <sstream>
29 #include <iomanip>
30 
38 /*********************************************************************
39  * Helper code
40  *********************************************************************/
41 
42 namespace ns3 {
43 
44 NS_LOG_COMPONENT_DEFINE ("TypeId");
45 
46 // IidManager needs to be in ns3 namespace for NS_ASSERT and NS_LOG
47 // to find g_log
48 
78 class IidManager : public Singleton<IidManager>
79 {
80 public:
86  uint16_t AllocateUid (std::string name);
92  void SetParent (uint16_t uid, uint16_t parent);
98  void SetGroupName (uint16_t uid, std::string groupName);
104  void SetSize (uint16_t uid, std::size_t size);
110  void AddConstructor (uint16_t uid, Callback<ObjectBase *> callback);
115  void HideFromDocumentation (uint16_t uid);
121  uint16_t GetUid (std::string name) const;
127  uint16_t GetUid (TypeId::hash_t hash) const;
133  std::string GetName (uint16_t uid) const;
139  TypeId::hash_t GetHash (uint16_t uid) const;
145  uint16_t GetParent (uint16_t uid) const;
151  std::string GetGroupName (uint16_t uid) const;
157  std::size_t GetSize (uint16_t uid) const;
163  Callback<ObjectBase *> GetConstructor (uint16_t uid) const;
169  bool HasConstructor (uint16_t uid) const;
174  uint16_t GetRegisteredN (void) const;
184  uint16_t GetRegistered (uint16_t i) const;
201  void AddAttribute (uint16_t uid,
202  std::string name,
203  std::string help,
204  uint32_t flags,
205  Ptr<const AttributeValue> initialValue,
209  const std::string &supportMsg = "");
216  void SetAttributeInitialValue (uint16_t uid,
217  std::size_t i,
218  Ptr<const AttributeValue> initialValue);
224  std::size_t GetAttributeN (uint16_t uid) const;
231  struct TypeId::AttributeInformation GetAttribute (uint16_t uid, std::size_t i) const;
246  void AddTraceSource (uint16_t uid,
247  std::string name,
248  std::string help,
249  Ptr<const TraceSourceAccessor> accessor,
250  std::string callback,
251  TypeId::SupportLevel supportLevel = TypeId::SUPPORTED,
252  const std::string &supportMsg = "");
258  std::size_t GetTraceSourceN (uint16_t uid) const;
265  struct TypeId::TraceSourceInformation GetTraceSource (uint16_t uid, std::size_t i) const;
271  bool MustHideFromDocumentation (uint16_t uid) const;
272 
273 private:
280  bool HasTraceSource (uint16_t uid, std::string name);
287  bool HasAttribute (uint16_t uid, std::string name);
293  static TypeId::hash_t Hasher (const std::string name);
294 
297  {
299  std::string name;
303  uint16_t parent;
305  std::string groupName;
307  std::size_t size;
315  std::vector<struct TypeId::AttributeInformation> attributes;
317  std::vector<struct TypeId::TraceSourceInformation> traceSources;
321  std::string supportMsg;
322  };
324  typedef std::vector<struct IidInformation>::const_iterator Iterator;
325 
331  struct IidManager::IidInformation * LookupInformation (uint16_t uid) const;
332 
334  std::vector<struct IidInformation> m_information;
335 
337  typedef std::map<std::string, uint16_t> namemap_t;
340 
342  typedef std::map<TypeId::hash_t, uint16_t> hashmap_t;
345 
346 
348  enum
349  {
356  HashChainFlag = 0x80000000
357  };
358 };
359 
360 
361 //static
363 IidManager::Hasher (const std::string name)
364 {
365  static ns3::Hasher hasher ( Create<Hash::Function::Murmur3> () );
366  return hasher.clear ().GetHash32 (name);
367 }
368 
374 #define IID "IidManager"
380 #define IIDL IID << ": "
381 
382 uint16_t
383 IidManager::AllocateUid (std::string name)
384 {
385  NS_LOG_FUNCTION (IID << name);
386  // Type names are definitive: equal names are equal types
387  NS_ASSERT_MSG (m_namemap.count (name) == 0,
388  "Trying to allocate twice the same uid: " << name);
389 
390  TypeId::hash_t hash = Hasher (name) & (~HashChainFlag);
391  if (m_hashmap.count (hash) == 1)
392  {
393  NS_LOG_ERROR ("Hash chaining TypeId for '" << name << "'. "
394  << "This is not a bug, but is extremely unlikely. "
395  << "Please contact the ns3 developers.");
396  // ns3 developer contacted about this message:
397  // You have four options (in order of difficulty):
398  // 1. Let it ride, and play the odds that a third collision
399  // never appears.
400  // 2. Change the name of the new (or old) tag, even trivially, to
401  // remove the collision.
402  // 3. Switch to 64-bit hashes.
403  // 4. Implement 2-bit (or higher) chaining.
404  //
405  // Oh, by the way, I owe you a beer, since I bet Mathieu that
406  // this would never happen.. -- Peter Barnes, LLNL
407 
408  NS_ASSERT_MSG (m_hashmap.count (hash | HashChainFlag) == 0,
409  "Triplicate hash detected while chaining TypeId for '"
410  << name
411  << "'. Please contact the ns3 developers for assistance.");
412  // ns3 developer contacted about this message:
413  // You have three options: #2-4 above.
414  //
415  // Oh, by the way, I have no idea how this crazy hashing idea got
416  // into ns3. -- Peter Barnes, LLNL
417 
418  // Alphabetize the two types, so it's deterministic
419  struct IidInformation * hinfo = LookupInformation (GetUid (hash));
420  if (name > hinfo->name)
421  { // new type gets chained
422  NS_LOG_LOGIC (IIDL << "New TypeId '" << name << "' getting chained.");
423  hash = hash | HashChainFlag;
424  }
425  else
426  { // chain old type
427  NS_LOG_LOGIC (IIDL << "Old TypeId '" << hinfo->name << "' getting chained.");
428  uint16_t oldUid = GetUid (hinfo->hash);
429  m_hashmap.erase (m_hashmap.find (hinfo->hash));
430  hinfo->hash = hash | HashChainFlag;
431  m_hashmap.insert (std::make_pair (hinfo->hash, oldUid));
432  // leave new hash unchained
433  }
434  }
435 
436  struct IidInformation information;
437  information.name = name;
438  information.hash = hash;
439  information.parent = 0;
440  information.groupName = "";
441  information.size = (std::size_t)(-1);
442  information.hasConstructor = false;
443  information.mustHideFromDocumentation = false;
444  information.supportLevel = TypeId::SUPPORTED;
445  m_information.push_back (information);
446  std::size_t tuid = m_information.size ();
447  NS_ASSERT (tuid <= 0xffff);
448  uint16_t uid = static_cast<uint16_t> (tuid);
449 
450  // Add to both maps:
451  m_namemap.insert (std::make_pair (name, uid));
452  m_hashmap.insert (std::make_pair (hash, uid));
453  NS_LOG_LOGIC (IIDL << uid);
454  return uid;
455 }
456 
458 IidManager::LookupInformation (uint16_t uid) const
459 {
460  NS_LOG_FUNCTION (IID << uid);
461  NS_ASSERT (uid <= m_information.size () && uid != 0);
462  NS_LOG_LOGIC (IIDL << m_information[uid - 1].name);
463  return const_cast<struct IidInformation *> (&m_information[uid - 1]);
464 }
465 
466 void
467 IidManager::SetParent (uint16_t uid, uint16_t parent)
468 {
469  NS_LOG_FUNCTION (IID << uid << parent);
470  NS_ASSERT (parent <= m_information.size ());
471  struct IidInformation *information = LookupInformation (uid);
472  information->parent = parent;
473 }
474 void
475 IidManager::SetGroupName (uint16_t uid, std::string groupName)
476 {
477  NS_LOG_FUNCTION (IID << uid << groupName);
478  struct IidInformation *information = LookupInformation (uid);
479  information->groupName = groupName;
480 }
481 void
482 IidManager::SetSize (uint16_t uid, std::size_t size)
483 {
484  NS_LOG_FUNCTION (IID << uid << size);
485  struct IidInformation *information = LookupInformation (uid);
486  information->size = size;
487 }
488 void
490 {
491  NS_LOG_FUNCTION (IID << uid);
492  struct IidInformation *information = LookupInformation (uid);
493  information->mustHideFromDocumentation = true;
494 }
495 
496 void
498 {
499  NS_LOG_FUNCTION (IID << uid << &callback);
500  struct IidInformation *information = LookupInformation (uid);
501  if (information->hasConstructor)
502  {
503  NS_FATAL_ERROR (information->name << " already has a constructor.");
504  }
505  information->hasConstructor = true;
506  information->constructor = callback;
507 }
508 
509 uint16_t
510 IidManager::GetUid (std::string name) const
511 {
512  NS_LOG_FUNCTION (IID << name);
513  uint16_t uid = 0;
514  namemap_t::const_iterator it = m_namemap.find (name);
515  if (it != m_namemap.end ())
516  {
517  uid = it->second;
518  }
519  NS_LOG_LOGIC (IIDL << uid);
520  return uid;
521 }
522 uint16_t
524 {
525  NS_LOG_FUNCTION (IID << hash);
526  hashmap_t::const_iterator it = m_hashmap.find (hash);
527  uint16_t uid = 0;
528  if (it != m_hashmap.end ())
529  {
530  uid = it->second;
531  }
532  NS_LOG_LOGIC (IIDL << uid);
533  return uid;
534 }
535 std::string
536 IidManager::GetName (uint16_t uid) const
537 {
538  NS_LOG_FUNCTION (IID << uid);
539  struct IidInformation *information = LookupInformation (uid);
540  NS_LOG_LOGIC (IIDL << information->name);
541  return information->name;
542 }
544 IidManager::GetHash (uint16_t uid) const
545 {
546  NS_LOG_FUNCTION (IID << uid);
547  struct IidInformation *information = LookupInformation (uid);
548  TypeId::hash_t hash = information->hash;
549  NS_LOG_LOGIC (IIDL << hash);
550  return hash;
551 }
552 uint16_t
553 IidManager::GetParent (uint16_t uid) const
554 {
555  NS_LOG_FUNCTION (IID << uid);
556  struct IidInformation *information = LookupInformation (uid);
557  uint16_t pid = information->parent;
558  NS_LOG_LOGIC (IIDL << pid);
559  return pid;
560 }
561 std::string
562 IidManager::GetGroupName (uint16_t uid) const
563 {
564  NS_LOG_FUNCTION (IID << uid);
565  struct IidInformation *information = LookupInformation (uid);
566  NS_LOG_LOGIC (IIDL << information->groupName);
567  return information->groupName;
568 }
569 std::size_t
570 IidManager::GetSize (uint16_t uid) const
571 {
572  NS_LOG_FUNCTION (IID << uid);
573  struct IidInformation *information = LookupInformation (uid);
574  std::size_t size = information->size;
575  NS_LOG_LOGIC (IIDL << size);
576  return size;
577 }
578 
580 IidManager::GetConstructor (uint16_t uid) const
581 {
582  NS_LOG_FUNCTION (IID << uid);
583  struct IidInformation *information = LookupInformation (uid);
584  if (!information->hasConstructor)
585  {
586  NS_FATAL_ERROR ("Requested constructor for " << information->name << " but it does not have one.");
587  }
588  return information->constructor;
589 }
590 
591 bool
592 IidManager::HasConstructor (uint16_t uid) const
593 {
594  NS_LOG_FUNCTION (IID << uid);
595  struct IidInformation *information = LookupInformation (uid);
596  bool hasC = information->hasConstructor;
597  NS_LOG_LOGIC (IIDL << hasC);
598  return hasC;
599 }
600 
601 uint16_t
603 {
604  NS_LOG_FUNCTION (IID << m_information.size ());
605  return static_cast<uint16_t> (m_information.size ());
606 }
607 uint16_t
608 IidManager::GetRegistered (uint16_t i) const
609 {
610  NS_LOG_FUNCTION (IID << i);
611  return i + 1;
612 }
613 
614 bool
616  std::string name)
617 {
618  NS_LOG_FUNCTION (IID << uid << name);
619  struct IidInformation *information = LookupInformation (uid);
620  while (true)
621  {
622  for (std::vector<struct TypeId::AttributeInformation>::const_iterator i = information->attributes.begin ();
623  i != information->attributes.end (); ++i)
624  {
625  if (i->name == name)
626  {
627  NS_LOG_LOGIC (IIDL << true);
628  return true;
629  }
630  }
631  struct IidInformation *parent = LookupInformation (information->parent);
632  if (parent == information)
633  {
634  // top of inheritance tree
635  NS_LOG_LOGIC (IIDL << false);
636  return false;
637  }
638  // check parent
639  information = parent;
640  }
641  NS_LOG_LOGIC (IIDL << false);
642  return false;
643 }
644 
645 void
647  std::string name,
648  std::string help,
649  uint32_t flags,
650  Ptr<const AttributeValue> initialValue,
653  TypeId::SupportLevel supportLevel,
654  const std::string &supportMsg)
655 {
656  NS_LOG_FUNCTION (IID << uid << name << help << flags <<
657  initialValue << accessor << checker <<
658  supportLevel << supportMsg);
659  struct IidInformation *information = LookupInformation (uid);
660  if (name.find (' ') != std::string::npos)
661  {
662  NS_FATAL_ERROR ("Attribute name \"" << name << "\" may not contain spaces ' ', " <<
663  "encountered when registering TypeId \"" <<
664  information->name << "\"");
665  }
666  if (HasAttribute (uid, name))
667  {
668  NS_FATAL_ERROR ("Attribute \"" << name <<
669  "\" already registered on tid=\"" <<
670  information->name << "\"");
671  }
672  struct TypeId::AttributeInformation info;
673  info.name = name;
674  info.help = help;
675  info.flags = flags;
676  info.initialValue = initialValue;
677  info.originalInitialValue = initialValue;
678  info.accessor = accessor;
679  info.checker = checker;
680  info.supportLevel = supportLevel;
681  info.supportMsg = supportMsg;
682  information->attributes.push_back (info);
683  NS_LOG_LOGIC (IIDL << information->attributes.size () - 1);
684 }
685 void
687  std::size_t i,
688  Ptr<const AttributeValue> initialValue)
689 {
690  NS_LOG_FUNCTION (IID << uid << i << initialValue);
691  struct IidInformation *information = LookupInformation (uid);
692  NS_ASSERT (i < information->attributes.size ());
693  information->attributes[i].initialValue = initialValue;
694 }
695 
696 
697 
698 std::size_t
699 IidManager::GetAttributeN (uint16_t uid) const
700 {
701  NS_LOG_FUNCTION (IID << uid);
702  struct IidInformation *information = LookupInformation (uid);
703  std::size_t size = information->attributes.size ();
704  NS_LOG_LOGIC (IIDL << size);
705  return size;
706 }
708 IidManager::GetAttribute (uint16_t uid, std::size_t i) const
709 {
710  NS_LOG_FUNCTION (IID << uid << i);
711  struct IidInformation *information = LookupInformation (uid);
712  NS_ASSERT (i < information->attributes.size ());
713  NS_LOG_LOGIC (IIDL << information->name);
714  return information->attributes[i];
715 }
716 
717 bool
719  std::string name)
720 {
721  NS_LOG_FUNCTION (IID << uid << name);
722  struct IidInformation *information = LookupInformation (uid);
723  while (true)
724  {
725  for (std::vector<struct TypeId::TraceSourceInformation>::const_iterator i = information->traceSources.begin ();
726  i != information->traceSources.end (); ++i)
727  {
728  if (i->name == name)
729  {
730  NS_LOG_LOGIC (IIDL << true);
731  return true;
732  }
733  }
734  struct IidInformation *parent = LookupInformation (information->parent);
735  if (parent == information)
736  {
737  // top of inheritance tree
738  NS_LOG_LOGIC (IIDL << false);
739  return false;
740  }
741  // check parent
742  information = parent;
743  }
744  NS_LOG_LOGIC (IIDL << false);
745  return false;
746 }
747 
748 void
750  std::string name,
751  std::string help,
753  std::string callback,
754  TypeId::SupportLevel supportLevel,
755  const std::string &supportMsg)
756 {
757  NS_LOG_FUNCTION (IID << uid << name << help <<
758  accessor << callback <<
759  supportLevel << supportMsg);
760  struct IidInformation *information = LookupInformation (uid);
761  if (HasTraceSource (uid, name))
762  {
763  NS_FATAL_ERROR ("Trace source \"" << name <<
764  "\" already registered on tid=\"" <<
765  information->name << "\"");
766  }
767  struct TypeId::TraceSourceInformation source;
768  source.name = name;
769  source.help = help;
770  source.accessor = accessor;
771  source.callback = callback;
772  source.supportLevel = supportLevel;
773  source.supportMsg = supportMsg;
774  information->traceSources.push_back (source);
775  NS_LOG_LOGIC (IIDL << information->traceSources.size () - 1);
776 }
777 std::size_t
778 IidManager::GetTraceSourceN (uint16_t uid) const
779 {
780  NS_LOG_FUNCTION (IID << uid);
781  struct IidInformation *information = LookupInformation (uid);
782  std::size_t size = information->traceSources.size ();
783  NS_LOG_LOGIC (IIDL << size);
784  return size;
785 }
787 IidManager::GetTraceSource (uint16_t uid, std::size_t i) const
788 {
789  NS_LOG_FUNCTION (IID << uid << i);
790  struct IidInformation *information = LookupInformation (uid);
791  NS_ASSERT (i < information->traceSources.size ());
792  NS_LOG_LOGIC (IIDL << information->name);
793  return information->traceSources[i];
794 }
795 bool
797 {
798  NS_LOG_FUNCTION (IID << uid);
799  struct IidInformation *information = LookupInformation (uid);
800  bool hide = information->mustHideFromDocumentation;
801  NS_LOG_LOGIC (IIDL << hide);
802  return hide;
803 }
804 
805 } // namespace ns3
806 
807 namespace ns3 {
808 
809 /*********************************************************************
810  * The TypeId class
811  *********************************************************************/
812 
813 TypeId::TypeId (const std::string &name)
814 {
815  NS_LOG_FUNCTION (this << name);
816  uint16_t uid = IidManager::Get ()->AllocateUid (name);
817  NS_LOG_LOGIC (uid);
818  NS_ASSERT (uid != 0);
819  m_tid = uid;
820 }
821 
822 
823 TypeId::TypeId (uint16_t tid)
824  : m_tid (tid)
825 {
826  NS_LOG_FUNCTION (this << tid);
827 }
828 TypeId
829 TypeId::LookupByName (std::string name)
830 {
831  NS_LOG_FUNCTION (name);
832  uint16_t uid = IidManager::Get ()->GetUid (name);
833  NS_ASSERT_MSG (uid != 0, "Assert in TypeId::LookupByName: " << name << " not found");
834  return TypeId (uid);
835 }
836 bool
837 TypeId::LookupByNameFailSafe (std::string name, TypeId *tid)
838 {
839  NS_LOG_FUNCTION (name << tid->GetUid ());
840  uint16_t uid = IidManager::Get ()->GetUid (name);
841  if (uid == 0)
842  {
843  return false;
844  }
845  *tid = TypeId (uid);
846  return true;
847 }
848 TypeId
850 {
851  uint16_t uid = IidManager::Get ()->GetUid (hash);
852  NS_ASSERT_MSG (uid != 0, "Assert in TypeId::LookupByHash: 0x"
853  << std::hex << hash << std::dec << " not found");
854  return TypeId (uid);
855 }
856 bool
858 {
859  uint16_t uid = IidManager::Get ()->GetUid (hash);
860  if (uid == 0)
861  {
862  return false;
863  }
864  *tid = TypeId (uid);
865  return true;
866 }
867 
868 uint16_t
870 {
872  return IidManager::Get ()->GetRegisteredN ();
873 }
874 TypeId
876 {
877  NS_LOG_FUNCTION (i);
878  return TypeId (IidManager::Get ()->GetRegistered (i));
879 }
880 
881 bool
882 TypeId::LookupAttributeByName (std::string name, struct TypeId::AttributeInformation *info) const
883 {
884  NS_LOG_FUNCTION (this << name << info);
885  TypeId tid;
886  TypeId nextTid = *this;
887  do
888  {
889  tid = nextTid;
890  for (std::size_t i = 0; i < tid.GetAttributeN (); i++)
891  {
892  struct TypeId::AttributeInformation tmp = tid.GetAttribute (i);
893  if (tmp.name == name)
894  {
895  if (tmp.supportLevel == TypeId::SUPPORTED)
896  {
897  *info = tmp;
898  return true;
899  }
900  else if (tmp.supportLevel == TypeId::DEPRECATED)
901  {
902  std::cerr << "Attribute '" << name << "' is deprecated: "
903  << tmp.supportMsg << std::endl;
904  *info = tmp;
905  return true;
906  }
907  else if (tmp.supportLevel == TypeId::OBSOLETE)
908  {
909  NS_FATAL_ERROR ("Attribute '" << name <<
910  "' is obsolete, with no fallback: " <<
911  tmp.supportMsg);
912  }
913  }
914  }
915  nextTid = tid.GetParent ();
916  }
917  while (nextTid != tid);
918  return false;
919 }
920 
921 TypeId
923 {
924  NS_LOG_FUNCTION (this << tid.GetUid ());
926  return *this;
927 }
928 TypeId
929 TypeId::SetGroupName (std::string groupName)
930 {
931  NS_LOG_FUNCTION (this << groupName);
932  IidManager::Get ()->SetGroupName (m_tid, groupName);
933  return *this;
934 }
935 TypeId
936 TypeId::SetSize (std::size_t size)
937 {
938  NS_LOG_FUNCTION (this << size);
939  IidManager::Get ()->SetSize (m_tid, size);
940  return *this;
941 }
942 TypeId
943 TypeId::GetParent (void) const
944 {
945  NS_LOG_FUNCTION (this);
946  uint16_t parent = IidManager::Get ()->GetParent (m_tid);
947  return TypeId (parent);
948 }
949 bool
950 TypeId::HasParent (void) const
951 {
952  NS_LOG_FUNCTION (this);
953  uint16_t parent = IidManager::Get ()->GetParent (m_tid);
954  return parent != m_tid;
955 }
956 bool
958 {
959  NS_LOG_FUNCTION (this << other.GetUid ());
960  TypeId tmp = *this;
961  while (tmp != other && tmp != tmp.GetParent ())
962  {
963  tmp = tmp.GetParent ();
964  }
965  return tmp == other && *this != other;
966 }
967 std::string
969 {
970  NS_LOG_FUNCTION (this);
971  std::string groupName = IidManager::Get ()->GetGroupName (m_tid);
972  return groupName;
973 }
974 
975 std::string
976 TypeId::GetName (void) const
977 {
978  NS_LOG_FUNCTION (this);
979  std::string name = IidManager::Get ()->GetName (m_tid);
980  return name;
981 }
982 
984 TypeId::GetHash (void) const
985 {
987  return hash;
988 }
989 std::size_t
990 TypeId::GetSize (void) const
991 {
992  NS_LOG_FUNCTION (this);
993  std::size_t size = IidManager::Get ()->GetSize (m_tid);
994  return size;
995 }
996 
997 bool
999 {
1000  NS_LOG_FUNCTION (this);
1001  bool hasConstructor = IidManager::Get ()->HasConstructor (m_tid);
1002  return hasConstructor;
1003 }
1004 
1005 void
1007 {
1008  NS_LOG_FUNCTION (this << &cb);
1010 }
1011 
1012 TypeId
1013 TypeId::AddAttribute (std::string name,
1014  std::string help,
1015  const AttributeValue &initialValue,
1018  SupportLevel supportLevel,
1019  const std::string &supportMsg)
1020 {
1021  NS_LOG_FUNCTION (this << name << help <<
1022  &initialValue << accessor << checker <<
1023  supportLevel << supportMsg);
1024  IidManager::Get ()->AddAttribute (m_tid, name, help, ATTR_SGC,
1025  initialValue.Copy (), accessor, checker,
1026  supportLevel, supportMsg);
1027  return *this;
1028 }
1029 
1030 TypeId
1031 TypeId::AddAttribute (std::string name,
1032  std::string help,
1033  uint32_t flags,
1034  const AttributeValue &initialValue,
1037  SupportLevel supportLevel,
1038  const std::string &supportMsg)
1039 {
1040  NS_LOG_FUNCTION (this << name << help << flags <<
1041  &initialValue << accessor << checker <<
1042  supportLevel << supportMsg);
1043  IidManager::Get ()->AddAttribute (m_tid, name, help, flags,
1044  initialValue.Copy (), accessor, checker,
1045  supportLevel, supportMsg);
1046  return *this;
1047 }
1048 
1049 bool
1051  Ptr<const AttributeValue> initialValue)
1052 {
1053  NS_LOG_FUNCTION (this << i << initialValue);
1054  IidManager::Get ()->SetAttributeInitialValue (m_tid, i, initialValue);
1055  return true;
1056 }
1057 
1058 
1061 {
1062  NS_LOG_FUNCTION (this);
1064  return cb;
1065 }
1066 
1067 bool
1069 {
1070  NS_LOG_FUNCTION (this);
1071  bool mustHide = IidManager::Get ()->MustHideFromDocumentation (m_tid);
1072  return mustHide;
1073 }
1074 
1075 std::size_t
1077 {
1078  NS_LOG_FUNCTION (this);
1079  std::size_t n = IidManager::Get ()->GetAttributeN (m_tid);
1080  return n;
1081 }
1083 TypeId::GetAttribute (std::size_t i) const
1084 {
1085  NS_LOG_FUNCTION (this << i);
1086  return IidManager::Get ()->GetAttribute (m_tid, i);
1087 }
1088 std::string
1089 TypeId::GetAttributeFullName (std::size_t i) const
1090 {
1091  NS_LOG_FUNCTION (this << i);
1092  struct TypeId::AttributeInformation info = GetAttribute (i);
1093  return GetName () + "::" + info.name;
1094 }
1095 
1096 std::size_t
1098 {
1099  NS_LOG_FUNCTION (this);
1100  return IidManager::Get ()->GetTraceSourceN (m_tid);
1101 }
1103 TypeId::GetTraceSource (std::size_t i) const
1104 {
1105  NS_LOG_FUNCTION (this << i);
1106  return IidManager::Get ()->GetTraceSource (m_tid, i);
1107 }
1108 
1109 TypeId
1110 TypeId::AddTraceSource (std::string name,
1111  std::string help,
1113  std::string callback,
1114  SupportLevel supportLevel,
1115  const std::string &supportMsg)
1116 {
1117  NS_LOG_FUNCTION (this << name << help <<
1118  accessor << callback <<
1119  supportLevel << supportMsg);
1120  IidManager::Get ()->AddTraceSource (m_tid, name, help,
1121  accessor, callback,
1122  supportLevel, supportMsg);
1123  return *this;
1124 }
1125 
1126 TypeId
1128 {
1129  NS_LOG_FUNCTION (this);
1131  return *this;
1132 }
1133 
1136  struct TraceSourceInformation *info) const
1137 {
1138  NS_LOG_FUNCTION (this << name);
1139  TypeId tid;
1140  TypeId nextTid = *this;
1141  struct TypeId::TraceSourceInformation tmp;
1142  do
1143  {
1144  tid = nextTid;
1145  for (std::size_t i = 0; i < tid.GetTraceSourceN (); i++)
1146  {
1147  tmp = tid.GetTraceSource (i);
1148  if (tmp.name == name)
1149  {
1150  if (tmp.supportLevel == TypeId::SUPPORTED)
1151  {
1152  *info = tmp;
1153  return tmp.accessor;
1154  }
1155  else if (tmp.supportLevel == TypeId::DEPRECATED)
1156  {
1157  std::cerr << "TraceSource '" << name << "' is deprecated: "
1158  << tmp.supportMsg << std::endl;
1159  *info = tmp;
1160  return tmp.accessor;
1161  }
1162  else if (tmp.supportLevel == TypeId::OBSOLETE)
1163  {
1164  NS_FATAL_ERROR ("TraceSource '" << name <<
1165  "' is obsolete, with no fallback: " <<
1166  tmp.supportMsg);
1167  }
1168  }
1169  }
1170  nextTid = tid.GetParent ();
1171  }
1172  while (nextTid != tid);
1173  return 0;
1174 }
1175 
1177 TypeId::LookupTraceSourceByName (std::string name) const
1178 {
1179  struct TraceSourceInformation info;
1180  return LookupTraceSourceByName (name, &info);
1181 }
1182 
1183 uint16_t
1184 TypeId::GetUid (void) const
1185 {
1186  NS_LOG_FUNCTION (this);
1187  return m_tid;
1188 }
1189 void
1190 TypeId::SetUid (uint16_t uid)
1191 {
1192  NS_LOG_FUNCTION (this << uid);
1193  m_tid = uid;
1194 }
1195 
1202 std::ostream & operator << (std::ostream &os, TypeId tid)
1203 {
1204  os << tid.GetName ();
1205  return os;
1206 }
1213 std::istream & operator >> (std::istream &is, TypeId &tid)
1214 {
1215  std::string tidString;
1216  is >> tidString;
1217  bool ok = TypeId::LookupByNameFailSafe (tidString, &tid);
1218  if (!ok)
1219  {
1220  is.setstate (std::ios_base::badbit);
1221  }
1222  return is;
1223 }
1224 
1225 
1227 
1229 {
1230  return a.m_tid < b.m_tid;
1231 }
1232 
1233 } // namespace ns3
Hold a value for an Attribute.
Definition: attribute.h:69
virtual Ptr< AttributeValue > Copy(void) const =0
Callback template class.
Definition: callback.h:1279
Generic Hash function interface.
Definition: hash.h:88
uint32_t GetHash32(const char *buffer, const std::size_t size)
Compute 32-bit hash of a byte buffer.
Definition: hash.h:239
Hasher & clear(void)
Restore initial state.
Definition: hash.cc:55
TypeId information manager.
Definition: type-id.cc:79
uint16_t GetRegisteredN(void) const
Get the total number of type ids.
Definition: type-id.cc:602
TypeId::hash_t GetHash(uint16_t uid) const
Get the hash of a type id.
Definition: type-id.cc:544
std::map< TypeId::hash_t, uint16_t > hashmap_t
Type of the by-hash index.
Definition: type-id.cc:342
uint16_t GetParent(uint16_t uid) const
Get the parent of a type id.
Definition: type-id.cc:553
std::map< std::string, uint16_t > namemap_t
Type of the by-name index.
Definition: type-id.cc:337
void SetAttributeInitialValue(uint16_t uid, std::size_t i, Ptr< const AttributeValue > initialValue)
Set the initial value of an Attribute.
Definition: type-id.cc:686
void SetGroupName(uint16_t uid, std::string groupName)
Set the group name of a type id.
Definition: type-id.cc:475
void SetParent(uint16_t uid, uint16_t parent)
Set the parent of a type id.
Definition: type-id.cc:467
void SetSize(uint16_t uid, std::size_t size)
Set the size of the object class referred to by this id.
Definition: type-id.cc:482
std::string GetGroupName(uint16_t uid) const
Get the group name of a type id.
Definition: type-id.cc:562
bool HasTraceSource(uint16_t uid, std::string name)
Check if a type id has a given TraceSource.
Definition: type-id.cc:718
uint16_t GetRegistered(uint16_t i) const
Get a type id by index.
Definition: type-id.cc:608
Callback< ObjectBase * > GetConstructor(uint16_t uid) const
Get the constructor Callback of a type id.
Definition: type-id.cc:580
std::size_t GetAttributeN(uint16_t uid) const
Get the number of attributes.
Definition: type-id.cc:699
uint16_t GetUid(std::string name) const
Get a type id by name.
Definition: type-id.cc:510
struct TypeId::TraceSourceInformation GetTraceSource(uint16_t uid, std::size_t i) const
Get the trace source by index.
Definition: type-id.cc:787
void AddConstructor(uint16_t uid, Callback< ObjectBase * > callback)
Add a constructor Callback to this type id.
Definition: type-id.cc:497
void HideFromDocumentation(uint16_t uid)
Mark this type id to be excluded from documentation.
Definition: type-id.cc:489
std::string GetName(uint16_t uid) const
Get the name of a type id.
Definition: type-id.cc:536
std::vector< struct IidInformation > m_information
The container of all type id records.
Definition: type-id.cc:334
@ HashChainFlag
Hash chaining flag.
Definition: type-id.cc:356
std::size_t GetTraceSourceN(uint16_t uid) const
Get the number of Trace sources.
Definition: type-id.cc:778
std::size_t GetSize(uint16_t uid) const
Get the size of a type id.
Definition: type-id.cc:570
struct IidManager::IidInformation * LookupInformation(uint16_t uid) const
Retrieve the information record for a type.
Definition: type-id.cc:458
struct TypeId::AttributeInformation GetAttribute(uint16_t uid, std::size_t i) const
Get Attribute information by index.
Definition: type-id.cc:708
bool MustHideFromDocumentation(uint16_t uid) const
Check if this TypeId should not be listed in documentation.
Definition: type-id.cc:796
bool HasConstructor(uint16_t uid) const
Check if a type id has a constructor Callback.
Definition: type-id.cc:592
bool HasAttribute(uint16_t uid, std::string name)
Check if a type id has a given Attribute.
Definition: type-id.cc:615
static TypeId::hash_t Hasher(const std::string name)
Hashing function.
Definition: type-id.cc:363
hashmap_t m_hashmap
The by-hash index.
Definition: type-id.cc:344
std::vector< struct IidInformation >::const_iterator Iterator
Iterator type.
Definition: type-id.cc:324
uint16_t AllocateUid(std::string name)
Create a new unique type id.
Definition: type-id.cc:383
void AddAttribute(uint16_t uid, std::string name, std::string help, uint32_t flags, Ptr< const AttributeValue > initialValue, Ptr< const AttributeAccessor > accessor, Ptr< const AttributeChecker > checker, TypeId::SupportLevel supportLevel=TypeId::SUPPORTED, const std::string &supportMsg="")
Record a new attribute in a type id.
Definition: type-id.cc:646
void AddTraceSource(uint16_t uid, std::string name, std::string help, Ptr< const TraceSourceAccessor > accessor, std::string callback, TypeId::SupportLevel supportLevel=TypeId::SUPPORTED, const std::string &supportMsg="")
Record a new TraceSource.
Definition: type-id.cc:749
namemap_t m_namemap
The by-name index.
Definition: type-id.cc:339
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:74
A template singleton.
Definition: singleton.h:61
static IidManager * Get(void)
Get a pointer to the singleton instance.
Definition: singleton.h:100
a unique identifier for an interface.
Definition: type-id.h:59
bool IsChildOf(TypeId other) const
Check if this TypeId is a child of another.
Definition: type-id.cc:957
bool SetAttributeInitialValue(std::size_t i, Ptr< const AttributeValue > initialValue)
Set the initial value of an Attribute.
Definition: type-id.cc:1050
std::size_t GetTraceSourceN(void) const
Get the number of Trace sources.
Definition: type-id.cc:1097
TypeId SetParent(void)
Set the parent TypeId.
Definition: type-id.h:631
static TypeId LookupByName(std::string name)
Get a TypeId by name.
Definition: type-id.cc:829
std::size_t GetAttributeN(void) const
Get the number of attributes.
Definition: type-id.cc:1076
TypeId SetSize(std::size_t size)
Set the size of this type.
Definition: type-id.cc:936
bool HasParent(void) const
Check if this TypeId has a parent.
Definition: type-id.cc:950
TypeId AddTraceSource(std::string name, std::string help, Ptr< const TraceSourceAccessor > accessor, std::string callback, SupportLevel supportLevel=SUPPORTED, const std::string &supportMsg="")
Record a new TraceSource.
Definition: type-id.cc:1110
struct TypeId::TraceSourceInformation GetTraceSource(std::size_t i) const
Get the trace source by index.
Definition: type-id.cc:1103
@ ATTR_SGC
The attribute can be read, and written at any time.
Definition: type-id.h:67
static bool LookupByHashFailSafe(hash_t hash, TypeId *tid)
Get a TypeId by hash.
Definition: type-id.cc:857
static uint16_t GetRegisteredN(void)
Get the number of registered TypeIds.
Definition: type-id.cc:869
uint16_t GetUid(void) const
Get the internal id of this TypeId.
Definition: type-id.cc:1184
hash_t GetHash(void) const
Get the hash.
Definition: type-id.cc:984
Callback< ObjectBase * > GetConstructor(void) const
Get the constructor callback.
Definition: type-id.cc:1060
std::string GetAttributeFullName(std::size_t i) const
Get the Attribute name by index.
Definition: type-id.cc:1089
struct TypeId::AttributeInformation GetAttribute(std::size_t i) const
Get Attribute information by index.
Definition: type-id.cc:1083
std::string GetGroupName(void) const
Get the group name.
Definition: type-id.cc:968
void SetUid(uint16_t uid)
Set the internal id of this TypeId.
Definition: type-id.cc:1190
uint16_t m_tid
The TypeId value.
Definition: type-id.h:562
TypeId SetGroupName(std::string groupName)
Set the group name.
Definition: type-id.cc:929
static TypeId LookupByHash(hash_t hash)
Get a TypeId by hash.
Definition: type-id.cc:849
static TypeId GetRegistered(uint16_t i)
Get a TypeId by index.
Definition: type-id.cc:875
bool HasConstructor(void) const
Check if this TypeId has a constructor.
Definition: type-id.cc:998
Ptr< const TraceSourceAccessor > LookupTraceSourceByName(std::string name) const
Find a TraceSource by name.
Definition: type-id.cc:1177
TypeId HideFromDocumentation(void)
Hide this TypeId from documentation.
Definition: type-id.cc:1127
bool MustHideFromDocumentation(void) const
Check if this TypeId should not be listed in documentation.
Definition: type-id.cc:1068
uint32_t hash_t
Type of hash values.
Definition: type-id.h:116
TypeId()
Default constructor.
Definition: type-id.h:601
TypeId GetParent(void) const
Get the parent of this TypeId.
Definition: type-id.cc:943
std::string GetName(void) const
Get the name.
Definition: type-id.cc:976
std::size_t GetSize(void) const
Get the size of this object.
Definition: type-id.cc:990
bool LookupAttributeByName(std::string name, struct AttributeInformation *info) const
Find an Attribute by name, retrieving the associated AttributeInformation.
Definition: type-id.cc:882
static bool LookupByNameFailSafe(std::string name, TypeId *tid)
Get a TypeId by name.
Definition: type-id.cc:837
SupportLevel
The level of support or deprecation for attributes or trace sources.
Definition: type-id.h:71
@ SUPPORTED
Attribute or trace source is currently used.
Definition: type-id.h:72
@ OBSOLETE
Attribute or trace source is not used anymore; simulation fails.
Definition: type-id.h:74
@ DEPRECATED
Attribute or trace source is deprecated; user is warned.
Definition: type-id.h:73
TypeId AddAttribute(std::string name, std::string help, const AttributeValue &initialValue, Ptr< const AttributeAccessor > accessor, Ptr< const AttributeChecker > checker, SupportLevel supportLevel=SUPPORTED, const std::string &supportMsg="")
Record in this TypeId the fact that a new attribute exists.
Definition: type-id.cc:1013
void DoAddConstructor(Callback< ObjectBase * > callback)
Implementation for AddConstructor().
Definition: type-id.cc:1006
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:67
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:88
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:165
#define NS_LOG_ERROR(msg)
Use NS_LOG to output a message of level LOG_ERROR.
Definition: log.h:257
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition: log.h:289
#define NS_LOG_FUNCTION_NOARGS()
Output the name of the function.
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
#define IIDL
Definition: type-id.cc:380
#define IID
Definition: type-id.cc:374
ns3::Hasher, ns3::Hash32() and ns3::Hash64() function declarations.
Debug message logging.
std::size_t hash(const BasicJsonType &j)
hash a JSON value
Definition: json.h:4680
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ATTRIBUTE_HELPER_CPP(Length)
bool operator<(const EventId &a, const EventId &b)
Definition: event-id.h:176
std::istream & operator>>(std::istream &is, Angles &a)
Definition: angles.cc:162
std::ostream & operator<<(std::ostream &os, const Angles &a)
Definition: angles.cc:139
ns3::Singleton declaration and template implementation.
The information record about a single type id.
Definition: type-id.cc:297
std::string groupName
The group name.
Definition: type-id.cc:305
uint16_t parent
The parent type id.
Definition: type-id.cc:303
std::vector< struct TypeId::AttributeInformation > attributes
The container of Attributes.
Definition: type-id.cc:315
Callback< ObjectBase * > constructor
The constructor Callback.
Definition: type-id.cc:311
std::size_t size
The size of the object represented by this type id.
Definition: type-id.cc:307
std::string supportMsg
Support message.
Definition: type-id.cc:321
std::string name
The type id name.
Definition: type-id.cc:299
bool hasConstructor
true if a constructor Callback has been registered.
Definition: type-id.cc:309
bool mustHideFromDocumentation
true if this type should be omitted from documentation.
Definition: type-id.cc:313
TypeId::hash_t hash
The type id hash value.
Definition: type-id.cc:301
std::vector< struct TypeId::TraceSourceInformation > traceSources
The container of TraceSources.
Definition: type-id.cc:317
TypeId::SupportLevel supportLevel
Support level/deprecation.
Definition: type-id.cc:319
Attribute implementation.
Definition: type-id.h:78
Ptr< const AttributeValue > originalInitialValue
Default initial value.
Definition: type-id.h:86
TypeId::SupportLevel supportLevel
Support level/deprecation.
Definition: type-id.h:94
std::string name
Attribute name.
Definition: type-id.h:80
Ptr< const AttributeAccessor > accessor
Accessor object.
Definition: type-id.h:90
uint32_t flags
AttributeFlags value.
Definition: type-id.h:84
Ptr< const AttributeChecker > checker
Checker object.
Definition: type-id.h:92
std::string supportMsg
Support message.
Definition: type-id.h:96
Ptr< const AttributeValue > initialValue
Configured initial value.
Definition: type-id.h:88
std::string help
Attribute help string.
Definition: type-id.h:82
TraceSource implementation.
Definition: type-id.h:100
std::string name
Trace name.
Definition: type-id.h:102
std::string supportMsg
Support message.
Definition: type-id.h:112
std::string help
Trace help string.
Definition: type-id.h:104
Ptr< const TraceSourceAccessor > accessor
Trace accessor.
Definition: type-id.h:108
std::string callback
Callback function signature type.
Definition: type-id.h:106
TypeId::SupportLevel supportLevel
Support level/deprecation.
Definition: type-id.h:110
ns3::TraceSourceAccessor and ns3::MakeTraceSourceAccessor declarations.
ns3::TypeId declaration; inline and template implementations.