Subversion Repositories altor32

// -*- C++ -*-

// Copyright (C) 2005, 2006, 2008, 2009, 2010, 2011

// Free Software Foundation, Inc.

//

// This file is part of the GNU ISO C++ Library.  This library is free

// software; you can redistribute it and/or modify it under the terms

// of the GNU General Public License as published by the Free Software

// Foundation; either version 3, or (at your option) any later

// version.

// This library 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.

// Under Section 7 of GPL version 3, you are granted additional

// permissions described in the GCC Runtime Library Exception, version

// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and

// a copy of the GCC Runtime Library Exception along with this program;

// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

// <http://www.gnu.org/licenses/>.

// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.

// Permission to use, copy, modify, sell, and distribute this software

// is hereby granted without fee, provided that the above copyright

// notice appears in all copies, and that both that copyright notice

// and this permission notice appear in supporting documentation. None

// of the above authors, nor IBM Haifa Research Laboratories, make any

// representation about the suitability of this software for any

// purpose. It is provided "as is" without express or implied

// warranty.

/**

 * @file tag_and_trait.hpp

 * Contains tags and traits, e.g., ones describing underlying

 * data structures.

 */

#ifndef PB_DS_TAG_AND_TRAIT_HPP

#define PB_DS_TAG_AND_TRAIT_HPP

#include <bits/c++config.h>

#include <ext/pb_ds/detail/type_utils.hpp>

/**

 * @namespace __gnu_pbds

 * @brief GNU extensions for policy-based data structures for public use.

 */

namespace __gnu_pbds

{

  /** @defgroup pbds Policy-Based Data Structures

   *  @ingroup extensions

   *

   *  This is a library of policy-based elementary data structures:

   *  associative containers and priority queues. It is designed for

   *  high-performance, flexibility, semantic safety, and conformance

   *  to the corresponding containers in std (except for some points

   *  where it differs by design).

   *

   *  For details, see:

   *  http://gcc.gnu.org/onlinedocs/libstdc++/ext/pb_ds/index.html

   *

   *  @{

   */

  /**

   *  @defgroup tags Tags

   *  @{

   */

  /// A trivial iterator tag. Signifies that the iterators has none of

  /// std::iterators's movement abilities.

  struct trivial_iterator_tag

  { };

  /// Prohibit moving trivial iterators.

  typedef void trivial_iterator_difference_type;

  /**

   *  @defgroup invalidation_tags  Invalidation Guarantees

   *  @ingroup tags

   *  @{

   */

  /**

   *  Signifies a basic invalidation guarantee that any iterator,

   *  pointer, or reference to a container object's mapped value type

   *  is valid as long as the container is not modified.

   */

  struct basic_invalidation_guarantee

  { };

  /**

   *  Signifies an invalidation guarantee that includes all those of

   *  its base, and additionally, that any point-type iterator,

   *  pointer, or reference to a container object's mapped value type

   *  is valid as long as its corresponding entry has not be erased,

   *  regardless of modifications to the container object.

   */

  struct point_invalidation_guarantee : public basic_invalidation_guarantee

  { };

  /**

   *  Signifies an invalidation guarantee that includes all those of

   *  its base, and additionally, that any range-type iterator

   *  (including the returns of begin() and end()) is in the correct

   *  relative positions to other range-type iterators as long as its

   *  corresponding entry has not be erased, regardless of

   *  modifications to the container object.

   */

  struct range_invalidation_guarantee : public point_invalidation_guarantee

  { };

  //@}

  /**

   *  @defgroup ds_tags Data Structure Type

   *  @ingroup tags

   *  @{

   */

  /// Base data structure tag.

  struct container_tag

  { };

  /// Basic sequence.

  struct sequence_tag : public container_tag { };

  /// Basic string container, inclusive of strings, ropes, etc.

  struct string_tag : public sequence_tag { };

  /// Basic associative-container.

  struct associative_tag : public container_tag { };

  /// Basic hash structure.

  struct basic_hash_tag : public associative_tag { };

  /// Collision-chaining hash.

  struct cc_hash_tag : public basic_hash_tag { };

  /// General-probing hash.

  struct gp_hash_tag : public basic_hash_tag { };

  /// Basic branch structure.

  struct basic_branch_tag : public associative_tag { };

  /// Basic tree structure.

  struct tree_tag : public basic_branch_tag { };

  /// Red-black tree.

  struct rb_tree_tag : public tree_tag { };

  /// Splay tree.

  struct splay_tree_tag : public tree_tag { };

  /// Ordered-vector tree.

  struct ov_tree_tag : public tree_tag { };

  /// Basic trie structure.

  struct trie_tag : public basic_branch_tag { };

  /// PATRICIA trie.

  struct pat_trie_tag : public trie_tag { };

  /// List-update.

  struct list_update_tag : public associative_tag { };

  /// Basic priority-queue.

  struct priority_queue_tag : public container_tag { };

  /// Pairing-heap.

  struct pairing_heap_tag : public priority_queue_tag { };

  /// Binomial-heap.

  struct binomial_heap_tag : public priority_queue_tag { };

  /// Redundant-counter binomial-heap.

  struct rc_binomial_heap_tag : public priority_queue_tag { };

  /// Binary-heap (array-based).

  struct binary_heap_tag : public priority_queue_tag { };

  /// Thin heap.

  struct thin_heap_tag : public priority_queue_tag { };

  //@}

  //@}

  /**

   *  @defgroup traits Traits

   *  @{

   */

  /**

   *  @brief Represents no type, or absence of type, for template tricks.

   *

   *  In a mapped-policy, indicates that an associative container is a set.

   *

   *  In a list-update policy, indicates that each link does not need

   *  metadata.

   *

   *  In a hash policy, indicates that the combining hash function

   *  is actually a ranged hash function.

   *

   *  In a probe policy, indicates that the combining probe function

   *  is actually a ranged probe function.

   */

  struct null_type { };

  /// A null node updator, indicating that no node updates are required.

  template<typename _Tp1, typename _Tp2, typename _Tp3, typename _Tp4>

    struct null_node_update : public null_type

    { };

  /// Primary template, container traits base.

  template<typename _Tag>

    struct container_traits_base;

  /// Specialization, cc hash.

  template<>

  struct container_traits_base<cc_hash_tag>

  {

    typedef cc_hash_tag                                 container_category;

    typedef point_invalidation_guarantee                invalidation_guarantee;

    enum

      {

        order_preserving = false,

        erase_can_throw = false,

        split_join_can_throw = false,

        reverse_iteration = false

      };

  };

  /// Specialization, gp hash.

  template<>

  struct container_traits_base<gp_hash_tag>

  {

    typedef gp_hash_tag                                 container_category;

    typedef basic_invalidation_guarantee                invalidation_guarantee;

    enum

      {

        order_preserving = false,

        erase_can_throw = false,

        split_join_can_throw = false,

        reverse_iteration = false

      };

  };

  /// Specialization, rb tree.

  template<>

  struct container_traits_base<rb_tree_tag>

  {

    typedef rb_tree_tag                                 container_category;

    typedef range_invalidation_guarantee                invalidation_guarantee;

    enum

      {

        order_preserving = true,

        erase_can_throw = false,

        split_join_can_throw = false,

        reverse_iteration = true

      };

  };

  /// Specialization, splay tree.

  template<>

  struct container_traits_base<splay_tree_tag>

  {

    typedef splay_tree_tag                              container_category;

    typedef range_invalidation_guarantee                invalidation_guarantee;

    enum

      {

        order_preserving = true,

        erase_can_throw = false,

        split_join_can_throw = false,

        reverse_iteration = true

      };

  };

  /// Specialization, ov tree.

  template<>

  struct container_traits_base<ov_tree_tag>

  {

    typedef ov_tree_tag                                 container_category;

    typedef basic_invalidation_guarantee                invalidation_guarantee;

    enum

      {

        order_preserving = true,

        erase_can_throw = true,

        split_join_can_throw = true,

        reverse_iteration = false

      };

  };

  /// Specialization, pat trie.

  template<>

  struct container_traits_base<pat_trie_tag>

  {

    typedef pat_trie_tag                                container_category;

    typedef range_invalidation_guarantee                invalidation_guarantee;

    enum

      {

        order_preserving = true,

        erase_can_throw = false,

        split_join_can_throw = true,

        reverse_iteration = true

      };

  };

  /// Specialization, list update.

  template<>

  struct container_traits_base<list_update_tag>

  {

    typedef list_update_tag                             container_category;

    typedef point_invalidation_guarantee                invalidation_guarantee;

    enum

      {

        order_preserving = false,

        erase_can_throw = false,

        split_join_can_throw = false,

        reverse_iteration = false

      };

  };

  /// Specialization, pairing heap.

  template<>

  struct container_traits_base<pairing_heap_tag>

  {

    typedef pairing_heap_tag                            container_category;

    typedef point_invalidation_guarantee                invalidation_guarantee;

    enum

      {

        order_preserving = false,

        erase_can_throw = false,

        split_join_can_throw = false,

        reverse_iteration = false

      };

  };

  /// Specialization, thin heap.

  template<>

  struct container_traits_base<thin_heap_tag>

  {

    typedef thin_heap_tag                               container_category;

    typedef point_invalidation_guarantee                invalidation_guarantee;

    enum

      {

        order_preserving = false,

        erase_can_throw = false,

        split_join_can_throw = false,

        reverse_iteration = false

      };

  };

  /// Specialization, binomial heap.

  template<>

  struct container_traits_base<binomial_heap_tag>

  {

    typedef binomial_heap_tag                           container_category;

    typedef point_invalidation_guarantee                invalidation_guarantee;

    enum

      {

        order_preserving = false,

        erase_can_throw = false,

        split_join_can_throw = false,

        reverse_iteration = false

      };

  };

  /// Specialization, rc binomial heap.

  template<>

  struct container_traits_base<rc_binomial_heap_tag>

  {

    typedef rc_binomial_heap_tag                        container_category;

    typedef point_invalidation_guarantee                invalidation_guarantee;

    enum

      {

        order_preserving = false,

        erase_can_throw = false,

        split_join_can_throw = false,

        reverse_iteration = false

      };

  };

  /// Specialization, binary heap.

  template<>

  struct container_traits_base<binary_heap_tag>

  {

    typedef binary_heap_tag                             container_category;

    typedef basic_invalidation_guarantee                invalidation_guarantee;

    enum

      {

        order_preserving = false,

        erase_can_throw = false,

        split_join_can_throw = true,

        reverse_iteration = false

      };

  };

  /// Container traits.

  // See Matt Austern for the name, S. Meyers MEFC++ #2, others.

  template<typename Cntnr>

  struct container_traits

  : public container_traits_base<typename Cntnr::container_category>

  {

    typedef Cntnr                                      container_type;

    typedef typename Cntnr::container_category         container_category;

    typedef container_traits_base<container_category>  base_type;

    typedef typename base_type::invalidation_guarantee invalidation_guarantee;

    enum

      {

        /// True only if Cntnr objects guarantee storing  keys by order.

        order_preserving = base_type::order_preserving,

        /// True only if erasing a key can throw.

        erase_can_throw = base_type::erase_can_throw,

        /// True only if split or join operations can throw.

        split_join_can_throw = base_type::split_join_can_throw,

        /// True only reverse iterators are supported.

        reverse_iteration = base_type::reverse_iteration

      };

  };

  //@}

  namespace detail

  {

    /// Dispatch mechanism, primary template for associative types.

    template<typename Key, typename Mapped, typename _Alloc, typename Tag,

             typename Policy_Tl = null_type>

      struct container_base_dispatch;

  } // namespace __detail

  //@}

} // namespace __gnu_pbds

#endif