FM / detail

/usr/include/boost/multi_index/detail

Name	Size	Mode	Actions
access_specifier.hpp	2115	0644	edit dl rm
adl_swap.hpp	858	0644	edit dl rm
allocator_traits.hpp	4957	0644	edit dl rm
archive_constructed.hpp	1991	0644	edit dl rm
auto_space.hpp	2907	0644	edit dl rm
base_type.hpp	1981	0644	edit dl rm
bidir_node_iterator.hpp	2584	0644	edit dl rm
bucket_array.hpp	7730	0644	edit dl rm
cons_stdtuple.hpp	2206	0644	edit dl rm
converter.hpp	1372	0644	edit dl rm
copy_map.hpp	4713	0644	edit dl rm
define_if_constexpr_macro.hpp	876	0644	edit dl rm
do_not_copy_elements_tag.hpp	762	0644	edit dl rm
duplicates_iterator.hpp	2574	0644	edit dl rm
hash_index_args.hpp	3066	0644	edit dl rm
hash_index_iterator.hpp	4407	0644	edit dl rm
hash_index_node.hpp	23170	0644	edit dl rm
has_tag.hpp	915	0644	edit dl rm
header_holder.hpp	1296	0644	edit dl rm
ignore_wstrict_aliasing.hpp	548	0644	edit dl rm
index_base.hpp	9189	0644	edit dl rm
index_loader.hpp	3472	0644	edit dl rm
index_matcher.hpp	6134	0644	edit dl rm
index_node_base.hpp	3500	0644	edit dl rm
index_saver.hpp	3787	0644	edit dl rm
invariant_assert.hpp	578	0644	edit dl rm
is_function.hpp	1439	0644	edit dl rm
is_index_list.hpp	978	0644	edit dl rm
is_transparent.hpp	3616	0644	edit dl rm
iter_adaptor.hpp	7591	0644	edit dl rm
modify_key_adaptor.hpp	1066	0644	edit dl rm
node_handle.hpp	6249	0644	edit dl rm
node_type.hpp	1783	0644	edit dl rm
no_duplicate_tags.hpp	2213	0644	edit dl rm
ord_index_args.hpp	2363	0644	edit dl rm
ord_index_impl.hpp	49850	0644	edit dl rm
ord_index_impl_fwd.hpp	4024	0644	edit dl rm
ord_index_node.hpp	20137	0644	edit dl rm
ord_index_ops.hpp	7629	0644	edit dl rm
promotes_arg.hpp	1886	0644	edit dl rm
raw_ptr.hpp	1187	0644	edit dl rm
restore_wstrict_aliasing.hpp	457	0644	edit dl rm
rnd_index_loader.hpp	4886	0644	edit dl rm
rnd_index_node.hpp	6453	0644	edit dl rm
rnd_index_ops.hpp	6003	0644	edit dl rm
rnd_index_ptr_array.hpp	3499	0644	edit dl rm
rnd_node_iterator.hpp	3135	0644	edit dl rm
rnk_index_ops.hpp	8621	0644	edit dl rm
safe_mode.hpp	18103	0644	edit dl rm
scope_guard.hpp	13703	0644	edit dl rm
seq_index_node.hpp	5455	0644	edit dl rm
seq_index_ops.hpp	6152	0644	edit dl rm
serialization_version.hpp	1801	0644	edit dl rm
uintptr_type.hpp	2446	0644	edit dl rm
unbounded.hpp	1556	0644	edit dl rm
undef_if_constexpr_macro.hpp	459	0644	edit dl rm
value_compare.hpp	1240	0644	edit dl rm
vartempl_support.hpp	10965	0644	edit dl rm

Edit: /usr/include/boost/multi_index/detail/copy_map.hpp (4713B)

/* Copyright 2003-2020 Joaquin M Lopez Munoz.
 * 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)
 *
 * See http://www.boost.org/libs/multi_index for library home page.
 */

#ifndef BOOST_MULTI_INDEX_DETAIL_COPY_MAP_HPP
#define BOOST_MULTI_INDEX_DETAIL_COPY_MAP_HPP

#if defined(_MSC_VER)
#pragma once
#endif

#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
#include <algorithm>
#include <boost/core/addressof.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include <boost/move/core.hpp>
#include <boost/move/utility_core.hpp>
#include <boost/multi_index/detail/allocator_traits.hpp>
#include <boost/multi_index/detail/auto_space.hpp>
#include <boost/multi_index/detail/raw_ptr.hpp>
#include <boost/noncopyable.hpp>
#include <functional>

namespace boost{

namespace multi_index{

namespace detail{

/* copy_map is used as an auxiliary structure during copy_() operations.
 * When a container with n nodes is replicated, node_map holds the pairings
 * between original and copied nodes, and provides a fast way to find a
 * copied node from an original one.
 * The semantics of the class are not simple, and no attempt has been made
 * to enforce it: multi_index_container handles it right. On the other hand,
 * the const interface, which is the one provided to index implementations,
 * only allows for:
 *   - Enumeration of pairs of (original,copied) nodes (excluding the headers),
 *   - fast retrieval of copied nodes (including the headers.)
 */

template <typename Node>
struct copy_map_entry
{
  copy_map_entry(Node* f,Node* s):first(f),second(s){}

Node* first;
  Node* second;

bool operator<(const copy_map_entry<Node>& x)const
  {
    return std::less<Node*>()(first,x.first);
  }
};

struct copy_map_value_copier
{
  template<typename Value>
  const Value& operator()(Value& x)const{return x;}
};

struct copy_map_value_mover
{
  template<typename Value>
  BOOST_RV_REF(Value) operator()(Value& x)const{return boost::move(x);}
};

template <typename Node,typename Allocator>
class copy_map:private noncopyable
{
  typedef typename rebind_alloc_for<
    Allocator,Node
  >::type                                  allocator_type;
  typedef allocator_traits<allocator_type> alloc_traits;
  typedef typename alloc_traits::pointer   pointer;

public:
  typedef const copy_map_entry<Node>*      const_iterator;
  typedef typename alloc_traits::size_type size_type;

copy_map(
    const Allocator& al,size_type size,Node* header_org,Node* header_cpy):
    al_(al),size_(size),spc(al_,size_),n(0),
    header_org_(header_org),header_cpy_(header_cpy),released(false)
  {}

~copy_map()
  {
    if(!released){
      for(size_type i=0;i<n;++i){
        alloc_traits::destroy(
          al_,boost::addressof((spc.data()+i)->second->value()));
        deallocate((spc.data()+i)->second);
      }
    }
  }

const_iterator begin()const{return raw_ptr<const_iterator>(spc.data());}
  const_iterator end()const{return raw_ptr<const_iterator>(spc.data()+n);}

void copy_clone(Node* node){clone(node,copy_map_value_copier());}
  void move_clone(Node* node){clone(node,copy_map_value_mover());}

Node* find(Node* node)const
  {
    if(node==header_org_)return header_cpy_;
    return std::lower_bound(
      begin(),end(),copy_map_entry<Node>(node,0))->second;
  }

void release()
  {
    released=true;
  }

private:
  allocator_type                             al_;
  size_type                                  size_;
  auto_space<copy_map_entry<Node>,Allocator> spc;
  size_type                                  n;
  Node*                                      header_org_;
  Node*                                      header_cpy_;
  bool                                       released;

pointer allocate()
  {
    return alloc_traits::allocate(al_,1);
  }

void deallocate(Node* node)
  {
    alloc_traits::deallocate(al_,static_cast<pointer>(node),1);
  }

template<typename ValueAccess>
  void clone(Node* node,ValueAccess access)
  {
    (spc.data()+n)->first=node;
    (spc.data()+n)->second=raw_ptr<Node*>(allocate());
    BOOST_TRY{
      alloc_traits::construct(
        al_,boost::addressof((spc.data()+n)->second->value()),
        access(node->value()));
    }
    BOOST_CATCH(...){
      deallocate((spc.data()+n)->second);
      BOOST_RETHROW;
    }
    BOOST_CATCH_END
    ++n;

if(n==size_){
      std::sort(
        raw_ptr<copy_map_entry<Node>*>(spc.data()),
        raw_ptr<copy_map_entry<Node>*>(spc.data())+size_);
    }
  }
};

} /* namespace multi_index::detail */

} /* namespace multi_index */

} /* namespace boost */

#endif

cmd: