/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

 /*

  * Copyright (c) 2008 INRIA

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License version 2 as

  * published by the Free Software Foundation;

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program; if not, write to the Free Software

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  *

  * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>

  */

 #include "attribute-list.h"

 #include "string.h"

 #include "singleton.h"

 namespace ns3 {

 /*********************************************************************

  *         The AttributeList container implementation

  *********************************************************************/

 AttributeList::AttributeList ()

 {}

 AttributeList::AttributeList (const AttributeList &o)

 {

   for (Attrs::const_iterator i = o.m_attributes.begin (); i != o.m_attributes.end (); i++)

     {

       struct Attr attr;

       attr.checker = i->checker;

       attr.value = i->value->Copy ();

       m_attributes.push_back (attr);

     }

 }

 AttributeList &

 AttributeList::operator = (const AttributeList &o)

 {

   Reset ();

   for (Attrs::const_iterator i = o.m_attributes.begin (); i != o.m_attributes.end (); i++)

     {

       struct Attr attr;

       attr.checker = i->checker;

       attr.value = i->value->Copy ();

       m_attributes.push_back (attr);

     }

   return *this;

 }

 AttributeList::~AttributeList ()

 {

   Reset ();

 }

 void

 AttributeList::Set (std::string name, const AttributeValue &value)

 {

   struct TypeId::AttributeInfo info;

   bool ok = TypeId::LookupAttributeByFullName (name, &info);

   if (!ok)

     {

       NS_FATAL_ERROR ("Could not find attribute "<<name);

     }

   ok = DoSet (&info, value);

   if (!ok)

     {

       NS_FATAL_ERROR ("Could not set value for attribute "<<name);

     }

 }

 bool 

 AttributeList::SetFailSafe (std::string name, const AttributeValue &value)

 {

   struct TypeId::AttributeInfo info;

   bool ok = TypeId::LookupAttributeByFullName (name, &info);

   if (!ok)

     {

       return false;

     }

   ok = DoSet (&info, value);

   return ok;

 }

 void

 AttributeList::SetWithTid (TypeId tid, std::string name, const AttributeValue & value)

 {

   struct TypeId::AttributeInfo info;

   bool ok = tid.LookupAttributeByName (name, &info);

   if (!ok)

     {

       NS_FATAL_ERROR ("Could not find attribute "<<tid.GetName ()<<"::"<<name);

     }

   ok = DoSet (&info, value);

   if (!ok)

     {

       NS_FATAL_ERROR ("Could not set value for attribute "<<tid.GetName ()<<"::"<<name);

     }

 }

 void

 AttributeList::DoSetOne (Ptr<const AttributeChecker> checker, const AttributeValue &value)

 {

   // get rid of any previous value stored in this

   // vector of values.

   for (Attrs::iterator k = m_attributes.begin (); k != m_attributes.end (); k++)

     {

       if (k->checker == checker)

         {

           m_attributes.erase (k);

           break;

         }

     }

   // store the new value.

   struct Attr attr;

   attr.checker = checker;

   attr.value = value.Copy ();

   m_attributes.push_back (attr);

 }

 bool

 AttributeList::DoSet (struct TypeId::AttributeInfo *info, const AttributeValue &value)

 {

   if (info->checker == 0)

     {

       return false;

     }

   bool ok = info->checker->Check (value);

   if (ok)

     {

       DoSetOne (info->checker, value);

       return true;

     }

   // attempt to convert to string.

   const StringValue *str = dynamic_cast<const StringValue *> (&value);

   if (str == 0)

     {

       return false;

     }

   // attempt to convert back to value.

   Ptr<AttributeValue> v = info->checker->Create ();

   ok = v->DeserializeFromString (str->Get (), info->checker);

   if (!ok)

     {

       return false;

     }

   ok = info->checker->Check (*v);

   if (!ok)

     {

       return false;

     }

   DoSetOne (info->checker, *v);

   return true;

 }

 void 

 AttributeList::Reset (void)

 {

   m_attributes.clear ();

 }

 AttributeList *

 AttributeList::GetGlobal (void)

 {

   return Singleton<AttributeList>::Get ();

 }

 std::string

 AttributeList::LookupAttributeFullNameByChecker (Ptr<const AttributeChecker> checker) const

 {

   for (uint32_t i = 0; i < TypeId::GetRegisteredN (); i++)

     {

       TypeId tid = TypeId::GetRegistered (i);

       for (uint32_t j = 0; j < tid.GetAttributeN (); j++)

         {

           if (checker == tid.GetAttributeChecker (j))

             {

               return tid.GetAttributeFullName (j);

             }

         }

     }

   NS_FATAL_ERROR ("Could not find requested Accessor.");

   // quiet compiler.

   return "";

 }

 std::string 

 AttributeList::SerializeToString (void) const

 {

   std::ostringstream oss;

   for (Attrs::const_iterator i = m_attributes.begin (); i != m_attributes.end ();)

     {

       std::string name = LookupAttributeFullNameByChecker (i->checker);

       oss << name << "=" << i->value->SerializeToString (i->checker);

       i++;

       if (i != m_attributes.end ())

         {

           oss << "|";

         }

     }  

   return oss.str ();

 }

 bool 

 AttributeList::DeserializeFromString (std::string str)

 {

   Reset ();

   std::string::size_type cur;

   cur = 0;

   do {

     std::string::size_type equal = str.find ("=", cur);

     if (equal == std::string::npos)

       {

         NS_FATAL_ERROR ("Error while parsing serialized attribute: \"" << str << "\"");

         break;

       }

     else

       {

         std::string name = str.substr (cur, equal-cur);

         struct TypeId::AttributeInfo info;

         if (!TypeId::LookupAttributeByFullName (name, &info))

           {

             NS_FATAL_ERROR ("Error while parsing serialized attribute: name does not exist: \"" << name << "\"");

             break;

           }

         else

           {

             std::string::size_type next = str.find ("|", cur);

             std::string value;

             if (next == std::string::npos)

               {

                 value = str.substr (equal+1, str.size () - (equal+1));

                 cur = str.size ();

               }

             else

               {

                 value = str.substr (equal+1, next - (equal+1));

                 cur++;

               }

             Ptr<AttributeValue> val = info.checker->Create ();

             bool ok = val->DeserializeFromString (value, info.checker);

             if (!ok)

               {

                 NS_FATAL_ERROR ("Error while parsing serialized attribute: value invalid: \"" << value << "\"");

                 break;

               }

             else

               {

                 DoSetOne (info.checker, *val);

               }

           }

       }

   } while (cur != str.size ());

   return true;

 }

 } // namespace ns3