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

/*

 * Copyright (c) 2016 University of Washington

 *

 * 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: Tom Henderson <tomhend@u.washington.edu>

 */

//

// Simple example showing how to add a vector of Ipv4Address and Ipv6Address

// instances to an attribute

//

#include "ns3/object.h"

#include "ns3/string.h"

#include "ns3/config.h"

#include "ns3/address-utils.h"

using namespace ns3;

class SampleIpAddressVectorClass : public Object

{

public:

  static TypeId GetTypeId (void);

  virtual TypeId GetInstanceTypeId (void) const;

  void Print (std::ostream &os) const;

private:

  static Ipv4AddressVector GetDefaultIpv4Vector (void);

  static Ipv6AddressVector GetDefaultIpv6Vector (void);

  Ipv4AddressVector m_vector4;

  Ipv4AddressVector m_vector4_1;

  Ipv6AddressVector m_vector6;

  Ipv6AddressVector m_vector6_1;

};

TypeId 

SampleIpAddressVectorClass::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::SampleIpAddressVectorClass")

    .SetParent<Object> ()

    .AddConstructor<SampleIpAddressVectorClass> ()

    .AddAttribute ("Ipv4Addresses",

                   "Ipv4 addresses",

                   Ipv4AddressVectorValue (SampleIpAddressVectorClass::GetDefaultIpv4Vector ()),

                   MakeIpv4AddressVectorAccessor (&SampleIpAddressVectorClass::m_vector4),

                   MakeIpv4AddressVectorChecker ())

    // Another way to configure the default value is with a StringValue

    .AddAttribute ("Ipv4Addresses2",

                   "Ipv4 addresses",

                   StringValue ("127.0.0.1,127.0.1.1"),

                   MakeIpv4AddressVectorAccessor (&SampleIpAddressVectorClass::m_vector4_1),

                   MakeIpv4AddressVectorChecker ())

    .AddAttribute ("Ipv6Addresses",

                   "Ipv6 addresses",

                   Ipv6AddressVectorValue (SampleIpAddressVectorClass::GetDefaultIpv6Vector ()),

                   MakeIpv6AddressVectorAccessor (&SampleIpAddressVectorClass::m_vector6),

                   MakeIpv6AddressVectorChecker ())

    .AddAttribute ("Ipv6Addresses2",

                   "Ipv6 addresses",

                   StringValue ("2001:DB8::1,2001:DB8::2"),

                   MakeIpv6AddressVectorAccessor (&SampleIpAddressVectorClass::m_vector6_1),

                   MakeIpv6AddressVectorChecker ())

  ;

  return tid;

}

TypeId 

SampleIpAddressVectorClass::GetInstanceTypeId (void) const

{

  return GetTypeId ();

}

void 

SampleIpAddressVectorClass::Print (std::ostream &os) const

{

  for (std::vector<Ipv4Address>::const_iterator it = m_vector4.begin (); 

       it != m_vector4.end (); )

    {

      it->Print (os);

      if (++it != m_vector4.end ())

        {

          os << ",";

        }

      else

        {

          break;

        }

    }

  os << std::endl;

  for (std::vector<Ipv6Address>::const_iterator it = m_vector6.begin (); 

       it != m_vector6.end (); )

    {

      it->Print (os);

      if (++it != m_vector6.end ())

        {

          os << ",";

        }

      else

        {

          break;

        }

    }

}

Ipv4AddressVector

SampleIpAddressVectorClass::GetDefaultIpv4Vector (void)

{

  Ipv4AddressVector v;

  v.push_back (Ipv4Address ("0.0.0.0"));

  return v;

}

Ipv6AddressVector

SampleIpAddressVectorClass::GetDefaultIpv6Vector (void)

{

  Ipv6AddressVector v;

  v.push_back (Ipv6Address ("::"));

  return v;

}

int main (int argc, char *argv[])

{

  Ptr<SampleIpAddressVectorClass> t = CreateObject<SampleIpAddressVectorClass> ();

  // Print out defaults 

  t->Print (std::cout); 

  std::cout << std::endl;

  Config::SetDefault ("ns3::SampleIpAddressVectorClass::Ipv4Addresses", StringValue ("192.0.2.1,192.0.2.2"));

  Config::SetDefault ("ns3::SampleIpAddressVectorClass::Ipv6Addresses", StringValue ("2001:DB8:A::1,2001:DB8:A::2"));

  Ptr<SampleIpAddressVectorClass> t2 = CreateObject<SampleIpAddressVectorClass> ();

  // Print out new defaults

  t2->Print (std::cout);

  std::cout << std::endl;

  // Modify the attribute values

  Ipv4AddressVector v;

  v.push_back (Ipv4Address ("203.0.113.1"));

  v.push_back (Ipv4Address ("203.0.113.2"));

  v.push_back (Ipv4Address ("203.0.113.3"));

  t->SetAttribute ("Ipv4Addresses", Ipv4AddressVectorValue (v));

  Ipv6AddressVector v6;

  v6.push_back (Ipv6Address ("2001:DB8:C::1"));

  v6.push_back (Ipv6Address ("2001:DB8:C::101"));

  t->SetAttribute ("Ipv6Addresses", Ipv6AddressVectorValue (v6));

  // Print out modified

  t->Print (std::cout); 

  std::cout << std::endl;

  return 0;

}

    obj = bld.create_ns3_program('ip-address-vector-example', ['network'])

    obj.source = 'ip-address-vector-example.cc'

ATTRIBUTE_HELPER_CPP (Ipv4AddressVector);

std::ostream &

operator << (std::ostream &os, const Ipv4AddressVector &ipv4AddressVector)

{

  for (uint32_t i = 0; i < ipv4AddressVector.size (); i++)

    {

      os << ipv4AddressVector[i];

      if (i < (ipv4AddressVector.size () - 1))

        {

          os << ",";

        }

    }

  return os;

}

std::istream &

operator >> (std::istream &is, Ipv4AddressVector &ipv4AddressVector)

{

  char delim = ',';

  std::string addressStr;

  is >> addressStr;

  std::vector<std::string> addrs;

  // parse input stream for addresses

  for (size_t p=0, q=0; p != addressStr.npos; p = q)

    {

      addrs.push_back (addressStr.substr (p + (p != 0), (q = addressStr.find (delim, p+1)) - p - (p != 0)));

    }

  if (addrs.size () > 0)

    {

      ipv4AddressVector.clear ();

      ipv4AddressVector.resize (addrs.size ());

      for (uint32_t i = 0; i < addrs.size (); i++)

        {

          ipv4AddressVector[i] = Ipv4Address (addrs[i].c_str ());

        }

    }

  else

    {

      is.setstate (std::ios_base::failbit);

    }

  return is;

}

ATTRIBUTE_HELPER_CPP (Ipv6AddressVector);

std::ostream &

operator << (std::ostream &os, const Ipv6AddressVector &ipv6AddressVector)

{

  for (uint32_t i = 0; i < ipv6AddressVector.size (); i++)

    {

      os << ipv6AddressVector[i];

      if (i < (ipv6AddressVector.size () - 1))

        {

          os << ",";

        }

    }

  return os;

}

std::istream &

operator >> (std::istream &is, Ipv6AddressVector &ipv6AddressVector)

{

  char delim = ',';

  std::string addressStr;

  is >> addressStr;

  std::vector<std::string> addrs;

  // parse input stream for addresses

  for (size_t p=0, q=0; p != addressStr.npos; p = q)

    {

      addrs.push_back (addressStr.substr (p + (p != 0), (q = addressStr.find (delim, p+1)) - p - (p != 0)));

    }

  if (addrs.size () > 0)

    {

      ipv6AddressVector.clear ();

      ipv6AddressVector.resize (addrs.size ());

      for (uint32_t i = 0; i < addrs.size (); i++)

        {

          ipv6AddressVector[i] = Ipv6Address (addrs[i].c_str ());

        }

    }

  else

    {

      is.setstate (std::ios_base::failbit);

    }

  return is;

}

typedef std::vector<Ipv4Address> Ipv4AddressVector;

std::ostream &operator << (std::ostream &os, const Ipv4AddressVector &ipv4AddressVector);

std::istream &operator >> (std::istream &is, Ipv4AddressVector &ipv4AddressVector);

ATTRIBUTE_HELPER_HEADER (Ipv4AddressVector);

typedef std::vector<Ipv6Address> Ipv6AddressVector;

std::ostream &operator << (std::ostream &os, const Ipv6AddressVector &ipv6AddressVector);

std::istream &operator >> (std::istream &is, Ipv6AddressVector &ipv6AddressVector);

ATTRIBUTE_HELPER_HEADER (Ipv6AddressVector);