cet::map_vector< Value > Class Template Reference

#include <map_vector.h>

Public Types
using	key_type = map_vector_key
using	mapped_type = Value
using	value_type = std::pair< key_type, mapped_type >
using	impl_type = std::vector< value_type >
using	size_type = typename impl_type::size_type
using	difference_type = typename impl_type::difference_type
using	iterator = typename impl_type::iterator
using	const_iterator = typename impl_type::const_iterator
using	reverse_iterator = typename impl_type::reverse_iterator
using	const_reverse_iterator = typename impl_type::const_reverse_iterator
using	allocator_type = typename impl_type::allocator_type
using	pointer = typename allocator_type::pointer
using	const_pointer = typename allocator_type::const_pointer
using	reference = typename allocator_type::reference
using	const_reference = typename allocator_type::const_reference

Public Member Functions
	map_vector ()=default
template<class InIter >
	map_vector (InIter const b, InIter const e)
bool	empty () const noexcept
size_type	size () const noexcept
size_type	max_size () const noexcept
size_type	capacity () const noexcept
allocator_type	get_allocator () const noexcept
value_type const &	front () const
value_type const &	back () const
size_t	delta () const
bool	has (key_type key) const
iterator	find (key_type key)
const_iterator	find (key_type key) const
const_iterator	findOrThrow (key_type key) const
mapped_type *	getOrNull (key_type key)
mapped_type const *	getOrNull (key_type key) const
mapped_type &	getOrThrow (key_type key)
mapped_type const &	getOrThrow (key_type key) const
mapped_type &	operator[] (key_type key)
mapped_type const &	operator[] (key_type key) const
mapped_type const &	at (key_type key) const
iterator	begin () noexcept
const_iterator	begin () const noexcept
iterator	end () noexcept
const_iterator	end () const noexcept
reverse_iterator	rbegin () noexcept
const_reverse_iterator	rbegin () const noexcept
reverse_iterator	rend () noexcept
const_reverse_iterator	rend () const noexcept
const_iterator	cbegin () const noexcept
const_iterator	cend () const noexcept
const_reverse_iterator	crbegin () const
const_reverse_iterator	crend () const noexcept
void	clear () noexcept
void	reserve (size_type const n)
void	swap (map_vector< mapped_type > &other)
std::pair< iterator, bool >	insert (value_type const &x)
template<class InIter >
void	insert (InIter b, InIter e)
template<class InIter >
void	append (InIter b, InIter e)

Static Public Member Functions
static short	Class_Version ()

Private Member Functions
bool	class_invariant () const

Static Private Member Functions
static bool	lt (value_type const &, value_type const &) noexcept
static bool	eq (value_type const &, value_type const &) noexcept

Private Attributes
impl_type	v_ {}

Detailed Description

template<class Value>
class cet::map_vector< Value >

Definition at line 29 of file map_vector.h.

Member Typedef Documentation

template<class Value>

using cet::map_vector< Value >::allocator_type = typename impl_type::allocator_type

Definition at line 100 of file map_vector.h.

template<class Value>

using cet::map_vector< Value >::const_iterator = typename impl_type::const_iterator

Definition at line 96 of file map_vector.h.

template<class Value>

using cet::map_vector< Value >::const_pointer = typename allocator_type::const_pointer

Definition at line 102 of file map_vector.h.

template<class Value>

using cet::map_vector< Value >::const_reference = typename allocator_type::const_reference

Definition at line 104 of file map_vector.h.

template<class Value>

using cet::map_vector< Value >::const_reverse_iterator = typename impl_type::const_reverse_iterator

Definition at line 98 of file map_vector.h.

template<class Value>

using cet::map_vector< Value >::difference_type = typename impl_type::difference_type

Definition at line 93 of file map_vector.h.

template<class Value>

using cet::map_vector< Value >::impl_type = std::vector<value_type>

Definition at line 90 of file map_vector.h.

template<class Value>

using cet::map_vector< Value >::iterator = typename impl_type::iterator

Definition at line 95 of file map_vector.h.

template<class Value>

using cet::map_vector< Value >::key_type = map_vector_key

Definition at line 87 of file map_vector.h.

template<class Value>

using cet::map_vector< Value >::mapped_type = Value

Definition at line 88 of file map_vector.h.

template<class Value>

using cet::map_vector< Value >::pointer = typename allocator_type::pointer

Definition at line 101 of file map_vector.h.

template<class Value>

using cet::map_vector< Value >::reference = typename allocator_type::reference

Definition at line 103 of file map_vector.h.

template<class Value>

using cet::map_vector< Value >::reverse_iterator = typename impl_type::reverse_iterator

Definition at line 97 of file map_vector.h.

template<class Value>

using cet::map_vector< Value >::size_type = typename impl_type::size_type

Definition at line 92 of file map_vector.h.

template<class Value>

using cet::map_vector< Value >::value_type = std::pair<key_type, mapped_type>

Definition at line 89 of file map_vector.h.

Constructor & Destructor Documentation

template<class Value>

cet::map_vector< Value >::map_vector ( )

default

template<class Value>

template<class InIter >

cet::map_vector< Value >::map_vector ( InIter const  b, InIter const  e  )

inline

Definition at line 110 of file map_vector.h.

  {
    insert(b, e);
  }

Member Function Documentation

template<class Value >

template<class InIter >

void cet::map_vector< Value >::append	(	InIter	b,
		InIter	e
	)

Definition at line 499 of file map_vector.h.

{
  std::for_each(b, e, [](auto const& pr) { return pr.first.ensure_valid(); });
  v_.insert(v_.cend(), b, e);
  assert(class_invariant());
}

template<class Value>

mapped_type const& cet::map_vector< Value >::at ( key_type  key ) const

inline

Definition at line 172 of file map_vector.h.

  {
    return getOrThrow(key);
  }

template<class Value >

cet::map_vector< Value >::value_type const & cet::map_vector< Value >::back

(

)

const

Definition at line 364 of file map_vector.h.

{
  if (v_.empty())
    throw cet::exception("map_vector::back") << "container is empty!\n";
  return v_.back();
}

template<class Value>

iterator cet::map_vector< Value >::begin ( )

inlinenoexcept

Definition at line 179 of file map_vector.h.

  {
    return v_.begin();
  }

template<class Value>

const_iterator cet::map_vector< Value >::begin ( ) const

inlinenoexcept

Definition at line 184 of file map_vector.h.

  {
    return v_.begin();
  }

template<class Value>

size_type cet::map_vector< Value >::capacity ( ) const

inlinenoexcept

Definition at line 134 of file map_vector.h.

  {
    return v_.capacity();
  }

template<class Value>

const_iterator cet::map_vector< Value >::cbegin ( ) const

inlinenoexcept

Definition at line 223 of file map_vector.h.

  {
    return v_.cbegin();
  }

template<class Value>

const_iterator cet::map_vector< Value >::cend ( ) const

inlinenoexcept

Definition at line 228 of file map_vector.h.

  {
    return v_.cend();
  }

template<class Value >

bool cet::map_vector< Value >::class_invariant ( ) const

private

Definition at line 511 of file map_vector.h.

{
  return std::is_sorted(v_.begin(), v_.end(), lt);
}

template<class Value>

static short cet::map_vector< Value >::Class_Version ( )

inlinestatic

Definition at line 281 of file map_vector.h.

  {
    return 10;
  }

template<class Value>

void cet::map_vector< Value >::clear ( )

inlinenoexcept

Definition at line 245 of file map_vector.h.

  {
    v_.clear();
  }

template<class Value>

const_reverse_iterator cet::map_vector< Value >::crbegin ( ) const

inline

Definition at line 233 of file map_vector.h.

  {
    return v_.crbegin();
  }

template<class Value>

const_reverse_iterator cet::map_vector< Value >::crend ( ) const

inlinenoexcept

Definition at line 238 of file map_vector.h.

  {
    return v_.crend();
  }

template<class Value>

size_t cet::map_vector< Value >::delta ( ) const

inline

Definition at line 152 of file map_vector.h.

  {
    return v_.empty() ? 0 : 1 + v_.back().first.asInt();
  }

template<class Value>

bool cet::map_vector< Value >::empty ( ) const

inlinenoexcept

Definition at line 119 of file map_vector.h.

  {
    return v_.empty();
  }

template<class Value>

iterator cet::map_vector< Value >::end ( )

inlinenoexcept

Definition at line 190 of file map_vector.h.

  {
    return v_.end();
  }

template<class Value>

const_iterator cet::map_vector< Value >::end ( ) const

inlinenoexcept

Definition at line 195 of file map_vector.h.

  {
    return v_.end();
  }

template<class Value >

bool cet::map_vector< Value >::eq ( value_type const &  v1, value_type const &  v2  )

staticprivatenoexcept

Definition at line 527 of file map_vector.h.

{
  return v1.first == v2.first;
}

template<class Value >

cet::map_vector< Value >::iterator cet::map_vector< Value >::find

(

key_type

key

)

Definition at line 381 of file map_vector.h.

{
  value_type const v{key, mapped_type{}};
  auto const begin = v_.begin(), end = v_.end();
  auto it = std::lower_bound(begin, end, v, lt);
  if (it != end && it->first != key)
    it = end;
  return it;
}

template<class Value >

cet::map_vector< Value >::const_iterator cet::map_vector< Value >::find

(

key_type

key

)

const

Definition at line 393 of file map_vector.h.

{
  value_type const v{key, mapped_type{}};
  auto const begin = v_.cbegin(), end = v_.cend();
  auto it = std::lower_bound(begin, end, v, lt);
  if (it != end && it->first != key)
    it = end;
  return it;
}

template<class Value >

cet::map_vector< Value >::const_iterator cet::map_vector< Value >::findOrThrow

(

key_type

key

)

const

Definition at line 405 of file map_vector.h.

{
  auto p = find(key);
  if (p == v_.cend())
    throw cet::exception("map_vector::getOrThrow")
      << "out of range (no such key): " << key.asInt() << std::endl;

  return p;
}

template<class Value >

cet::map_vector< Value >::value_type const & cet::map_vector< Value >::front

(

)

const

Definition at line 355 of file map_vector.h.

{
  if (v_.empty())
    throw cet::exception("map_vector::front") << "container is empty!\n";
  return v_.front();
}

template<class Value>

allocator_type cet::map_vector< Value >::get_allocator ( ) const

inlinenoexcept

Definition at line 140 of file map_vector.h.

  {
    return v_.get_allocator();
  }

template<class Value >

Value * cet::map_vector< Value >::getOrNull

(

key_type

key

)

Definition at line 417 of file map_vector.h.

{
  auto it = find(key);
  return it == v_.end() ? nullptr : &it->second;
}

template<class Value >

Value const * cet::map_vector< Value >::getOrNull

(

key_type

key

)

const

Definition at line 425 of file map_vector.h.

{
  auto it = find(key);
  return it == v_.cend() ? nullptr : &it->second;
}

template<class Value >

Value & cet::map_vector< Value >::getOrThrow

(

key_type

key

)

Definition at line 433 of file map_vector.h.

{
  auto* p = getOrNull(key);
  if (p == nullptr)
    throw cet::exception("map_vector::getOrThrow")
      << "out of range (no such key): " << key.asInt() << std::endl;

  return *p;
}

template<class Value >

Value const & cet::map_vector< Value >::getOrThrow

(

key_type

key

)

const

Definition at line 445 of file map_vector.h.

{
  auto const* p = getOrNull(key);
  if (p == nullptr)
    throw cet::exception("map_vector::getOrThrow")
      << "out of range (no such key): " << key.asInt() << std::endl;

  return *p;
}

template<class Value >

bool cet::map_vector< Value >::has

(

key_type

key

)

const

Definition at line 373 of file map_vector.h.

{
  value_type const v{key, mapped_type{}};
  return std::binary_search(v_.begin(), v_.end(), v, lt);
}

template<class Value >

std::pair< typename cet::map_vector< Value >::iterator, bool > cet::map_vector< Value >::insert

(

value_type const &

x

)

Definition at line 471 of file map_vector.h.

{
  v.first.ensure_valid();
  auto const begin = v_.begin(), end = v_.end();
  auto it = std::lower_bound(begin, end, v, lt);
  if (it == end || it->first != v.first)
    return std::make_pair(v_.insert(it, v), true);
  return std::make_pair(it, false);
}

template<class Value >

template<class InIter >

void cet::map_vector< Value >::insert	(	InIter	b,
		InIter	e
	)

Definition at line 484 of file map_vector.h.

{
  std::for_each(b, e, [](auto const& pr) { return pr.first.ensure_valid(); });
  impl_type result;
  result.reserve(size() + std::distance(b, e));
  std::merge(v_.cbegin(), v_.cend(), b, e, back_inserter(result), lt);
  auto new_end = std::unique(result.begin(), result.end(), eq);
  result.erase(new_end, result.end());
  result.shrink_to_fit();
  v_.swap(result);
}

template<class Value >

bool cet::map_vector< Value >::lt ( value_type const &  v1, value_type const &  v2  )

staticprivatenoexcept

Definition at line 520 of file map_vector.h.

{
  return v1.first < v2.first;
}

template<class Value>

size_type cet::map_vector< Value >::max_size ( ) const

inlinenoexcept

Definition at line 129 of file map_vector.h.

  {
    return v_.max_size();
  }

template<class Value >

Value & cet::map_vector< Value >::operator[]

(

key_type

key

)

Definition at line 456 of file map_vector.h.

{
  value_type const v{key, mapped_type{}};
  auto const begin = v_.begin(), end = v_.end();
  auto it = std::lower_bound(begin, end, v, lt);
  if (it == end || it->first != key)
    it = v_.insert(it, std::move(v));
  return it->second;
}

template<class Value>

mapped_type const& cet::map_vector< Value >::operator[] ( key_type  key ) const

inline

Definition at line 170 of file map_vector.h.

{ return getOrThrow(key); }

template<class Value>

reverse_iterator cet::map_vector< Value >::rbegin ( )

inlinenoexcept

Definition at line 201 of file map_vector.h.

  {
    return v_.rbegin();
  }

template<class Value>

const_reverse_iterator cet::map_vector< Value >::rbegin ( ) const

inlinenoexcept

Definition at line 206 of file map_vector.h.

  {
    return v_.rbegin();
  }

template<class Value>

reverse_iterator cet::map_vector< Value >::rend ( )

inlinenoexcept

Definition at line 212 of file map_vector.h.

  {
    return v_.rend();
  }

template<class Value>

const_reverse_iterator cet::map_vector< Value >::rend ( ) const

inlinenoexcept

Definition at line 217 of file map_vector.h.

  {
    return v_.rend();
  }

template<class Value>

void cet::map_vector< Value >::reserve ( size_type const  n )

inline

Definition at line 251 of file map_vector.h.

  {
    v_.reserve(n);
  }

template<class Value>

size_type cet::map_vector< Value >::size ( ) const

inlinenoexcept

Definition at line 124 of file map_vector.h.

  {
    return v_.size();
  }

template<class Value>

void cet::map_vector< Value >::swap ( map_vector< mapped_type > &  other )

inline

Definition at line 257 of file map_vector.h.

  {
    v_.swap(other.v_);
  }

Member Data Documentation

template<class Value>

impl_type cet::map_vector< Value >::v_ {}

private

Definition at line 287 of file map_vector.h.

---

The documentation for this class was generated from the following file:

• cetlib/cetlib/map_vector.h