Upload Tizen:Base source

1 files changed, 453 insertions, 0 deletions

diff --git a/build_windows/dbstl_common.h b/build_windows/dbstl_common.h
new file mode 100644
index 0000000..3c63632
--- /dev/null
+++ b/build_windows/dbstl_common.h
@@ -0,0 +1,453 @@
+#ifndef _DB_STL_COMMON_H
+#define _DB_STL_COMMON_H
+
+#ifdef DBSTL_DEBUG_LEAK
+#include "vld.h"
+#endif
+
+#include <assert.h>
+
+#include "db_cxx.h"
+
+// In release builds, the native assert will be disabled so we
+// can't use it in dbstl in cases where we rely on the expression being
+// evaluated to change the state of the application.
+//
+#if !defined(DEBUG) && !defined(_DEBUG)
+#undef dbstl_assert
+#define dbstl_assert(expression)
+#else
+#undef dbstl_assert
+#define dbstl_assert(expression) do {			\
+	if (!(expression)) {				\
+		FailedAssertionException ex(__FILE__, __LINE__, #expression);\
+		throw ex; } } while (0)
+#endif
+
+#ifndef SIZE_T_MAX
+// The max value for size_t variables, one fourth of 2 powers 32.
+#define SIZE_T_MAX 1073741824
+#endif
+
+#if defined( DB_WIN32) || defined(_WIN32)
+#include <windows.h>
+#include <tchar.h>
+#else
+#define TCHAR char
+#define _T(e) (e)
+#define _ftprintf fprintf
+#define _snprintf snprintf
+#define _tcschr strchr
+#define _tcscmp strcmp
+#define _tcscpy strcpy
+#define _tcslen strlen
+#define _tgetopt getopt
+#define _tmain main
+#define _tprintf printf
+#define _ttoi atoi
+#endif
+
+// Macro for HAVE_WSTRING (detected by configure)
+#define	HAVE_WSTRING	1
+
+// Thread local storage modifier declaration.
+#define	TLS_DECL_MODIFIER	__declspec(thread)
+#define	TLS_DEFN_MODIFIER	__declspec(thread)
+
+#if !defined(TLS_DECL_MODIFIER) && !defined(HAVE_PTHREAD_TLS)
+#error "No appropriate TLS modifier defined."
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+//
+// C++ compiler portability control macro definitions.
+// If a C++ compiler does not support the following capabilities, disabling
+// these flags will remove usage of the feature from DB STL.
+// Where possible a DB STL has implemented work-arounds for the missing
+// functionality.
+//
+#define HAVE_EXPLICIT_KEYWORD			1
+#define HAVE_NAMESPACE				1
+#define HAVE_TYPENAME				1
+
+// Platform specific compiler capability configuration.
+#ifdef WIN32
+#define CLS_SCOPE(clstmpl_name)
+#else
+
+// C++ standard: It is not possible to define a full specialized version of
+// a member function of a class template inside the class body. It needs to
+// be defined outside the class template, and must be defined in the namespace
+// scope.
+#define CLS_SCOPE(clstmpl_name) clstmpl_name::
+#define NO_IN_CLASS_FULL_SPECIALIZATION  1
+#define NO_MEMBER_FUNCTION_PARTIAL_SPECIALIZATION 1
+#endif
+
+#if HAVE_NAMESPACE
+#define START_NS(nsname) namespace nsname {
+#define END_NS }
+#else
+#define START_NS(nsname) struct nsname {
+#define END_NS };
+#endif
+
+#if HAVE_EXPLICIT_KEYWORD
+#define EXPLICIT explicit
+#else
+#define EXPLICIT
+#endif
+
+#if HAVE_TYPENAME
+#define Typename typename
+#else
+#define Typename class
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+// End of compiler portability control macro definitions.
+////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+//
+// Iterator status macro definitions.
+//
+#define INVALID_ITERATOR_POSITION -1 // Iterator goes out of valid range.
+#define INVALID_ITERATOR_CURSOR -2 // The iterator's dbc cursor is invalid.
+#define ITERATOR_DUP_ERROR -3 // Failed to duplicate a cursor.
+
+// Current cursor's key or data dbt has no data.
+#define INVALID_KEY_DATA -4
+#define EMPTY_DBT_DATA -5 // Current cursor's pointed data dbt has no data.
+#define ITERATOR_AT_END -6
+#define CURSOR_NOT_OPEN -7
+
+///////////////////////////////////////////////////////////////////////
+// End of iterator status macro definitions.
+//////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+//
+// Helper macros definitions.
+//
+// Use BDBOP and BDBOP2 to wrap Berkeley DB calls. The macros validate the 
+// return value. On failure, the wrappers clean up, and generate the
+// expected exception.
+//
+#define BDBOP(bdb_call, ret) do { 					\
+	if ((ret = (bdb_call)) != 0) throw_bdb_exception(#bdb_call, ret);\
+	} while(0)
+#define BDBOP2(bdb_call, ret, cleanup) do {				\
+	if ((ret = (bdb_call)) != 0) { (cleanup); 			\
+		throw_bdb_exception(#bdb_call, ret);}			\
+	} while (0)
+// Do not throw the exception if bdb_call returned a specified error number.
+#define BDBOP3(bdb_call, ret, exception, cleanup) do {			\
+	if (((ret = (bdb_call)) != 0) && (ret & exception) == 0) {	\
+		(cleanup); throw_bdb_exception(#bdb_call, ret);}	\
+	} while (0)
+
+#define THROW(exception_type, arg_list) do {		\
+	exception_type ex arg_list; throw ex; } while (0)
+
+#define THROW0(exception_type)	do {			\
+	exception_type ex; throw ex; } while (0)
+
+#define INVALID_INDEX ((index_type)-1)
+#define INVALID_DLEN ((u_int32_t)-1)
+
+#define DBSTL_MAX_DATA_BUF_LEN 1024 * 4096
+#define DBSTL_MAX_KEY_BUF_LEN 1024 * 4096
+#define DBSTL_MAX_MTX_ENV_MUTEX 4096 * 4
+#define DBSTL_BULK_BUF_SIZE 256 * 1024
+
+#define COMPARE_CHECK(obj) if (this == &obj) return true;
+#define ASSIGNMENT_PREDCOND(obj) if (this == &obj) return obj;
+//////////////////////////////////////////////////////////////////
+// End of helper macro definitions.
+//////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////
+//
+// Public global function declarations.
+// These functions are open/public functionalities of dbstl for
+// dbstl users to call.
+//
+START_NS(dbstl)
+// _exported is a macro we employ from db_cxx.h of Berkeley DB C++
+// API. If we want to export the symbols it decorates on Windows,
+// we must define the macro "DB_CREATE_DLL", as is defined in dbstl
+// project property.
+/// \defgroup dbstl_global_functions dbstl global public functions
+//@{
+
+/// \name Functions to close database/environments.
+/// Normally you don't have to close any database 
+/// or environment handles, they will be closed automatically.
+/// Though you still have the following API to close them.
+//@{ 
+/// Close pdb regardless of reference count. You must make sure pdb
+/// is not used by others before calling this method.
+/// You can close the underlying database of a container and assign 
+/// another database with right configurations to it, if the configuration
+/// is not suitable for the container, there will be an 
+/// InvalidArgumentException type of exception thrown.
+/// You can't use the container after you called close_db and before setting 
+/// another valid database handle to the container via 
+/// db_container::set_db_handle() function.
+/// \param pdb The database handle to close.
+_exported void close_db(Db *pdb);
+
+/// Close all open database handles regardless of reference count.
+/// You can't use any container after you called close_all_dbs and 
+/// before setting another valid database handle to the 
+/// container via db_container::set_db_handle() function.
+/// \sa close_db(Db *);
+_exported void close_all_dbs();
+
+/// \brief Close specified database environment handle regardless of reference 
+/// count. 
+///
+/// Make sure the environment is not used by any other databases.
+/// \param pdbenv The database environment handle to close.
+_exported void close_db_env(DbEnv *pdbenv);
+
+/// \brief Close all open database environment handles regardless of
+/// reference count.
+///
+/// You can't use the container after you called close_db and before setting
+/// another valid database handle to the container via 
+/// db_container::set_db_handle() function. \sa close_db_env(DbEnv *);
+_exported void close_all_db_envs();
+//@}
+
+/// \name Transaction control global functions.
+/// dbstl transaction API. You should call these API rather than DB C/C++
+/// API to use Berkeley DB transaction features.
+//@{ 
+/// Begin a new transaction from the specified environment "env". 
+/// This function is called by dbstl user to begin an external transaction.
+/// The "flags" parameter is passed to DbEnv::txn_begin(). 
+/// If a transaction created from 
+/// the same database environment already exists and is unresolved,
+/// the new transaction is started as a child transaction of that transaction,
+/// and thus you can't specify the parent transaction.
+/// \param env The environment to start a transaction from.
+/// \param flags It is set to DbEnv::txn_begin() function.
+/// \return The newly created transaction.
+///
+_exported DbTxn* begin_txn(u_int32_t flags, DbEnv *env);
+
+/// Commit current transaction opened in the environment "env".
+/// This function is called by user to commit an external explicit transaction.
+/// \param env The environment whose current transaction is to be committed.
+/// \param flags It is set to DbTxn::commit() funcion.
+/// \sa commit_txn(DbEnv *, DbTxn *, u_int32_t);
+///
+_exported void commit_txn(DbEnv *env, u_int32_t flags = 0);
+
+/// Commit a specified transaction and all its child transactions.
+/// \param env The environment where txn is started from.
+/// \param txn The transaction to commit, can be a parent transaction of a 
+/// nested transaction group, all un-aborted child transactions of 
+/// it will be committed. 
+/// \param flags It is passed to each DbTxn::commit() call.
+/// \sa commit_txn(DbEnv *, u_int32_t);
+_exported void commit_txn(DbEnv *env, DbTxn *txn, u_int32_t flags = 0);
+
+/// Abort current transaction of environment "env". This function is called by
+/// dbstl user to abort an outside explicit transaction.
+/// \param env The environment whose current transaction is to be aborted.
+/// \sa abort_txn(DbEnv *, DbTxn *);
+_exported void abort_txn(DbEnv *env);
+
+/// Abort specified transaction "txn" and all its child transactions. 
+/// That is, "txn" can be a parent transaction of a nested transaction group.
+/// \param env The environment where txn is started from.
+/// \param txn The transaction to abort, can be a parent transaction of a 
+/// nested transaction group, all child transactions of it will be aborted.
+/// \sa abort_txn(DbEnv *);
+///
+_exported void abort_txn(DbEnv *env, DbTxn *txn);
+
+/// Get current transaction of environment "env".
+/// \param env The environment whose current transaction we want to get.
+/// \return Current transaction of env.
+_exported DbTxn* current_txn(DbEnv *env);
+
+/// Set environment env's current transaction handle to be newtxn. The original
+/// transaction handle returned without aborting or commiting. This function
+/// is used for users to use one transaction among multiple threads.
+/// \param env The environment whose current transaction to replace.
+/// \param newtxn The new transaction to be as the current transaction of env.
+/// \return The old current transaction of env. It is not resolved.
+_exported DbTxn* set_current_txn_handle(DbEnv *env, DbTxn *newtxn);
+//@} 
+
+/// \name Functions to open and register database/environment handles.
+//@{ 
+/// Register a Db handle "pdb1". This handle and handles opened in it will be
+/// closed by ResourceManager, so application code must not try to close or
+/// delete it. Users can do enough configuration before opening the Db then
+/// register it via this function.
+/// All database handles should be registered via this function in each 
+/// thread using the handle. The only exception is the database handle opened
+/// by dbstl::open_db should not be registered in the thread of the 
+/// dbstl::open_db call.
+/// \param pdb1 The database handle to register into dbstl for current thread.
+///
+_exported void register_db(Db *pdb1);
+
+/// Register a DbEnv handle env1, this handle and handles opened in it will be
+/// closed by ResourceManager. Application code must not try to close or delete
+/// it. Users can do enough config before opening the DbEnv and then register
+/// it via this function.
+/// All environment handles should be registered via this function in each 
+/// thread using the handle. The only exception is the environment handle 
+/// opened by dbstl::open_db_env should not be registered in the thread of 
+/// the dbstl::open_db_env call.
+/// \param env1 The environment to register into dbstl for current thread.
+///
+_exported void register_db_env(DbEnv *env1);
+
+/// Helper function to open a database and register it into dbstl for the 
+/// calling thread.
+/// Users still need to register it in any other thread using it if it
+/// is shared by multiple threads, via register_db() function.
+/// Users don't need to delete or free the memory of the returned object, 
+/// dbstl will take care of that.
+/// When you don't use dbstl::open_db() but explicitly call DB C++ API to
+/// open a database, you must new the Db object, rather than create it 
+/// on stack, and you must delete the Db object by yourself.
+/// \param penv The environment to open the database from.
+/// \param cflags The create flags passed to Db class constructor.
+/// \param filename The database file name, passed to Db::open.
+/// \param dbname The database name, passed to Db::open.
+/// \param dbtype The database type, passed to Db::open.
+/// \param oflags The database open flags, passed to Db::open.
+/// \param mode The database open mode, passed to Db::open.
+/// \param txn The transaction to open the database from, passed to Db::open.
+/// \param set_flags The flags to be set to the created database handle.
+/// \return The opened database handle.
+/// \sa register_db(Db *);
+/// \sa open_db_env;
+///
+_exported Db* open_db (DbEnv *penv, const char *filename, DBTYPE dbtype,
+    u_int32_t oflags, u_int32_t set_flags, int mode = 0644, DbTxn *txn = NULL,
+    u_int32_t cflags = 0, const char* dbname = NULL);
+
+/// Helper function to open an environment and register it into dbstl for the
+/// calling thread. Users still need to register it in any other thread if it
+/// is shared by multiple threads, via register_db_env() function above.
+/// Users don't need to delete or free the memory of the returned object, 
+/// dbstl will take care of that.
+/// 
+/// When you don't use dbstl::open_env() but explicitly call DB C++ API to
+/// open an environment, you must new the DbEnv object, rather than create it
+/// on stack, and you must delete the DbEnv object by yourself.
+/// \param env_home Environment home directory, it must exist. Passed to 
+/// DbEnv::open.
+/// \param cflags DbEnv constructor creation flags, passed to DbEnv::DbEnv.
+/// \param set_flags Flags to set to the created environment before opening it.
+/// \param oflags Environment open flags, passed to DbEnv::open.
+/// \param mode Environment region files mode, passed to DbEnv::open.
+/// \param cachesize Environment cache size, by default 4M bytes.
+/// \return The opened database environment handle.
+/// \sa register_db_env(DbEnv *); 
+/// \sa open_db;
+///
+_exported DbEnv* open_env(const char *env_home, u_int32_t set_flags,
+    u_int32_t oflags = DB_CREATE | DB_INIT_MPOOL,
+    u_int32_t cachesize = 4 * 1024 * 1024,
+    int mode = 0644,
+    u_int32_t cflags = 0/* Flags for DbEnv constructor. */);
+//@}
+
+/// @name Mutex API based on Berkeley DB mutex.
+/// These functions are in-process mutex support which uses Berkeley DB 
+/// mutex mechanisms. You can call these functions to do portable 
+/// synchronization for your code.
+//@{
+/// Allocate a Berkeley DB mutex.
+/// \return Berkeley DB mutex handle.
+_exported db_mutex_t alloc_mutex();
+/// Lock a mutex, wait if it is held by another thread.
+/// \param mtx The mutex handle to lock.
+/// \return 0 if succeed, non-zero otherwise, call db_strerror to get message.
+_exported int lock_mutex(db_mutex_t mtx);
+/// Unlock a mutex, and return immediately.
+/// \param mtx The mutex handle to unlock.
+/// \return 0 if succeed, non-zero otherwise, call db_strerror to get message.
+_exported int unlock_mutex(db_mutex_t mtx);
+/// Free a mutex, and return immediately.
+/// \param mtx The mutex handle to free.
+/// \return 0 if succeed, non-zero otherwise, call db_strerror to get message.
+_exported void free_mutex(db_mutex_t mtx);
+//@}
+
+/// Close cursors opened in dbp1.
+/// \param dbp1 The database handle whose active cursors to close.
+/// \return The number of cursors closed by this call.
+_exported size_t close_db_cursors(Db* dbp1);
+
+/// \name Other global functions.
+//@{
+/// If there are multiple threads within a process that make use of dbstl, then
+/// this function should be called in a single thread mutual exclusively before
+/// any use of dbstl in a process; Otherwise, you don't need to call it, but
+/// are allowed to call it anyway.
+_exported void dbstl_startup();
+
+/// This function releases any memory allocated in the heap by code of dbstl.
+/// So you can only call dbstl_exit() right before the entire process exits.
+/// It will release any memory allocated by dbstl that have to live during
+/// the entire process lifetime.
+_exported void dbstl_exit();
+
+/// Operators to compare two Dbt objects.
+/// \param d1 Dbt object to compare.
+/// \param d2 Dbt object to compare.
+_exported bool operator==(const Dbt&d1, const Dbt&d2);
+/// Operators to compare two DBT objects.
+/// \param d1 DBT object to compare.
+/// \param d2 DBT object to compare.
+_exported bool operator==(const DBT&d1, const DBT&d2);
+
+/// If exisiting random temporary database name generation mechanism is still
+/// causing name clashes, users can set this global suffix number which will
+/// be append to each temporary database file name and incremented after each
+/// append, and by default it is 0.
+/// \param num Starting number to append to each temporary db file name.
+_exported void set_global_dbfile_suffix_number(u_int32_t num);
+//@}
+
+//@} // dbstl_global_functions
+
+// Internally used memory allocation functions, they will throw an exception
+// of NotEnoughMemoryException if can't allocate memory.
+_exported void * DbstlReAlloc(void *ptr, size_t size);
+_exported void * DbstlMalloc(size_t size);
+
+_exported u_int32_t hash_default(Db * /*dbp*/, const void *key, u_int32_t len);
+
+// Default string manipulation callbacks.
+_exported u_int32_t dbstl_strlen(const char *str);
+_exported void dbstl_strcpy(char *dest, const char *src, size_t num);
+_exported int dbstl_strncmp(const char *s1, const char *s2, size_t num);
+_exported int dbstl_strcmp(const char *s1, const char *s2);
+_exported int dbstl_wcscmp(const wchar_t *s1, const wchar_t *s2);
+_exported int dbstl_wcsncmp(const wchar_t *s1, const wchar_t *s2, size_t num);
+_exported u_int32_t dbstl_wcslen(const wchar_t *str);
+_exported void dbstl_wcscpy(wchar_t *dest, const wchar_t *src, size_t num);
+
+END_NS
+
+//////////////////////////////////////////////////////////////////
+// End of public global function declarations.
+//////////////////////////////////////////////////////////////////
+
+#endif /* !_DB_STL_COMMON_H */