Mercurial Mercurial > ns-3.24 / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/core/model/enum.cc
changeset 7169 358f71a624d8
parent 6821 203367ae7433
child 9134 7a750f032acd
equal deleted inserted replaced
7168:7c724be8f9a6 7169:358f71a624d8 
    23 
    23 
    24 namespace ns3 {
 
    24 namespace ns3 {
 
    25 
    25 
    26 EnumValue::EnumValue ()
 
    26 EnumValue::EnumValue ()
 
    27   : m_v ()
 
    27   : m_v ()
 
    28 {}
 
    28 {
 
       
    29 }
 
    29 EnumValue::EnumValue (int v)
 
    30 EnumValue::EnumValue (int v)
 
    30   : m_v (v)
 
    31   : m_v (v)
 
    31 {}
 
    32 {
 
    32 void 
    33 }
 
       
    34 void
 
    33 EnumValue::Set (int v)
 
    35 EnumValue::Set (int v)
 
    34 {
 
    36 {
 
    35   m_v = v;
 
    37   m_v = v;
 
    36 }
 
    38 }
 
    37 int 
    39 int
 
    38 EnumValue::Get (void) const
 
    40 EnumValue::Get (void) const
 
    39 {
 
    41 {
 
    40   return m_v;
 
    42   return m_v;
 
    41 }
 
    43 }
 
    42 Ptr<AttributeValue>
 
    44 Ptr<AttributeValue>
 
    50   const EnumChecker *p = dynamic_cast<const EnumChecker *> (PeekPointer (checker));
 
    52   const EnumChecker *p = dynamic_cast<const EnumChecker *> (PeekPointer (checker));
 
    51   NS_ASSERT (p != 0);
 
    53   NS_ASSERT (p != 0);
 
    52   for (EnumChecker::ValueSet::const_iterator i = p->m_valueSet.begin (); i != p->m_valueSet.end (); i++)
 
    54   for (EnumChecker::ValueSet::const_iterator i = p->m_valueSet.begin (); i != p->m_valueSet.end (); i++)
 
    53     {
 
    55     {
 
    54       if (i->first == m_v)
 
    56       if (i->first == m_v)
 
    55 	{
 
    57         {
 
    56 	  return i->second;
 
    58           return i->second;
 
    57 	}
 
    59         }
 
    58     }
 
    60     }
 
    59   
    61 
    60   NS_FATAL_ERROR ("The user has set an invalid C++ value in this Enum");
 
    62   NS_FATAL_ERROR ("The user has set an invalid C++ value in this Enum");
 
    61   // quiet compiler.
 
    63   // quiet compiler.
 
    62   return "";
 
    64   return "";
 
    63 }
 
    65 }
 
    64 bool 
    66 bool 
    67   const EnumChecker *p = dynamic_cast<const EnumChecker *> (PeekPointer (checker));
 
    69   const EnumChecker *p = dynamic_cast<const EnumChecker *> (PeekPointer (checker));
 
    68   NS_ASSERT (p != 0);
 
    70   NS_ASSERT (p != 0);
 
    69   for (EnumChecker::ValueSet::const_iterator i = p->m_valueSet.begin (); i != p->m_valueSet.end (); i++)
 
    71   for (EnumChecker::ValueSet::const_iterator i = p->m_valueSet.begin (); i != p->m_valueSet.end (); i++)
 
    70     {
 
    72     {
 
    71       if (i->second == value)
 
    73       if (i->second == value)
 
    72 	{
 
    74         {
 
    73 	  m_v = i->first;
 
    75           m_v = i->first;
 
    74 	  return true;
 
    76           return true;
 
    75 	}
 
    77         }
 
    76     }
 
    78     }
 
    77   return false;
 
    79   return false;
 
    78 }
 
    80 }
 
    79 
    81 
    80 EnumChecker::EnumChecker ()
 
    82 EnumChecker::EnumChecker ()
 
    81 {}
 
    83 {
 
    82 
    84 }
 
    83 void 
    85 
       
    86 void
 
    84 EnumChecker::AddDefault (int v, std::string name)
 
    87 EnumChecker::AddDefault (int v, std::string name)
 
    85 {
 
    88 {
 
    86   m_valueSet.push_front (std::make_pair (v, name));
 
    89   m_valueSet.push_front (std::make_pair (v, name));
 
    87 }
 
    90 }
 
    88 void 
    91 void
 
    89 EnumChecker::Add (int v, std::string name)
 
    92 EnumChecker::Add (int v, std::string name)
 
    90 {
 
    93 {
 
    91   m_valueSet.push_back (std::make_pair (v, name));
 
    94   m_valueSet.push_back (std::make_pair (v, name));
 
    92 }
 
    95 }
 
    93 bool 
    96 bool
 
    94 EnumChecker::Check (const AttributeValue &value) const
 
    97 EnumChecker::Check (const AttributeValue &value) const
 
    95 {
 
    98 {
 
    96   const EnumValue *p = dynamic_cast<const EnumValue *> (&value);
 
    99   const EnumValue *p = dynamic_cast<const EnumValue *> (&value);
 
    97   if (p == 0)
 
   100   if (p == 0)
 
    98     {
 
   101     {
 
    99       return false;
 
   102       return false;
 
   100     }
 
   103     }
 
   101   for (ValueSet::const_iterator i = m_valueSet.begin (); i != m_valueSet.end (); i++)
 
   104   for (ValueSet::const_iterator i = m_valueSet.begin (); i != m_valueSet.end (); i++)
 
   102     {
 
   105     {
 
   103       if (i->first == p->Get ())
 
   106       if (i->first == p->Get ())
 
   104 	{
 
   107         {
 
   105 	  return true;
 
   108           return true;
 
   106 	}
 
   109         }
 
   107     }
 
   110     }
 
   108   return false;
 
   111   return false;
 
   109 }
 
   112 }
 
   110 std::string 
   113 std::string 
   111 EnumChecker::GetValueTypeName (void) const
 
   114 EnumChecker::GetValueTypeName (void) const
 
   233       return checker;
 
   236       return checker;
 
   234     }
 
   237     }
 
   235   checker->Add (v12, n12);
 
   238   checker->Add (v12, n12);
 
   236   if (n13 == "")
 
   239   if (n13 == "")
 
   237     {
 
   240     {
 
   238           return checker;
 
   241       return checker;
 
   239     }
 
   242     }
 
   240   checker->Add (v13, n13);
 
   243   checker->Add (v13, n13);
 
   241   if (n14 == "")
 
   244   if (n14 == "")
 
   242         {
 
   245     {
 
   243           return checker;
 
   246       return checker;
 
   244         }
 
   247     }
 
   245   checker->Add (v14, n14);
 
   248   checker->Add (v14, n14);
 
   246   if (n15 == "")
 
   249   if (n15 == "")
 
   247     {
 
   250     {
 
   248           return checker;
 
   251       return checker;
 
   249     }
 
   252     }
 
   250   checker->Add (v15, n15);
 
   253   checker->Add (v15, n15);
 
   251   if (n16 == "")
 
   254   if (n16 == "")
 
   252     {
 
   255     {
 
   253           return checker;
 
   256       return checker;
 
   254     }
 
   257     }
 
   255   checker->Add (v16, n16);
 
   258   checker->Add (v16, n16);
 
   256   if (n17 == "")
 
   259   if (n17 == "")
 
   257     {
 
   260     {
 
   258           return checker;
 
   261       return checker;
 
   259     }
 
   262     }
 
   260   checker->Add (v17, n17);
 
   263   checker->Add (v17, n17);
 
   261   if (n18 == "")
 
   264   if (n18 == "")
 
   262     {
 
   265     {
 
   263           return checker;
 
   266       return checker;
 
   264     }
 
   267     }
 
   265   checker->Add (v18, n18);
 
   268   checker->Add (v18, n18);
 
   266   if (n19 == "")
 
   269   if (n19 == "")
 
   267     {
 
   270     {
 
   268           return checker;
 
   271       return checker;
 
   269     }
 
   272     }
 
   270   checker->Add (v19, n19);
 
   273   checker->Add (v19, n19);
 
   271   if (n20 == "")
 
   274   if (n20 == "")
 
   272     {
 
   275     {
 
   273           return checker;
 
   276       return checker;
 
   274     }
 
   277     }
 
   275   checker->Add (v20, n20);
 
   278   checker->Add (v20, n20);
 
   276   if (n21 == "")
 
   279   if (n21 == "")
 
   277     {
 
   280     {
 
   278           return checker;
 
   281       return checker;
 
   279     }
 
   282     }
 
   280   checker->Add (v21, n21);
 
   283   checker->Add (v21, n21);
 
   281   if (n22 == "")
 
   284   if (n22 == "")
 
   282     {
 
   285     {
 
   283           return checker;
 
   286       return checker;
 
   284     }
 
   287     }
 
   285   checker->Add (v22, n22);
 
   288   checker->Add (v22, n22);
 
   286   return checker;
 
   289   return checker;
 
   287 }
 
   290 }
 
   288 
   291
ns-3.24