/// <summary>Streamingly lists directory entries in the repository. (<c>svn list</c>)</summary>
public unsafe bool List(SvnTarget target, SvnListArgs args, EventHandler <SvnListEventArgs> listHandler)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
// We allow a null listHandler; the args object might just handle it itself
EnsureState(SvnContextState.AuthorizationInitialized);
using var pool = new AprPool(_pool);
using var store = new ArgsStore(this, args, pool);
args.Prepare(target, args.Revision.RevisionType != SvnRevisionType.None);
if (listHandler != null)
{
args.List += listHandler;
}
try
{
svn_opt_revision_t pegrev = target.Revision.AllocSvnRevision(pool);
svn_opt_revision_t rev = args.Revision.Or(target.Revision).AllocSvnRevision(pool);
using var svnclient_list_func_handle = new SafeFuncHandle <svn_client_list_func2_t>(svnclient_list_handler);
svn_error_t r = svn_client.svn_client_list3(
target.AllocAsString(pool),
pegrev,
rev,
(svn_depth_t)args.Depth,
(uint)args.RetrieveEntries,
args.RetrieveLocks,
args.IncludeExternals,
svnclient_list_func_handle.Get(),
_clientBaton.Handle,
CtxHandle,
pool.Handle);
return(args.HandleResult(this, r, target));
}
finally
{
if (listHandler != null)
{
args.List -= listHandler;
}
}
}
/// <summary>Streamingly retrieves information about a local or remote item (<c>svn info</c>)</summary>
public unsafe bool Info(SvnTarget target, SvnInfoArgs args, EventHandler <SvnInfoEventArgs> infoHandler)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
// We allow a null infoHandler; the args object might just handle it itself
EnsureState(SvnContextState.AuthorizationInitialized);
using var pool = new AprPool(_pool);
using var store = new ArgsStore(this, args, pool);
if (infoHandler != null)
{
args.Info += infoHandler;
}
try
{
var pegRev = target.GetSvnRevision(SvnRevision.None, SvnRevision.Head).AllocSvnRevision(pool);
var rev = args.Revision.Or(target.GetSvnRevision(SvnRevision.None, SvnRevision.Head)).AllocSvnRevision(pool);
using var svn_info_receiver_handle = new SafeFuncHandle <svn_client_info_receiver2_t>(svn_info_receiver);
svn_error_t r = svn_client.svn_client_info4(
target.AllocAsString(pool, true),
pegRev,
rev,
(svn_depth_t)args.Depth,
args.RetrieveExcluded,
args.RetrieveActualOnly,
args.IncludeExternals,
CreateChangeListsList(args.ChangeLists, pool), // Intersect ChangeLists
svn_info_receiver_handle.Get(),
_clientBaton.Handle,
CtxHandle,
pool.Handle);
return(args.HandleResult(this, r, target));
}
finally
{
if (infoHandler != null)
{
args.Info -= infoHandler;
}
}
}
unsafe bool InternalLog(ICollection <string> targets, Uri searchRoot, SvnRevision altPegRev, SvnLogArgs args, EventHandler <SvnLogEventArgs> logHandler)
{
if (targets == null)
{
throw new ArgumentNullException(nameof(targets));
}
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
EnsureState(SvnContextState.AuthorizationInitialized);
using var pool = new AprPool(_pool);
using var store = new ArgsStore(this, args, pool);
args._mergeLogLevel = 0; // Clear log level
args._searchRoot = searchRoot;
if (logHandler != null)
{
args.Log += logHandler;
}
try
{
apr_array_header_t retrieveProperties;
if (args.RetrieveAllProperties)
{
retrieveProperties = null;
}
else if (args.RetrievePropertiesUsed)
{
retrieveProperties = AllocArray(args.RetrieveProperties, pool);
}
else
{
retrieveProperties = svn_compat.svn_compat_log_revprops_in(pool.Handle);
}
svn_opt_revision_t pegRev = args.OriginRevision.Or(altPegRev).AllocSvnRevision(pool);
int count = args.RangesUsed ? args.Ranges.Count : 1;
var revisionRanges = apr_tables.apr_array_make(
pool.Handle, count, sizeof(svn_opt_revision_range_t.__Internal *));
if (args.RangesUsed)
{
foreach (SvnRevisionRange r in args.Ranges)
{
var range = (svn_opt_revision_range_t.__Internal *)pool.Alloc(
sizeof(svn_opt_revision_range_t.__Internal));
range->start = r.StartRevision.Or(SvnRevision.Head).ToSvnRevision();
range->end = r.EndRevision.Or(SvnRevision.Zero).ToSvnRevision();
*((svn_opt_revision_range_t.__Internal * *)apr_tables.apr_array_push(revisionRanges)) = range;
}
}
else
{
var range = (svn_opt_revision_range_t.__Internal *)pool.Alloc(
sizeof(svn_opt_revision_range_t.__Internal));
range->start = args.Start.Or(args.OriginRevision).Or(SvnRevision.Head).ToSvnRevision();
range->end = args.End.Or(SvnRevision.Zero).ToSvnRevision();
*((svn_opt_revision_range_t.__Internal * *)apr_tables.apr_array_push(revisionRanges)) = range;
}
using var svnclient_log_receiver_handle = new SafeFuncHandle <svn_log_entry_receiver_t>(svnclient_log_handler);
svn_error_t err = svn_client.svn_client_log5(
AllocArray(targets, pool),
pegRev,
revisionRanges,
args.Limit,
args.RetrieveChangedPaths,
args.StrictNodeHistory,
args.RetrieveMergedRevisions,
retrieveProperties,
svnclient_log_receiver_handle.Get(),
_clientBaton.Handle,
CtxHandle,
pool.Handle);
return(args.HandleResult(this, err, targets));
}
finally
{
if (logHandler != null)
{
args.Log -= logHandler;
}
args._searchRoot = null;
args._mergeLogLevel = 0;
}
}
public CommitResultReceiver(SvnClientContext client)
{
CommitCallback = new SafeFuncHandle <svn_commit_callback2_t>(the_commit_callback2);
_commitBaton = new AprBaton <CommitResultReceiver>(this);
_client = client;
}
/// <summary>Gets status data for the specified path</summary>
public unsafe bool Status(string path, SvnStatusArgs args, EventHandler <SvnStatusEventArgs> statusHandler)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException(nameof(path));
}
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
if (!IsNotUri(path))
{
throw new ArgumentException(SharpSvnStrings.ArgumentMustBeAPathNotAUri, nameof(path));
}
// We allow a null statusHandler; the args object might just handle it itself
if (args.ContactRepository)
{
EnsureState(SvnContextState.AuthorizationInitialized);
}
else
{
EnsureState(SvnContextState.ConfigLoaded);
}
using var pool = new AprPool(_pool);
using var store = new ArgsStore(this, args, pool);
if (statusHandler != null)
{
args.Status += statusHandler;
}
try
{
int version = 0;
svn_opt_revision_t pegRev = args.Revision.AllocSvnRevision(pool);
using var svnclient_status_func_handle = new SafeFuncHandle <svn_client_status_func_t>(svnclient_status_handler);
svn_error_t r = svn_client.svn_client_status6(
ref version,
CtxHandle,
pool.AllocDirent(path),
pegRev,
(svn_depth_t)args.Depth,
args.RetrieveAllEntries,
args.RetrieveRemoteStatus,
!args.IgnoreWorkingCopyStatus,
args.RetrieveIgnoredEntries,
args.IgnoreExternals,
args.KeepDepth,
CreateChangeListsList(args.ChangeLists, pool), // Intersect ChangeLists
svnclient_status_func_handle.Get(),
_clientBaton.Handle,
pool.Handle);
return(args.HandleResult(this, r, path));
}
finally
{
if (statusHandler != null)
{
args.Status -= statusHandler;
}
}
}
