public static C4Query *c4query_new(C4Database *db, string queryExpression, string sortExpression, C4Error *outError)
{
using (var queryExpression_ = new C4String(queryExpression))
using (var sortExpression_ = new C4String(sortExpression)) {
return(NativeRaw.c4query_new(db, queryExpression_.AsC4Slice(), sortExpression_.AsC4Slice(), outError));
}
}
public static C4DocEnumerator *c4db_enumerateAllDocs(C4Database *database, string startDocID, string endDocID, C4EnumeratorOptions *options, C4Error *outError)
{
using (var startDocID_ = new C4String(startDocID))
using (var endDocID_ = new C4String(endDocID)) {
return(NativeRaw.c4db_enumerateAllDocs(database, startDocID_.AsC4Slice(), endDocID_.AsC4Slice(), options, outError));
}
}
public static C4RawDocument *c4raw_get(C4Database *database, string storeName, string docID, C4Error *outError)
{
using (var storeName_ = new C4String(storeName))
using (var docID_ = new C4String(docID)) {
return(NativeRaw.c4raw_get(database, storeName_.AsC4Slice(), docID_.AsC4Slice(), outError));
}
}
public static C4Replicator *c4repl_new(C4Database *db, C4Address remoteAddress, string remoteDatabaseName,
C4Database *otherDb, C4ReplicatorParameters @params, C4Error *err)
{
using (var remoteDatabaseName_ = new C4String(remoteDatabaseName)) {
return(c4repl_new(db, remoteAddress, remoteDatabaseName_.AsC4Slice(), otherDb, @params, err));
}
}
public static C4Key *c4key_newFullTextString(string text, string language)
{
using (var text_ = new C4String(text))
using (var language_ = new C4String(language)) {
return(NativeRaw.c4key_newFullTextString(text_.AsC4Slice(), language_.AsC4Slice()));
}
}
public void TestInvalidDocID()
{
RunTestVariants(() =>
{
NativePrivate.c4log_warnOnErrors(false);
LiteCoreBridge.Check(err => Native.c4db_beginTransaction(Db, err));
try {
Action <C4Slice> checkPutBadDocID = (C4Slice docID) =>
{
C4Error e;
var rq = new C4DocPutRequest();
rq.body = Body;
rq.save = true;
rq.docID = docID;
((long)Native.c4doc_put(Db, &rq, null, &e)).Should()
.Be(0, "because the invalid doc ID should cause the put to fail");
e.domain.Should().Be(C4ErrorDomain.LiteCoreDomain);
e.code.Should().Be((int)C4ErrorCode.BadDocID);
};
checkPutBadDocID(C4Slice.Constant(""));
string tooLong = new string(Enumerable.Repeat('x', 241).ToArray());
using (var tooLong_ = new C4String(tooLong)) {
checkPutBadDocID(tooLong_.AsC4Slice());
}
checkPutBadDocID(C4Slice.Constant("oops\x00oops")); // Bad UTF-8
checkPutBadDocID(C4Slice.Constant("oops\noops")); // Control characters
} finally {
NativePrivate.c4log_warnOnErrors(true);
LiteCoreBridge.Check(err => Native.c4db_endTransaction(Db, true, err));
}
});
}
public static bool c4db_setCookie(C4Database *db, string setCookieHeader, string fromHost, C4Error *outError)
{
using (var setCookieHeader_ = new C4String(setCookieHeader))
using (var fromHost_ = new C4String(fromHost)) {
return(NativeRaw.c4db_setCookie(db, setCookieHeader_.AsC4Slice(), fromHost_.AsC4Slice(), outError));
}
}
public static C4Document *c4doc_getForPut(C4Database *database, string docID, string parentRevID, bool deleting, bool allowConflict, C4Error *outError)
{
using (var docID_ = new C4String(docID))
using (var parentRevID_ = new C4String(parentRevID)) {
return(NativeRawPrivate.c4doc_getForPut(database, docID_.AsC4Slice(), parentRevID_.AsC4Slice(), deleting, allowConflict, outError));
}
}
public static bool c4db_createIndex(C4Database *database, string name, string expressionsJSON, C4IndexType indexType, C4IndexOptions *indexOptions, C4Error *outError)
{
using (var name_ = new C4String(name))
using (var expressionsJSON_ = new C4String(expressionsJSON)) {
return(NativeRaw.c4db_createIndex(database, name_.AsC4Slice(), expressionsJSON_.AsC4Slice(), indexType, indexOptions, outError));
}
}
public static bool c4db_copy(string sourcePath, string destinationPath, C4DatabaseConfig *config, C4Error *error)
{
using (var sourcePath_ = new C4String(sourcePath))
using (var destinationPath_ = new C4String(destinationPath)) {
return(NativeRaw.c4db_copy(sourcePath_.AsC4Slice(), destinationPath_.AsC4Slice(), config, error));
}
}
public static bool c4doc_selectCommonAncestorRevision(C4Document *doc, string rev1ID, string rev2ID)
{
using (var rev1ID_ = new C4String(rev1ID))
using (var rev2ID_ = new C4String(rev2ID)) {
return(NativeRaw.c4doc_selectCommonAncestorRevision(doc, rev1ID_.AsC4Slice(), rev2ID_.AsC4Slice()));
}
}
public static string FLJSON5_ToJSON(string json5, FLError *error)
{
using (var json5_ = new C4String(json5)) {
using (var retVal = NativeRaw.FLJSON5_ToJSON((FLSlice)json5_.AsC4Slice(), error)) {
return(((FLSlice)retVal).CreateString());
}
}
}
public static string c4query_fullTextMatched(C4Query *query, string docID, ulong seq, C4Error *outError)
{
using (var docID_ = new C4String(docID)) {
using (var retVal = NativeRaw.c4query_fullTextMatched(query, docID_.AsC4Slice(), seq, outError)) {
return(((C4Slice)retVal).CreateString());
}
}
}
public static byte[] c4db_encodeJSON(C4Database *db, string jsonData, C4Error *outError)
{
using (var jsonData_ = new C4String(jsonData)) {
using (var retVal = NativeRaw.c4db_encodeJSON(db, jsonData_.AsC4Slice(), outError)) {
return(((C4Slice)retVal).ToArrayFast());
}
}
}
public static string FLData_ConvertJSON(string json, FLError *outError)
{
using (var json_ = new C4String(json)) {
using (var retVal = NativeRaw.FLData_ConvertJSON((FLSlice)json_.AsC4Slice(), outError)) {
return(((FLSlice)retVal).CreateString());
}
}
}
public static C4Document *c4doc_create(C4Database *db, string docID, byte[] body, C4RevisionFlags revisionFlags, C4Error *error)
{
using (var docID_ = new C4String(docID))
fixed(byte *body_ = body)
{
return(NativeRaw.c4doc_create(db, docID_.AsC4Slice(), new C4Slice(body_, body == null ? 0 : (ulong)body.Length), revisionFlags, error));
}
}
public static string c4doc_generateRevID(string body, string parentRevID, bool deletion)
{
using (var body_ = new C4String(body))
using (var parentRevID_ = new C4String(parentRevID)) {
using (var retVal = NativeRaw.c4doc_generateRevID(body_.AsC4Slice(), parentRevID_.AsC4Slice(), deletion)) {
return(((C4Slice)retVal).CreateString());
}
}
}
public static C4BlobStore *c4blob_openStore(string dirPath,
C4DatabaseFlags flags,
C4EncryptionKey *encryptionKey,
C4Error *outError)
{
using (var dirPath_ = new C4String(dirPath)) {
return(NativeRaw.c4blob_openStore(dirPath_.AsC4Slice(), flags, encryptionKey, outError));
}
}
public static bool c4raw_put(C4Database *database, string storeName, string key, string meta, string body, C4Error *outError)
{
using (var storeName_ = new C4String(storeName))
using (var key_ = new C4String(key))
using (var meta_ = new C4String(meta))
using (var body_ = new C4String(body)) {
return(NativeRaw.c4raw_put(database, storeName_.AsC4Slice(), key_.AsC4Slice(), meta_.AsC4Slice(), body_.AsC4Slice(), outError));
}
}
public static bool c4doc_resolveConflict(C4Document *doc, string winningRevID, string losingRevID, byte[] mergedBody, C4RevisionFlags mergedFlags, C4Error *error)
{
using (var winningRevID_ = new C4String(winningRevID))
using (var losingRevID_ = new C4String(losingRevID))
fixed(byte *mergedBody_ = mergedBody)
{
return(NativeRaw.c4doc_resolveConflict(doc, winningRevID_.AsC4Slice(), losingRevID_.AsC4Slice(), new C4Slice(mergedBody_, mergedBody == null ? 0 : (ulong)mergedBody.Length), mergedFlags, error));
}
}
private unsafe C4Slice Reduce(void *context)
{
if (_reduce == null)
{
return(C4Slice.Null);
}
_lastReturn.Dispose();
_lastReturn = new C4String(_reduce(_context));
return(_lastReturn.AsC4Slice());
}
public void TestDuplicateRev()
{
RunTestVariants(() =>
{
var docID = "mydoc";
var body = "{\"key\":\"value\"}";
var doc = PutDoc(docID, null, body);
var revID = doc->revID.CreateString();
Native.c4doc_free(doc);
body = "{\"key\":\"newvalue\"}";
doc = PutDoc(docID, revID, body);
var revID2a = doc->revID.CreateString();
Native.c4doc_free(doc);
LiteCoreBridge.Check(err => Native.c4db_beginTransaction(Db, err));
var success = false;
try {
using (var docID_ = new C4String(docID))
using (var revID_ = new C4String(revID))
using (var body_ = new C4String(body)) {
var history = new C4Slice[] { revID_.AsC4Slice() };
fixed(C4Slice * history_ = history)
{
var rq = new C4DocPutRequest
{
allowConflict = true,
docID = docID_.AsC4Slice(),
history = history_,
historyCount = 1,
body = body_.AsC4Slice(),
revFlags = 0,
save = true
};
doc = (C4Document *)LiteCoreBridge.Check(err =>
{
var local = rq;
return(Native.c4doc_put(Db, &local, null, err));
});
doc->docID.CreateString().Should().Be(docID);
}
}
} finally {
LiteCoreBridge.Check(err => Native.c4db_endTransaction(Db, success, err));
}
var revID2b = doc->revID.CreateString();
Native.c4doc_free(doc);
revID2b.Should().Be(revID2a, "because an identical revision was inserted");
});
}
public static string c4view_fullTextMatched(C4View *view,
string docID,
C4SequenceNumber seq,
uint fullTextID,
C4Error *outError)
{
using (var docID_ = new C4String(docID)) {
using (var retVal = NativeRaw.c4view_fullTextMatched(view, docID_.AsC4Slice(), seq, fullTextID, outError)) {
return(((C4Slice)retVal).CreateString());
}
}
}
public static C4QueryEnumerator *c4view_fullTextQuery(C4View *view,
string queryString,
string queryStringLanguage,
C4QueryOptions *c4Options,
C4Error *outError)
{
using (var queryString_ = new C4String(queryString))
using (var queryStringLanguage_ = new C4String(queryStringLanguage)) {
return(NativeRaw.c4view_fullTextQuery(view, queryString_.AsC4Slice(), queryStringLanguage_.AsC4Slice(),
c4Options, outError));
}
}
private CBForestQueryEnumerator QueryEnumeratorWithOptions(QueryOptions options)
{
var enumerator = default(C4QueryEnumerator *);
var startKey = options.StartKey;
var endKey = options.EndKey;
if (options.Descending)
{
startKey = Misc.KeyForPrefixMatch(startKey, options.PrefixMatchLevel);
}
else
{
endKey = Misc.KeyForPrefixMatch(options.EndKey, options.PrefixMatchLevel);
}
using (var startkeydocid_ = new C4String(options.StartKeyDocId))
using (var endkeydocid_ = new C4String(options.EndKeyDocId)) {
WithC4Keys(new object[] { startKey, endKey }, false, startEndKey =>
WithC4Keys(options.Keys == null ? null : options.Keys.ToArray(), true, c4keys =>
{
var opts = C4QueryOptions.DEFAULT;
opts.descending = options.Descending;
opts.endKey = startEndKey[1];
opts.endKeyDocID = endkeydocid_.AsC4Slice();
opts.inclusiveEnd = options.InclusiveEnd;
opts.inclusiveStart = options.InclusiveStart;
if (c4keys != null)
{
opts.keysCount = (uint)c4keys.Length;
}
if (!options.Reduce)
{
opts.limit = (ulong)options.Limit;
opts.skip = (ulong)options.Skip;
}
opts.startKey = startEndKey[0];
opts.startKeyDocID = startkeydocid_.AsC4Slice();
fixed(C4Key * *keysPtr = c4keys)
{
opts.keys = keysPtr;
enumerator = (C4QueryEnumerator *)ForestDBBridge.Check(err => {
var localOpts = opts;
return(Native.c4view_query(IndexDB, &localOpts, err));
});
}
})
);
}
return(new CBForestQueryEnumerator(enumerator));
}
public static C4View *c4view_open(C4Database *database,
string path,
string viewName,
string version,
C4DatabaseConfig *config,
C4Error *outError)
{
using (var path_ = new C4String(path))
using (var viewName_ = new C4String(viewName))
using (var version_ = new C4String(version)) {
return(NativeRaw.c4view_open(database, path_.AsC4Slice(), viewName_.AsC4Slice(), version_.AsC4Slice(),
config, outError));
}
}
protected override void SetupVariant(int option)
{
base.SetupVariant(option);
var c = new List <char>(Enumerable.Repeat('a', SizeOfDocument));
c.Add((char)0);
var content = new string(c.ToArray());
C4Error err;
Native.c4db_beginTransaction(Db, &err).Should().BeTrue("because starting a transaction should succeed");
var rng = new Random();
for (int i = 0; i < NumDocuments; i++)
{
using (var docID = new C4String($"doc-{rng.Next():D8}-{rng.Next():D8}-{rng.Next():D8}-{i:D4}"))
using (var revID = new C4String("1-deadbeefcafebabe80081e50"))
using (var json = new C4String("{{\"content\":\"{content}\"}}")) {
var history = IsRevTrees() ? new C4String[1] {
new C4String("1-deadbeefcafebabe80081e50")
}
: new C4String[1] {
new C4String("1@deadbeefcafebabe80081e50")
};
var rawHistory = history.Select(x => x.AsC4Slice()).ToArray();
fixed(C4Slice *rawHistory_ = rawHistory)
{
var rq = new C4DocPutRequest();
rq.existingRevision = true;
rq.docID = docID.AsC4Slice();
rq.history = rawHistory_;
rq.historyCount = 1;
rq.body = json.AsC4Slice();
rq.save = true;
var doc = Native.c4doc_put(Db, &rq, null, &err);
((long)doc).Should().NotBe(0, $"because otherwise the put failed");
Native.c4doc_free(doc);
}
}
}
Native.c4db_endTransaction(Db, true, &err).Should().BeTrue("because otherwise the transaction failed to end");
Console.WriteLine($"Created {NumDocuments} docs");
Native.c4db_getDocumentCount(Db).Should().Be(NumDocuments, "because the number of documents should be the number that was just inserted");
}
private C4Document *PutDoc(C4Database *db, string docID, string revID, string body, C4RevisionFlags flags, C4Error *error = null)
{
LiteCoreBridge.Check(err => Native.c4db_beginTransaction(db, err));
var success = false;
try {
using (var docID_ = new C4String(docID))
using (var revID_ = new C4String(revID))
using (var body_ = new C4String(body)) {
var history = new C4Slice[] { revID_.AsC4Slice() };
fixed(C4Slice *history_ = history)
{
var rq = new C4DocPutRequest
{
allowConflict = false,
docID = docID_.AsC4Slice(),
history = revID == null ? null : history_,
historyCount = revID == null ? 0UL : 1UL,
body = body_.AsC4Slice(),
revFlags = flags,
remoteDBID = _remoteDocID,
save = true
};
C4Document *doc;
if (error != null)
{
var local = rq;
doc = Native.c4doc_put(db, &local, null, error);
}
else
{
doc = (C4Document *)LiteCoreBridge.Check(err =>
{
var local = rq;
return(Native.c4doc_put(db, &local, null, err));
});
}
success = true;
return(doc);
}
}
} finally {
LiteCoreBridge.Check(err => Native.c4db_endTransaction(db, success, err));
}
}
protected bool ReadFileByLines(string path, Func <FLSlice, bool> callback)
{
using (var tr = new StreamReader(File.Open(path, FileMode.Open))) {
string line;
while ((line = tr.ReadLine()) != null)
{
using (var c4 = new C4String(line)) {
if (!callback((FLSlice)c4.AsC4Slice()))
{
return(false);
}
}
}
}
return(true);
}
internal bool ReadFileByLines(string path, Func <FLSlice, bool> callback)
{
#if WINDOWS_UWP
var url = $"ms-appx:///Assets/{path}";
var file = Windows.Storage.StorageFile.GetFileFromApplicationUriAsync(new Uri(url))
.AsTask()
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
var lines = Windows.Storage.FileIO.ReadLinesAsync(file).AsTask().ConfigureAwait(false).GetAwaiter().GetResult();
foreach (var line in lines)
{
#elif __ANDROID__
var ctx = global::Couchbase.Lite.Tests.Android.MainActivity.ActivityContext;
using (var tr = new StreamReader(ctx.Assets.Open(path))) {
string line;
while ((line = tr.ReadLine()) != null)
{
#elif __IOS__
var bundlePath = ios::Foundation.NSBundle.MainBundle.PathForResource(Path.GetFileNameWithoutExtension(path), Path.GetExtension(path));
using (var tr = new StreamReader(File.Open(bundlePath, FileMode.Open, FileAccess.Read)))
{
string line;
while ((line = tr.ReadLine()) != null)
{
#else
using (var tr = new StreamReader(File.Open(path, FileMode.Open))) {
string line;
while ((line = tr.ReadLine()) != null)
{
#endif
using (var c4 = new C4String(line)) {
if (!callback((FLSlice)c4.AsC4Slice()))
{
return(false);
}
}
}
#if !WINDOWS_UWP
}
#endif
return(true);
}
/// <summary>
/// Reads a raw document from the database. In Couchbase Lite the store named "info" is used for
/// per-database key/value pairs, and the store "_local" is used for local documents.
/// </summary>
/// <param name="db">The database to operate on</param>
/// <param name="storeName">The name of the store to read from</param>
/// <param name="docID">The ID of the document to retrieve</param>
/// <param name="outError">The error that occurred if the operation doesn't succeed</param>
/// <returns>A pointer to the retrieved document on success, or null on failure</returns>
public static C4RawDocument* c4raw_get(C4Database *db, string storeName, string docID, C4Error *outError)
{
using(var storeName_ = new C4String(storeName))
using(var docID_ = new C4String(docID)) {
return c4raw_get(db, storeName_.AsC4Slice(), docID_.AsC4Slice(), outError);
}
}
/// <summary>
/// Adds a revision to a document, as a child of the currently selected revision
/// (or as a root revision if there is no selected revision.)
/// On success, the new revision will be selected.
/// Must be called within a transaction.
/// </summary>
/// <param name="doc">The document to operate on</param>
/// <param name="revID">The ID of the revision being inserted</param>
/// <param name="body">The (JSON) body of the revision</param>
/// <param name="deleted">True if this revision is a deletion (tombstone)</param>
/// <param name="hasAttachments">True if this revision contains an _attachments dictionary</param>
/// <param name="allowConflict">If false, and the parent is not a leaf, a 409 error is returned</param>
/// <param name="outError">The error that occurred if the operation doesn't succeed</param>
/// <returns>The number of revisions inserted (0, 1, or -1 on error)</returns>
public static int c4doc_insertRevision(C4Document *doc, string revID, string body, bool deleted, bool hasAttachments,
bool allowConflict, C4Error *outError)
{
using(var revID_ = new C4String(revID))
using(var body_ = new C4String(body)) {
return c4doc_insertRevision(doc, revID_.AsC4Slice(), body_.AsC4Slice(), deleted,
hasAttachments, allowConflict, outError);
}
}
public static int c4doc_purgeRevision(C4Document *doc, string revId, C4Error *outError)
{
using(var revId_ = new C4String(revId)) {
return c4doc_purgeRevision(doc, revId_.AsC4Slice(), outError);
}
}
/// <summary>
/// Adds a map key, before the next value. When adding to a map, every value must be
/// preceded by a key.
/// </summary>
/// <param name="key">The key to operate on</param>
/// <param name="s">The value to store</param>
public static void c4key_addMapKey(C4Key *key, string s)
{
using(var s_ = new C4String(s)) {
c4key_addMapKey(key, s_.AsC4Slice());
}
}
public static bool c4db_purgeDoc(C4Database *db, string docId, C4Error *outError)
{
using (var docId_ = new C4String(docId)) {
return c4db_purgeDoc(db, docId_.AsC4Slice(), outError);
}
}
/// <summary>
/// Creates an enumerator ordered by docID.
/// Options have the same meanings as in Couchbase Lite.
/// There's no 'limit' option; just stop enumerating when you're done.
/// Caller is responsible for freeing the enumerator when finished with it.
/// </summary>
/// <param name="db">The database to operate on</param>
/// <param name="startDocID">The document ID to begin at</param>
/// <param name="endDocID">The document ID to end at</param>
/// <param name="options">Enumeration options (NULL for defaults)</param>
/// <param name="outError">The error that occurred if the operation doesn't succeed</param>
/// <returns>A pointer to the enumeator on success, otherwise null</returns>
public static C4DocEnumerator* c4db_enumerateAllDocs(C4Database *db, string startDocID, string endDocID, C4EnumeratorOptions *options,
C4Error *outError)
{
using(var startDocID_ = new C4String(startDocID))
using(var endDocID_ = new C4String(endDocID)) {
return c4db_enumerateAllDocs(db, startDocID_.AsC4Slice(), endDocID_.AsC4Slice(), options, outError);
}
}
/// <summary>
/// Writes a raw document to the database, or deletes it if both meta and body are NULL.
/// </summary>
/// <param name="db">The database to operate on</param>
/// <param name="storeName">The store to write to</param>
/// <param name="key">The key to store</param>
/// <param name="meta">The metadata to store</param>
/// <param name="body">The body to store</param>
/// <param name="outError">The error that occurred if the operation doesn't succeed</param>
/// <returns>true on success, false otherwise</returns>
public static bool c4raw_put(C4Database *db, string storeName, string key, string meta, string body, C4Error *outError)
{
using(var storeName_ = new C4String(storeName))
using(var key_ = new C4String(key))
using(var meta_ = new C4String(meta))
using(var body_ = new C4String(body)) {
return c4raw_put(db, storeName_.AsC4Slice(), key_.AsC4Slice(), meta_.AsC4Slice(),
body_.AsC4Slice(), outError);
}
}
/// <summary>
/// Gets a document from the database. If there's no such document, the behavior depends on
/// the mustExist flag.If it's true, NULL is returned. If it's false, a valid C4Document
/// The current revision is selected(if the document exists.)
/// </summary>
/// <param name="db">The database to retrieve from</param>
/// <param name="docID">The ID of the document to retrieve</param>
/// <param name="mustExist">Whether or not to create the document on demand</param>
/// <param name="outError">The error that occurred if the operation doesn't succeed</param>
/// <returns>A pointer to the retrieved document on success, or null on failure</returns>
public static C4Document* c4doc_get(C4Database *db, string docID, bool mustExist, C4Error *outError)
{
using(var docID_ = new C4String(docID)) {
return c4doc_get(db, docID_.AsC4Slice(), mustExist, outError);
}
}
/// <summary>
/// Opens a database.
/// </summary>
/// <param name="path">The path to the DB file</param>
/// <param name="readOnly">Whether or not the DB should be opened in read-only mode</param>
/// <param name="encryptionKey">The option encryption key used to encrypt the database</param>
/// <param name="outError">The error that occurred if the operation doesn't succeed</param>
/// <returns>A database instance for use in the C4 API</returns>
public static C4Database *c4db_open(string path, C4DatabaseFlags flags,
C4EncryptionKey *encryptionKey, C4Error *outError)
{
using(var path_ = new C4String(path)) {
return c4db_open(path_.AsC4Slice(), flags, encryptionKey, outError);
}
}
/// <summary>
/// Opens a view, or creates it if the file doesn't already exist.
/// </summary>
/// <param name="db">The database the view is associated with</param>
/// <param name="path">The file that the view is stored in</param>
/// <param name="viewName">The name of the view</param>
/// <param name="version">The version of the view's map function</param>
/// <param name="flags">The flags for opening the view file</param>
/// <param name="encryptionKey">The option encryption key used to encrypt the database</param>
/// <param name="outError">The error that occurred if the operation doesn't succeed</param>
/// <returns>A pointer to the view on success, otherwise null</returns>
public static C4View* c4view_open(C4Database *db, string path, string viewName, string version, C4DatabaseFlags flags,
C4EncryptionKey *encryptionKey, C4Error *outError)
{
using(var path_ = new C4String(path))
using(var viewName_ = new C4String(viewName))
using(var version_ = new C4String(version)) {
return c4view_open(db, path_.AsC4Slice(), viewName_.AsC4Slice(), version_.AsC4Slice(), flags, encryptionKey, outError);
}
}
/// <summary>
/// Sets a document's docType. (By convention this is the value of the "type" property of the
/// current revision's JSON; this value can be used as optimization when indexing a view.)
/// The change will not be persisted until the document is saved.
/// </summary>
/// <param name="doc">The document to operate on</param>
/// <param name="docType">The document type to set</param>
/// <param name="outError">The error that occurred if the operation doesn't succeed</param>
/// <returns>true on success, false otherwise</returns>
public static bool c4doc_setType(C4Document *doc, string docType, C4Error *outError)
{
using(var docType_ = new C4String(docType)) {
return c4doc_setType(doc, docType_.AsC4Slice(), outError);
}
}
/// <summary>
/// Selects a specific revision of a document (or no revision, if revID is NULL.)
/// </summary>
/// <param name="doc">The document to operate on</param>
/// <param name="revID">The revID of the revision to select</param>
/// <param name="withBody">Whether or not to load the body of the revision</param>
/// <param name="outError">The error that occurred if the operation doesn't succeed</param>
/// <returns>true on success, false otherwise</returns>
public static bool c4doc_selectRevision(C4Document *doc, string revID, bool withBody, C4Error *outError)
{
using(var revID_ = new C4String(revID)) {
return c4doc_selectRevision(doc, revID_.AsC4Slice(), withBody, outError);
}
}
