Boost C++ Libraries Home Libraries People FAQ More
PrevUpHomeNext

Boost.Container Header Reference

Header <boost/container/adaptive_pool.hpp>
Header <boost/container/allocator.hpp>
Header <boost/container/allocator_traits.hpp>
Header <boost/container/batch_deque.hpp>
Header <boost/container/container_fwd.hpp>
Header <boost/container/deque.hpp>
Header <boost/container/devector.hpp>
Header <boost/container/flat_map.hpp>
Header <boost/container/flat_set.hpp>
Header <boost/container/list.hpp>
Header <boost/container/map.hpp>
Header <boost/container/new_allocator.hpp>
Header <boost/container/node_allocator.hpp>
Header <boost/container/options.hpp>
Header <boost/container/scoped_allocator.hpp>
Header <boost/container/scoped_allocator_fwd.hpp>
Header <boost/container/set.hpp>
Header <boost/container/slist.hpp>
Header <boost/container/small_vector.hpp>
Header <boost/container/stable_vector.hpp>
Header <boost/container/static_vector.hpp>
Header <boost/container/string.hpp>
Header <boost/container/throw_exception.hpp>
Header <boost/container/vector.hpp>

Header <boost/container/adaptive_pool.hpp>

namespace boost {
  namespace container {
    template<typename T, std::size_t NodesPerBlock = ADP_nodes_per_block, 
             std::size_t MaxFreeBlocks = ADP_max_free_blocks, 
             std::size_t OverheadPercent = ADP_overhead_percent> 
      class adaptive_pool;
  }
}

Header <boost/container/allocator.hpp>

This class is an extended STL-compatible that offers advanced allocation mechanism (in-place expansion, shrinking, burst-allocation...)

This allocator is a wrapper around a modified DLmalloc. 

namespace boost {
  namespace container {
    template<typename T> class allocator;
  }
}

Header <boost/container/allocator_traits.hpp>

namespace boost {
  namespace container {
    template<typename Allocator> struct allocator_traits;
  }
}

Header <boost/container/batch_deque.hpp>

namespace boost {
  namespace container {
    template<typename T, typename BatchDequePolicy = batch_deque_policy<512>, 
             typename Allocator = std::allocator<T> > 
      class batch_deque;

    template<std::size_t SegmentSize> struct batch_deque_policy;
    template<typename T, typename PX, typename AX, typename PY, typename AY> 
      bool operator==(const batch_deque< T, PX, AX > & x, 
                      const batch_deque< T, PY, AY > & y);
    template<typename T, typename PX, typename AX, typename PY, typename AY> 
      bool operator<(const batch_deque< T, PX, AX > & x, 
                     const batch_deque< T, PY, AY > & y);
    template<typename T, typename PX, typename AX, typename PY, typename AY> 
      bool operator!=(const batch_deque< T, PX, AX > & x, 
                      const batch_deque< T, PY, AY > & y);
    template<typename T, typename PX, typename AX, typename PY, typename AY> 
      bool operator>(const batch_deque< T, PX, AX > & x, 
                     const batch_deque< T, PY, AY > & y);
    template<typename T, typename PX, typename AX, typename PY, typename AY> 
      bool operator>=(const batch_deque< T, PX, AX > & x, 
                      const batch_deque< T, PY, AY > & y);
    template<typename T, typename PX, typename AX, typename PY, typename AY> 
      bool operator<=(const batch_deque< T, PX, AX > & x, 
                      const batch_deque< T, PY, AY > & y);
    template<typename T, typename P, typename Allocator> 
      void swap(batch_deque< T, P, Allocator > & x, 
                batch_deque< T, P, Allocator > & y);
  }
}

Header <boost/container/container_fwd.hpp>

This header file forward declares the following containers:

It forward declares the following allocators:

And finally it defines the following types 

namespace boost {
  namespace container {
    struct default_init_t;
    struct ordered_range_t;
    struct ordered_unique_range_t;

    enum tree_type_enum;
    typedef implementation_defined tree_assoc_defaults;

    static const ordered_range_t ordered_range;
    static const ordered_unique_range_t ordered_unique_range;
    static const default_init_t default_init;
  }
}

Header <boost/container/deque.hpp>

namespace boost {
  namespace container {
    template<typename T, typename Allocator = new_allocator<T> > class deque;
  }
}

Header <boost/container/devector.hpp>

namespace boost {
  namespace container {
    template<typename T, 
             typename SmallBufferPolicy = devector_small_buffer_policy<0>, 
             typename GrowthPolicy = devector_growth_policy, 
             typename Allocator = std::allocator<T> > 
      class devector;

    struct devector_growth_policy;
    template<unsigned Size> struct devector_small_buffer_policy;
    struct reserve_only_tag;
    struct unsafe_uninitialized_tag;
    template<typename T, typename AllocatorX, typename SBPX, typename GPX, 
             typename AllocatorY, typename SBPY, typename GPY> 
      bool operator==(const devector< T, AllocatorX, SBPX, GPX > & x, 
                      const devector< T, AllocatorY, SBPY, GPY > & y);
    template<typename T, typename AllocatorX, typename SBPX, typename GPX, 
             typename AllocatorY, typename SBPY, typename GPY> 
      bool operator<(const devector< T, AllocatorX, SBPX, GPX > & x, 
                     const devector< T, AllocatorY, SBPY, GPY > & y);
    template<typename T, typename AllocatorX, typename SBPX, typename GPX, 
             typename AllocatorY, typename SBPY, typename GPY> 
      bool operator!=(const devector< T, AllocatorX, SBPX, GPX > & x, 
                      const devector< T, AllocatorY, SBPY, GPY > & y);
    template<typename T, typename AllocatorX, typename SBPX, typename GPX, 
             typename AllocatorY, typename SBPY, typename GPY> 
      bool operator>(const devector< T, AllocatorX, SBPX, GPX > & x, 
                     const devector< T, AllocatorY, SBPY, GPY > & y);
    template<typename T, typename AllocatorX, typename SBPX, typename GPX, 
             typename AllocatorY, typename SBPY, typename GPY> 
      bool operator>=(const devector< T, AllocatorX, SBPX, GPX > & x, 
                      const devector< T, AllocatorY, SBPY, GPY > & y);
    template<typename T, typename AllocatorX, typename SBPX, typename GPX, 
             typename AllocatorY, typename SBPY, typename GPY> 
      bool operator<=(const devector< T, AllocatorX, SBPX, GPX > & x, 
                      const devector< T, AllocatorY, SBPY, GPY > & y);
    template<typename T, typename Allocator, typename SBP, typename GP> 
      void swap(devector< T, Allocator, SBP, GP > & x, 
                devector< T, Allocator, SBP, GP > & y);
  }
}

Header <boost/container/flat_map.hpp>

namespace boost {
  namespace container {
    template<typename Key, typename T, typename Compare = std::less<Key>, 
             typename Allocator = new_allocator< std::pair< Key, T> > > 
      class flat_map;
    template<typename Key, typename T, typename Compare = std::less<Key>, 
             typename Allocator = new_allocator< std::pair< Key, T> > > 
      class flat_multimap;
  }
}

Header <boost/container/flat_set.hpp>

namespace boost {
  namespace container {
    template<typename Key, typename Compare = std::less<Key>, 
             typename Allocator = new_allocator<Key> > 
      class flat_multiset;
    template<typename Key, typename Compare = std::less<Key>, 
             typename Allocator = new_allocator<Key> > 
      class flat_set;
  }
}

Header <boost/container/list.hpp>

namespace boost {
  namespace container {
    template<typename T, typename Allocator = new_allocator<T> > class list;
  }
}

Header <boost/container/map.hpp>

namespace boost {
  namespace container {
    template<typename Key, typename T, typename Compare = std::less<Key>, 
             typename Allocator = new_allocator< std::pair< const Key, T> >, 
             typename MapOptions = tree_assoc_defaults> 
      class map;
    template<typename Key, typename T, typename Compare = std::less<Key>, 
             typename Allocator = new_allocator< std::pair< const Key, T> >, 
             typename MultiMapOptions = tree_assoc_defaults> 
      class multimap;
  }
}

Header <boost/container/new_allocator.hpp>

namespace boost {
  namespace container {
    template<typename T> class new_allocator;

    template<> class new_allocator<void>;

    template<bool Value> struct new_allocator_bool;
  }
}

Header <boost/container/node_allocator.hpp>

namespace boost {
  namespace container {
    template<typename T, 
             std::size_t NodesPerBlock = NodeAlloc_nodes_per_block> 
      class node_allocator;
  }
}

Header <boost/container/options.hpp>

namespace boost {
  namespace container {
    template<bool Enabled> struct optimize_size;
    template<class... Options> struct tree_assoc_options;
    template<tree_type_enum TreeType> struct tree_type;
  }
}

Header <boost/container/scoped_allocator.hpp>

namespace boost {
  namespace container {
    template<typename T> struct constructible_with_allocator_prefix;
    template<typename T> struct constructible_with_allocator_suffix;

    template<typename OuterAlloc, typename... InnerAllocs> 
      class scoped_allocator_adaptor;

    template<bool ZeroInner> struct scoped_allocator_operator_equal;

    template<> struct scoped_allocator_operator_equal<true>;

    template<typename T, typename Allocator> struct uses_allocator;
    template<typename OuterA1, typename OuterA2, 
             BOOST_CONTAINER_SCOPEDALLOC_ALLINNERCLASS > 
      bool operator==(const scoped_allocator_adaptor< OuterA1, InnerAllocs...> & a, 
                      const scoped_allocator_adaptor< OuterA2, InnerAllocs...> & b);
    template<typename OuterA1, typename OuterA2, 
             BOOST_CONTAINER_SCOPEDALLOC_ALLINNERCLASS > 
      bool operator!=(const scoped_allocator_adaptor< OuterA1, InnerAllocs...> & a, 
                      const scoped_allocator_adaptor< OuterA2, InnerAllocs...> & b);
  }
}

Header <boost/container/scoped_allocator_fwd.hpp>

This header file forward declares boost::container::scoped_allocator_adaptor and defines the following types: 

namespace boost {
  namespace container {
    typedef const std::allocator_arg_t & allocator_arg_t;

    static allocator_arg_t allocator_arg;
  }
}

Header <boost/container/set.hpp>

namespace boost {
  namespace container {
    template<typename Key, typename Compare = std::less<Key>, 
             typename Allocator = new_allocator<Key>, 
             typename MultiSetOptions = tree_assoc_defaults> 
      class multiset;
    template<typename Key, typename Compare = std::less<Key>, 
             typename Allocator = new_allocator<Key>, 
             typename SetOptions = tree_assoc_defaults> 
      class set;
  }
}

Header <boost/container/slist.hpp>

namespace boost {
  namespace container {
    template<typename T, typename Allocator = new_allocator<T> > class slist;
  }
}

Header <boost/container/small_vector.hpp>

namespace boost {
  namespace container {
    template<typename T, std::size_t N, 
             typename Allocator = new_allocator<T> > 
      class small_vector;
    template<typename Allocator> class small_vector_allocator;
    template<typename T, typename SecondaryAllocator> class small_vector_base;
  }
}

Header <boost/container/stable_vector.hpp>

namespace boost {
  namespace container {
    template<typename T, typename Allocator = new_allocator<T> > 
      class stable_vector;
  }
}

Header <boost/container/static_vector.hpp>

namespace boost {
  namespace container {
    template<typename Value, std::size_t Capacity> class static_vector;
    template<typename V, std::size_t C1, std::size_t C2> 
      bool operator==(static_vector< V, C1 > const &, 
                      static_vector< V, C2 > const &);
    template<typename V, std::size_t C1, std::size_t C2> 
      bool operator!=(static_vector< V, C1 > const &, 
                      static_vector< V, C2 > const &);
    template<typename V, std::size_t C1, std::size_t C2> 
      bool operator<(static_vector< V, C1 > const &, 
                     static_vector< V, C2 > const &);
    template<typename V, std::size_t C1, std::size_t C2> 
      bool operator>(static_vector< V, C1 > const &, 
                     static_vector< V, C2 > const &);
    template<typename V, std::size_t C1, std::size_t C2> 
      bool operator<=(static_vector< V, C1 > const &, 
                      static_vector< V, C2 > const &);
    template<typename V, std::size_t C1, std::size_t C2> 
      bool operator>=(static_vector< V, C1 > const &, 
                      static_vector< V, C2 > const &);
    template<typename V, std::size_t C1, std::size_t C2> 
      void swap(static_vector< V, C1 > &, static_vector< V, C2 > &);
  }
}

Header <boost/container/string.hpp>

namespace boost {
  namespace container {
    template<typename CharT, typename Traits = std::char_traits<CharT>, 
             typename Allocator = new_allocator<CharT> > 
      class basic_string;
    typedef basic_string< char,std::char_traits< char >,new_allocator< char > > string;
    typedef basic_string< wchar_t,std::char_traits< wchar_t >,new_allocator< wchar_t > > wstring;
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string< CharT, Traits, Allocator > 
      operator+(const basic_string< CharT, Traits, Allocator > & x, 
                const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string< CharT, Traits, Allocator > 
      operator+(basic_string< CharT, Traits, Allocator > && x, 
                basic_string< CharT, Traits, Allocator > && y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string< CharT, Traits, Allocator > 
      operator+(basic_string< CharT, Traits, Allocator > && x, 
                const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string< CharT, Traits, Allocator > 
      operator+(const basic_string< CharT, Traits, Allocator > & x, 
                basic_string< CharT, Traits, Allocator > && y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string< CharT, Traits, Allocator > 
      operator+(const CharT * s, basic_string< CharT, Traits, Allocator > y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string< CharT, Traits, Allocator > 
      operator+(basic_string< CharT, Traits, Allocator > x, const CharT * s);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string< CharT, Traits, Allocator > 
      operator+(CharT c, basic_string< CharT, Traits, Allocator > y);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string< CharT, Traits, Allocator > 
      operator+(basic_string< CharT, Traits, Allocator > x, const CharT c);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator==(const basic_string< CharT, Traits, Allocator > & x, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator==(const CharT * s, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator==(const basic_string< CharT, Traits, Allocator > & x, 
                      const CharT * s);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator!=(const basic_string< CharT, Traits, Allocator > & x, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator!=(const CharT * s, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator!=(const basic_string< CharT, Traits, Allocator > & x, 
                      const CharT * s);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator<(const basic_string< CharT, Traits, Allocator > & x, 
                     const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator<(const CharT * s, 
                     const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator<(const basic_string< CharT, Traits, Allocator > & x, 
                     const CharT * s);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator>(const basic_string< CharT, Traits, Allocator > & x, 
                     const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator>(const CharT * s, 
                     const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator>(const basic_string< CharT, Traits, Allocator > & x, 
                     const CharT * s);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator<=(const basic_string< CharT, Traits, Allocator > & x, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator<=(const CharT * s, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator<=(const basic_string< CharT, Traits, Allocator > & x, 
                      const CharT * s);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator>=(const basic_string< CharT, Traits, Allocator > & x, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator>=(const CharT * s, 
                      const basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      bool operator>=(const basic_string< CharT, Traits, Allocator > & x, 
                      const CharT * s);
    template<typename CharT, typename Traits, typename Allocator> 
      void swap(basic_string< CharT, Traits, Allocator > & x, 
                basic_string< CharT, Traits, Allocator > & y);
    template<typename CharT, typename Traits, typename Allocator> 
      std::basic_ostream< CharT, Traits > & 
      operator<<(std::basic_ostream< CharT, Traits > & os, 
                 const basic_string< CharT, Traits, Allocator > & s);
    template<typename CharT, typename Traits, typename Allocator> 
      std::basic_istream< CharT, Traits > & 
      operator>>(std::basic_istream< CharT, Traits > & is, 
                 basic_string< CharT, Traits, Allocator > & s);
    template<typename CharT, typename Traits, typename Allocator> 
      std::basic_istream< CharT, Traits > & 
      getline(std::istream & is, basic_string< CharT, Traits, Allocator > & s, 
              CharT delim);
    template<typename CharT, typename Traits, typename Allocator> 
      std::basic_istream< CharT, Traits > & 
      getline(std::basic_istream< CharT, Traits > & is, 
              basic_string< CharT, Traits, Allocator > & s);
    template<typename Ch, typename Allocator> 
      std::size_t hash_value(basic_string< Ch, std::char_traits< Ch >, Allocator > const & v);
  }
}

Header <boost/container/throw_exception.hpp>

namespace boost {
  namespace container {
    void throw_bad_alloc();
    void throw_out_of_range(const char *);
    void throw_length_error(const char *);
    void throw_logic_error(const char *);
    void throw_runtime_error(const char *);
  }
}

Header <boost/container/vector.hpp>

namespace boost {
  namespace container {
    template<typename T, typename Allocator = new_allocator<T> > class vector;
  }
}
Copyright © 2009-2013 Ion Gaztanaga

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)

PrevUpHomeNext