Class template trans

Class template trans_map

stldb::concurrent::trans_map — Parameters:

Synopsis

// In header: </Users/bobw/workspaces/STLdb/stldb_lib/stldb/containers/concurrent_trans_map.h>

template<typename K, typename V, typename Comparator = std::less<K>, 
         typename Allocator = boost::interprocess::allocator<std::pair<const K, V>,						    typename boost::interprocess::managed_mapped_file::segment_manager>, 
         typename mutex_family = stldb::bounded_mutex_family, 
         int picket_lock_size = 31> 
class trans_map : public boost::interprocess::map< K, TransEntry< V >, std::less< K >, Allocator::template rebind< std::pair< K, TransEntry< V > > >::other >
{
public:
  // types
  typedef Allocator::template rebind< std::pair< K, TransEntry< V > > >::other                                                  base_alloc;            
  typedef boost::interprocess::map< K, TransEntry< V >, Comparator, base_alloc >                                                baseclass;             
  typedef K                                                                                                                     key_type;              
  typedef TransEntry< V >                                                                                                       mapped_type;           
  typedef std::pair< const K, TransEntry< V > >                                                                                 value_type;            
  typedef Comparator                                                                                                            key_compare;           
  typedef Allocator                                                                                                             allocator_type;        
  typedef mutex_family::upgradable_mutex_type                                                                                   upgradable_mutex_type; 
  typedef mutex_family::mutex_type                                                                                              mutex_type;            
  typedef mutex_family::condition_type                                                                                          condition_type;        
  typedef picket_lock_set< value_type, mutex_type, picket_lock_size >                                                           picket_lock_t;         
  typedef value_type &                                                                                                          reference;             
  typedef const value_type &                                                                                                    const_reference;       
  typedef value_type *                                                                                                          pointer;               
  typedef const value_type *                                                                                                    const_pointer;         
  typedef Allocator::size_type                                                                                                  size_type;             
  typedef Allocator::difference_type                                                                                            difference_type;       
  typedef trans_assoc_iterator< trans_map, typename baseclass::iterator, boost::interprocess::scoped_lock< mutex_type > >       iterator;              
  typedef trans_assoc_iterator< trans_map, typename baseclass::const_iterator, boost::interprocess::scoped_lock< mutex_type > > const_iterator;        
  typedef std::reverse_iterator< iterator >                                                                                     reverse_iterator;      
  typedef std::reverse_iterator< const_iterator >                                                                               const_reverse_iterator;

  // member classes/structs/unions

  struct pending_change_map_t : public std::map< baseclass::iterator, value_type, iter_less< baseclass::iterator > >
  {
    // construct/copy/destruct
    pending_change_map_t();

    // public data members
    bool exclusive_commit;
    bool exclusive_rollback;
    std::vector< typename trans_map::pointer > _modified_entries;
    std::vector< mutex_type * > _locks_held;
  };

  // construct/copy/destruct
  explicit trans_map(const Comparator &, const Allocator &, const char *);
  template<typename InputIterator> 
    trans_map(InputIterator, InputIterator, const Comparator &, 
              const Allocator &, const Transaction &, int);
  trans_map(const trans_map &);
  ~trans_map();

  // public member functions
  allocator_type get_allocator() const;
  iterator begin();
  const_iterator begin() const;
  iterator end();
  const_iterator end() const;
  reverse_iterator rbegin();
  const_reverse_iterator rbegin() const;
  reverse_iterator rend();
  const_reverse_iterator rend() const;
  iterator begin(Transaction &);
  iterator end(Transaction &);
  reverse_iterator rbegin(Transaction &);
  reverse_iterator rend(Transaction &);
  std::pair< iterator, bool > insert(const value_type &, Transaction &);
  iterator insert(iterator, const value_type &, Transaction &);
  template<typename InputIterator> 
    void insert(InputIterator, InputIterator, Transaction &);
  template<typename wait_policy_t> 
    std::pair< iterator, bool > 
    insert(const value_type &, Transaction &, wait_policy_t &);
  template<typename wait_policy_t> 
    iterator insert(iterator, const value_type &, Transaction &, 
                    wait_policy_t &);
  template<typename InputIterator, typename wait_policy_t> 
    void insert(InputIterator, InputIterator, Transaction &, wait_policy_t &);
  void erase(iterator, Transaction &);
  size_type erase(const K &, Transaction &);
  void erase(iterator, iterator, Transaction &);
  template<typename wait_policy_t> 
    void erase(iterator, Transaction &, wait_policy_t &);
  template<typename wait_policy_t> 
    size_type erase(const K &, Transaction &, wait_policy_t &);
  template<typename wait_policy_t> 
    void erase(iterator, iterator, Transaction &, wait_policy_t &);
  void clear(exclusive_transaction &);
  void swap(trans_map &, exclusive_transaction &);
  iterator find(const K &);
  const_iterator find(const K &) const;
  iterator find(const K &, Transaction &);
  iterator lower_bound(const K &);
  const_iterator lower_bound(const K &) const;
  iterator lower_bound(const K &, Transaction &);
  iterator upper_bound(const K &);
  const_iterator upper_bound(const K &) const;
  iterator upper_bound(const K &, Transaction &);
  void lock(iterator &, Transaction &);
  template<typename wait_policy_t> 
    void lock(iterator &, Transaction &, wait_policy_t &);
  V & update(iterator &, const V &, Transaction &);
  template<typename wait_policy_t> 
    V & update(iterator &, const V &, Transaction &, wait_policy_t &);
  upgradable_mutex_type & mutex();
  mutex_type & mutexForRow(const typename baseclass::iterator &);
  void print_stats();
  const char * get_name();

  // private member functions
  template<typename bound_method_t, typename wait_policy_t> 
    bound_method_t::result_type 
    while_row_locked(const bound_method_t &, iterator &, Transaction &, 
                     wait_policy_t &);
  void erase_i(iterator &, Transaction &);
  baseclass::size_type erase_i(const K &, Transaction &);
  void erase_i(iterator &, iterator, Transaction &);
  void lock_i(iterator &, Transaction &);
  V & update_i(iterator &, const V &, Transaction &);
  value_type & pendingUpdate(Transaction &, typename baseclass::iterator);
  value_type addPendingUpdate(Transaction &, typename baseclass::iterator, 
                              const V &);
  void addPendingInsert(Transaction &, typename baseclass::iterator);
  void addPendingErase(Transaction &, typename baseclass::iterator);
  void addPendingUnlock(Transaction &, typename baseclass::iterator);
  template<typename Database_t> 
    void save_checkpoint(Database_t &, checkpoint_ofstream &, 
                         transaction_id_t);
  void load_checkpoint(checkpoint_ifstream &);
};

Description

`trans_map` public construct/copy/destruct

explicit trans_map(const Comparator & comp, const Allocator & alloc, 
                   const char * name);

template<typename InputIterator> 
  trans_map(InputIterator first, InputIterator last, const Comparator & comp, 
            const Allocator & alloc, const Transaction & trans, int id);

```
trans_map(const trans_map & rarg);
```
```
~trans_map();
```

`trans_map` public member functions

```
allocator_type get_allocator() const;
```
```
iterator begin();
```
```
const_iterator begin() const;
```
```
iterator end();
```
```
const_iterator end() const;
```
```
reverse_iterator rbegin();
```
```
const_reverse_iterator rbegin() const;
```
```
reverse_iterator rend();
```
```
const_reverse_iterator rend() const;
```
```
iterator begin(Transaction & trans);
```
```
iterator end(Transaction & trans);
```

reverse_iterator rbegin(Transaction & trans);

reverse_iterator rend(Transaction & trans);

std::pair< iterator, bool > insert(const value_type &, Transaction & trans);

iterator insert(iterator, const value_type &, Transaction & trans);

template<typename InputIterator> 
  void insert(InputIterator, InputIterator, Transaction & trans);

template<typename wait_policy_t> 
  std::pair< iterator, bool > 
  insert(const value_type &, Transaction & trans, wait_policy_t & wait_policy);

template<typename wait_policy_t> 
  iterator insert(iterator, const value_type &, Transaction & trans, 
                  wait_policy_t & wait_policy);

template<typename InputIterator, typename wait_policy_t> 
  void insert(InputIterator, InputIterator, Transaction & trans, 
              wait_policy_t & wait_policy);

void erase(iterator, Transaction & trans);

size_type erase(const K &, Transaction & trans);

void erase(iterator, iterator, Transaction & trans);

template<typename wait_policy_t> 
  void erase(iterator, Transaction & trans, wait_policy_t & wait_policy);

template<typename wait_policy_t> 
  size_type erase(const K &, Transaction & trans, wait_policy_t & wait_policy);

template<typename wait_policy_t> 
  void erase(iterator, iterator, Transaction & trans, 
             wait_policy_t & wait_policy);

void clear(exclusive_transaction & trans);

void swap(trans_map & other, exclusive_transaction & trans);

```
iterator find(const K & key);
```

const_iterator find(const K & key) const;

iterator find(const K & key, Transaction & trans);

```
iterator lower_bound(const K & key);
```

const_iterator lower_bound(const K & key) const;

iterator lower_bound(const K & key, Transaction & trans);

```
iterator upper_bound(const K & key);
```

const_iterator upper_bound(const K & key) const;

iterator upper_bound(const K & key, Transaction & trans);

void lock(iterator & i, Transaction & trans);

template<typename wait_policy_t> 
  void lock(iterator & i, Transaction & trans, wait_policy_t & wait_policy);

V & update(iterator & i, const V & newVal, Transaction & trans);

template<typename wait_policy_t> 
  V & update(iterator & i, const V & newVal, Transaction & trans, 
             wait_policy_t & wait_policy);

```
upgradable_mutex_type & mutex();
```

mutex_type & mutexForRow(const typename baseclass::iterator & i);

```
void print_stats();
```
```
const char * get_name();
```

`trans_map` private member functions

template<typename bound_method_t, typename wait_policy_t> 
  bound_method_t::result_type 
  while_row_locked(const bound_method_t & bound_method, iterator & i, 
                   Transaction & trans, wait_policy_t & wait_policy);

void erase_i(iterator & i, Transaction & trans);

baseclass::size_type erase_i(const K &, Transaction & trans);

void erase_i(iterator & i, iterator, Transaction & trans);

void lock_i(iterator & i, Transaction & trans);

V & update_i(iterator & i, const V & newVal, Transaction & trans);

value_type & 
pendingUpdate(Transaction & trans, typename baseclass::iterator location);

Support for MVCC

value_type addPendingUpdate(Transaction & trans, 
                            typename baseclass::iterator location, 
                            const V & newVal);

void addPendingInsert(Transaction & trans, 
                      typename baseclass::iterator location);

void addPendingErase(Transaction & trans, 
                     typename baseclass::iterator location);

void addPendingUnlock(Transaction & trans, 
                      typename baseclass::iterator location);

template<typename Database_t> 
  void save_checkpoint(Database_t & db, checkpoint_ofstream & checkpoint, 
                       transaction_id_t last_checkpoint_lsn);

void load_checkpoint(checkpoint_ifstream & checkpoint);

Class template trans_map

Synopsis

Description

trans_map public construct/copy/destruct

trans_map public member functions

trans_map private member functions

`trans_map` public construct/copy/destruct

`trans_map` public member functions

`trans_map` private member functions