namespace stldb {
  typedef int64_t transaction_id_t;

  static const transaction_id_t no_transaction;
}

namespace stldb {
  template<typename void_alloc_type> class commit_buffer_t;
}

STLDB_DATABASE_CONFIG_

namespace stldb {
  template<typename ManagedRegionType> class container_proxy_base;
  template<typename ManagedRegionType, typename ContainerT> 
    class container_proxy;

  template<typename ManagedRegionType, typename K, typename V, typename Pred, 
           typename Alloc> 
    class container_proxy<ManagedRegionType, boost::interprocess::map< K, V, Pred, Alloc >>;
  template<typename ManagedRegionType, typename K, typename V, typename Pred, 
           typename Alloc> 
    class container_proxy<ManagedRegionType, std::map< K, V, Pred, Alloc >>;
}

typedef boost::archive::binary_iarchive boost_iarchive_t;

STLDB_CONCURRENT_TRANS_ITERATOR_H

namespace stldb {
  namespace concurrent {
    template<typename container_t, typename base_iterator, typename lock_type> 
      class trans_assoc_iterator;
    template<typename container_t, typename base_iterator, typename lock_type> 
      bool operator==(const trans_assoc_iterator< container_t, base_iterator, lock_type > & larg, 
                      const trans_assoc_iterator< container_t, base_iterator, lock_type > & rarg);
    template<typename container_t, typename base_iterator, typename lock_type> 
      bool operator==(const trans_assoc_iterator< container_t, base_iterator, lock_type > & larg, 
                      const base_iterator & rarg);
    template<typename container_t, typename base_iterator, typename lock_type> 
      bool operator==(const base_iterator & larg, 
                      const trans_assoc_iterator< container_t, base_iterator, lock_type > & rarg);
    template<typename container_t, typename base_iterator, typename lock_type> 
      bool operator!=(const trans_assoc_iterator< container_t, base_iterator, lock_type > & larg, 
                      const trans_assoc_iterator< container_t, base_iterator, lock_type > & rarg);
    template<typename container_t, typename base_iterator, typename lock_type> 
      bool operator!=(const trans_assoc_iterator< container_t, base_iterator, lock_type > & larg, 
                      const base_iterator & rarg);
    template<typename container_t, typename base_iterator, typename lock_type> 
      bool operator!=(const base_iterator & larg, 
                      const trans_assoc_iterator< container_t, base_iterator, lock_type > & rarg);
  }
}namespace std {
}

STLDB_CONCURRENT_TRANS_MAP_H

namespace stldb {
  template<typename ManagedRegionType, typename K, typename V, typename Pred, 
           typename Allocator, typename mutex_family, int picket_lock_size> 
    class container_proxy<ManagedRegionType, concurrent::trans_map< K, V, Pred, Allocator, mutex_family, picket_lock_size >>;
  namespace concurrent {
    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;
  }
}

typedef boost::archive::binary_iarchive boost_iarchive_t;

STLDB_ITER_LESS

namespace stldb {
  template<typename iterator_type> struct iter_less;
}

template<typename CharT, typename Traits, typename Alloc1, typename Alloc2> 
  bool operator==(const std::basic_string< CharT, Traits, Alloc1 > & str1, 
                  const boost::interprocess::basic_string< CharT, Traits, Alloc2 > & str2);
template<typename CharT, typename Traits, typename Alloc1, typename Alloc2> 
  bool operator==(const boost::interprocess::basic_string< CharT, Traits, Alloc1 > & str2, 
                  const std::basic_string< CharT, Traits, Alloc2 > & str1);
template<typename CharT, typename Traits, typename Alloc1, typename Alloc2> 
  bool operator!=(const std::basic_string< CharT, Traits, Alloc1 > & str1, 
                  const boost::interprocess::basic_string< CharT, Traits, Alloc2 > & str2);
template<typename CharT, typename Traits, typename Alloc1, typename Alloc2> 
  bool operator!=(const boost::interprocess::basic_string< CharT, Traits, Alloc1 > & str2, 
                  const std::basic_string< CharT, Traits, Alloc2 > & str1);

namespace boost {
  namespace serialization {
    template<typename Archive, typename CharT, typename CharTraits, 
             typename AllocType> 
      void save(Archive & ar, 
                const boost::interprocess::basic_string< CharT, CharTraits, AllocType > & s, 
                unsigned int version);
    template<typename Archive, typename CharT, typename CharTraits, 
             typename AllocType> 
      void load(Archive & ar, 
                boost::interprocess::basic_string< CharT, CharTraits, AllocType > & s, 
                unsigned int version);
    template<typename Archive, typename CharT, typename CharTraits, 
             typename AllocType> 
      void serialize(Archive & ar, 
                     boost::interprocess::basic_string< CharT, CharTraits, AllocType > & t, 
                     const unsigned int file_version);
    template<typename Archive, typename CharT, typename CharTraits, 
             typename AllocType> 
      void save(Archive & ar, 
                const std::basic_string< CharT, CharTraits, AllocType > & s, 
                unsigned int version);
    template<typename Archive, typename CharT, typename CharTraits, 
             typename AllocType> 
      void load(Archive & ar, 
                std::basic_string< CharT, CharTraits, AllocType > & s, 
                unsigned int version);
    template<typename Archive, typename CharT, typename CharTraits, 
             typename AllocType> 
      void serialize(Archive & ar, 
                     std::basic_string< CharT, CharTraits, AllocType > & t, 
                     const unsigned int file_version);
  }
}

STLDB_TRANS_ITERATOR_H

namespace stldb {
  template<typename container_t, typename base_iterator> 
    class trans_assoc_iterator;
  template<typename container_t, typename base_iterator> 
    bool operator==(const trans_assoc_iterator< container_t, base_iterator > & larg, 
                    const trans_assoc_iterator< container_t, base_iterator > & rarg);
  template<typename container_t, typename base_iterator> 
    bool operator==(const trans_assoc_iterator< container_t, base_iterator > & larg, 
                    const base_iterator & rarg);
  template<typename container_t, typename base_iterator> 
    bool operator==(const base_iterator & larg, 
                    const trans_assoc_iterator< container_t, base_iterator > & rarg);
  template<typename container_t, typename base_iterator> 
    bool operator!=(const trans_assoc_iterator< container_t, base_iterator > & larg, 
                    const trans_assoc_iterator< container_t, base_iterator > & rarg);
  template<typename container_t, typename base_iterator> 
    bool operator!=(const trans_assoc_iterator< container_t, base_iterator > & larg, 
                    const base_iterator & rarg);
  template<typename container_t, typename base_iterator> 
    bool operator!=(const base_iterator & larg, 
                    const trans_assoc_iterator< container_t, base_iterator > & rarg);
}

STLDB_TRANS_MAP_H

namespace stldb {
  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> 
    class trans_map;

  template<typename ManagedRegionType, typename K, typename V, typename Pred, 
           typename Allocator, typename mutex_family> 
    class container_proxy<ManagedRegionType, trans_map< K, V, Pred, Allocator, mutex_family >>;
}

typedef boost::archive::binary_iarchive boost_iarchive_t;

STLDB_TRANSENTRY_H

namespace stldb {
  template<typename T> class TransEntry;

  enum TransactionalOperations { No_op =  0, Lock_op =  1, Insert_op, 
                                 Update_op, Delete_op, Clear_op, Swap_op };
}

namespace stldb {
  template<typename T, typename Alloc, 
           typename Lock = boost::interprocess::interprocess_upgradable_mutex, 
           typename CondVar = boost::interprocess::interprocess_condition> 
    class trans_vector;
}

namespace stldb {
  struct create_or_recover_t;
  struct open_create_or_recover_t;
  struct open_or_create_t;
  struct open_or_recover_t;
  struct open_only_t;

  static const create_or_recover_t create_or_recover;
  static const open_only_t open_only;
  static const open_create_or_recover_t open_create_or_recover;
  static const open_or_create_t open_or_create;
  static const open_or_recover_t open_or_recover;
}

namespace stldb {
  template<typename void_allocator_t, typename mutex_t> struct DatabaseInfo;

  template<typename ManagedRegionType> class Database;
}

namespace stldb {
  template<typename void_alloc_t> class database_registry;
}

namespace stldb {
  class stldb_exception;
  class row_deleted_exception;
  class row_level_lock_contention;
  class lock_timeout_exception;
  class recovery_needed;
  class recover_from_log_failed;
}

namespace stldb {
  class log_reader;
}

STLDB_LOGGER_H

namespace stldb {
  template<typename void_alloc_t, typename mutex_type> struct SharedLogInfo;

  template<typename void_alloc_t, typename mutex_type> class Logger;

  static const int max_txn_per_write;
  static io::write_region_t iov;
  static struct log_header headers;
}

namespace stldb {
  struct log_header;
  BOOST_STLDB_DECL uint32_t adler(const uint8_t * data, std::size_t len);
}

namespace stldb {
  template<typename ManagedRegionType> class recovery_manager;
}

typedef boost::archive::binary_iarchive boost_iarchive_t;

namespace stldb {
  struct log_stats;
  struct database_stats;
}

namespace stldb {
  class bounded_interprocess_mutex;
  class bounded_interprocess_recursive_mutex;
  class bounded_interprocess_upgradable_mutex;

  struct bounded_mutex_family;

  boost::posix_time::time_duration BOOST_STLDB_DECL bounded_mutex_timeout;
}

namespace stldb {
  class file_lock;
}

namespace stldb {
  template<typename T, typename mutex_type, int NumLocks = 31> 
    class picket_lock_set;
}

namespace stldb {
  template<typename container_lock_t> class wait_indefinitely_policy;
  template<typename container_lock_t> class bounded_wait_policy;
}

STLDB_TRACE(lvl, msg)

namespace stldb {
  class tracer;
  class tracing;
  class cerr_tracer;

  enum trace_level_t { none_e =  0, severe_e, error_e, warning_e, info_e, 
                       fine_e, finer_e, finest_e };
}

STLDB_TRANSACTION_H

namespace stldb {
  class TransactionalOperation;

  struct disposer;

  class transactional_op_list;
  class Transaction;
  class exclusive_transaction;

  typedef boost::intrusive::list< TransactionalOperation > trans_op_list_type;
}

typedef boost::archive::binary_oarchive boost_oarchive_t;
typedef boost::archive::binary_iarchive boost_iarchive_t;