using std::runtime_error::runtime_error;

/// The error code as defined in objectbox.h via the OBX_ERROR_* constants

virtual int code() const = 0;

using Exception::Exception;

/// Always OBX_ERROR_ILLEGAL_ARGUMENT

int code() const override { return OBX_ERROR_ILLEGAL_ARGUMENT; }

using Exception::Exception;

/// Always OBX_ERROR_ILLEGAL_STATE

int code() const override { return OBX_ERROR_ILLEGAL_STATE; }

using Exception::Exception;

/// Always OBX_ERROR_MAX_DATA_SIZE_EXCEEDED

int code() const override { return OBX_ERROR_MAX_DATA_SIZE_EXCEEDED; }

using IllegalStateException::IllegalStateException;

/// Always OBX_ERROR_SHUTTING_DOWN

int code() const override { return OBX_ERROR_SHUTTING_DOWN; }

const int code_;

explicit DbException(const std::string& text, int code = 0) : Exception(text), code_(code) {}

explicit DbException(const char* text, int code = 0) : Exception(text), code_(code) {}

/// The error code as defined in objectbox.h via the OBX_ERROR_* constants

int code() const override { return code_; }

using Exception::Exception;

/// Always OBX_ERROR_FEATURE_NOT_AVAILABLE

int code() const override { return OBX_ERROR_FEATURE_NOT_AVAILABLE; }

std::string msg(text1);

if (text2) msg.append(text2);

throw IllegalArgumentException(msg);

std::string msg(text1);

if (text2) msg.append(text2);

throw IllegalStateException(msg);

std::string msg;

if (contextPrefix) msg.append(contextPrefix).append(": ");

if (err == OBX_SUCCESS) { // Zero, there's no error actually: this is atypical corner case, which should be avoided

msg += "No error occurred (operation was successful)";

throw IllegalStateException(msg);

} else {

appendLastErrorText(err, msg);

throwError(err, msg);

}

obx_err lastErr = obx_last_error_code();

if (err == lastErr) {

assert(lastErr != 0); // checked indirectly against err before

outMessage += obx_last_error_message();

} else { // Do not use obx_last_error_message() as primary msg because it originated from another code

outMessage.append("Error code ").append(std::to_string(err));

if (lastErr != 0) {

outMessage.append(" (last: ").append(std::to_string(lastErr));

outMessage.append(", last msg: ").append(obx_last_error_message()).append(")");

}

}

if (err == OBX_SUCCESS) { // Zero, there's no error actually: this is atypical corner case, which should be avoided

throw IllegalStateException("No error occurred; operation was successful. Given message: " + message);

} else {

if (err == OBX_ERROR_ILLEGAL_ARGUMENT) {

throw IllegalArgumentException(message);

} else if (err == OBX_ERROR_ILLEGAL_STATE) {

throw IllegalStateException(message);

} else if (err == OBX_ERROR_SHUTTING_DOWN) {

throw ShuttingDownException(message);

} else if (err == OBX_ERROR_MAX_DATA_SIZE_EXCEEDED) {

throw MaxDataSizeExceededException(message);

} else if (err == OBX_ERROR_FEATURE_NOT_AVAILABLE) {

throw FeatureNotAvailableException(message);

} else {

throw DbException(message, err);

}

}

if (err == OBX_NO_SUCCESS) return false;

if (err == OBX_SUCCESS) return true;

throwLastError(err);

OBX_bytes_lazy* cPtr_;

BytesLazy() : cPtr_(nullptr) {}

explicit BytesLazy(OBX_bytes_lazy* cBytes) : cPtr_(cBytes) {}

BytesLazy(BytesLazy&& src) noexcept : cPtr_(src.cPtr_) { src.cPtr_ = nullptr; }

/// No copying allowed: OBX_bytes_lazy needs a single owner (no method to "clone" it).

BytesLazy(const BytesLazy& src) = delete;

~BytesLazy() { clear(); }

/// @returns true if it holds actual bytes resources (e.g. not default-constructed and not clear()ed yet).

bool hasBytes() { return cPtr_ != nullptr; }

/// @returns true if it does not hold any bytes resources (e.g. default-constructed or already clear()ed).

bool isNull() { return cPtr_ == nullptr; }

void swap(BytesLazy& other) { std::swap(cPtr_, other.cPtr_); }

/// Clears any bytes resources

void clear() {

obx_bytes_lazy_free(cPtr_);

cPtr_ = nullptr;

}

/// Gets the bytes and its size using the given "out" references.

void get(const void*& outBytes, size_t& outSize) const {

if (cPtr_ == nullptr) throw IllegalStateException("This instance does not hold any bytes resources");

internal::checkErrOrThrow(obx_bytes_lazy_get(cPtr_, &outBytes, &outSize));

}

/// Note that this will potentially resolve actual bytes just like get().

/// Also, it would be more efficient to only call get() to get everything in a single call.

size_t size() {

if (cPtr_ == nullptr) throw IllegalStateException("This instance does not hold any bytes resources");

size_t size = 0;

internal::checkErrOrThrow(obx_bytes_lazy_get(cPtr_, nullptr, &size));

return size;

}

virtual ~Closable() = default;

virtual bool isClosed() = 0;

virtual void close() = 0;

friend class Store;

friend class SyncServer;

mutable OBX_store_options* opt = nullptr;

OBX_store_options* release() {

OBX_store_options* result = opt;

opt = nullptr;

return result;

}

Options() {

opt = obx_opt();

internal::checkPtrOrThrow(opt, "Could not create store options");

}

/// @deprecated is this used by generator?

explicit Options(OBX_model* model) : Options() { this->model(model); }

~Options() { obx_opt_free(opt); }

/// Set the model on the options. The default is no model.

/// NOTE: the model is always freed by this function, including when an error occurs.

Options& model(OBX_model* model) {

internal::checkErrOrThrow(obx_opt_model(opt, model));

return *this;

}

/// Set the store directory on the options. The default is "objectbox".

/// Use the prefix "memory:" to open an in-memory database, e.g. "memory:myApp" (see docs for details).

Options& directory(const char* dir) {

internal::checkErrOrThrow(obx_opt_directory(opt, dir));

return *this;

}

/// Set the store directory on the options. The default is "objectbox".

/// Use the prefix "memory:" to open an in-memory database, e.g. "memory:myApp" (see docs for details).

Options& directory(const std::string& dir) { return directory(dir.c_str()); }

/// Gets the option for "directory"; this is either the default, or, the value set by directory().

std::string getDirectory() const {

const char* dir = obx_opt_get_directory(opt);

internal::checkPtrOrThrow(dir, "Could not get directory");

return dir;

}

/// Set the maximum db size on the options. The default is 1Gb.

Options& maxDbSizeInKb(uint64_t sizeInKb) {

obx_opt_max_db_size_in_kb(opt, sizeInKb);

return *this;

}

/// Gets the option for "max DB size"; this is either the default, or, the value set by maxDbSizeInKb().

uint64_t getMaxDbSizeInKb() const { return obx_opt_get_max_db_size_in_kb(opt); }

/// Data size tracking is more involved than DB size tracking, e.g. it stores an internal counter.

/// Thus only use it if a stricter, more accurate limit is required (it's off by default).

/// It tracks the size of actual data bytes of objects (system and metadata is not considered).

/// On the upside, reaching the data limit still allows data to be removed (assuming DB limit is not reached).

/// Max data and DB sizes can be combined; data size must be below the DB size.

Options& maxDataSizeInKb(uint64_t sizeInKb) {

obx_opt_max_data_size_in_kb(opt, sizeInKb);

return *this;

}

/// Gets the option for "max DB size"; this is either the default, or, the value set by maxDataSizeInKb().

uint64_t getMaxDataSizeInKb() const { return obx_opt_get_max_data_size_in_kb(opt); }

/// Set the file mode on the options. The default is 0644 (unix-style)

Options& fileMode(unsigned int fileMode) {

obx_opt_file_mode(opt, fileMode);

return *this;

}

/// Set the maximum number of readers (related to read transactions.

/// "Readers" are an finite resource for which we need to define a maximum number upfront.

/// The default value is enough for most apps and usually you can ignore it completely.

/// However, if you get the OBX_ERROR_MAX_READERS_EXCEEDED error, you should verify your threading.

/// For each thread, ObjectBox uses multiple readers.

/// Their number (per thread) depends on number of types, relations, and usage patterns.

/// Thus, if you are working with many threads (e.g. in a server-like scenario), it can make sense to increase

/// the maximum number of readers.

///

/// \note The internal default is currently 126. So when hitting this limit, try values around 200-500.

///

/// \attention Each thread that performed a read transaction and is still alive holds on to a reader slot.

/// These slots only get vacated when the thread ends. Thus be mindful with the number of active threads.

/// Alternatively, you can opt to try the experimental noReaderThreadLocals option flag.

Options& maxReaders(unsigned int maxReaders) {

obx_opt_max_readers(opt, maxReaders);

return *this;

}

/// Disables the usage of thread locals for "readers" related to read transactions.

/// This can make sense if you are using a lot of threads that are kept alive.

/// \note This is still experimental, as it comes with subtle behavior changes at a low level and may affect

/// corner cases with e.g. transactions, which may not be fully tested at the moment.

Options& noReaderThreadLocals(bool flag) {

obx_opt_no_reader_thread_locals(opt, flag);

return *this;

}

/// Set the model on the options copying the given bytes. The default is no model.

Options& modelBytes(const void* bytes, size_t size) {

internal::checkErrOrThrow(obx_opt_model_bytes(opt, bytes, size));

return *this;

}

/// Like modelBytes() BUT WITHOUT copying the given bytes.

/// Thus, you must keep the bytes available until after the store is created.

Options& modelBytesDirect(const void* bytes, size_t size) {

internal::checkErrOrThrow(obx_opt_model_bytes_direct(opt, bytes, size));

return *this;

}

/// When the DB is opened initially, ObjectBox can do a consistency check on the given amount of pages.

/// Reliable file systems already guarantee consistency, so this is primarily meant to deal with unreliable

/// OSes, file systems, or hardware. Thus, usually a low number (e.g. 1-20) is sufficient and does not impact

/// startup performance significantly. To completely disable this you can pass 0, but we recommend a setting of

/// at least 1.

/// Note: ObjectBox builds upon ACID storage, which guarantees consistency given that the file system is working

/// correctly (in particular fsync).

/// @param pageLimit limits the number of checked pages (currently defaults to 0, but will be increased in the

/// future)

/// @param flags flags used to influence how the validation checks are performed

Options& validateOnOpenPages(size_t pageLimit, uint32_t flags = OBXValidateOnOpenPagesFlags_None) {

obx_opt_validate_on_open_pages(opt, pageLimit, flags);

return *this;

}

/// When the DB is opened initially, ObjectBox can do a validation over the key/value pairs to check, for example,

/// whether they're consistent towards our internal specification.

/// @param flags flags used to influence how the validation checks are performed;

/// only OBXValidateOnOpenKvFlags_None is supported for now.

Options& validateOnOpenKv(uint32_t flags = OBXValidateOnOpenKvFlags_None) {

obx_opt_validate_on_open_kv(opt, flags);

return *this;

}

/// Don't touch unless you know exactly what you are doing:

/// Advanced setting typically meant for language bindings (not end users). See OBXPutPaddingMode description.

Options& putPaddingMode(OBXPutPaddingMode mode) {

obx_opt_put_padding_mode(opt, mode);

return *this;

}

/// Advanced setting meant only for special scenarios: setting to false causes opening the database in a

/// limited, schema-less mode. If you don't know what this means exactly: ignore this flag. Defaults to true.

Options& readSchema(bool value) {

obx_opt_read_schema(opt, value);

return *this;

}

/// Advanced setting recommended to be used together with read-only mode to ensure no data is lost.

/// Ignores the latest data snapshot (committed transaction state) and uses the previous snapshot instead.

/// When used with care (e.g. backup the DB files first), this option may also recover data removed by the

/// latest transaction. Defaults to false.

Options& usePreviousCommit(bool value) {

obx_opt_use_previous_commit(opt, value);

return *this;

}

/// Open store in read-only mode: no schema update, no write transactions. Defaults to false.

Options& readOnly(bool value) {

obx_opt_read_only(opt, value);

return *this;

}

/// Configure debug flags; e.g. to influence logging. Defaults to NONE.

Options& debugFlags(uint32_t flags) {

obx_opt_debug_flags(opt, flags);

return *this;

}

/// Adds debug flags to potentially existing ones (that were previously set).

Options& addDebugFlags(uint32_t flags) {

obx_opt_add_debug_flags(opt, flags);

return *this;

}

/// Gets the option for "debug flags"; this is either the default, or, the value set by debugFlags().

uint32_t getDebugFlags() const { return obx_opt_get_debug_flags(opt); }

/// Maximum of async elements in the queue before new elements will be rejected.

/// Hitting this limit usually hints that async processing cannot keep up;

/// data is produced at a faster rate than it can be persisted in the background.

/// In that case, increasing this value is not the only alternative; other values might also optimize

/// throughput. For example, increasing maxInTxDurationMicros may help too.

Options& asyncMaxQueueLength(size_t value) {

obx_opt_async_max_queue_length(opt, value);

return *this;

}

/// Producers (AsyncTx submitter) is throttled when the queue size hits this

Options& asyncThrottleAtQueueLength(size_t value) {

obx_opt_async_throttle_at_queue_length(opt, value);

return *this;

}

/// Sleeping time for throttled producers on each submission

Options& asyncThrottleMicros(uint32_t value) {

obx_opt_async_throttle_micros(opt, value);

return *this;

}

/// Maximum duration spent in a transaction before AsyncQ enforces a commit.

/// This becomes relevant if the queue is constantly populated at a high rate.

Options& asyncMaxInTxDuration(uint32_t micros) {

obx_opt_async_max_in_tx_duration(opt, micros);

return *this;

}

/// Maximum operations performed in a transaction before AsyncQ enforces a commit.

/// This becomes relevant if the queue is constantly populated at a high rate.

Options& asyncMaxInTxOperations(uint32_t value) {

obx_opt_async_max_in_tx_operations(opt, value);

return *this;

}

/// Before the AsyncQ is triggered by a new element in queue to starts a new run, it delays actually starting

/// the transaction by this value. This gives a newly starting producer some time to produce more than one a

/// single operation before AsyncQ starts. Note: this value should typically be low to keep latency low and

/// prevent accumulating too much operations.

Options& asyncPreTxnDelay(uint32_t delayMicros) {

obx_opt_async_pre_txn_delay(opt, delayMicros);

return *this;

}

/// Before the AsyncQ is triggered by a new element in queue to starts a new run, it delays actually starting

/// the transaction by this value. This gives a newly starting producer some time to produce more than one a

/// single operation before AsyncQ starts. Note: this value should typically be low to keep latency low and

/// prevent accumulating too much operations.

Options& asyncPreTxnDelay(uint32_t delayMicros, uint32_t delay2Micros, size_t minQueueLengthForDelay2) {

obx_opt_async_pre_txn_delay4(opt, delayMicros, delay2Micros, minQueueLengthForDelay2);

return *this;

}

/// Similar to preTxDelay but after a transaction was committed.

/// One of the purposes is to give other transactions some time to execute.

/// In combination with preTxDelay this can prolong non-TX batching time if only a few operations are around.

Options& asyncPostTxnDelay(uint32_t delayMicros) {

obx_opt_async_post_txn_delay(opt, delayMicros);

return *this;

}

/// Similar to preTxDelay but after a transaction was committed.

/// One of the purposes is to give other transactions some time to execute.

/// In combination with preTxDelay this can prolong non-TX batching time if only a few operations are around.

/// @param subtractProcessingTime If set, the delayMicros is interpreted from the start of TX processing.

/// In other words, the actual delay is delayMicros minus the TX processing time including the commit.

/// This can make timings more accurate (e.g. when fixed batching interval are given).

Options& asyncPostTxnDelay(uint32_t delayMicros, uint32_t delay2Micros, size_t minQueueLengthForDelay2,

bool subtractProcessingTime = false) {

obx_opt_async_post_txn_delay5(opt, delayMicros, delay2Micros, minQueueLengthForDelay2, subtractProcessingTime);

return *this;

}

/// Numbers of operations below this value are considered "minor refills"

Options& asyncMinorRefillThreshold(size_t queueLength) {

obx_opt_async_minor_refill_threshold(opt, queueLength);

return *this;

}

/// If non-zero, this allows "minor refills" with small batches that came in (off by default).

Options& asyncMinorRefillMaxCount(uint32_t value) {

obx_opt_async_minor_refill_max_count(opt, value);

return *this;

}

/// Default value: 10000, set to 0 to deactivate pooling

Options& asyncMaxTxPoolSize(size_t value) {

obx_opt_async_max_tx_pool_size(opt, value);

return *this;

}

/// Total cache size; default: ~ 0.5 MB

Options& asyncObjectBytesMaxCacheSize(uint64_t value) {

obx_opt_async_object_bytes_max_cache_size(opt, value);

return *this;

}

/// Maximal size for an object to be cached (only cache smaller ones)

Options& asyncObjectBytesMaxSizeToCache(uint64_t value) {

obx_opt_async_object_bytes_max_size_to_cache(opt, value);

return *this;

}

/// Registers a log callback, which is called for a selection of log events.

/// Note: this does not replace the default logging, which is much more extensive (at least at this point).

Options& logCallback(obx_log_callback* callback, void* userData) {

obx_opt_log_callback(opt, callback, userData);

return *this;

}

/// Before opening the database, this options instructs to restore the database content from the given backup file.

/// Note: backup is a server-only feature.

/// By default, actually restoring the backup is only performed if no database already exists

/// (database does not contain data).

/// @param flags For default behavior pass 0, or adjust defaults using OBXBackupRestoreFlags bit flags,

/// e.g., to overwrite all existing data in the database.

Options& backupRestore(const char* backupFile, uint32_t flags = 0) {

obx_opt_backup_restore(opt, backupFile, flags);

return *this;

}

/// Enables Write-ahead logging (WAL); for now this is only supported for in-memory DBs.

/// @param flags WAL itself is enabled by setting flag OBXWalFlags_EnableWal (also the default parameter value).

/// Combine with other flags using bitwise OR or switch off WAL by passing 0.

Options& wal(uint32_t flags = OBXWalFlags_EnableWal) {

obx_opt_wal(opt, flags);

return *this;

}

/// The WAL file gets consolidated when it reached this size limit when opening the database.

/// This setting is meant for applications that prefer to consolidate on startup,

/// which may avoid consolidations on commits while the application is running.

/// The default is 4096 (4 MB).

Options& walMaxFileSizeOnOpenInKb(uint64_t size_in_kb) {

obx_opt_wal_max_file_size_on_open_in_kb(opt, size_in_kb);

return *this;

}

/// The WAL file gets consolidated when it reaches this size limit after a commit.

/// As consolidation takes some time, it is a trade-off between accumulating enough data

/// and the time the consolidation takes (longer with more data).

/// The default is 16384 (16 MB).

Options& walMaxFileSizeInKb(uint64_t size_in_kb) {

obx_opt_wal_max_file_size_in_kb(opt, size_in_kb);

return *this;

}

std::atomic<OBX_store*> cStore_;

const bool owned_; ///< whether the store pointer is owned (true except for SyncServer::store())

std::shared_ptr<Closable> syncClient_;

std::mutex syncClientMutex_;

friend Sync;

friend SyncBuilder;

friend SyncClient;

friend SyncServer;

explicit Store(OBX_store* ptr, bool owned) : cStore_(ptr), owned_(owned) {

OBX_VERIFY_ARGUMENT(cStore_ != nullptr);

}

/// Return the (runtime) version of the library to be printed.

/// The current format is "major.minor.patch" (e.g. "1.0.0") but may change in any future release.

/// Thus, only use for information purposes.

/// @see getVersion() for integer based versions

static const char* versionCString() { return obx_version_string(); }

/// Creates a new string containing versionCString()

static std::string versionString() { return std::string(versionCString()); }

/// Return the version of the ObjectBox core to be printed (currently also contains a version date and features).

/// The format may change in any future release; only use for information purposes.

static const char* versionCoreCString() { return obx_version_core_string(); }

/// Creates a new string containing versionCoreCString()

static std::string versionCoreString() { return std::string(versionCoreCString()); }

/// Return the version of the library as ints. Pointers may be null

static void getVersion(int* major, int* minor, int* patch) { obx_version(major, minor, patch); }

/// Enable (or disable) debug logging for ObjectBox internals.

/// This requires a version of the library with the DebugLog feature.

/// You can check if the feature is available with obx_has_feature(OBXFeature_DebugLog).

static void debugLog(bool enabled) { internal::checkErrOrThrow(obx_debug_log(enabled)); }

/// Checks if debug logs are enabled for ObjectBox internals.

/// This depends on the availability of the DebugLog feature.

/// If the feature is available, it returns the current state, which is adjustable via obx_debug_log().

/// Otherwise, it always returns false for standard release builds

/// (or true if you are having a special debug version).

static bool debugLogEnabled() { return obx_debug_log_enabled(); }

/// Sets the runtime log level for ObjectBox internals.

/// @throws Exception if the call fails (e.g. level out of range).

static void logLevelSet(OBXLogLevel level) { internal::checkErrOrThrow(obx_log_level_set(level)); }

/// Gets the current runtime log level for ObjectBox internals.

static OBXLogLevel logLevelGet() { return obx_log_level_get(); }

/// Delete the store files from the given directory

static void removeDbFiles(const std::string& directory) {

internal::checkErrOrThrow(obx_remove_db_files(directory.c_str()));

}

static size_t getDbFileSize(const std::string& directory) { return obx_db_file_size(directory.c_str()); }

// -- Instance methods ---------------------------------------------------

/// Creates a Store with the given model and default Options.

explicit Store(OBX_model* model) : Store(Options().model(model)) {}

/// Creates a Store with the given Options, which also contain the data model.

explicit Store(Options& options)

: Store(internal::checkedPtrOrThrow(obx_store_open(options.release()), "Can not open store"), true) {}

/// Creates a Store with the given Options, which also contain the data model.

explicit Store(Options&& options) : Store(options) {}

/// Wraps an existing C-API store pointer, taking ownership (don't close it manually anymore)

explicit Store(OBX_store* cStore) : Store(cStore, true) {}

/// Can't be copied, single owner of C resources is required (to avoid double-free during destruction)

Store(const Store&) = delete;

Store(Store&& source) noexcept;

virtual ~Store();

/// @throws ShuttingDownException if the Store is closed (close() was call on the store).

OBX_store* cPtr() const;

/// @returns non-zero ID for the Store

uint64_t id() const;

/// Get Store type

/// @return One of ::OBXStoreTypeId

uint32_t getStoreTypeId() { return obx_store_type_id(cPtr()); }

/// Get the size of the store. For a disk-based store type, this corresponds to the size on disk, and for the

/// in-memory store type, this is roughly the used memory bytes occupied by the data.

/// @return the size in bytes of the database, or 0 if the file does not exist or some error occurred.

uint64_t getDbSize() const { return obx_store_size(cPtr()); }

/// The size in bytes occupied by the database on disk (if any).

/// @returns 0 if the underlying database is in-memory only, or the size could not be determined.

uint64_t getDbSizeOnDisk() const { return obx_store_size_on_disk(cPtr()); }

template <class EntityBinding>

Box<EntityBinding> box() {

return Box<EntityBinding>(*this);

}

/// Starts a transaction using the given mode.

Transaction tx(TxMode mode);

/// Starts a read(-only) transaction.

Transaction txRead();

/// Starts a (read &) write transaction.

Transaction txWrite();

/// Does not throw if the given type name is not found (it may still throw in other conditions).

obx_schema_id getEntityTypeIdNoThrow(const char* entityName) const {

return obx_store_entity_id(cPtr(), entityName);

}

obx_schema_id getEntityTypeId(const char* entityName) const {

obx_schema_id typeId = getEntityTypeIdNoThrow(entityName);

if (typeId == 0) internal::throwIllegalStateException("No entity type found for name: ", entityName);

return typeId;

}

/// Does not throw if the given property name is not found (it may still throw in other conditions).

obx_schema_id getPropertyIdNoThrow(obx_schema_id entityId, const char* propertyName) const {

return obx_store_entity_property_id(cPtr(), entityId, propertyName);

}

obx_schema_id getPropertyId(obx_schema_id entityId, const char* propertyName) const {

obx_schema_id propertyId = getPropertyIdNoThrow(entityId, propertyName);

if (propertyId == 0) internal::throwIllegalStateException("No property found for name: ", propertyName);

return propertyId;

}

obx_schema_id getPropertyId(const char* entityName, const char* propertyName) const {

return getPropertyId(getEntityTypeId(entityName), propertyName);

}

BoxTypeless boxTypeless(const char* entityName);

/// Await all (including future) async submissions to be completed (the async queue becomes empty).

/// @returns true if all submissions were completed (or async processing was not started)

/// @returns false if shutting down or an error occurred

bool awaitCompletion() { return obx_store_await_async_completion(cPtr()); }

/// Await previously submitted async operations to be completed (the async queue may still contain elements).

/// @returns true if all submissions were completed (or async processing was not started)

/// @returns false if shutting down or an error occurred

bool awaitSubmitted() { return obx_store_await_async_submitted(cPtr()); }

/// Backs up the store DB to the given backup-file, using the given flags.

/// Note: backup is a server-only feature.

/// @param flags 0 for defaults or OBXBackupFlags bit flags

void backUpToFile(const char* backupFile, uint32_t flags = 0) const {

obx_err err = obx_store_back_up_to_file(cPtr(), backupFile, flags);

internal::checkErrOrThrow(err);

}

/// @return an existing SyncClient associated with the store (if available; see Sync::client() to create one)

/// @note: implemented in objectbox-sync.hpp

std::shared_ptr<SyncClient> syncClient();

/// Prepares the store to close by setting its internal state to "closing".

/// Methods like tx() an boxFor() will throw ShuttingDownException once closing is initiated.

/// Unlike close(), this method will return immediately and does not free resources just yet.

/// This is typically used in a multi-threaded context to allow an orderly shutdown in stages which go through a

/// "not accepting new requests" state.

void prepareToClose();

/// Closes all resources of this store before the destructor is called, e.g. to avoid waiting in the destructor.

/// Avoid calling methods on the Store after this call; most methods will throw ShuttingDownException in that case.

/// Calling close() more than once have no effect, and concurrent calls to close() are fine too.

/// \note This waits for write transactions to finish before returning from this call.

/// \note The Store destructor also calls close(), so you do not have to call this method explicitly unless you want

/// to control the timing of closing resources and potentially waiting for asynchronous resources (e.g. transactions

/// and internal queues) to finish up.

void close();

source.cStore_ = nullptr;

std::lock_guard<std::mutex> lock(source.syncClientMutex_);

syncClient_ = std::move(source.syncClient_);

{

// Clean up SyncClient by explicitly closing it, even if it isn't the only shared_ptr to the instance.

// This prevents invalid use of store after it's been closed.

std::shared_ptr<Closable> syncClient;

{

std::lock_guard<std::mutex> lock(syncClientMutex_);

syncClient = std::move(syncClient_);

syncClient_ = nullptr; // to make the current state obvious

}

if (syncClient && !syncClient->isClosed()) {

#ifndef NDEBUG // todo we probably want our LOG macros here too

long useCount = syncClient.use_count();

if (useCount > 1) { // print external refs only thus "- 1"

printf("SyncClient still active with %ld references when store got closed\n", (useCount - 1));

}

#endif // NDEBUG

syncClient->close();

}

}

if (owned_) {

OBX_store* storeToClose = cStore_.exchange(nullptr); // Close exactly once

obx_store_close(storeToClose);

}

uint64_t id = obx_store_id(cPtr());

internal::checkIdOrThrow(id);

return id;

TxMode mode_;

OBX_txn* cTxn_;

Transaction(Store& store, TxMode mode);

/// Delete because the default copy constructor can break things (i.e. a Transaction can not be copied).

Transaction(const Transaction&) = delete;

/// Move constructor, used by Store::tx()

Transaction(Transaction&& source) noexcept : mode_(source.mode_), cTxn_(source.cTxn_) { source.cTxn_ = nullptr; }

/// Copy-and-swap style

Transaction& operator=(Transaction source);

/// Never throws

virtual ~Transaction() { closeNoThrow(); };

/// A Transaction is active if it was not ended via success(), close() or moving.

bool isActive() { return cTxn_ != nullptr; }

/// The transaction pointer of the ObjectBox C API.

/// @throws if this Transaction was already closed or moved

OBX_txn* cPtr() const;

/// "Finishes" this write transaction successfully; performs a commit if this is the top level transaction and all

/// inner transactions (if any) were also successful. This object will also be "closed".

/// @throws Exception if this is not a write TX or it was closed before (e.g. via success()).

void success();

/// Explicit close to free up resources (non-throwing version).

/// It's OK to call this method multiple times; additional calls will have no effect.

obx_err closeNoThrow();

/// Explicit close to free up resources; unlike closeNoThrow() (which is also called by the destructor), this

/// version throw in the unlikely case of failing.

/// It's OK to call this method multiple times; additional calls will have no effect.

void close();

/// The data size of the committed state (not updated for this transaction).

uint64_t getDataSizeCommitted() const;

/// Cumulative change (delta) of data size by this pending transaction (uncommitted).

int64_t getDataSizeChange() const;

OBX_txn* txn = cTxn_;

OBX_VERIFY_STATE(txn);

cTxn_ = nullptr;

internal::checkErrOrThrow(obx_txn_success(txn));