store options: add StoreOptions class, use it in Builder #41

Author: loryruta

objectbox/builder.py

@@ -16,33 +16,38 @@
 from objectbox.c import *
 from objectbox.model import Model
 from objectbox.objectbox import ObjectBox
+from objectbox.store_options import StoreOptions
 
 
 class Builder:
     def __init__(self):
         self._model = Model()
-        self._directory = ''
+        self._directory = None
+        self._max_db_size_in_kb = None
 
     def directory(self, path: str) -> 'Builder':
         self._directory = path
         return self
 
+    def max_db_size_in_kb(self, size_in_kb: int) -> 'Builder':
+        self._max_db_size_in_kb = size_in_kb
+        return self
+
     def model(self, model: Model) -> 'Builder':
         self._model = model
         self._model._finish()
         return self
 
     def build(self) -> 'ObjectBox':
-        c_options = obx_opt()
-
+        options = StoreOptions()
         try:
-            if len(self._directory) > 0:
-                obx_opt_directory(c_options, c_str(self._directory))
-
-            obx_opt_model(c_options, self._model._c_model)
+            if self._directory:
+                options.directory(self._directory)
+            if self._max_db_size_in_kb:
+                options.max_db_size_in_kb(self._max_db_size_in_kb)
+            options.model(self._model)
         except CoreException:
-            obx_opt_free(c_options)
+            options._free()
             raise
-
-        c_store = obx_store_open(c_options)
+        c_store = obx_store_open(options._c_handle)
         return ObjectBox(c_store)

objectbox/store_options.py

@@ -0,0 +1,158 @@
+from objectbox.c import *
+from objectbox.model import Model
+
+
+class StoreOptions:
+    """ A RAII wrapper to the C API for setting the store options. """
+
+    _c_handle: Optional[int]
+
+    def __init__(self):
+        self._c_handle = obx_opt()
+
+    def _free(self):
+        if self._c_handle is not None:
+            obx_opt_free(self._c_handle)
+            self._c_handle = None
+
+    def directory(self, path: str):
+        obx_opt_directory(self._c_handle, c_str(path))
+        return self
+
+    def max_db_size_in_kb(self, size_in_kb: int):
+        obx_opt_max_db_size_in_kb(self._c_handle, size_in_kb)
+        return self
+
+    def max_data_size_in_kb(self, size_in_kb: int):
+        obx_opt_max_data_size_in_kb(self._c_handle, size_in_kb)
+        return self
+
+    def file_mode(self, file_mode: int):
+        obx_opt_file_mode(self._c_handle, file_mode)
+        return self
+
+    def max_readers(self, max_readers: int):
+        obx_opt_max_readers(self._c_handle, max_readers)
+        return self
+
+    def no_reader_thread_locals(self, flag: bool):
+        obx_opt_max_readers(self._c_handle, flag)
+        return self
+
+    def model(self, model: Model):
+        obx_opt_model(self._c_handle, model._c_model)
+        return self
+
+    def model_bytes(self, bytes_: bytes):
+        obx_opt_model_bytes(self._c_handle, len(bytes_))
+        return self
+
+    def model_bytes_direct(self, bytes_: bytes):
+        obx_opt_model_bytes_direct(self._c_handle, len(bytes_))
+        return self
+
+    def validate_on_open_pages(self, page_limit: int, flags: int):
+        raise NotImplementedError  # TODO
+
+    def validate_on_open_kv(self, flags: OBXValidateOnOpenKvFlags):
+        raise NotImplementedError  # TODO
+
+    def put_padding_mode(self, mode: OBXPutPaddingMode):
+        obx_opt_put_padding_mode(self._c_handle, mode)
+        return self
+
+    def read_schema(self, value: bool):
+        obx_opt_read_schema(self._c_handle, value)
+        return self
+
+    def use_previous_commit(self, value: bool):
+        obx_opt_use_previous_commit(self._c_handle, value)
+        return self
+
+    def read_only(self, value: bool):
+        obx_opt_read_only(self._c_handle, value)
+        return self
+
+    def debug_flags(self, flags: OBXDebugFlags):
+        obx_opt_debug_flags(self._c_handle, flags)
+        return self
+
+    def add_debug_flags(self, flags: OBXDebugFlags):
+        obx_opt_add_debug_flags(self._c_handle, flags)
+        return self
+
+    def async_max_queue_length(self, value: int):
+        obx_opt_async_max_queue_length(self._c_handle, value)
+        return self
+
+    def async_throttle_at_queue_length(self, value: int):
+        obx_opt_async_throttle_at_queue_length(self._c_handle, value)
+        return self
+
+    def async_throttle_micros(self, value: int):
+        obx_opt_async_throttle_micros(self._c_handle, value)
+        return self
+
+    def async_max_in_tx_duration(self, micros: int):
+        obx_opt_async_max_in_tx_duration(self._c_handle, micros)
+        return self
+
+    def async_max_in_tx_operations(self, value: int):
+        obx_opt_async_max_in_tx_operations(self._c_handle, value)
+        return self
+
+    def async_pre_txn_delay(self, delay_micros: int):
+        obx_opt_async_pre_txn_delay(self._c_handle, delay_micros)
+        return self
+
+    def async_pre_txn_delay4(self, delay_micros: int, delay2_micros: int, min_queue_length_for_delay2: int):
+        obx_opt_async_pre_txn_delay4(self._c_handle, delay_micros, delay2_micros, min_queue_length_for_delay2)
+        return self
+
+    def async_post_txn_delay(self, delay_micros: int):
+        obx_opt_async_post_txn_delay(self._c_handle, delay_micros)
+        return self
+
+    def async_post_txn_delay5(self, delay_micros: int, delay2_micros: int, min_queue_length_for_delay2: int,
+                              subtract_processing_time: bool):
+        obx_opt_async_post_txn_delay5(self._c_handle, delay_micros, delay2_micros, min_queue_length_for_delay2,
+                                      subtract_processing_time)
+        return self
+
+    def async_minor_refill_threshold(self, queue_length: int):
+        obx_opt_async_minor_refill_threshold(self._c_handle, queue_length)
+        return self
+
+    def async_minor_refill_max_count(self, value: int):
+        obx_opt_async_minor_refill_max_count(self._c_handle, value)
+        return self
+
+    def async_max_tx_pool_size(self, value: int):
+        obx_opt_async_max_tx_pool_size(self._c_handle, value)
+        return self
+
+    def async_object_bytes_max_cache_size(self, value: int):
+        obx_opt_async_object_bytes_max_cache_size(self._c_handle, value)
+        return self
+
+    def async_object_bytes_max_size_to_cache(self, value: int):
+        obx_opt_async_object_bytes_max_size_to_cache(self._c_handle, value)
+        return self
+
+    # TODO def log_callback(self):
+
+    def backup_restore(self, backup_file: str, flags: OBXBackupRestoreFlags):
+        raise NotImplementedError  # TODO
+
+    def get_directory(self) -> str:
+        dir_bytes = obx_opt_get_directory(self._c_handle)
+        return dir_bytes.decode('utf-8')
+
+    def get_max_db_size_in_kb(self) -> int:
+        return obx_opt_get_max_db_size_in_kb(self._c_handle)
+
+    def get_max_data_size_in_kb(self) -> int:
+        return obx_opt_get_max_data_size_in_kb(self._c_handle)
+
+    def get_debug_flags(self) -> OBXDebugFlags:
+        return obx_opt_get_debug_flags(self._c_handle)