namespace stldb {
  typedef int64_t transaction_id_t;
  typedef int64_t log_seq_num_t;

  static const transaction_id_t no_transaction;
}

namespace stldb {
  class checkpoint_fstream_base;
  class checkpoint_ifstream;
  template<typename T> class checkpoint_iterator;
  class checkpoint_ofstream;

  typedef std::pair< boost::interprocess::offset_t, std::size_t > checkpoint_loc_t;
}

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

namespace stldb {
  template<typename managed_region_t> class checkpoint_manager;
}

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

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

  template<typename ManagedRegionType> class container_proxy_base;
}

typedef boost::archive::binary_iarchive boost_iarchive_t;

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 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;

namespace stldb {
}

typedef boost::archive::binary_iarchive boost_iarchive_t;

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

typedef boost::archive::binary_iarchive boost_iarchive_t;

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 CharT, typename CharTraits, typename AllocType> 
      void save(boost::archive::xml_oarchive & ar, 
                const boost::interprocess::basic_string< CharT, CharTraits, AllocType > & s, 
                unsigned int version);
    template<typename CharT, typename CharTraits, typename AllocType> 
      void load(boost::archive::xml_iarchive & 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);
  }
}

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);
}

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

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

  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;
}namespace std {
}

typedef boost::archive::binary_iarchive boost_iarchive_t;

SET_CHECKSUM()
CHECK_CHECKSUM()

namespace stldb {
  class trans_set_hook;
  template<typename T> class TransEntry;

  enum TransactionalOperations { No_op = = 0, Lock_op = = 1, Insert_op, 
                                 Update_op, Delete_op, Deleted_Insert_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_only_t;
  struct open_or_create_t;
  struct open_or_recover_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 ManagedRegionType> class Database;

  template<typename void_allocator_t, typename mutex_t> struct DatabaseInfo;
}

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

STLDB_DYNAMIC__MANAGED_MAPPED_FILE_HPP

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

namespace stldb {
  class log_reader;
}

namespace stldb {
  template<typename void_alloc_t, typename mutex_type> class Logger;

  template<typename void_alloc_t, typename mutex_type> struct SharedLogInfo;
}

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 database_stats;
  struct log_stats;
}

BOOST_STLDB_DECL

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 bounded_wait_policy;
  template<typename container_lock_t> class wait_indefinitely_policy;
}

STLDB_TRACE(lvl, msg)
STLDB_TRACEDB(lvl, dbname, msg)
STLDB_TRACE_DEBUG(lvl, msg)
STLDB_TRACEDB_DEBUG(lvl, dbname, msg)

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

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

namespace stldb {
  struct disposer;

  class exclusive_transaction;
  class Transaction;
  class transactional_op_list;
  class TransactionalOperation;

  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;