job->ScheduleBackup();

}

struct ConflictCallbackContext {

std::function<bool(std::string_view)> filterCallback;

std::function<int(int)> conflictCallback;

};

// the reason for using static functions here is that SQLite needs a

// function pointer

static std::function<int(int)> conflictCallback;

static int xConflict(void* pCtx, int eConflict, sqlite3_changeset_iter* pIter) {

if (!conflictCallback) return SQLITE_CHANGESET_ABORT;

return conflictCallback(eConflict);

auto ctx = static_cast<ConflictCallbackContext*>(pCtx);

if (!ctx->conflictCallback) return SQLITE_CHANGESET_ABORT;

return ctx->conflictCallback(eConflict);

}

static std::function<bool(std::string)> filterCallback;

static int xFilter(void* pCtx, const char* zTab) {

if (!filterCallback) return 1;

return filterCallback(zTab) ? 1 : 0;

auto ctx = static_cast<ConflictCallbackContext*>(pCtx);

if (!ctx->filterCallback) return 1;

return ctx->filterCallback(zTab) ? 1 : 0;

}

void DatabaseSync::ApplyChangeset(const FunctionCallbackInfo<Value>& args) {

conflictCallback = nullptr;

filterCallback = nullptr;

ConflictCallbackContext context;

DatabaseSync* db;

ASSIGN_OR_RETURN_UNWRAP(&db, args.This());

return;

}

Local<Function> conflictFunc = conflictValue.As<Function>();

conflictCallback = [env, conflictFunc](int conflictType) -> int {

context.conflictCallback = [env, conflictFunc](int conflictType) -> int {

Local<Value> argv[] = {Integer::New(env->isolate(), conflictType)};

TryCatch try_catch(env->isolate());

Local<Value> result =

Local<Function> filterFunc = filterValue.As<Function>();

filterCallback = [env, filterFunc](std::string item) -> bool {

context.filterCallback = [env,

filterFunc](std::string_view item) -> bool {

// TODO(@jasnell): The use of ToLocalChecked here means that if

// the filter function throws an error the process will crash.

// The filterCallback should be updated to avoid the check and

// propagate the error correctly.

Local<Value> argv[] = {String::NewFromUtf8(env->isolate(),

item.c_str(),

NewStringType::kNormal)

.ToLocalChecked()};

Local<Value> argv[] = {

String::NewFromUtf8(env->isolate(),

item.data(),

NewStringType::kNormal,

static_cast<int>(item.size()))

.ToLocalChecked()};

Local<Value> result =

filterFunc->Call(env->context(), Null(env->isolate()), 1, argv)

.ToLocalChecked();

const_cast<void*>(static_cast<const void*>(buf.data())),

xFilter,

xConflict,

nullptr);

static_cast<void*>(&context));

if (r == SQLITE_OK) {

args.GetReturnValue().Set(true);

return;