name.h

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
/*
 * Copyright (c) 2013, Regents of the University of California
 *                     Alexander Afanasyev
 *                     Zhenkai Zhu
 *
 * BSD license, See the LICENSE file for more information
 *
 * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
 *         Zhenkai Zhu <zhenkai@cs.ucla.edu>
 */

#ifndef NDN_NAME_H
#define NDN_NAME_H

#include "ns3/ndn-common.h"
#include "ns3/simple-ref-count.h"
#include "ns3/attribute.h"
#include "ns3/attribute-helper.h"

#include "name-component.h"

NDN_NAMESPACE_BEGIN

class Name : public SimpleRefCount<Name>
{
public:
  typedef std::vector<name::Component>::iterator iterator;
  typedef std::vector<name::Component>::const_iterator const_iterator;
  typedef std::vector<name::Component>::reverse_iterator reverse_iterator;
  typedef std::vector<name::Component>::const_reverse_iterator const_reverse_iterator;
  typedef std::vector<name::Component>::reference reference;
  typedef std::vector<name::Component>::const_reference const_reference;

  typedef name::Component partial_type;
  
  //                              CONSTRUCTORS                                 //

  Name ();

  Name (const Name &other);

  Name (const std::string &url);

  template<class Iterator>
  Name (Iterator begin, Iterator end);

  Name &
  operator= (const Name &other);


  //                                SETTERS                                    //

  inline Name &
  append (const name::Component &comp);

  inline Name &
  appendBySwap (name::Component &comp);
  
  template<class Iterator>
  inline Name &
  append (Iterator begin, Iterator end);

  inline Name &
  append (const Name &comp);

  inline Name &
  append (const std::string &compStr);

  inline Name &
  append (const void *buf, size_t size);

  inline Name &
  appendNumber (uint64_t number);

  inline Name &
  appendNumberWithMarker (uint64_t number, unsigned char marker);

  inline Name &
  appendSeqNum (uint64_t seqno);

  inline Name &
  appendControlNum (uint64_t control);

  inline Name &
  appendBlkId (uint64_t blkid);

  Name &
  appendVersion (uint64_t version = Name::nversion);

  //                                GETTERS                                    //

  inline size_t
  size () const;

  const name::Component &
  get (int index) const;

  name::Component &
  get (int index);

  inline Name::const_iterator
  begin () const;           

  inline Name::iterator
  begin ();                 

  inline Name::const_iterator
  end () const;             

  inline Name::iterator
  end ();                   

  inline Name::const_reverse_iterator
  rbegin () const;          

  inline Name::reverse_iterator
  rbegin ();                

  inline Name::const_reverse_iterator
  rend () const;            

  inline Name::reverse_iterator
  rend ();                  



  Name
  getSubName (size_t pos = 0, size_t len = npos) const;

  inline Name
  getPrefix (size_t len, size_t skip = 0) const;

  inline Name
  getPostfix (size_t len, size_t skip = 0) const;

  std::string
  toUri () const;

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

  // Helpers and compatibility wrappers

  int
  compare (const Name &name) const;

  inline bool
  operator == (const Name &name) const;

  inline bool
  operator != (const Name &name) const;

  inline bool
  operator <= (const Name &name) const;

  inline bool
  operator < (const Name &name) const;

  inline bool
  operator >= (const Name &name) const;

  inline bool
  operator > (const Name &name) const;

  inline name::Component &
  operator [] (int index);

  inline const name::Component &
  operator [] (int index) const;

  Name
  operator + (const Name &name) const;

  template<class T>
  inline void
  push_back (const T &comp);

public:
  // Data Members (public):
  const static size_t npos = static_cast<size_t> (-1);
  const static uint64_t nversion = static_cast<uint64_t> (-1);

private:
  std::vector<name::Component> m_comps;
};

inline std::ostream &
operator << (std::ostream &os, const Name &name)
{
  name.toUri (os);
  return os;
}

inline std::istream &
operator >> (std::istream &is, Name &name)
{
  std::string line;
  is >> line;
  name = Name (line);

  return is;
}

// Definition of inline methods

template<class Iterator>
Name::Name (Iterator begin, Iterator end)
{
  append (begin, end);
}

inline Name &
Name::append (const name::Component &comp)
{
  if (comp.size () != 0)
    m_comps.push_back (comp);
  return *this;
}

inline Name &
Name::appendBySwap (name::Component &comp)
{
  if (comp.size () != 0)
    {
      Name::iterator newComp = m_comps.insert (end (), name::Component ());
      newComp->swap (comp);
    }
  return *this;
}

template<class Iterator>
inline Name &
Name::append (Iterator begin, Iterator end)
{
  for (Iterator i = begin; i != end; i++)
    {
      append (*i);
    }
  return *this;
}

Name &
Name::append (const Name &comp)
{
  if (this == &comp)
    {
      // have to double-copy if the object is self, otherwise results very frustrating (because we use vector...)
      return append (Name (comp.begin (), comp.end ()));
    }
  return append (comp.begin (), comp.end ());
}

Name &
Name::append (const std::string &compStr)
{
  name::Component comp (compStr);
  return appendBySwap (comp);
}

Name &
Name::append (const void *buf, size_t size)
{
  name::Component comp (buf, size);
  return appendBySwap (comp);
}

Name &
Name::appendNumber (uint64_t number)
{
  name::Component comp;
  return appendBySwap (comp.fromNumber (number));
}

Name &
Name::appendNumberWithMarker (uint64_t number, unsigned char marker)
{
  name::Component comp;
  return appendBySwap (comp.fromNumberWithMarker (number, marker));
}

inline Name &
Name::appendSeqNum (uint64_t seqno)
{
  return appendNumberWithMarker (seqno, 0x00);
}

inline Name &
Name::appendControlNum (uint64_t control)
{
  return appendNumberWithMarker (control, 0xC1);
}

inline Name &
Name::appendBlkId (uint64_t blkid)
{
  return appendNumberWithMarker (blkid, 0xFB);
}

inline size_t
Name::size () const
{
  return m_comps.size ();
}

inline Name::const_iterator
Name::begin () const
{
  return m_comps.begin ();
}

inline Name::iterator
Name::begin ()
{
  return m_comps.begin ();
}

inline Name::const_iterator
Name::end () const
{
  return m_comps.end ();
}

inline Name::iterator
Name::end ()
{
  return m_comps.end ();
}

inline Name::const_reverse_iterator
Name::rbegin () const
{
  return m_comps.rbegin ();
}

inline Name::reverse_iterator
Name::rbegin ()
{
  return m_comps.rbegin ();
}

inline Name::const_reverse_iterator
Name::rend () const
{
  return m_comps.rend ();
}


inline Name::reverse_iterator
Name::rend ()
{
  return m_comps.rend ();
}




inline Name
Name::getPrefix (size_t len, size_t skip/* = 0*/) const
{
  return getSubName (skip, len);
}

inline Name
Name::getPostfix (size_t len, size_t skip/* = 0*/) const
{
  return getSubName (size () - len - skip, len);
}


template<class T>
inline void
Name::push_back (const T &comp)
{
  append (comp);
}

inline bool
Name::operator ==(const Name &name) const
{
  return (compare (name) == 0);
}

inline bool
Name::operator !=(const Name &name) const
{
  return (compare (name) != 0);
}

inline bool
Name::operator <= (const Name &name) const
{
  return (compare (name) <= 0);
}

inline bool
Name::operator < (const Name &name) const
{
  return (compare (name) < 0);
}

inline bool
Name::operator >= (const Name &name) const
{
  return (compare (name) >= 0);
}

inline bool
Name::operator > (const Name &name) const
{
  return (compare (name) > 0);
}

inline name::Component &
Name::operator [] (int index)
{
  return get (index);
}

inline const name::Component &
Name::operator [] (int index) const
{
  return get (index);
}

ATTRIBUTE_HELPER_HEADER (Name);

NDN_NAMESPACE_END

#endif