src/Tizen.Applications.DataControl/Interop/Interop.DataControl.cs

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 using System;
  18 using System.Runtime.InteropServices;
  19 using System.Text;
  20 using Tizen.Applications;
  21 using Tizen;
  22 using Tizen.Applications.DataControl;
  23
  24 internal static partial class Interop
  25 {
  26     internal static partial class DataControl
  27     {
  28
  29         internal enum NativeResultType : int
  30         {
  31             Success = Tizen.Internals.Errors.ErrorCode.None,
  32             OutOfMemory = Tizen.Internals.Errors.ErrorCode.OutOfMemory,
  33             IoError = Tizen.Internals.Errors.ErrorCode.IoError,
  34             InvalidParameter = Tizen.Internals.Errors.ErrorCode.InvalidParameter,
  35             PermissionDenied = Tizen.Internals.Errors.ErrorCode.PermissionDenied,
  36             MaxExceed = -0x01190000 | 0x01,
  37         }
  38
  39         internal sealed class SafeBulkDataHandle : SafeHandle
  40         {
  41             internal SafeBulkDataHandle()
  42                 : base(IntPtr.Zero, true)
  43             {
  44             }
  45
  46             internal SafeBulkDataHandle(IntPtr existingHandle, bool ownsHandle) : base(IntPtr.Zero, ownsHandle)
  47             {
  48                 SetHandle(existingHandle);
  49             }
  50
  51             public override bool IsInvalid
  52             {
  53                 get { return this.handle == IntPtr.Zero; }
  54             }
  55
  56             protected override bool ReleaseHandle()
  57             {
  58                 DataControl.BulkFree(this.handle);
  59                 this.SetHandle(IntPtr.Zero);
  60                 return true;
  61             }
  62         }
  63
  64         internal sealed class SafeBulkResultDataHandle : SafeHandle
  65         {
  66             internal SafeBulkResultDataHandle()
  67                 : base(IntPtr.Zero, true)
  68             {
  69             }
  70
  71             internal SafeBulkResultDataHandle(IntPtr existingHandle, bool ownsHandle) : base(IntPtr.Zero, ownsHandle)
  72             {
  73                 SetHandle(existingHandle);
  74             }
  75
  76             public override bool IsInvalid
  77             {
  78                 get { return this.handle == IntPtr.Zero; }
  79             }
  80
  81             protected override bool ReleaseHandle()
  82             {
  83                 DataControl.BulkResultFree(this.handle);
  84                 this.SetHandle(IntPtr.Zero);
  85                 return true;
  86             }
  87         }
  88
  89         internal sealed class SafeCursorHandle : SafeHandle
  90         {
  91             internal SafeCursorHandle()
  92                 : base(IntPtr.Zero, true)
  93             {
  94             }
  95
  96             internal SafeCursorHandle(IntPtr existingHandle, bool ownsHandle) : base(IntPtr.Zero, ownsHandle)
  97             {
  98                 SetHandle(existingHandle);
  99             }
 100
 101             public override bool IsInvalid
 102             {
 103                 get { return this.handle == IntPtr.Zero; }
 104             }
 105
 106             protected override bool ReleaseHandle()
 107             {
 108                 this.SetHandle(IntPtr.Zero);
 109                 return true;
 110             }
 111         }
 112
 113         internal sealed class SafeDataControlHandle : SafeHandle
 114         {
 115             internal SafeDataControlHandle()
 116                 : base(IntPtr.Zero, true)
 117             {
 118             }
 119
 120             internal SafeDataControlHandle(IntPtr existingHandle, bool ownsHandle) : base(IntPtr.Zero, ownsHandle)
 121             {
 122                 SetHandle(existingHandle);
 123             }
 124
 125             public override bool IsInvalid
 126             {
 127                 get { return this.handle == IntPtr.Zero; }
 128             }
 129
 130             protected override bool ReleaseHandle()
 131             {
 132                 DataControl.Destroy(this.handle);
 133                 this.SetHandle(IntPtr.Zero);
 134                 return true;
 135             }
 136         }
 137
 138         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_create")]
 139         internal static extern ResultType DataControlCreate(out SafeDataControlHandle handle);
 140
 141         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_destroy")]
 142         internal static extern ResultType Destroy(IntPtr handle);
 143
 144         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_get_provider_id")]
 145         internal static extern ResultType DataControlGetProviderId(SafeDataControlHandle handle, out string providerId);
 146
 147         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_set_provider_id")]
 148         internal static extern ResultType DataControlSetProviderId(SafeDataControlHandle handle, string providerId);
 149
 150         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_set_data_id")]
 151         internal static extern ResultType DataControlSetDataId(SafeDataControlHandle handle, string dataId);
 152
 153         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_get_data_id")]
 154         internal static extern ResultType DataControlGetDataId(SafeDataControlHandle handle, out string dataId);
 155
 156         internal delegate void MapGetResponseCallback(int requestID,
 157             IntPtr provider, string[] resultValueList, int resultValueCount, bool providerResult, string error, IntPtr userData);
 158         internal delegate void MapSetResponseCallback(int requestID,
 159             IntPtr provider, bool providerResult, string error, IntPtr userData);
 160         internal delegate void MapAddResponseCallback(int requestID,
 161             IntPtr provider, bool providerResult, string error, IntPtr userData);
 162         internal delegate void MapRemoveResponseCallback(int requestID,
 163             IntPtr provider, bool providerResult, string error, IntPtr userData);
 164         internal delegate void MapBulkAddResponseCallback(int requestID,
 165             IntPtr provider, IntPtr bulkResults, bool providerResult, string error, IntPtr userData);
 166
 167         [StructLayoutAttribute(LayoutKind.Sequential)]
 168         internal struct MapResponseCallbacks
 169         {
 170             public MapGetResponseCallback Get;
 171             public MapSetResponseCallback Set;
 172             public MapAddResponseCallback Add;
 173             public MapRemoveResponseCallback Remove;
 174         }
 175
 176         internal delegate void SqlSelectResponseCallback(int requestID,
 177             IntPtr provider, IntPtr cursor, bool providerResult, string error, IntPtr userData);
 178         internal delegate void SqlInsertResponseCallback(int requestID,
 179             IntPtr provider, long inserted_row_id, bool providerResult, string error, IntPtr userData);
 180         internal delegate void SqlUpdateResponseCallback(int requestID,
 181             IntPtr provider, bool providerResult, string error, IntPtr userData);
 182         internal delegate void SqlDeleteResponseCallback(int requestID,
 183             IntPtr provider, bool providerResult, string error, IntPtr userData);
 184         internal delegate void SqlBulkInsertResponseCallback(int requestID,
 185             IntPtr provider, IntPtr bulk_results, bool providerResult, string error, IntPtr userData);
 186
 187         [StructLayoutAttribute(LayoutKind.Sequential)]
 188         internal struct SqlResponseCallbacks
 189         {
 190             public SqlSelectResponseCallback Select;
 191             public SqlInsertResponseCallback Insert;
 192             public SqlUpdateResponseCallback Update;
 193             public SqlDeleteResponseCallback Delete;
 194         }
 195
 196         [DllImport(Libraries.DataControl, EntryPoint = "data_control_map_register_response_cb")]
 197         internal static extern ResultType RegisterMapResponse(SafeDataControlHandle provider, ref MapResponseCallbacks callback, IntPtr userData);
 198
 199         [DllImport(Libraries.DataControl, EntryPoint = "data_control_map_unregister_response_cb")]
 200         internal static extern ResultType UnregisterMapResponse(SafeDataControlHandle provider);
 201
 202         [DllImport(Libraries.DataControl, EntryPoint = "data_control_map_register_add_bulk_data_response_cb")]
 203         internal static extern ResultType RegisterMapBulkResponseCallback(SafeDataControlHandle provider, MapBulkAddResponseCallback callback, IntPtr userData);
 204
 205         [DllImport(Libraries.DataControl, EntryPoint = "data_control_map_unregister_add_bulk_data_response_cb")]
 206         internal static extern ResultType UnregisterMapBulkResponseCallback(SafeDataControlHandle provider);
 207
 208         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_register_response_cb")]
 209         internal static extern ResultType RegisterSqlResponseCallback(SafeDataControlHandle provider, ref SqlResponseCallbacks callback, IntPtr userData);
 210
 211         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_unregister_response_cb")]
 212         internal static extern ResultType UnregisterSqlResponseCallback(SafeDataControlHandle provider);
 213
 214         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_register_insert_bulk_data_response_cb")]
 215         internal static extern ResultType RegisterSqlBulkResponseCallback(SafeDataControlHandle provider, SqlBulkInsertResponseCallback callback, IntPtr userData);
 216
 217         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_unregister_insert_bulk_data_response_cb")]
 218         internal static extern ResultType UnregisterSqlBulkResponseCallback(SafeDataControlHandle provider);
 219
 220         internal delegate void MapGetRequestCallback(int requestID,
 221             IntPtr provider, string key, IntPtr userData);
 222         internal delegate void MapSetRequestCallback(int requestID,
 223             IntPtr provider, string key, string oldValue, string newValue, IntPtr userData);
 224         internal delegate void MapAddRequestCallback(int requestID,
 225             IntPtr provider, string key, string value, IntPtr userData);
 226         internal delegate void MapRemoveRequestCallback(int requestID,
 227             IntPtr provider, string key, string value, IntPtr userData);
 228
 229         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 230         internal delegate void MapBulkAddRequestCallback(int requestID,
 231             IntPtr provider, IntPtr bulkData, IntPtr userData);
 232
 233         [StructLayoutAttribute(LayoutKind.Sequential)]
 234         internal struct MapRequestCallbacks
 235         {
 236             public MapGetRequestCallback Get;
 237             public MapSetRequestCallback Set;
 238             public MapAddRequestCallback Add;
 239             public MapRemoveRequestCallback Remove;
 240         }
 241
 242         internal delegate void SqlInsertRequestCallback(int requestID,
 243             IntPtr provider, IntPtr insertData, IntPtr userData);
 244         internal delegate void SqlSelectRequestCallback(int requestID,
 245             IntPtr provider, IntPtr columnList, int columnCount, string where, string order, IntPtr userData);
 246         internal delegate void SqlUpdateRequestCallback(int requestID,
 247             IntPtr provider, IntPtr updateData, string where, IntPtr userData);
 248         internal delegate void SqlDeleteRequestCallback(int requestID,
 249             IntPtr provider, string where, IntPtr userData);
 250
 251         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 252         internal delegate void SqlBulkInsertRequestCallback(int requestID,
 253             IntPtr provider, IntPtr bulk_data, IntPtr userData);
 254
 255         [StructLayoutAttribute(LayoutKind.Sequential)]
 256         internal struct SqlRequestCallbacks
 257         {
 258             public SqlInsertRequestCallback Insert;
 259             public SqlSelectRequestCallback Select;
 260             public SqlUpdateRequestCallback Update;
 261             public SqlDeleteRequestCallback Delete;
 262         }
 263
 264         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_map_register_cb")]
 265         internal static extern ResultType RegisterMapRequest(ref MapRequestCallbacks callback, IntPtr userData);
 266
 267         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_sql_register_cb")]
 268         internal static extern ResultType RegisterSqlRequest(ref SqlRequestCallbacks callback, IntPtr userData);
 269
 270         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_sql_register_insert_bulk_data_request_cb")]
 271         internal static extern ResultType RegisterSqlBulkRequest(SqlBulkInsertRequestCallback callback, IntPtr userData);
 272
 273         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_sql_unregister_insert_bulk_data_request_cb")]
 274         internal static extern ResultType UnregisterSqlBulkRequest();
 275
 276         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_map_register_add_bulk_data_request_cb")]
 277         internal static extern ResultType RegisterMapBulkRequest(MapBulkAddRequestCallback callback, IntPtr userData);
 278
 279         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_map_unregister_add_bulk_data_request_cb")]
 280         internal static extern ResultType UnregisterMapBulkRequest();
 281
 282         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_send_map_result")]
 283         internal static extern ResultType SendMapResult(int requestID);
 284
 285         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_send_map_get_value_result")]
 286         internal static extern ResultType SendMapGetResult(int requestID, string[] valueList, int valueCount);
 287
 288         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_send_insert_result")]
 289         internal static extern ResultType SendInsertResult(int requestID, long rowId);
 290
 291         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_send_update_result")]
 292         internal static extern ResultType SendUpdateResult(int requestID);
 293
 294         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_send_delete_result")]
 295         internal static extern ResultType SendDeleteResult(int requestID);
 296
 297         [DllImport(Libraries.DataControl, EntryPoint = "datacontrol_provider_send_select_result_without_data")]
 298         internal static extern ResultType SendSelectResult(int requestID, out int fd);
 299
 300         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_send_error")]
 301         internal static extern ResultType SendError(int requestID, string error);
 302
 303         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_insert")]
 304         internal static extern ResultType Insert(SafeDataControlHandle provider, SafeBundleHandle insertData, out int requestId);
 305
 306         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_select_with_page")]
 307         internal static extern ResultType Select(SafeDataControlHandle provider, string[] columnList, int columnCount, string where, string order, int pageNumber,
 308             int countPerPage, out int requestID);
 309
 310         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_delete")]
 311         internal static extern ResultType Delete(SafeDataControlHandle provider, string where, out int requestID);
 312
 313         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_update")]
 314         internal static extern ResultType Update(SafeDataControlHandle provider, SafeBundleHandle updatetData, string where, out int requestID);
 315
 316         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_insert_bulk_data")]
 317         internal static extern ResultType BulkInsert(SafeDataControlHandle provider, SafeBulkDataHandle insertData, out int requestID);
 318
 319         [DllImport(Libraries.DataControl, EntryPoint = "data_control_map_add")]
 320         internal static extern ResultType MapAdd(SafeDataControlHandle provider, string key, string value, out int requestId);
 321
 322         [DllImport(Libraries.DataControl, EntryPoint = "data_control_map_set")]
 323         internal static extern ResultType MapSet(SafeDataControlHandle provider, string key, string oldValue, string newValue, out int requestId);
 324
 325         [DllImport(Libraries.DataControl, EntryPoint = "data_control_map_remove")]
 326         internal static extern ResultType MapRemove(SafeDataControlHandle provider, string key, string value, out int requestId);
 327
 328         [DllImport(Libraries.DataControl, EntryPoint = "data_control_map_get_with_page")]
 329         internal static extern ResultType MapGet(SafeDataControlHandle provider, string key, out int requestId, int pageNumber,
 330             int countPerPage);
 331         [DllImport(Libraries.DataControl, EntryPoint = "data_control_map_add_bulk_data")]
 332         internal static extern ResultType BulkAdd(SafeDataControlHandle provider, SafeBulkDataHandle insertData, out int requestID);
 333
 334         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_create_insert_statement")]
 335         internal static extern string CreateInsertStatement(SafeDataControlHandle provider, SafeBundleHandle insertData);
 336
 337         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_create_delete_statement")]
 338         internal static extern string CreateDeleteStatement(SafeDataControlHandle provider, string where);
 339
 340         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_create_update_statement")]
 341         internal static extern string CreateUpdateStatement(SafeDataControlHandle provider, SafeBundleHandle updateData, string where);
 342
 343         [DllImport(Libraries.DataControl, EntryPoint = "datacontrol_provider_get_select_page_info")]
 344         internal static extern ResultType GetSelectPageInfo(int requestId, out int pageNum, out int countPerPage);
 345
 346         [DllImport(Libraries.DataControl, EntryPoint = "datacontrol_provider_write_socket")]
 347         internal static extern unsafe ResultType WriteSelectResult(int socketFd, byte* buffer, uint nbytes, out uint bytesWrite);
 348
 349         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_send_data_change_noti")]
 350         internal static extern ResultType SendDataChange(IntPtr handle, ChangeType type, SafeBundleHandle data);
 351
 352         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_step_next")]
 353         internal static extern ResultType Next(SafeCursorHandle cursor);
 354
 355         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_step_last")]
 356         internal static extern ResultType Last(SafeCursorHandle cursor);
 357
 358         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_step_first")]
 359         internal static extern ResultType First(SafeCursorHandle cursor);
 360
 361         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_step_previous")]
 362         internal static extern ResultType Prev(SafeCursorHandle cursor);
 363
 364         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_get_column_count")]
 365         internal static extern int GetColumnCount(SafeCursorHandle cursor);
 366
 367         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_get_column_name")]
 368         internal static extern ResultType GetColumnName(SafeCursorHandle cursor, int idx, StringBuilder name);
 369
 370         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_get_column_item_size")]
 371         internal static extern int GetItemSize(SafeCursorHandle cursor, int idx);
 372
 373         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_get_column_item_type")]
 374         internal static extern ResultType GetItemType(SafeCursorHandle cursor, int idx, out int type);
 375
 376         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_get_blob_data")]
 377         internal static extern ResultType GetBlob(SafeCursorHandle cursor, int idx, byte[] buffer, int size);
 378
 379         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_get_int_data")]
 380         internal static extern ResultType GetInt(SafeCursorHandle cursor, int idx, out int data);
 381
 382         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_get_int64_data")]
 383         internal static extern ResultType GetInt64(SafeCursorHandle cursor, int idx, out long data);
 384
 385         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_get_double_data")]
 386         internal static extern ResultType Getdouble(SafeCursorHandle cursor, int idx, out double data);
 387
 388         [DllImport(Libraries.DataControl, EntryPoint = "data_control_sql_get_text_data")]
 389         internal static extern unsafe ResultType GetText(SafeCursorHandle cursor, int idx, byte[] data);
 390
 391         [DllImport(Libraries.DataControl, EntryPoint = "data_control_bulk_data_create")]
 392         internal static extern ResultType BulkCreate(out SafeBulkDataHandle handle);
 393
 394         [DllImport(Libraries.DataControl, EntryPoint = "data_control_bulk_data_add")]
 395         internal static extern ResultType BulkAdd(SafeBulkDataHandle handle, SafeBundleHandle data);
 396
 397         [DllImport(Libraries.DataControl, EntryPoint = "data_control_bulk_data_get_count")]
 398         internal static extern ResultType BulkGetCount(SafeBulkDataHandle handle, out int count);
 399
 400         [DllImport(Libraries.DataControl, EntryPoint = "data_control_bulk_data_destroy")]
 401         internal static extern ResultType BulkFree(IntPtr handle);
 402
 403         [DllImport(Libraries.DataControl, EntryPoint = "data_control_bulk_data_get_data")]
 404         internal static extern ResultType BulkGetData(SafeBulkDataHandle handle, int idx, out IntPtr data);
 405
 406         [DllImport(Libraries.DataControl, EntryPoint = "data_control_bulk_result_data_create")]
 407         internal static extern ResultType BulkResultCreate(out SafeBulkResultDataHandle handle);
 408
 409         [DllImport(Libraries.DataControl, EntryPoint = "data_control_bulk_result_data_add")]
 410         internal static extern ResultType BulkResultAdd(SafeBulkResultDataHandle handle, SafeBundleHandle data, int result);
 411
 412         [DllImport(Libraries.DataControl, EntryPoint = "data_control_bulk_result_data_get_count")]
 413         internal static extern ResultType BulkResultGetCount(SafeBulkResultDataHandle handle, out int count);
 414
 415         [DllImport(Libraries.DataControl, EntryPoint = "data_control_bulk_result_data_get_result_data")]
 416         internal static extern ResultType BulkResultGetData(SafeBulkResultDataHandle handle, int idx, out IntPtr data, out int result);
 417
 418         [DllImport(Libraries.DataControl, EntryPoint = "data_control_bulk_result_data_get_result_data")]
 419         internal static extern ResultType BulkResultGetResult(SafeBulkResultDataHandle handle, int idx, out IntPtr data, out int result);
 420
 421         [DllImport(Libraries.DataControl, EntryPoint = "data_control_bulk_result_data_destroy")]
 422         internal static extern ResultType BulkResultFree(IntPtr handle);
 423
 424         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 425         internal delegate void AddCallbackResultCallback(IntPtr handle, ResultType type, int callbackID, IntPtr userData);
 426
 427         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 428         internal delegate void DataChangeCallback(IntPtr handle, ChangeType type, IntPtr data, IntPtr userData);
 429
 430         [DllImport(Libraries.DataControl, EntryPoint = "data_control_add_data_change_cb", CallingConvention = CallingConvention.Cdecl)]
 431         internal static extern ResultType AddDataChangeCallback(SafeDataControlHandle provider, DataChangeCallback callback,
 432             IntPtr userData, AddCallbackResultCallback resultCallback, IntPtr resultCbUserData, out int callbackID);
 433
 434         [DllImport(Libraries.DataControl, EntryPoint = "data_control_remove_data_change_cb", CallingConvention = CallingConvention.Cdecl)]
 435         internal static extern ResultType RemoveDataChangeCallback(SafeDataControlHandle provider, int callbackID);
 436
 437         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 438         internal delegate bool DataChangeConsumerFilterCb(IntPtr handle, string consumerAppid, IntPtr userData);
 439
 440         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_add_data_change_consumer_filter_cb", CallingConvention = CallingConvention.Cdecl)]
 441         internal static extern ResultType AddDataChangeConsumerFilterCallback(DataChangeConsumerFilterCb callback,
 442             IntPtr userData,
 443             out int callbackID);
 444
 445         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_remove_data_change_consumer_filter_cb")]
 446         internal static extern int RemoveDataChangeConsumerFilterCallback(int callbackID);
 447
 448         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_send_bulk_insert_result")]
 449         internal static extern ResultType SendBulkInsertResult(int requestId, SafeBulkResultDataHandle result);
 450
 451         [DllImport(Libraries.DataControl, EntryPoint = "data_control_provider_send_map_bulk_add_result")]
 452         internal static extern ResultType SendMapBulkAddResult(int requestId, SafeBulkResultDataHandle result);
 453
 454         internal static class UnsafeCode
 455         {
 456             internal static unsafe ResultType WriteResult(int socketFd, byte[] value, int nbytes, out uint bytesWrite)
 457             {
 458                 fixed (byte* pointer = value)
 459                 {
 460                     return WriteSelectResult(socketFd, pointer, (uint)nbytes, out bytesWrite);
 461                 }
 462             }
 463         }
 464
 465     }
 466 }