// Copyright 2005 The Trustees of Indiana University.

// Distributed under the Boost Software License, Version 1.0.

// (See accompanying file LICENSE_1_0.txt or copy at

// http://www.boost.org/LICENSE_1_0.txt)

//  Authors: Jeremiah Willcock

//           Douglas Gregor

//           Andrew Lumsdaine

// Indexed properties -- used for CSR and CSR-like graphs

#ifndef BOOST_GRAPH_INDEXED_PROPERTIES_HPP

#define BOOST_GRAPH_INDEXED_PROPERTIES_HPP

#include <vector>

#include <utility>

#include <algorithm>

#include <climits>

#include <iterator>

#include <boost/graph/graph_traits.hpp>

#include <boost/graph/properties.hpp>

#include <boost/iterator/counting_iterator.hpp>

#include <boost/integer.hpp>

#include <boost/iterator/iterator_facade.hpp>

#include <boost/mpl/if.hpp>

namespace boost {

namespace detail {

template<typename Derived, typename Property, typename Descriptor>

class indexed_vertex_properties

{

public:

  typedef no_property vertex_property_type;

  typedef Property vertex_bundled;

  // Directly access a vertex or edge bundle

  Property& operator[](Descriptor v)

  { return m_vertex_properties[get(vertex_index, derived(), v)]; }

  const Property& operator[](Descriptor v) const

  { return m_vertex_properties[get(vertex_index, derived(), v)]; }

protected:

  // Default-construct with no property values

  indexed_vertex_properties() {}

  // Initialize with n default-constructed property values

  indexed_vertex_properties(std::size_t n) : m_vertex_properties(n) { }

  // Resize the properties vector

  void resize(std::size_t n)

  {

    m_vertex_properties.resize(n);

  }

  // Reserve space in the vector of properties

  void reserve(std::size_t n)

  {

    m_vertex_properties.reserve(n);

  }

  // Add a new property value to the back

  void push_back(const Property& prop)

  {

    m_vertex_properties.push_back(prop);

  }

  // Access to the derived object

  Derived& derived() { return *static_cast<Derived*>(this); }

  const Derived& derived() const

  { return *static_cast<const Derived*>(this); }

public: // should be private, but friend templates not portable

  std::vector<Property> m_vertex_properties;

};

template<typename Derived, typename Descriptor>

class indexed_vertex_properties<Derived, void, Descriptor>

{

  struct secret {};

 public:

  typedef no_property vertex_property_type;

  typedef void vertex_bundled;

  secret operator[](secret) { return secret(); }

 protected:

  // All operations do nothing.

  indexed_vertex_properties() { }

  indexed_vertex_properties(std::size_t) { }

  void resize(std::size_t) { }

  void reserve(std::size_t) { }

};

template<typename Derived, typename Property, typename Descriptor>

class indexed_edge_properties

{

public:

  typedef no_property edge_property_type;

  typedef Property edge_bundled;

  typedef Property edge_push_back_type;

  // Directly access a edge or edge bundle

  Property& operator[](Descriptor v)

  { return m_edge_properties[get(edge_index, derived(), v)]; }

  const Property& operator[](Descriptor v) const

  { return m_edge_properties[get(edge_index, derived(), v)]; }

protected:

  // Default-construct with no property values

  indexed_edge_properties() {}

  // Initialize with n default-constructed property values

  indexed_edge_properties(std::size_t n) : m_edge_properties(n) { }

  // Resize the properties vector

  void resize(std::size_t n)

  {

    m_edge_properties.resize(n);

  }

  // Reserve space in the vector of properties

  void reserve(std::size_t n)

  {

    m_edge_properties.reserve(n);

  }

 public:

  // Add a new property value to the back

  void push_back(const Property& prop)

  {

    m_edge_properties.push_back(prop);

  }

 private:

  // Access to the derived object

  Derived& derived() { return *static_cast<Derived*>(this); }

  const Derived& derived() const

  { return *static_cast<const Derived*>(this); }

public: // should be private, but friend templates not portable

  std::vector<Property> m_edge_properties;

};

template<typename Derived, typename Descriptor>

class indexed_edge_properties<Derived, void, Descriptor>

{

  struct secret {};

 public:

  typedef no_property edge_property_type;

  typedef void edge_bundled;

  typedef void* edge_push_back_type;

  secret operator[](secret) { return secret(); }

 protected:

  // All operations do nothing.

  indexed_edge_properties() { }

  indexed_edge_properties(std::size_t) { }

  void resize(std::size_t) { }

  void reserve(std::size_t) { }

 public:

  void push_back(const edge_push_back_type&) { }

};

}

}

#endif // BOOST_GRAPH_INDEXED_PROPERTIES_HPP