btrieveCpp.h

Go to the documentation of this file.

//
// Copyright (C) 2016 - Actian Corp.
//

// This file exists in both project "zen.core" and "zen.docs".
// Make sure that both files are kept in sync.
//
// When updating this file make the corresponding changes to "btrieveC.h".

#ifndef _BTRIEVECPP_H
#define _BTRIEVECPP_H

#include <cstddef>
#include <deque>

#include "btrieveC.h"

class BRestful;
class BtrieveBulkCreatePayload;
class BtrieveBulkCreateResult;
class BtrieveBulkDeleteAttributes;
class BtrieveBulkDeleteResult;
class BtrieveBulkRetrieveAttributes;
class BtrieveBulkRetrieveResult;
class BtrieveClient;
class BtrieveCollection;
class BtrieveDocumentSet;
class BtrieveFile;
class BtrieveFileAttributes;
class BtrieveFileInformation;
class BtrieveFilter;
class BtrieveIndexAttributes;
class BtrieveKeySegment;
class BtrieveVersion;

class LINKAGE Btrieve
{
public:
   static const int MAXIMUM_RECORD_LENGTH = BTRIEVE_MAXIMUM_RECORD_LENGTH;

   static const int MAXIMUM_KEY_LENGTH = BTRIEVE_MAXIMUM_KEY_LENGTH;

   static const int MAXIMUM_BULK_RECORD_COUNT = BTRIEVE_MAXIMUM_BULK_RECORD_COUNT;

   enum ACSMode {
      ACS_MODE_NONE = 0,
      ACS_MODE_NAMED = 1,
      ACS_MODE_NUMBERED = 2,
      ACS_MODE_CASE_INSENSITIVE = 3,
      ACS_MODE_DEFAULT = 4,
      ACS_MODE_UNKNOWN = -7
   };

   enum CreateMode {
      CREATE_MODE_OVERWRITE = 0,
      CREATE_MODE_NO_OVERWRITE = 1,
      CREATE_MODE_UNKNOWN = -7
   };

   enum Comparison {
      COMPARISON_NONE = 0,
      COMPARISON_EQUAL = 1,
      COMPARISON_GREATER_THAN = 2,
      COMPARISON_LESS_THAN = 3,
      COMPARISON_NOT_EQUAL = 4,
      COMPARISON_GREATER_THAN_OR_EQUAL = 5,
      COMPARISON_LESS_THAN_OR_EQUAL = 6,
      COMPARISON_LIKE = 7,
      COMPARISON_NOT_LIKE = 8,
      COMPARISON_JSON_QUERY_MATCH = 9,
      COMPARISON_UNKNOWN = -7
   };

   enum Connector {
      CONNECTOR_LAST = 0,
      CONNECTOR_AND = 1,
      CONNECTOR_OR = 2,
      CONNECTOR_UNKNOWN = -7
   };


   enum DiskDrive {
      DISK_DRIVE_A = 0, 
      DISK_DRIVE_B = 1, 
      DISK_DRIVE_C = 2,
      DISK_DRIVE_D = 3, 
      DISK_DRIVE_E = 4, 
      DISK_DRIVE_F = 5,
      DISK_DRIVE_G = 6, 
      DISK_DRIVE_H = 7, 
      DISK_DRIVE_I = 8,
      DISK_DRIVE_J = 9, 
      DISK_DRIVE_K = 10, 
      DISK_DRIVE_L = 11,
      DISK_DRIVE_M = 12, 
      DISK_DRIVE_N = 13, 
      DISK_DRIVE_O = 14,
      DISK_DRIVE_P = 15, 
      DISK_DRIVE_Q = 16, 
      DISK_DRIVE_R = 17,
      DISK_DRIVE_S = 18, 
      DISK_DRIVE_T = 19, 
      DISK_DRIVE_U = 20,
      DISK_DRIVE_V = 21, 
      DISK_DRIVE_W = 22, 
      DISK_DRIVE_X = 23,
      DISK_DRIVE_Y = 24, 
      DISK_DRIVE_Z = 25, 
      DISK_DRIVE_DEFAULT = 26,
      DISK_DRIVE_UNKNOWN = -7
   };

   enum DuplicateMode {
      DUPLICATE_MODE_NOT_ALLOWED = 0,
      DUPLICATE_MODE_ALLOWED_NONREPEATING = 1,
      DUPLICATE_MODE_ALLOWED_REPEATING = 2,
      DUPLICATE_MODE_UNKNOWN = -7
   };

   enum DataType {
      DATA_TYPE_CHAR = 0,
      DATA_TYPE_ZSTRING = 1,
      DATA_TYPE_INTEGER = 2,
      DATA_TYPE_UNSIGNED_BINARY = 3,
      DATA_TYPE_FLOAT = 4,
      DATA_TYPE_AUTOINCREMENT = 5,
      DATA_TYPE_DATE = 6,
      DATA_TYPE_NUMERICSTS = 7,
      DATA_TYPE_TIME = 8,
      DATA_TYPE_NUMERICSA = 9,
      DATA_TYPE_DECIMAL = 10,
      DATA_TYPE_CURRENCY = 11,
      DATA_TYPE_MONEY = 12,
      DATA_TYPE_TIMESTAMP = 13,
      DATA_TYPE_LOGICAL = 14,
      DATA_TYPE_WSTRING = 15,
      DATA_TYPE_NUMERIC = 16,
      DATA_TYPE_WZSTRING = 17,
      DATA_TYPE_BFLOAT = 18,
      DATA_TYPE_GUID = 19,
      DATA_TYPE_LSTRING = 20,
      DATA_TYPE_NULL_INDICATOR_SEGMENT = 21,
      DATA_TYPE_LEGACY_STRING = 22,
      DATA_TYPE_LEGACY_BINARY = 23,
      DATA_TYPE_AUTOTIMESTAMP = 24,
      DATA_TYPE_CLOB = 25,
      DATA_TYPE_TIMESTAMP2 = 26,
      DATA_TYPE_BIT = 27,
      DATA_TYPE_NUMERICSLB = 28,
      DATA_TYPE_NUMERICSLS = 29,
      DATA_TYPE_NUMERICSTB = 30,
      DATA_TYPE_UNKNOWN = -7 
   };

   enum FileVersion {
      FILE_VERSION_6_0 = 0,
      FILE_VERSION_6_1 = 1,
      FILE_VERSION_7_0 = 2,
      FILE_VERSION_8_0 = 3,
      FILE_VERSION_9_0 = 4,
      FILE_VERSION_9_5 = 5,
      FILE_VERSION_13_0 = 7,
      FILE_VERSION_DEFAULT = 6,
      FILE_VERSION_UNKNOWN = -7
   };

   enum FreeSpaceThreshold {
      FREE_SPACE_THRESHOLD_10_PERCENT = 0,
      FREE_SPACE_THRESHOLD_20_PERCENT = 1,
      FREE_SPACE_THRESHOLD_30_PERCENT = 2,
      FREE_SPACE_THRESHOLD_DEFAULT = 3,
      FREE_SPACE_THRESHOLD_UNKNOWN = -7
   };

   enum Index {
      INDEX_1 = 0,
      INDEX_2 = 1,
      INDEX_3 = 2,
      INDEX_4 = 3,
      INDEX_5 = 4,
      INDEX_6 = 5,
      INDEX_7 = 6,
      INDEX_8 = 7,
      INDEX_9 = 8,
      INDEX_10 = 9,
      INDEX_11 = 10,
      INDEX_12 = 11,
      INDEX_13 = 12,
      INDEX_14 = 13,
      INDEX_15 = 14,
      INDEX_16 = 15,
      INDEX_17 = 16,
      INDEX_18 = 17,
      INDEX_19 = 18,
      INDEX_20 = 19,
      INDEX_21 = 20,
      INDEX_22 = 21,
      INDEX_23 = 22,
      INDEX_24 = 23,
      INDEX_25 = 24,
      INDEX_26 = 25,
      INDEX_27 = 26,
      INDEX_28 = 27,
      INDEX_29 = 28,
      INDEX_30 = 29,
      INDEX_31 = 30,
      INDEX_32 = 31,
      INDEX_33 = 32,
      INDEX_34 = 33,
      INDEX_35 = 34,
      INDEX_36 = 35,
      INDEX_37 = 36,
      INDEX_38 = 37,
      INDEX_39 = 38,
      INDEX_40 = 39,
      INDEX_41 = 40,
      INDEX_42 = 41,
      INDEX_43 = 42,
      INDEX_44 = 43,
      INDEX_45 = 44,
      INDEX_46 = 45,
      INDEX_47 = 46,
      INDEX_48 = 47,
      INDEX_49 = 48,
      INDEX_50 = 49,
      INDEX_51 = 50,
      INDEX_52 = 51,
      INDEX_53 = 52,
      INDEX_54 = 53,
      INDEX_55 = 54,
      INDEX_56 = 55,
      INDEX_57 = 56,
      INDEX_58 = 57,
      INDEX_59 = 58,
      INDEX_60 = 59,
      INDEX_61 = 60,
      INDEX_62 = 61,
      INDEX_63 = 62,
      INDEX_64 = 63,
      INDEX_65 = 64,
      INDEX_66 = 65,
      INDEX_67 = 66,
      INDEX_68 = 67,
      INDEX_69 = 68,
      INDEX_70 = 69,
      INDEX_71 = 70,
      INDEX_72 = 71,
      INDEX_73 = 72,
      INDEX_74 = 73,
      INDEX_75 = 74,
      INDEX_76 = 75,
      INDEX_77 = 76,
      INDEX_78 = 77,
      INDEX_79 = 78,
      INDEX_80 = 79,
      INDEX_81 = 80,
      INDEX_82 = 81,
      INDEX_83 = 82,
      INDEX_84 = 83,
      INDEX_85 = 84,
      INDEX_86 = 85,
      INDEX_87 = 86,
      INDEX_88 = 87,
      INDEX_89 = 88,
      INDEX_90 = 89,
      INDEX_91 = 90,
      INDEX_92 = 91,
      INDEX_93 = 92,
      INDEX_94 = 93,
      INDEX_95 = 94,
      INDEX_96 = 95,
      INDEX_97 = 96,
      INDEX_98 = 97,
      INDEX_99 = 98,
      INDEX_100 = 99,
      INDEX_101 = 100,
      INDEX_102 = 101,
      INDEX_103 = 102,
      INDEX_104 = 103,
      INDEX_105 = 104,
      INDEX_106 = 105,
      INDEX_107 = 106,
      INDEX_108 = 107,
      INDEX_109 = 108,
      INDEX_110 = 109,
      INDEX_111 = 110,
      INDEX_112 = 111,
      INDEX_113 = 112,
      INDEX_114 = 113,
      INDEX_115 = 114,
      INDEX_116 = 115,
      INDEX_117 = 116,
      INDEX_118 = 117,
      INDEX_119 = 118,
      INDEX_SYSTEM_VERSION_2 = 124,
      INDEX_SYSTEM = 125, 
      INDEX_NONE = -1, 
      INDEX_UNKNOWN = -7
   };

   enum LocationMode {
      LOCATION_MODE_NO_PREFERENCE = 0,
      LOCATION_MODE_FORCE_LOCAL = 1,
      LOCATION_MODE_FORCE_REMOTE = 2,
      LOCATION_MODE_UNKNOWN = -7
   };

   enum LockMode {
      LOCK_MODE_NONE = 0,
      LOCK_MODE_SINGLE_WAIT = 1,
      LOCK_MODE_SINGLE_NO_WAIT = 2,
      LOCK_MODE_MULTIPLE_WAIT = 3,
      LOCK_MODE_MULTIPLE_NO_WAIT = 4,
      LOCK_MODE_UNKNOWN = -7
   };

   enum NullKeyMode {
      NULL_KEY_MODE_ALL_SEGMENTS = 0,
      NULL_KEY_MODE_ANY_SEGMENTS = 1,
      NULL_KEY_MODE_NONE = 2,
      NULL_KEY_MODE_UNKNOWN = -7 
   };

   enum OpenMode {
      OPEN_MODE_NORMAL = 0,
      OPEN_MODE_ACCELERATED = 1,
      OPEN_MODE_READ_ONLY = 2,
      OPEN_MODE_EXCLUSIVE = 3,
      OPEN_MODE_WRITABLE = 4,
      OPEN_MODE_UNKNOWN = -7
   };

   enum OwnerMode {
      OWNER_MODE_NONE = 0,
      OWNER_MODE_NO_ENCRYPTION_NO_READ_ALLOWED = 1,
      OWNER_MODE_NO_ENCRYPTION_READ_ALLOWED = 2,
      OWNER_MODE_ENCRYPTION_NO_READ_ALLOWED = 3,
      OWNER_MODE_ENCRYPTION_READ_ALLOWED = 4,
      OWNER_MODE_UNKNOWN = -7
   };

   enum EncryptType {
      ENCRYPT_TYPE_NONE = 0,
      ENCRYPT_TYPE_TRADITIONAL = 1,
      ENCRYPT_TYPE_128_BIT = 2,
      ENCRYPT_TYPE_AES_192 = 3,
      ENCRYPT_TYPE_AES_256 = 4,
      ENCRYPT_TYPE_UNKNOWN = -7
   };

   enum PageLockType {
      PAGE_LOCK_TYPE_NONE = 0,
      PAGE_LOCK_TYPE_DATA_PAGE = 1,
      PAGE_LOCK_TYPE_INDEX_PAGE = 2,
      PAGE_LOCK_TYPE_VARIABLE_PAGE = 3,
      PAGE_LOCK_TYPE_UNKNOWN = -7
   };

   enum PageSize {
      PAGE_SIZE_512 = 0,
      PAGE_SIZE_1024 = 1,
      PAGE_SIZE_1536 = 2,
      PAGE_SIZE_2048 = 3,
      PAGE_SIZE_3072 = 4,
      PAGE_SIZE_3584 = 5,
      PAGE_SIZE_4096 = 6,
      PAGE_SIZE_8192 = 7,
      PAGE_SIZE_16384 = 8,
      PAGE_SIZE_DEFAULT = 9,
      PAGE_SIZE_UNKNOWN = -7
   };

   enum RecordCompressionMode {
      RECORD_COMPRESSION_MODE_NONE = 0,
      RECORD_COMPRESSION_MODE_BLANK_TRUNCATION = 1,
      RECORD_COMPRESSION_MODE_RUN_LENGTH_ENCODING = 2,
      RECORD_COMPRESSION_MODE_UNKNOWN = -7
   };

   enum StatusCode {
      STATUS_CODE_NO_ERROR = 0,
      STATUS_CODE_INVALID_FUNCTION = 1,
      STATUS_CODE_IO_ERROR = 2,
      STATUS_CODE_FILE_NOT_OPEN = 3,
      STATUS_CODE_KEY_VALUE_NOT_FOUND = 4,
      STATUS_CODE_DUPLICATE_KEY_VALUE = 5,
      STATUS_CODE_INVALID_INDEX_NUMBER = 6,
      STATUS_CODE_DIFFERENT_INDEX_NUMBER = 7,
      STATUS_CODE_POSITION_NOT_SET = 8,
      STATUS_CODE_END_OF_FILE = 9,
      STATUS_CODE_MODIFIABLE_KEYVALUE_ERROR = 10,
      STATUS_CODE_FILENAME_BAD = 11,
      STATUS_CODE_FILE_NOT_FOUND = 12,
      STATUS_CODE_EXTENDED_FILE_ERROR = 13,
      STATUS_CODE_PREIMAGE_OPEN_ERROR = 14,
      STATUS_CODE_PREIMAGE_IO_ERROR = 15,
      STATUS_CODE_EXPANSION_ERROR = 16,
      STATUS_CODE_CLOSE_ERROR = 17,
      STATUS_CODE_DISKFULL = 18,
      STATUS_CODE_UNRECOVERABLE_ERROR = 19,
      STATUS_CODE_RECORD_MANAGER_INACTIVE = 20,
      STATUS_CODE_KEYBUFFER_TOO_SHORT = 21,
      STATUS_CODE_DATALENGTH_ERROR = 22,
      STATUS_CODE_POSITIONBLOCK_LENGTH = 23,
      STATUS_CODE_PAGE_SIZE_ERROR = 24,
      STATUS_CODE_CREATE_IO_ERROR = 25,
      STATUS_CODE_NUMBER_OF_INDEXES = 26,
      STATUS_CODE_INVALID_KEY_POSITION = 27,
      STATUS_CODE_INVALID_RECORD_LENGTH = 28,
      STATUS_CODE_INVALID_KEYLENGTH = 29,
      STATUS_CODE_NOT_A_BTRIEVE_FILE = 30,
      STATUS_CODE_FILE_ALREADY_EXTENDED = 31,
      STATUS_CODE_EXTEND_IO_ERROR = 32,
      STATUS_CODE_BTR_CANNOT_UNLOAD = 33,
      STATUS_CODE_INVALID_EXTENSION_NAME = 34,
      STATUS_CODE_DIRECTORY_ERROR = 35,
      STATUS_CODE_TRANSACTION_ERROR = 36,
      STATUS_CODE_TRANSACTION_IS_ACTIVE = 37,
      STATUS_CODE_TRANSACTION_FILE_IO_ERROR = 38,
      STATUS_CODE_END_TRANSACTION_ERROR = 39,
      STATUS_CODE_TRANSACTION_MAX_FILES = 40,
      STATUS_CODE_OPERATION_NOT_ALLOWED = 41,
      STATUS_CODE_INCOMPLETE_ACCEL_ACCESS = 42,
      STATUS_CODE_INVALID_RECORD_ADDRESS = 43,
      STATUS_CODE_NULL_KEYPATH = 44,
      STATUS_CODE_INCONSISTENT_KEY_FLAGS = 45,
      STATUS_CODE_ACCESS_TO_FILE_DENIED = 46,
      STATUS_CODE_MAXIMUM_OPEN_FILES = 47,
      STATUS_CODE_INVALID_ALT_SEQUENCE_DEF = 48,
      STATUS_CODE_KEY_TYPE_ERROR = 49,
      STATUS_CODE_OWNER_ALREADY_SET = 50,
      STATUS_CODE_INVALID_OWNER = 51,
      STATUS_CODE_ERROR_WRITING_CACHE = 52,
      STATUS_CODE_INVALID_INTERFACE = 53,
      STATUS_CODE_VARIABLE_PAGE_ERROR = 54,
      STATUS_CODE_AUTOINCREMENT_ERROR = 55,
      STATUS_CODE_INCOMPLETE_INDEX = 56,
      STATUS_CODE_EXPANED_MEM_ERROR = 57,
      STATUS_CODE_COMPRESS_BUFFER_TOO_SHORT = 58,
      STATUS_CODE_FILE_ALREADY_EXISTS = 59,
      STATUS_CODE_REJECT_COUNT_REACHED = 60,
      STATUS_CODE_SMALL_EX_GET_BUFFER_ERROR = 61,
      STATUS_CODE_INVALID_GET_EXPRESSION = 62,
      STATUS_CODE_INVALID_EXT_INSERT_BUFF = 63,
      STATUS_CODE_OPTIMIZE_LIMIT_REACHED = 64,
      STATUS_CODE_INVALID_EXTRACTOR = 65,
      STATUS_CODE_RI_TOO_MANY_DATABASES = 66,
      STATUS_CODE_RIDDF_CANNOT_OPEN = 67,
      STATUS_CODE_RI_CASCADE_TOO_DEEP = 68,
      STATUS_CODE_RI_CASCADE_ERROR = 69,
      STATUS_CODE_RI_VIOLATION = 71,
      STATUS_CODE_RI_REFERENCED_FILE_CANNOT_OPEN = 72,
      STATUS_CODE_RI_OUT_OF_SYNC = 73,
      STATUS_CODE_END_CHANGED_TO_ABORT = 74,
      STATUS_CODE_RI_CONFLICT = 76,
      STATUS_CODE_CANT_LOOP_IN_SERVER = 77,
      STATUS_CODE_DEAD_LOCK = 78,
      STATUS_CODE_PROGRAMMING_ERROR = 79,
      STATUS_CODE_CONFLICT = 80,
      STATUS_CODE_LOCKERROR = 81,
      STATUS_CODE_LOST_POSITION = 82,
      STATUS_CODE_READ_OUTSIDE_TRANSACTION = 83,
      STATUS_CODE_RECORD_INUSE = 84,
      STATUS_CODE_FILE_INUSE = 85,
      STATUS_CODE_FILE_TABLE_FULL = 86,
      STATUS_CODE_NOHANDLES_AVAILABLE = 87,
      STATUS_CODE_INCOMPATIBLE_MODE_ERROR = 88,
      STATUS_CODE_DEVICE_TABLE_FULL = 90,
      STATUS_CODE_SERVER_ERROR = 91,
      STATUS_CODE_TRANSACTION_TABLE_FULL = 92,
      STATUS_CODE_INCOMPATIBLE_LOCK_TYPE = 93,
      STATUS_CODE_PERMISSION_ERROR = 94,
      STATUS_CODE_SESSION_NO_LONGER_VALID = 95,
      STATUS_CODE_COMMUNICATIONS_ERROR = 96,
      STATUS_CODE_DATA_MESSAGE_TOO_SMALL = 97,
      STATUS_CODE_INTERNAL_TRANSACTION_ERROR = 98,
      STATUS_CODE_REQUESTER_CANT_ACCESS_RUNTIME = 99,
      STATUS_CODE_NO_CACHE_BUFFERS_AVAIL = 100,
      STATUS_CODE_NO_OS_MEMORY_AVAIL = 101,
      STATUS_CODE_NO_STACK_AVAIL = 102,
      STATUS_CODE_CHUNK_OFFSET_TOO_LONG = 103,
      STATUS_CODE_LOCALE_ERROR = 104,
      STATUS_CODE_CANNOT_CREATE_WITH_VAT = 105,
      STATUS_CODE_CHUNK_CANNOT_GET_NEXT = 106,
      STATUS_CODE_CHUNK_INCOMPATIBLE_FILE = 107,
      STATUS_CODE_TRANSACTION_TOO_COMPLEX = 109,
      STATUS_CODE_ARCH_BLOG_OPEN_ERROR = 110,
      STATUS_CODE_ARCH_FILE_NOT_LOGGED = 111,
      STATUS_CODE_ARCH_FILE_IN_USE = 112,
      STATUS_CODE_ARCH_LOGFILE_NOT_FOUND = 113,
      STATUS_CODE_ARCH_LOGFILE_INVALID = 114,
      STATUS_CODE_ARCH_DUMPFILE_ACCESS_ERROR = 115,
      STATUS_CODE_LOCATOR_FILE_INDICATOR = 116,
      STATUS_CODE_NO_SYSTEM_LOCKS_AVAILABLE = 130,
      STATUS_CODE_FILE_FULL = 132,
      STATUS_CODE_MORE_THAN_5_CONCURRENT_USERS = 133,
      STATUS_CODE_ISR_NOT_FOUND = 134,
      STATUS_CODE_ISR_INVALID = 135,
      STATUS_CODE_ACS_NOT_FOUND = 136,
      STATUS_CODE_CANNOT_CONVERT_RP = 137,
      STATUS_CODE_INVALID_NULL_INDICATOR = 138,
      STATUS_CODE_INVALID_KEY_OPTION = 139,
      STATUS_CODE_INCOMPATIBLE_CLOSE = 140,
      STATUS_CODE_INVALID_USERNAME = 141,
      STATUS_CODE_INVALID_DATABASE = 142,
      STATUS_CODE_NO_SSQL_RIGHTS = 143,
      STATUS_CODE_ALREADY_LOGGED_IN = 144,
      STATUS_CODE_NO_DATABASE_SERVICES = 145,
      STATUS_CODE_DUPLICATE_SYSTEM_KEY = 146,
      STATUS_CODE_LOG_SEGMENT_MISSING = 147,
      STATUS_CODE_ROLL_FORWARD_ERROR = 148,
      STATUS_CODE_SYSTEM_KEY_INTERNAL = 149,
      STATUS_CODE_DBS_INTERNAL_ERROR = 150,
      STATUS_CODE_CHUNK_OFFSET_TOO_SMALL = 151,
      STATUS_CODE_INVALID_PARAMETER_TO_MKDE = 160,
      STATUS_CODE_USER_COUNT_LIMIT_EXCEEDED = 161,
      STATUS_CODE_CLIENT_TABLE_FULL = 162,
      STATUS_CODE_LAST_SEGMENT_ERROR = 163,
      STATUS_CODE_LOGIN_FAILED_BAD_USERNAME = 170,
      STATUS_CODE_LOGIN_FAILED_BAD_PASSWORD = 171,
      STATUS_CODE_LOGIN_FAILED_BAD_DATABASE = 172,
      STATUS_CODE_LOGIN_ALREADY_LOGGED_IN = 173,
      STATUS_CODE_LOGIN_LOGOUT_FAILED = 174,
      STATUS_CODE_LOGIN_WRONG_URI_FORMAT = 175,
      STATUS_CODE_LOGIN_FILE_AND_TABLE_NOT_FOUND = 176,
      STATUS_CODE_LOGIN_TABLE_NOT_IN_DATABASE = 177,
      STATUS_CODE_LOGIN_DIRECTORY_NOT_IN_DATABASE = 178,
      STATUS_CODE_LOCK_PARM_OUTOFRANGE = 1001,
      STATUS_CODE_MEM_ALLOCATION_ERR = 1002,
      STATUS_CODE_MEM_PARM_TOO_SMALL = 1003,
      STATUS_CODE_PAGE_SIZE_PARM_OUTOFRANGE = 1004,
      STATUS_CODE_INVALID_PREIMAGE_PARM = 1005,
      STATUS_CODE_PREIMAGE_BUF_PARM_OUTOFRANGE = 1006,
      STATUS_CODE_FILES_PARM_OUTOFRANGE = 1007,
      STATUS_CODE_INVALID_INIT_PARM = 1008,
      STATUS_CODE_INVALID_TRANS_PARM = 1009,
      STATUS_CODE_ERROR_ACC_TRANS_CONTROL_FILE = 1010,
      STATUS_CODE_COMPRESSION_BUF_PARM_OUTOFRANGE = 1011,
      STATUS_CODE_INV_N_OPTION = 1012,
      STATUS_CODE_TASK_LIST_FULL = 1013,
      STATUS_CODE_STOP_WARNING = 1014,
      STATUS_CODE_POINTER_PARM_INVALID = 1015,
      STATUS_CODE_ALREADY_INITIALIZED = 1016,
      STATUS_CODE_REQ_CANT_FIND_RES_DLL = 1017,
      STATUS_CODE_ALREADY_INSIDE_BTR_FUNCTION = 1018,
      STATUS_CODE_CALLBACK_ABORT = 1019,
      STATUS_CODE_INTF_COMM_ERROR = 1020,
      STATUS_CODE_FAILED_TO_INITIALIZE = 1021,
      STATUS_CODE_MKDE_SHUTTING_DOWN = 1022,
      STATUS_CODE_INTERNAL_ERROR = 2000,
      STATUS_CODE_INSUFFICIENT_MEM_ALLOC = 2001,
      STATUS_CODE_INVALID_OPTION = 2002,
      STATUS_CODE_NO_LOCAL_ACCESS_ALLOWED = 2003,
      STATUS_CODE_SPX_NOT_INSTALLED = 2004,
      STATUS_CODE_INCORRECT_SPX_VERSION = 2005,
      STATUS_CODE_NO_AVAIL_SPX_CONNECTION = 2006,
      STATUS_CODE_INVALID_PTR_PARM = 2007,
      STATUS_CODE_CANT_CONNECT_TO_615 = 2008,
      STATUS_CODE_CANT_LOAD_MKDE_ROUTER = 2009,
      STATUS_CODE_UT_THUNK_NOT_LOADED = 2010,
      STATUS_CODE_NO_RESOURCE_DLL = 2011,
      STATUS_CODE_OS_ERROR = 2012,
      STATUS_CODE_MK_ROUTER_MEM_ERROR = 3000,
      STATUS_CODE_MK_NO_LOCAL_ACCESS_ALLOWED = 3001,
      STATUS_CODE_MK_NO_RESOURCE_DLL = 3002,
      STATUS_CODE_MK_INCOMPAT_COMPONENT = 3003,
      STATUS_CODE_MK_TIMEOUT_ERROR = 3004,
      STATUS_CODE_MK_OS_ERROR = 3005,
      STATUS_CODE_MK_INVALID_SESSION = 3006,
      STATUS_CODE_MK_SERVER_NOT_FOUND = 3007,
      STATUS_CODE_MK_INVALID_CONFIG = 3008,
      STATUS_CODE_MK_NETAPI_NOT_LOADED = 3009,
      STATUS_CODE_MK_NWAPI_NOT_LOADED = 3010,
      STATUS_CODE_MK_THUNK_NOT_LOADED = 3011,
      STATUS_CODE_MK_LOCAL_NOT_LOADED = 3012,
      STATUS_CODE_MK_PNSL_NOT_LOADED = 3013,
      STATUS_CODE_MK_CANT_FIND_ENGINE = 3014,
      STATUS_CODE_MK_INIT_ERROR = 3015,
      STATUS_CODE_MK_INTERNAL_ERROR = 3016,
      STATUS_CODE_MK_LOCAL_MKDE_DATABUF_TOO_SMALL = 3017,
      STATUS_CODE_MK_CLOSED_ERROR = 3018,
      STATUS_CODE_MK_SEMAPHORE_ERROR = 3019,
      STATUS_CODE_MK_LOADING_ERROR = 3020,
      STATUS_CODE_MK_BAD_SRB_FORMAT = 3021,
      STATUS_CODE_MK_DATABUF_LEN_TOO_LARGE = 3022,
      STATUS_CODE_MK_TASK_TABLE_FULL = 3023,
      STATUS_CODE_MK_INVALID_OP_ON_REMOTE = 3024,
      STATUS_CODE_MK_PIDS_NOT_LOADED = 3025,
      STATUS_CODE_MK_BAD_PIDS = 3026,
      STATUS_CODE_MK_IDS_CONNECT_FAILURE = 3027,
      STATUS_CODE_MK_IDS_LOGIN_FAILURE = 3028,
      STATUS_CODE_NL_FAILURE = 3101,
      STATUS_CODE_NL_NOT_INITIALIZED = 3102,
      STATUS_CODE_NL_NAME_NOT_FOUND = 3103,
      STATUS_CODE_NL_PERMISSION_ERROR = 3104,
      STATUS_CODE_NL_NO_AVAILABLE_TRANSPORT = 3105,
      STATUS_CODE_NL_CONNECTION_FAILURE = 3106,
      STATUS_CODE_NL_OUT_OF_MEMORY = 3107,
      STATUS_CODE_NL_INVALID_SESSION = 3108,
      STATUS_CODE_NL_MORE_DATA = 3109,
      STATUS_CODE_NL_NOT_CONNECTED = 3110,
      STATUS_CODE_NL_SEND_FAILURE = 3111,
      STATUS_CODE_NL_RECEIVE_FAILURE = 3112,
      STATUS_CODE_NL_INVALID_SERVER_TYPE = 3113,
      STATUS_CODE_NL_SRT_FULL = 3114,
      STATUS_CODE_NL_TRANSPORT_FAILURE = 3115,
      STATUS_CODE_NL_RCV_DATA_OVERFLOW = 3116,
      STATUS_CODE_NL_CST_FULL = 3117,
      STATUS_CODE_NL_INVALID_ADDRESS_FAMILY = 3118,
      STATUS_CODE_NL_NO_AUTH_CONTEXT_AVAILABLE = 3119,
      STATUS_CODE_NL_INVALID_AUTH_TYPE = 3120,
      STATUS_CODE_NL_INVALID_AUTH_OBJECT = 3121,
      STATUS_CODE_NL_AUTH_LEN_TOO_SMALL = 3122,
      STATUS_CODE_NL_INVALID_SESSION_LEVEL_PARM = 3123,
      STATUS_CODE_NL_TASK_TABLE_FULL = 3124,
      STATUS_CODE_NL_NDS_NAME_RESOLUTION_ERROR = 3125,
      STATUS_CODE_NL_FILE_NAME_RESOLUTION_ERROR = 3126,
      STATUS_CODE_NL_IDS_SEND_FAILURE = 3127,
      STATUS_CODE_NL_IDS_RCV_FAILURE = 3128,
      STATUS_CODE_UNKNOWN = -7,
   };

   enum SystemDataMode {
      SYSTEM_DATA_MODE_YES = 0, 
      SYSTEM_DATA_MODE_NO = 1,
      SYSTEM_DATA_MODE_DEFAULT = 2,
      SYSTEM_DATA_MODE_VERSION_2 = 3,
      SYSTEM_DATA_MODE_UNKNOWN = -7
   };

   enum TransactionMode {
      TRANSACTION_MODE_EXCLUSIVE = 0,
      TRANSACTION_MODE_CONCURRENT_WRITE_WAIT = 1,
      TRANSACTION_MODE_CONCURRENT_NO_WRITE_WAIT = 2,
      TRANSACTION_MODE_UNKNOWN = -7
   };

   enum UnlockMode {
      UNLOCK_MODE_SINGLE = 0,
      UNLOCK_MODE_MULTIPLE = 1,
      UNLOCK_MODE_UNKNOWN = -7
   };

   enum VariableLengthRecordsMode {
      VARIABLE_LENGTH_RECORDS_MODE_NO = 0, 
      VARIABLE_LENGTH_RECORDS_MODE_YES = 1,
      VARIABLE_LENGTH_RECORDS_MODE_YES_VARIABLE_ALLOCATION_TAILS = 2,
      VARIABLE_LENGTH_RECORDS_MODE_UNKNOWN = -7
   };

   enum VersionType {
      VERSION_TYPE_NONE = 0, 
      VERSION_TYPE_BTRIEVE_ENGINE = 1, 
      VERSION_TYPE_WORKGROUP_ENGINE = 2,
      VERSION_TYPE_DOS_WORKSTATION = 3, 
      VERSION_TYPE_CLIENT_REQUESTOR = 4,
      VERSION_TYPE_WINDOWS_SERVER_ENGINE = 5, 
      VERSION_TYPE_UNIX = 6, 
      VERSION_TYPE_CLIENT_ENGINE = 7, 
      VERSION_TYPE_UNKNOWN = -7
   };

   enum SystemField {
      SYSTEM_FIELD_CREATE_TIME = 0,
      SYSTEM_FIELD_UPDATE_TIME = 1,
      SYSTEM_FIELD_UNKNOWN = -7 
   };

   static const char *ACSModeToString(ACSMode ACSMode);
   static const char *DuplicateModeToString(DuplicateMode duplicateMode);
   static const char *DataTypeToString(DataType dataType);
   static const char *FileVersionToString(FileVersion fileVersion);
   static const char *FreeSpaceThresholdToString(FreeSpaceThreshold freeSpaceThreshold);
   static const char *IndexToString(Index index);
   static const char *NullKeyModeToString(NullKeyMode nullKeyMode);
   static const char *PageSizeToString(PageSize pageSize);
   static const char *RecordCompressionModeToString(RecordCompressionMode recordCompressionMode);
   static const char *StatusCodeToString(StatusCode statusCode);
   static const char *SystemDataModeToString(SystemDataMode systemDataMode);
   static const char *VersionTypeToString(VersionType versionType);
   static const char *PageLockTypeToString(PageLockType pageLockType);
   static const char *LockModeToString(LockMode lockMode);
   static const char *OwnerModeToString(OwnerMode ownerMode);
   static const char *EncryptTypeToString(EncryptType encryptType);
   static const char *VariableLengthRecordsModeToString(VariableLengthRecordsMode variableLengthRecordsMode);
   static const char *SystemFieldToString(SystemField systemField);
   static long long UnixEpochMicrosecondsToTimestamp(long long microseconds);
   static long long TimestampToUnixEpochMicroseconds(long long timestamp);

private:
   Btrieve();
   ~Btrieve();
};

class LINKAGE BtrieveClient
{
public:
   BtrieveClient();
   BtrieveClient(int serviceAgentIdentifier, int clientIdentifier);
   ~BtrieveClient();

   Btrieve::StatusCode GetVersion(BtrieveVersion *btrieveVersion, BtrieveFile *btrieveFile = NULL);
   Btrieve::StatusCode FileOpen(BtrieveFile *btrieveFile, const char *fileName, const char *ownerName, Btrieve::OpenMode openMode, Btrieve::LocationMode locationMode = Btrieve::LOCATION_MODE_NO_PREFERENCE);
   Btrieve::StatusCode FileOpen(BtrieveFile *btrieveFile, const wchar_t *fileName, const char *ownerName, Btrieve::OpenMode openMode, Btrieve::LocationMode locationMode = Btrieve::LOCATION_MODE_NO_PREFERENCE);

// Avoid Windows renaming of GetCurrentDirectory.
#ifdef GetCurrentDirectory
   #undef GetCurrentDirectory
#endif

   const char *GetCurrentDirectory(Btrieve::DiskDrive diskDrive);
#ifndef SWIG
   Btrieve::StatusCode GetCurrentDirectory(Btrieve::DiskDrive diskDrive, char *currentDirectory, int currentDirectorySize);
#endif
   Btrieve::StatusCode GetCurrentDirectory(Btrieve::DiskDrive diskDrive, wchar_t *currentDirectory, int currentDirectorySize);
   Btrieve::StatusCode ContinuousOperationBegin(const char *pathNames);
   Btrieve::StatusCode ContinuousOperationBegin(const wchar_t *pathNames);
   Btrieve::StatusCode ContinuousOperationEnd(const char *pathNames);
   Btrieve::StatusCode ContinuousOperationEnd(const wchar_t *pathNames);
   Btrieve::StatusCode FileClose(BtrieveFile *btrieveFile);  
   Btrieve::StatusCode FileCreate(BtrieveFileAttributes *btrieveFileAttributes, const char *fileName, Btrieve::CreateMode createMode, Btrieve::LocationMode locationMode = Btrieve::LOCATION_MODE_NO_PREFERENCE);
   Btrieve::StatusCode FileCreate(BtrieveFileAttributes *btrieveFileAttributes, BtrieveIndexAttributes *btrieveIndexAttributes, const char *fileName, Btrieve::CreateMode createMode, Btrieve::LocationMode locationMode = Btrieve::LOCATION_MODE_NO_PREFERENCE);
   Btrieve::StatusCode FileCreate(BtrieveFileAttributes *btrieveFileAttributes, const wchar_t *fileName, Btrieve::CreateMode createMode, Btrieve::LocationMode locationMode = Btrieve::LOCATION_MODE_NO_PREFERENCE);
   Btrieve::StatusCode FileCreate(BtrieveFileAttributes *btrieveFileAttributes, BtrieveIndexAttributes *btrieveIndexAttributes, const wchar_t *fileName, Btrieve::CreateMode createMode, Btrieve::LocationMode locationMode = Btrieve::LOCATION_MODE_NO_PREFERENCE);
   Btrieve::StatusCode FileDelete(const char *fileName);
   Btrieve::StatusCode FileDelete(const wchar_t *fileName);
   Btrieve::StatusCode FileRename(const char *existingFileName, const char *newFileName);
   Btrieve::StatusCode FileRename(const wchar_t *existingFileName, const wchar_t *newFileName);
   Btrieve::StatusCode GetLastStatusCode();
   Btrieve::StatusCode Login(const char *databaseURI);
   Btrieve::StatusCode Login(const wchar_t *databaseURI);
   Btrieve::StatusCode Logout(const char *databaseURI);
   Btrieve::StatusCode Logout(const wchar_t *databaseURI);
   Btrieve::StatusCode Reset();

// Avoid Windows renaming of SetCurrentDirectory.
#ifdef SetCurrentDirectory
   #undef SetCurrentDirectory
#endif

   Btrieve::StatusCode SetCurrentDirectory(const char *currentDirectory);
   Btrieve::StatusCode SetCurrentDirectory(const wchar_t *currentDirectory);
   Btrieve::StatusCode Stop();
   Btrieve::StatusCode TransactionAbort();
   Btrieve::StatusCode TransactionBegin(Btrieve::TransactionMode transactionMode, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   Btrieve::StatusCode TransactionEnd();
   int GetServiceAgentIdentifier();
   int GetClientIdentifier();
   Btrieve::StatusCode CollectionCreate(const char *collectionName);
   Btrieve::StatusCode CollectionDelete(const char *collectionName);
   Btrieve::StatusCode CollectionRename(const char *existingCollectionName, const char *newCollectionName);
   Btrieve::StatusCode CollectionOpen(BtrieveCollection *btrieveCollection, const char *collectionName, const char *password = NULL);
   Btrieve::StatusCode CollectionClose(BtrieveCollection *btrieveCollection);  

private:
   btrieve_client_t btrieveClient = NULL;
};

class LINKAGE BtrieveFile
{
   friend class BtrieveClient;

protected:
   btrieve_file_t GetBtrieveFile();
   btrieve_file_t *GetBtrieveFilePtr();
   BtrieveFile(btrieve_file_t btrieveFileIn);

public:
   BtrieveFile();
   ~BtrieveFile();

   Btrieve::StatusCode RecordDelete();
   int RecordRetrieveByFraction(Btrieve::Index index, int numerator, int denominator, char *record, int recordSize, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   int RecordRetrieveByFraction(Btrieve::Index index, int numerator, int denominator, char *key, int keySize, char *record, int recordSize, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   int RecordRetrieveByPercentage(Btrieve::Index index, int percentage, char *record, int recordSize, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   int RecordRetrieveByPercentage(Btrieve::Index index, int percentage, char *key, int keySize, char *record, int recordSize, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   int RecordRetrieveByCursorPosition(Btrieve::Index index, long long cursorPosition, char *record, int recordSize, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   int RecordRetrieveByCursorPosition(Btrieve::Index index, long long cursorPosition, char *key, int keySize, char *record, int recordSize, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   int RecordRetrieve(Btrieve::Comparison comparison, Btrieve::Index index, char *key, int keyLength, char *record, int recordSize, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   Btrieve::StatusCode KeyRetrieve(Btrieve::Comparison comparison, Btrieve::Index index, char *key, int keyLength);
   Btrieve::StatusCode BulkRetrieveNext(BtrieveBulkRetrieveAttributes *bulkRetrieveAttributes, BtrieveBulkRetrieveResult *bulkRetrieveResult, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   Btrieve::StatusCode BulkRetrievePrevious(BtrieveBulkRetrieveAttributes *bulkRetrieveAttributes, BtrieveBulkRetrieveResult *bulkRetrieveResult, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   Btrieve::StatusCode BulkDeleteNext(BtrieveBulkDeleteAttributes *bulkDeleteAttributes, BtrieveBulkDeleteResult *bulkDeleteResult);
   Btrieve::StatusCode BulkDeletePrevious(BtrieveBulkDeleteAttributes *bulkDeleteAttributes, BtrieveBulkDeleteResult *bulkDeleteResult);
   Btrieve::StatusCode GetInformation(BtrieveFileInformation *btrieveFileInformation);
   int RecordRetrieveFirst(Btrieve::Index index, char *record, int recordSize, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   int RecordRetrieveFirst(Btrieve::Index index, char *key, int keySize, char *record, int recordSize, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   Btrieve::StatusCode KeyRetrieveFirst(Btrieve::Index index, char *key, int keySize);
   int GetNumerator(long long cursorPosition, int denominator);
   int GetNumerator(Btrieve::Index index, const char *key, int keyLength, int denominator);
   int RecordRetrieveLast(Btrieve::Index index, char *record, int recordSize, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   int RecordRetrieveLast(Btrieve::Index index, char *key, int keySize, char *record, int recordSize, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   Btrieve::StatusCode KeyRetrieveLast(Btrieve::Index index, char *key, int keySize);
   Btrieve::StatusCode GetLastStatusCode();
   Btrieve::StatusCode KeyRetrieveNext(char *key, int keySize);
   int RecordRetrieveNext(char *record, int recordSize, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   int RecordRetrieveNext(char *key, int keySize, char *record, int recordSize, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   int GetPercentage(long long cursorPosition);
   int GetPercentage(Btrieve::Index index, const char *key, int keyLength);
   long long GetCursorPosition();
   long long GetRecordCreateTime();
   long long GetRecordUpdateTime();
   Btrieve::StatusCode KeyRetrievePrevious(char *key, int keySize);
   int RecordRetrievePrevious(char *record, int recordSize, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   int RecordRetrievePrevious(char *key, int keySize, char *record, int recordSize, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   int RecordRetrieveChunk(int offset, int length, char *chunk, int chunkSize, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   int RecordRetrieveChunk(int length, char *chunk, int chunkSize, Btrieve::LockMode lockMode = Btrieve::LOCK_MODE_NONE);
   Btrieve::StatusCode IndexCreate(BtrieveIndexAttributes *btrieveIndexAttributes);
   Btrieve::StatusCode IndexDrop(Btrieve::Index index);
   Btrieve::StatusCode RecordCreate(char *record, int recordLength);
   Btrieve::StatusCode BulkCreate(BtrieveBulkCreatePayload *btrieveBulkCreatePayload, BtrieveBulkCreateResult *btrieveBulkCreateResult);
   Btrieve::StatusCode SetOwner(Btrieve::OwnerMode ownerMode, const char *ownerName = NULL, const char *ownerNameAgain = NULL, bool useLongOwnerName = true);
   Btrieve::StatusCode RecordTruncate(int offset);
   Btrieve::StatusCode RecordTruncate();
   Btrieve::StatusCode RecordUnlock(Btrieve::UnlockMode unlockMode);
   Btrieve::StatusCode UnlockCursorPosition(long long cursorPosition);
   Btrieve::StatusCode RecordUpdate(const char *record, int recordLength);
   Btrieve::StatusCode RecordAppendChunk(const char *chunk, int chunkLength);
   Btrieve::StatusCode RecordDeleteChunk(int offset, int chunkLength);
   Btrieve::StatusCode RecordDeleteChunk(int chunkLength);
   Btrieve::StatusCode RecordInsertChunk(int offset, const char *chunk, int chunkLength);
   Btrieve::StatusCode RecordInsertChunk(const char *chunk, int chunkLength);
   Btrieve::StatusCode RecordUpdateChunk(int offset, const char *chunk, int chunkLength);
   Btrieve::StatusCode RecordUpdateChunk(const char *chunk, int chunkLength);

private:
   btrieve_file_t btrieveFile = NULL;
};

class LINKAGE BtrieveFileAttributes
{
   friend class BtrieveClient;

protected:
   btrieve_file_attributes_t GetBtrieveFileAttributes();

public:
   BtrieveFileAttributes();
   ~BtrieveFileAttributes();

   Btrieve::StatusCode SetBalancedIndexes(bool enableBalancedIndexes);
   Btrieve::StatusCode SetRecordCompressionMode(Btrieve::RecordCompressionMode recordCompressionMode);
   Btrieve::StatusCode SetReservedDuplicatePointerCount(int reservedDuplicatePointerCount);
   Btrieve::StatusCode SetFileVersion(Btrieve::FileVersion fileVersion);
   Btrieve::StatusCode SetFreeSpaceThreshold(Btrieve::FreeSpaceThreshold freeSpaceThreshold);
   Btrieve::StatusCode SetPageSize(Btrieve::PageSize pageSize, bool enablePageCompression = false);
   Btrieve::StatusCode SetFixedRecordLength(int fixedRecordLength);
   Btrieve::StatusCode SetPreallocatedPageCount(int preallocatedPageCount);
   Btrieve::StatusCode SetSystemDataMode(Btrieve::SystemDataMode systemDataMode);
   Btrieve::StatusCode SetVariableLengthRecordsMode(Btrieve::VariableLengthRecordsMode variableLengthRecordsMode);
   Btrieve::StatusCode SetKeyOnly(bool enableKeyOnly);

private:
   btrieve_file_attributes_t btrieveFileAttributes = NULL;
};

class LINKAGE BtrieveFileInformation
{
   friend class BtrieveFile;

protected:
   btrieve_file_information_t GetBtrieveFileInformation();

public:
   BtrieveFileInformation();
   ~BtrieveFileInformation();

   Btrieve::StatusCode GetLastStatusCode();
   Btrieve::FileVersion GetFileVersion();
   Btrieve::FreeSpaceThreshold GetFreeSpaceThreshold();
   Btrieve::PageSize GetPageSize();
   Btrieve::SystemDataMode GetSystemDataMode();
   Btrieve::StatusCode GetKeySegment(BtrieveKeySegment *btrieveKeySegment, int keySegmentNumber);
   int GetBalancedIndexes();
   Btrieve::RecordCompressionMode GetRecordCompressionMode();
   int GetKeyOnly();
   int GetPageCompression();
   int GetPagePreallocation();
   Btrieve::VariableLengthRecordsMode GetVariableLengthRecordsMode();
   int GetUnusedDuplicatePointerCount();
   int GetIndexCount();
   int GetFixedRecordLength();
   long long GetRecordCount();
   int GetSegmented();
   int GetUnusedPageCount();
   Btrieve::Index GetLogIndex();
   int GetLoggable();
   int GetSystemData();
   int GetSystemIndexSize();
   int GetSystemIndex();
   int GetSystemIndexVersion();
   long long GetDuplicateRecordConflictCursorPosition();
   Btrieve::Index GetDuplicateRecordConflictIndex();
   int GetIdentifier();
   int GetHandleCount();
   int GetOpenTimestamp();
   int GetUsageCount();
   int GetExplicitLocks();
   int GetClientTransactions();
   int GetReadOnly();
   int GetContinuousOperation();
   int GetReferentialIntegrityConstraints();
   Btrieve::OwnerMode GetOwnerMode();
   Btrieve::EncryptType GetEncryptionType();
   int GetWrongOwner();
   int GetGatewayMajorVersion();
   int GetGatewayMinorVersion();
   int GetGatewayPatchLevel();
   int GetGatewayPlatform();
   const char *GetGatewayName();
#ifndef SWIG
   Btrieve::StatusCode GetGatewayName(char *name, int nameSize);
#endif
   int GetLockOwnerImplicitLock();
   int GetLockOwnerFileLock();
   int GetLockOwnerRecordLock();
   int GetLockOwnerSameProcess();
   int GetLockOwnerWriteNoWait();
   int GetLockOwnerWriteHold();
   int GetLockOwnerTimeInTransaction();
   int GetLockOwnerTransactionLevel();
   const char *GetLockOwnerName();
#ifndef SWIG
   Btrieve::StatusCode GetLockOwnerName(char *name, int nameSize);
#endif
   int GetLockOwnerServiceAgentIdentifier();
   int GetLockOwnerClientIdentifier();
   Btrieve::LockMode GetLockOwnerExplicitLockMode();
   Btrieve::PageLockType GetLockOwnerPageLockType();
   Btrieve::Index GetLockOwnerIndex();
   const char *GetReferentialIntegrityFileName();
#ifndef SWIG
   Btrieve::StatusCode GetReferentialIntegrityFileName(char *name, int nameSize);
#endif
   int GetReferentialIntegrityOperationCode();
   long long GetReferentialIntegrityCursorPosition();
   int GetSegmentCount();
   const char *GetSegmentFileName(int segmentFileNumber);
#ifndef SWIG
   Btrieve::StatusCode GetSegmentFileName(int segmentFileNumber, char *name, int nameSize);
#endif

   // TODO: Coalesce some of the following.
        int GetSecurityHandleTrusted();
        int GetSecurityHandleImplicit();
        int GetSecurityHandleExplicit();
        int GetSecurityHandleAuthenticationByDatabase();
        int GetSecurityHandleAuthorizationByDatabase();
        int GetSecurityHandleWindowsNamedPipe();
        int GetSecurityHandleWorkgroup();
        int GetSecurityHandleBtpasswd();
        int GetSecurityHandlePAM();
        int GetSecurityHandleRTSSComplete();
        int GetSecurityHandleRTSSPreauthorized();
        int GetSecurityHandleRTSSDisabled();
        int GetSecurityCurrentDatabaseTrusted();
        int GetSecurityCurrentDatabaseImplicit();
        int GetSecurityCurrentDatabaseExplicit();
        int GetSecurityCurrentDatabaseAuthenticationByDatabase();
        int GetSecurityCurrentDatabaseAuthorizationByDatabase();
        int GetSecurityCurrentDatabaseWindowsNamedPipe();
        int GetSecurityCurrentDatabaseWorkgroup();
        int GetSecurityCurrentDatabaseBtpasswd();
        int GetSecurityCurrentDatabasePAM();
        int GetSecurityCurrentDatabaseRTSSComplete();
        int GetSecurityCurrentDatabaseRTSSPreauthorized();
        int GetSecurityCurrentDatabaseRTSSDisabled();
        int GetSecurityPermissionNoRights();
        int GetSecurityPermissionOpen();
        int GetSecurityPermissionRead();
        int GetSecurityPermissionCreateFile();
        int GetSecurityPermissionUpdate();
        int GetSecurityPermissionCreateRecord();
        int GetSecurityPermissionDelete();
        int GetSecurityPermissionExecute();
        int GetSecurityPermissionAlter();
        int GetSecurityPermissionRefer();
        int GetSecurityPermissionCreateView();
        int GetSecurityPermissionCreateStoredProcedure();
        const char *GetSecurityHandleDatabaseName();
#ifndef SWIG
        Btrieve::StatusCode GetSecurityHandleDatabaseName(char *name, int nameSize);
#endif
        const char *GetSecurityHandleTableName();
#ifndef SWIG
        Btrieve::StatusCode GetSecurityHandleTableName(char *name, int nameSize);
#endif
        const char *GetSecurityHandleUserName();
#ifndef SWIG
        Btrieve::StatusCode GetSecurityHandleUserName(char *name, int nameSize);
#endif
        const char *GetSecurityCurrentDatabaseName();
#ifndef SWIG
        Btrieve::StatusCode GetSecurityCurrentDatabaseName(char *name, int nameSize);
#endif
        const char *GetSecurityCurrentUserName();
#ifndef SWIG
        Btrieve::StatusCode GetSecurityCurrentUserName(char *name, int nameSize);
#endif

private:
   btrieve_file_information_t btrieveFileInformation = NULL;
};

class LINKAGE BtrieveFilter
{
   friend class BtrieveBulkRetrieveAttributes;
   friend class BtrieveBulkDeleteAttributes;

protected:
   btrieve_filter_t GetBtrieveFilter();

public:
   BtrieveFilter();
   ~BtrieveFilter();

   Btrieve::StatusCode SetComparison(Btrieve::Comparison comparison);
   Btrieve::StatusCode SetComparisonConstant(const char *constant, int constantLength);
   Btrieve::StatusCode SetComparisonField(int offset);
   Btrieve::StatusCode SetField(int offset, int length, Btrieve::DataType dataType);
   Btrieve::StatusCode SetSystemField(Btrieve::SystemField systemField);
   Btrieve::StatusCode SetLikeCodePageName(const char *name);
   Btrieve::StatusCode SetConnector(Btrieve::Connector connector);
   Btrieve::StatusCode SetACSMode(Btrieve::ACSMode ACSMode);
   Btrieve::StatusCode SetACSUserDefined(const char *name);
   Btrieve::StatusCode SetACSName(const char *name);

private:
   btrieve_filter_t btrieveFilter = NULL;
};

class LINKAGE BtrieveBulkRetrieveAttributes
{
   friend class BtrieveFile;

protected:
   btrieve_bulk_retrieve_attributes_t GetBtrieveBulkRetrieveAttributes();

public:
   BtrieveBulkRetrieveAttributes();
   ~BtrieveBulkRetrieveAttributes();

   Btrieve::StatusCode AddField(int offset, int length);
   Btrieve::StatusCode AddFilter(BtrieveFilter *btrieveFilter);
   Btrieve::StatusCode SetMaximumRecordCount(int maximumRecordCount);
   Btrieve::StatusCode SetMaximumRejectCount(int maximumRejectCount);
   Btrieve::StatusCode SetSkipCurrentRecord(bool skipCurrentRecord);

private:
   btrieve_bulk_retrieve_attributes_t bulkRetrieveAttributes = NULL;
};

class LINKAGE BtrieveBulkDeleteAttributes
{
   friend class BtrieveFile;

protected:
   btrieve_bulk_delete_attributes_t GetBtrieveBulkDeleteAttributes();

public:
   BtrieveBulkDeleteAttributes();
   ~BtrieveBulkDeleteAttributes();

   Btrieve::StatusCode AddFilter(BtrieveFilter *btrieveFilter);
   Btrieve::StatusCode SetMaximumRecordCount(int maximumRecordCount);
   Btrieve::StatusCode SetMaximumRejectCount(int maximumRejectCount);
   Btrieve::StatusCode SetSkipCurrentRecord(bool skipCurrentRecord);

private:
   btrieve_bulk_delete_attributes_t bulkDeleteAttributes = NULL;
};

class LINKAGE BtrieveBulkRetrieveResult
{
   friend class BtrieveFile;

protected:
   btrieve_bulk_retrieve_result_t GetBtrieveBulkRetrieveResult();

public:
   BtrieveBulkRetrieveResult();
   ~BtrieveBulkRetrieveResult();

   Btrieve::StatusCode GetLastStatusCode();
   int GetRecord(int recordNumber, char *record, int recordSize);
   int GetRecordCount();
   int GetRecordLength(int recordNumber);
   long long GetRecordCursorPosition(int recordNumber);

private:
   btrieve_bulk_retrieve_result_t bulkRetrieveResult = NULL;
};

class LINKAGE BtrieveBulkDeleteResult
{
   friend class BtrieveFile;

protected:
   btrieve_bulk_delete_result_t GetBtrieveBulkDeleteResult();

public:
   BtrieveBulkDeleteResult();
   ~BtrieveBulkDeleteResult();

   Btrieve::StatusCode GetLastStatusCode();
   int GetRecordCount();
   long long GetRecordCursorPosition(int recordNumber);

private:
   btrieve_bulk_delete_result_t bulkDeleteResult = NULL;
};

class LINKAGE BtrieveIndexAttributes
{
   friend class BtrieveClient;
   friend class BtrieveFile;

protected:
   btrieve_index_attributes_t GetBtrieveIndexAttributes();

public:
   BtrieveIndexAttributes();
   ~BtrieveIndexAttributes();

   Btrieve::StatusCode AddKeySegment(BtrieveKeySegment *btrieveKeySegment);
   Btrieve::StatusCode SetIndex(Btrieve::Index index);
   Btrieve::StatusCode SetDuplicateMode(Btrieve::DuplicateMode duplicateMode);
   Btrieve::StatusCode SetModifiable(bool enableModifiable);
   Btrieve::StatusCode SetACSMode(Btrieve::ACSMode ACSMode);
   Btrieve::StatusCode SetACSName(const char *ACSName);
   Btrieve::StatusCode SetACSNumber(int ACSNumber);
   Btrieve::StatusCode SetACSUserDefined(const char *ACSName, const char *ACSMap, int ACSMapLength);

private:
   btrieve_index_attributes_t btrieveIndexAttributes = NULL;
};

class LINKAGE BtrieveBulkCreatePayload
{
   friend class BtrieveFile;

protected:
   btrieve_bulk_create_payload_t GetBtrieveBulkCreatePayload();

public:
   BtrieveBulkCreatePayload();
   ~BtrieveBulkCreatePayload();

   Btrieve::StatusCode AddRecord(const char *record, int recordLength);

private:
   btrieve_bulk_create_payload_t btrieveBulkCreatePayload = NULL;
};

class LINKAGE BtrieveBulkCreateResult
{
   friend class BtrieveFile;

protected:
   btrieve_bulk_create_result_t GetBtrieveBulkCreateResult();

public:
   BtrieveBulkCreateResult();
   ~BtrieveBulkCreateResult();

   Btrieve::StatusCode GetLastStatusCode();
   int GetRecordCount();
   long long GetRecordCursorPosition(int recordNumber);

private:
   btrieve_bulk_create_result_t btrieveBulkCreateResult = NULL;
};

class LINKAGE BtrieveKeySegment
{
   friend class BtrieveIndexAttributes;
   friend class BtrieveFileInformation;

protected:
   btrieve_key_segment_t GetBtrieveKeySegment();
   BtrieveKeySegment(btrieve_key_segment_t btrieveKeySegmentIn);

public:
   BtrieveKeySegment();
   ~BtrieveKeySegment();

   Btrieve::StatusCode GetLastStatusCode();
   Btrieve::ACSMode GetACSMode();
   int GetModifiable();
   int GetKeyContinues();
   Btrieve::DataType GetDataType();
   int GetACSNumber();
   int GetDescendingSortOrder();
   Btrieve::DuplicateMode GetDuplicateMode();
   Btrieve::Index GetIndex();
   int GetLength();
   Btrieve::NullKeyMode GetNullKeyMode();
   int GetNullValue();
   int GetOffset();
   long long GetUniqueValueCount();
   Btrieve::StatusCode SetDescendingSortOrder(bool setDescendingSortOrder);
   Btrieve::StatusCode SetField(int offset, int length, Btrieve::DataType dataType);
   Btrieve::StatusCode SetNullKeyMode(Btrieve::NullKeyMode nullKeyMode);
   Btrieve::StatusCode SetNullValue(int nullValue);

private:
   btrieve_key_segment_t btrieveKeySegment = NULL;
};

class LINKAGE BtrieveVersion
{
   friend class BtrieveClient;

protected:
   btrieve_version_t GetBtrieveVersion();

public:
   BtrieveVersion();
   ~BtrieveVersion();

   Btrieve::StatusCode GetLastStatusCode();
   Btrieve::VersionType GetClientVersionType();
   Btrieve::VersionType GetRemoteVersionType();
   Btrieve::VersionType GetLocalVersionType();
   int GetClientRevisionNumber();
   int GetClientVersionNumber();
   int GetRemoteRevisionNumber();
   int GetRemoteVersionNumber();
   int GetLocalRevisionNumber();
   int GetLocalVersionNumber();

private:
   btrieve_version_t btrieveVersion = NULL;
};

class LINKAGE BtrieveCollection
{
   friend class BtrieveClient;

protected:
   void SetBtrieveClient(BtrieveClient *btrieveClient);
   BtrieveFile *GetBtrieveFile();

public:
   BtrieveCollection();
   ~BtrieveCollection();

   int DocumentCreate(const char *json);
   int DocumentCreate(const char *json, const char *blob, int blobLength);
   Btrieve::StatusCode DocumentRetrieveBlob(int id, char *blob, int blobSize, int documentBlobOffset = 0, int documentBlobLength = 0);
   const char *DocumentRetrieveJson(int id);
   const char *DocumentRetrieveJson(int id, char *blob, int blobSize, int documentBlobOffset = 0, int documentBlobLength = 0);
#ifndef SWIG
   Btrieve::StatusCode DocumentRetrieve(int id, char *json = NULL, int jsonSize = 0, char *blob = NULL, int blobSize = 0, int documentBlobOffset = 0, int documentBlobLength = 0);
#endif
   Btrieve::StatusCode DocumentUpdate(int id, const char *json);
   Btrieve::StatusCode DocumentUpdate(int id, const char *json, const char *blob, int blobLength);
   Btrieve::StatusCode DocumentDelete(int id);
   Btrieve::StatusCode Query(BtrieveDocumentSet *btrieveDocumentSet, const char *query = NULL);
   Btrieve::StatusCode Encrypt(const char *password, const char *passwordAgain);
   Btrieve::StatusCode Decrypt();
   Btrieve::StatusCode GetLastStatusCode();
   Btrieve::StatusCode SetLastStatusCode(Btrieve::StatusCode statusCode);

private:
   BtrieveClient *btrieveClient = NULL;
   BtrieveFile *btrieveFile = NULL;
   Btrieve::StatusCode lastStatusCode = Btrieve::STATUS_CODE_NO_ERROR;
};

class LINKAGE BtrieveDocumentSet
{
   friend class BtrieveCollection;

protected:
   std::deque<int> *GetStdDeque();
   
public:
   BtrieveDocumentSet();
   ~BtrieveDocumentSet();

   int Size();
   int PopFirst();
   int PopLast();
   Btrieve::StatusCode GetLastStatusCode();

private:
   std::deque<int> *stdDeque = NULL;
   Btrieve::StatusCode lastStatusCode = Btrieve::STATUS_CODE_NO_ERROR;
};

class LINKAGE BRestful
{
public:
   static const char *POST(const char *collectionName, const char *json = NULL);
   static const char *POST(const char *collectionName, const char *json, const char *blob, int blobLength);

// Avoid Windows defining of DELETE.
#ifdef DELETE
   #undef DELETE
#endif

   static const char *DELETE(const char *collectionName, int id = -1);

   static const char *GET(const char *collectionName, int id);
   static const char *GET(const char *collectionName, int id, char *blob, int blobSize, int documentBlobOffset = 0, int documentBlobLength = 0);
 
   static const char *GET(const char *collectionName, const char *query = NULL);

   static const char *PUT(const char *collectionName, int id, const char *json);
   static const char *PUT(const char *collectionName, int id, const char *json, const char *blob, int blobLength);

private:
   BRestful();
   ~BRestful();
};

#endif