public SvnStreamWrapper(Stream stream, bool enableRead, bool enableWrite, AprPool pool) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } if (!enableRead && !enableWrite) { throw new ArgumentException("enableRead or enableWrite must be set to true"); } Stream = stream; _streamBaton = new AprBaton <SvnStreamWrapper>(this); _pool = pool; if (enableRead && !Stream.CanRead) { throw new InvalidOperationException("Can't enable reading on an unreadable stream"); } if (enableWrite && !Stream.CanWrite) { throw new InvalidOperationException("Can't enable writing on an unwritable stream"); } Init(enableRead, enableWrite, stream.CanSeek); }
internal AprArray(IEnumerable items, AprPool pool) { if (items == null) { throw new ArgumentNullException(nameof(items)); } if (pool == null) { throw new ArgumentNullException(nameof(pool)); } int nItems = 0; foreach (TManaged t in items) { if (ReferenceEquals(t, null)) { throw new ArgumentException(SharpSvnStrings.ItemInListIsNull, nameof(items)); } nItems++; } _marshaller = Activator.CreateInstance <TMarshaller>(); _pool = pool; _handle = apr_tables.apr_array_make(pool.Handle, nItems, _marshaller.ItemSize); foreach (TManaged t in items) { var ptr = apr_tables.apr_array_push(_handle); _marshaller.Write(t, ptr, pool); } }
public unsafe SvnCommitItem Read(IntPtr ptr, AprPool pool) { var ppcCommitItem = (svn_client_commit_item3_t.__Internal * *)ptr.ToPointer(); var pcCommitItem = svn_client_commit_item3_t.__CreateInstance(new IntPtr(*ppcCommitItem)); return(new SvnCommitItem(pcCommitItem, pool)); }
static unsafe IntPtr _svn_wc_conflict_resolver_func( void **resultPtr, IntPtr descriptionPtr, IntPtr baton, IntPtr resultPoolPtr, IntPtr scratchPoolPtr) { var client = AprBaton <SvnClient> .Get(baton); var conflictResult = svn_wc.svn_wc_create_conflict_result( svn_wc_conflict_choice_t.svn_wc_conflict_choose_postpone, null, apr_pool_t.__CreateInstance(resultPoolPtr)); *resultPtr = conflictResult.__Instance.ToPointer(); var resultPool = new AprPool(resultPoolPtr, false); // Connect to parent pool var scratchPool = new AprPool(scratchPoolPtr, false); // Connect to parent pool var description = svn_wc_conflict_description2_t.__CreateInstance(descriptionPtr); var ea = new SvnConflictEventArgs(description, scratchPool); try { client.HandleClientConflict(ea); if (ea.Cancel) { return(svn_error.svn_error_create((int)SvnErrorCode.SVN_ERR_CANCELLED, null, "Operation canceled from OnConflict").__Instance); } conflictResult.choice = (svn_wc_conflict_choice_t)ea.Choice; if (ea.Choice == SvnAccept.Merged) { if (ea.MergedValue != null) { conflictResult.merged_value = resultPool.AllocSvnString(ea.MergedValue); } if (ea.MergedFile != null) { conflictResult.merged_file = resultPool.AllocAbsoluteDirent(ea.MergedFile); } } return(IntPtr.Zero); } catch (Exception e) { return(SvnException.CreateExceptionSvnError("Conflict resolver", e).__Instance); } finally { ea.Detach(false); scratchPool.Dispose(); resultPool.Dispose(); } }
/// <summary>Creates a childpool within the specified parent pool</summary> public AprPool(AprPool parentPool) { if (parentPool == null) { throw new ArgumentNullException(nameof(parentPool)); } _tag = new AprPoolTag(parentPool._tag); _parent = parentPool; _handle = svn_pools.svn_pool_create(parentPool.Handle); _destroyPool = true; }
public void Write(SvnTarget value, IntPtr ptr, AprPool pool) { var srcObj = svn_client_copy_source_t.__CreateInstance( pool.AllocCleared(sizeof(svn_client_copy_source_t.__Internal))); var src = (svn_client_copy_source_t.__Internal * *)ptr; *src = (svn_client_copy_source_t.__Internal *)srcObj.__Instance; srcObj.path = value.AllocAsString(pool, true); srcObj.revision = value.GetSvnRevision(SvnRevision.Working, SvnRevision.Head).AllocSvnRevision(pool); srcObj.peg_revision = value.GetSvnRevision(SvnRevision.Working, SvnRevision.Head).AllocSvnRevision(pool); }
public unsafe ArgsStore(SvnClientContext client, SvnClientArgs args, AprPool pool) { if (args == null) { throw new ArgumentNullException(nameof(args)); } if (client._currentArgs != null) { throw new InvalidOperationException(SharpSvnStrings.SvnClientOperationInProgress); } args.Prepare(); client._currentArgs = args; _client = client; var ctx = _client.CtxHandle; _wcCtx = ctx.wc_ctx; { svn_client__private_ctx_t pctx = libsvnsharp_client.svn_client__get_private_ctx(ctx); pctx.total_progress = 0; } _lastContext = SvnClientContext._activeContext; SvnClientContext._activeContext = _client; try { if (!client.KeepSession && pool != null) { svn_wc_context_t.__Internal *p_wc_ctx = null; var error = svn_wc.svn_wc_context_create((void **)&p_wc_ctx, null, pool.Handle, pool.Handle); if (error != null) { throw SvnException.Create(error); } ctx.wc_ctx = svn_wc_context_t.__CreateInstance(new IntPtr(p_wc_ctx)); } client.HandleProcessing(new SvnProcessingEventArgs(args.CommandType)); } catch (Exception) { client._currentArgs = null; SvnClientContext._activeContext = _lastContext; throw; } }
internal static unsafe string Utf8_PathPtrToString(sbyte *ptr, AprPool pool) { if (ptr == null || pool == null) { return(null); } if (*ptr == 0) { return(string.Empty); } return(Utf8_PtrToString(svn_dirent_uri.svn_dirent_local_style(ptr, pool.Handle))); }
static unsafe IntPtr svnStreamMark(IntPtr baton, void **mark, IntPtr pool_ptr) { SvnStreamWrapper sw = AprBaton <SvnStreamWrapper> .Get(baton); using (var pool = new AprPool(pool_ptr, false)) { long *pos = (long *)pool.Alloc(sizeof(long)); *pos = sw.Stream.Position; *mark = (void *)pos; } return(IntPtr.Zero); }
static unsafe IntPtr _libsvnsharp_commit_log_func( sbyte **logMsg, sbyte **tmpFile, IntPtr commitItemsPtr, IntPtr baton, IntPtr pool) { var client = AprBaton <SvnClientContext> .Get(baton); var tmpPool = new AprPool(pool, false); var commit_items = apr_array_header_t.__CreateInstance(commitItemsPtr); var ea = new SvnCommittingEventArgs(commit_items, client.CurrentCommandArgs.CommandType, tmpPool); *logMsg = null; *tmpFile = null; try { client.HandleClientCommitting(ea); if (ea.Cancel) { return(svn_error.svn_error_create((int)SvnErrorCode.SVN_ERR_CANCELLED, null, "Operation canceled from OnCommitting").__Instance); } else if (ea.LogMessage != null) { *logMsg = tmpPool.AllocUnixString(ea.LogMessage); } else if (!client._noLogMessageRequired) { return(svn_error.svn_error_create((int)SvnErrorCode.SVN_ERR_CANCELLED, null, "Commit canceled: A logmessage is required").__Instance); } else { *logMsg = tmpPool.AllocString(""); } return(IntPtr.Zero); } catch (Exception e) { return(SvnException.CreateExceptionSvnError("Commit log", e).__Instance); } finally { ea.Detach(false); tmpPool.Dispose(); } }
internal AprArray(apr_array_header_t handle, AprPool pool) { if (handle == null) { throw new ArgumentNullException(nameof(handle)); } if (pool == null) { throw new ArgumentNullException(nameof(pool)); } _marshaller = Activator.CreateInstance <TMarshaller>(); _handle = handle; _pool = pool; IsReadOnly = true; }
internal static apr_array_header_t AllocArray(ICollection <string> strings, AprPool pool) { if (strings == null) { throw new ArgumentNullException(nameof(strings)); } if (pool == null) { throw new ArgumentNullException(nameof(pool)); } if (strings.Any(s => s == null)) { throw new ArgumentException(SharpSvnStrings.ItemInListIsNull, nameof(strings)); } var aprStrings = new AprArray <string, AprCStrMarshaller>(strings, pool); return(aprStrings.Handle); }
static void _svn_wc_notify_func2(IntPtr baton, IntPtr notifyPtr, IntPtr pool) { var client = AprBaton <SvnClient> .Get(baton); var aprPool = new AprPool(pool, false); var notify = svn_wc_notify_t.__CreateInstance(notifyPtr); var ea = new SvnNotifyEventArgs(notify, client.CurrentCommandArgs.CommandType, aprPool); try { client.HandleClientNotify(ea); } finally { ea.Detach(false); aprPool.Dispose(); } }
static IntPtr the_commit_callback2(IntPtr commit_info_ptr, IntPtr baton, IntPtr pool) { var tmpPool = new AprPool(pool, false); var receiver = AprBaton <CommitResultReceiver> .Get(baton); try { var commit_info = svn_commit_info_t.__CreateInstance(commit_info_ptr); receiver.ProvideCommitResult(commit_info, tmpPool); return(IntPtr.Zero); } catch (Exception e) { return(SvnException.CreateExceptionSvnError("CommitResult function", e).__Instance); } finally { tmpPool.Dispose(); } }
internal AprArray(ICollection <TManaged> items, AprPool pool) { if (items == null) { throw new ArgumentNullException(nameof(items)); } if (pool == null) { throw new ArgumentNullException(nameof(pool)); } _marshaller = Activator.CreateInstance <TMarshaller>(); _pool = pool; _handle = apr_tables.apr_array_make(pool.Handle, items.Count, _marshaller.ItemSize); foreach (var t in items) { var ptr = apr_tables.apr_array_push(_handle); _marshaller.Write(t, ptr, pool); } }
public unsafe NoArgsStore(SvnClientContext client, AprPool pool) { if (client._currentArgs != null) { throw new InvalidOperationException(SharpSvnStrings.SvnClientOperationInProgress); } _client = client; var ctx = _client.CtxHandle; _wcCtx = ctx.wc_ctx; _lastContext = SvnClientContext._activeContext; SvnClientContext._activeContext = _client; try { if (!client.KeepSession && pool != null) { svn_wc_context_t.__Internal *p_wc_ctx = null; var error = svn_wc.svn_wc_context_create((void **)&p_wc_ctx, null, pool.Handle, pool.Handle); if (error != null) { throw SvnException.Create(error); } ctx.wc_ctx = svn_wc_context_t.__CreateInstance(new IntPtr(p_wc_ctx)); } } catch (Exception) { SvnClientContext._activeContext = _lastContext; throw; } }
void IItemMarshaller <string> .Write(string value, IntPtr ptr, AprPool pool) { sbyte **ppStr = (sbyte **)ptr.ToPointer(); *ppStr = pool.AllocUri(value); }
Uri IItemMarshaller <Uri> .Read(IntPtr ptr, AprPool pool) { sbyte **ppcStr = (sbyte **)ptr.ToPointer(); return(SvnBase.Utf8_PtrToUri(*ppcStr, SvnNodeKind.Unknown)); }
string IItemMarshaller <string> .Read(IntPtr ptr, AprPool pool) { sbyte **ppcStr = (sbyte **)ptr.ToPointer(); return(SvnBase.Utf8_PtrToString(*ppcStr)); }
public unsafe long Read(IntPtr ptr, AprPool pool) { return(*(long *)ptr); }
public unsafe void Write(long value, IntPtr ptr, AprPool pool) { long *pRev = (long *)ptr; *pRev = value; }
public string Read(IntPtr ptr, AprPool pool) { var ppcStr = (sbyte **)ptr; return(SvnBase.Utf8_PtrToString(*ppcStr)); }
internal static unsafe SvnPropertyCollection CreatePropertyDictionary(apr_hash_t propHash, AprPool pool) { if (propHash == null) { throw new ArgumentNullException(nameof(propHash)); } if (pool == null) { throw new ArgumentNullException(nameof(pool)); } var _properties = new SvnPropertyCollection(); for (var hi = apr_hash.apr_hash_first(pool.Handle, propHash); hi != null; hi = apr_hash.apr_hash_next(hi)) { sbyte *pKey; long keyLen = 0; svn_string_t.__Internal *propValPtr; apr_hash.apr_hash_this(hi, (void **)&pKey, ref keyLen, (void **)&propValPtr); var propVal = svn_string_t.__CreateInstance(new IntPtr(propValPtr)); _properties.Add(SvnPropertyValue.Create(pKey, propVal, null)); } return(_properties); }
internal static unsafe apr_hash_t CreateRevPropList(SvnRevisionPropertyCollection revProps, AprPool pool) { if (pool == null) { throw new ArgumentNullException(nameof(pool)); } if (revProps != null && revProps.Count != 0) { apr_hash_t items = apr_hash.apr_hash_make(pool.Handle); foreach (SvnPropertyValue value in revProps) { sbyte *key = pool.AllocString(value.Key); var val = pool.AllocSvnString((byte[])value.RawValue); apr_hash.apr_hash_set(items, new IntPtr(key), Constants.APR_HASH_KEY_STRING, val.__Instance); } return(items); } return(null); }
internal static apr_array_header_t CreateChangeListsList(ICollection <string> changelists, AprPool pool) { if (pool == null) { throw new ArgumentNullException(nameof(pool)); } if (changelists != null && changelists.Count > 0) { return(AllocArray(changelists, pool)); } return(null); }
internal static apr_array_header_t AllocCopyArray <TSvnTarget>(ICollection <TSvnTarget> targets, AprPool pool) where TSvnTarget : SvnTarget { if (targets == null) { throw new ArgumentNullException(nameof(targets)); } foreach (SvnTarget s in targets) { if (s == null) { throw new ArgumentException(SharpSvnStrings.ItemInListIsNull, nameof(targets)); } } var aprTargets = new AprArray <SvnTarget, SvnCopyTargetMarshaller>(targets, pool); return(aprTargets.Handle); }
public void Write(string value, IntPtr ptr, AprPool pool) { var ppStr = (sbyte **)ptr; *ppStr = pool.AllocString(value); }
public void Write(string value, IntPtr ptr, AprPool pool) { sbyte **ppStr = (sbyte **)ptr; *ppStr = pool.AllocDirent(value); }
public string Read(IntPtr ptr, AprPool pool) { sbyte **ppcStr = (sbyte **)ptr; return(SvnBase.Utf8_PtrToString(svn_dirent_uri.svn_dirent_local_style(*ppcStr, pool.Handle))); }
internal void ProvideCommitResult(svn_commit_info_t commit_info, AprPool pool) { CommitResult = SvnCommittedEventArgs.Create(_client, commit_info, pool); _client.HandleClientCommitted(CommitResult); }