コード例 #1
0
ファイル: SvnClient.cs プロジェクト: softec/SubversionSharp
 public SvnClient(SvnClientContext ctx, AprPool pool)
 {
     mGlobalPool = pool;
     mPool = Svn.PoolCreate(mGlobalPool);
     mContext = ctx;
     mAuthObjs = null;
 }
コード例 #2
0
        public static void Blame(SvnUrl pathOrUrl,
								 SvnOptRevision start, SvnOptRevision end, 
								 BlameReceiver receiver, IntPtr baton,
							     SvnClientContext ctx, AprPool pool)
        {
            InternalBlame(pathOrUrl, start, end, receiver, baton, ctx, pool);
        }
コード例 #3
0
ファイル: SvnClient.cs プロジェクト: softec/SubversionSharp
 public SvnClient(AprPool pool)
 {
     mGlobalPool = pool;
     mPool = Svn.PoolCreate(mGlobalPool);
     mContext = SvnClientContext.Create(mGlobalPool);
     mContext.Config = SvnConfig.GetConfig(mGlobalPool);
     mAuthObjs = null;
 }
コード例 #4
0
        public static void Add(SvnPath path,
							   bool recurse, 
							   SvnClientContext ctx, AprPool pool)
        {
            Debug.WriteLine(String.Format("svn_client_add({0},{1},{2},{3})",path,recurse,ctx,pool));
            SvnError err = Svn.svn_client_add(path,
                                              (recurse ? 1 :0), ctx, pool);
            if( !err.IsNoError )
                throw new SvnException(err);
        }
コード例 #5
0
        public static void Relocate(SvnPath dir, SvnUrl from, SvnUrl to,
                                    bool recurse,
                                    SvnClientContext ctx, AprPool pool)
        {
            Debug.WriteLine(String.Format("svn_client_relocate({0},{1},{2},{3},{4},{5})", dir, from, to, recurse, ctx, pool));
            SvnError err = Svn.svn_client_relocate(dir, from, to, (recurse ? 1 : 0), ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
        }
コード例 #6
0
        public static void Add(SvnPath path,
                               bool recurse,
                               SvnClientContext ctx, AprPool pool)
        {
            Debug.WriteLine(String.Format("svn_client_add({0},{1},{2},{3})", path, recurse, ctx, pool));
            SvnError err = Svn.svn_client_add(path,
                                              (recurse ? 1 :0), ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
        }
コード例 #7
0
        public static AprString UuidFromUrl(SvnUrl url, SvnClientContext ctx, AprPool pool)
        {
            IntPtr s;

            Debug.Write(String.Format("svn_client_uuid_from_url({0},{1})...", url, ctx, pool));
            SvnError err = Svn.svn_client_uuid_from_url(out s, url, ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
            Debug.WriteLine(String.Format("Done({0})", s));
            return(s);
        }
コード例 #8
0
        public static SvnClientCommitInfo Delete(AprArray paths, bool force,
                                                 SvnClientContext ctx, AprPool pool)
        {
            IntPtr commitInfo;

            Debug.Write(String.Format("svn_client_delete({0},{1},{2},{3})...", paths, force, ctx, pool));
            SvnError err = Svn.svn_client_delete(out commitInfo, paths, (force ? 1 : 0), ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
            Debug.WriteLine(String.Format("Done({0})", commitInfo));
            return(commitInfo);
        }
コード例 #9
0
        public static SvnClientCommitInfo Import(SvnPath path, SvnUrl url, bool nonrecursive,
                                                 SvnClientContext ctx, AprPool pool)
        {
            IntPtr commitInfo;

            Debug.Write(String.Format("svn_client_import({0},{1},{2},{3},{4})...", path, url, nonrecursive, ctx, pool));
            SvnError err = Svn.svn_client_import(out commitInfo, path, url, (nonrecursive ? 1 : 0),
                                                 ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
            Debug.WriteLine(String.Format("Done({0})", commitInfo));
            return(commitInfo);
        }
コード例 #10
0
        public static SvnClientCommitInfo Commit(AprArray targets, bool nonrecursive,
                                                 SvnClientContext ctx, AprPool pool)
        {
            IntPtr commitInfo;

            Debug.Write(String.Format("svn_client_commit({0},{1},{2},{3})...", targets, nonrecursive, ctx, pool));
            SvnError err = Svn.svn_client_commit(out commitInfo, targets, (nonrecursive ? 1 : 0),
                                                 ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
            Debug.WriteLine(String.Format("Done({0})", commitInfo));
            return(commitInfo);
        }
コード例 #11
0
        public static SvnString RevPropGet(string propName, SvnUrl url,
                                           SvnOptRevision revision, out int setRev,
                                           SvnClientContext ctx, AprPool pool)
        {
            IntPtr s;

            Debug.Write(String.Format("svn_client_revprop_get({0},{1},{2},{3},{4})...", propName, url, revision, ctx, pool));
            SvnError err = Svn.svn_client_revprop_get(propName, out s, url, revision, out setRev,
                                                      ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
            Debug.WriteLine(String.Format("Done({0},{1})", s, setRev));
            return(s);
        }
コード例 #12
0
        public static AprHash RevPropList(SvnUrl url,
                                          SvnOptRevision revision, out int setRev,
                                          SvnClientContext ctx, AprPool pool)
        {
            IntPtr h;

            Debug.Write(String.Format("svn_client_revprop_list({0},{1},{2},{3})...", url, revision, ctx, pool));
            SvnError err = Svn.svn_client_revprop_list(out h, url, revision, out setRev,
                                                       ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
            Debug.WriteLine(String.Format("Done({0},{1})", h, setRev));
            return(h);
        }
コード例 #13
0
        protected static AprHash InternalList(IAprUnmanaged pathOrUrl,
                                              SvnOptRevision revision, bool recurse,
                                              SvnClientContext ctx, AprPool pool)
        {
            IntPtr h;

            Debug.Write(String.Format("svn_client_list({0},{1},{2},{3},{4})...", pathOrUrl, revision, recurse, ctx, pool));
            SvnError err = Svn.svn_client_ls(out h, pathOrUrl.ToIntPtr(), revision, (recurse ? 1 : 0),
                                             ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
            Debug.WriteLine(String.Format("Done({0})", h));
            return(h);
        }
コード例 #14
0
        public static int Switch(SvnPath path, SvnUrl url,
                                 SvnOptRevision revision,
                                 bool recurse, SvnClientContext ctx, AprPool pool)
        {
            int rev;

            Debug.Write(String.Format("svn_client_switch({0},{1},{2},{3},{4},{5})...", path, url, revision, recurse, ctx, pool));
            SvnError err = Svn.svn_client_switch(out rev, path, url,
                                                 revision,
                                                 (recurse ? 1 :0), ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
            Debug.WriteLine(String.Format("Done({0})", rev));
            return(rev);
        }
コード例 #15
0
        protected static void InternalBlame(IAprUnmanaged pathOrUrl,
                                            SvnOptRevision start, SvnOptRevision end,
                                            BlameReceiver receiver, IntPtr baton,
                                            SvnClientContext ctx, AprPool pool)
        {
            SvnDelegate receiverDelegate = new SvnDelegate(receiver);

            Debug.WriteLine(String.Format("svn_client_blame({0},{1},{2},{3},{4:X},{5},{6})", pathOrUrl, start, end, receiver.Method.Name, baton.ToInt32(), ctx, pool));
            SvnError err = Svn.svn_client_blame(pathOrUrl.ToIntPtr(), start, end,
                                                (Svn.svn_client_blame_receiver_t)receiverDelegate.Wrapper,
                                                baton,
                                                ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
        }
コード例 #16
0
        public static void Diff(AprArray diffOptions,
                                SvnUrl path1, SvnOptRevision revision1,
                                SvnUrl path2, SvnOptRevision revision2,
                                bool recurse, bool ignoreAncestry, bool noDiffDeleted,
                                AprFile outFile, AprFile errFile,
                                SvnClientContext ctx, AprPool pool)
        {
            Debug.WriteLine(String.Format("svn_client_diff({0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11})", diffOptions, path1, revision1, path2, revision2, recurse, ignoreAncestry, noDiffDeleted, outFile, errFile, ctx, pool));
            SvnError err = Svn.svn_client_diff(diffOptions, path1, revision1, path2, revision2,
                                               (recurse ? 1 : 0), (ignoreAncestry ? 1 : 0),
                                               (noDiffDeleted ? 1 : 0), outFile, errFile,
                                               ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
        }
コード例 #17
0
        protected static AprHash InternalPropGet(string propName, IAprUnmanaged target,
                                                 SvnOptRevision revision, bool recurse,
                                                 SvnClientContext ctx, AprPool pool)
        {
            IntPtr h;

            Debug.Write(String.Format("svn_client_propget({0},{1},{2},{3},{4},{5})...", propName, target, revision, recurse, ctx, pool));
            SvnError err = Svn.svn_client_propget(out h, propName, target.ToIntPtr(), revision,
                                                  (recurse ? 1 : 0),
                                                  ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
            Debug.WriteLine(String.Format("Done({0})", h));
            return(h);
        }
コード例 #18
0
        protected static int InternalExport(IAprUnmanaged from, SvnPath to,
                                            SvnOptRevision revision,
                                            bool force, SvnClientContext ctx, AprPool pool)
        {
            int rev;

            Debug.Write(String.Format("svn_client_export({0},{1},{2},{3},{4},{5})...", from, to, revision, force, ctx, pool));
            SvnError err = Svn.svn_client_export(out rev, from.ToIntPtr(), to,
                                                 revision,
                                                 (force ? 1 :0), ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
            Debug.WriteLine(String.Format("Done({0})", rev));
            return(rev);
        }
コード例 #19
0
        public static int RevPropSet(string propName, SvnString propVal,
                                     SvnUrl url, SvnOptRevision revision, bool force,
                                     SvnClientContext ctx, AprPool pool)
        {
            int rev;

            Debug.Write(String.Format("svn_client_revprop_set({0},{1},{2},{3},{4},{5},{6})...", propName, propVal, url, revision, force, ctx, pool));
            SvnError err = Svn.svn_client_revprop_set(propName, propVal, url, revision,
                                                      out rev, (force ? 1 : 0),
                                                      ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
            Debug.WriteLine(String.Format("Done({0})", rev));
            return(rev);
        }
コード例 #20
0
        protected static SvnClientCommitInfo InternalCopy(IAprUnmanaged srcPath, SvnOptRevision srcRevision,
                                                          IAprUnmanaged dstPath,
                                                          SvnClientContext ctx, AprPool pool)
        {
            IntPtr commitInfo;

            Debug.Write(String.Format("svn_client_copy({0},{1},{2},{3},{4})...", srcPath, srcRevision, dstPath, ctx, pool));
            SvnError err = Svn.svn_client_copy(out commitInfo, srcPath.ToIntPtr(), srcRevision,
                                               dstPath.ToIntPtr(),
                                               ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
            Debug.WriteLine(String.Format("Done({0})", commitInfo));
            return(commitInfo);
        }
コード例 #21
0
        protected static void InternalMerge(IAprUnmanaged source1, SvnOptRevision revision1,
                                            IAprUnmanaged source2, SvnOptRevision revision2,
                                            SvnPath targetWCPath, bool recurse,
                                            bool ignoreAncestry, bool force, bool dryRun,
                                            SvnClientContext ctx, AprPool pool)
        {
            Debug.WriteLine(String.Format("svn_client_merge({0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10})", source1, revision1, source2, revision2, targetWCPath, recurse, ignoreAncestry, force, dryRun, ctx, pool));
            SvnError err = Svn.svn_client_merge(source1.ToIntPtr(), revision1,
                                                source2.ToIntPtr(), revision2,
                                                targetWCPath, (recurse ? 1 : 0),
                                                (ignoreAncestry ? 1 : 0), (force ? 1 : 0),
                                                (dryRun ? 1 : 0),
                                                ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
        }
コード例 #22
0
        public static void Log(AprArray targets,
                               SvnOptRevision start, SvnOptRevision end,
                               bool discoverChangedPaths, bool strictNodeHistory,
                               LogMessageReceiver receiver, IntPtr baton,
                               SvnClientContext ctx, AprPool pool)
        {
            SvnDelegate receiverDelegate = new SvnDelegate(receiver);

            Debug.WriteLine(String.Format("svn_client_log({0},{1},{2},{3},{4},{5},{6:X},{7},{8})", targets, start, end, discoverChangedPaths, strictNodeHistory, receiver.Method.Name, baton.ToInt32(), ctx, pool));
            SvnError err = Svn.svn_client_log(targets, start, end,
                                              (discoverChangedPaths ? 1 :0),
                                              (strictNodeHistory ? 1 :0),
                                              (Svn.svn_log_message_receiver_t)receiverDelegate.Wrapper,
                                              baton,
                                              ctx, pool);

            if (!err.IsNoError)
            {
                throw new SvnException(err);
            }
        }
コード例 #23
0
 public static AprString UuidFromUrl(SvnUrl url, SvnClientContext ctx, AprPool pool)
 {
     IntPtr s;
     Debug.Write(String.Format("svn_client_uuid_from_url({0},{1})...",url,ctx,pool));
     SvnError err = Svn.svn_client_uuid_from_url(out s, url, ctx, pool);
     if( !err.IsNoError )
         throw new SvnException(err);
     Debug.WriteLine(String.Format("Done({0})",s));
     return(s);
 }
コード例 #24
0
        public static int Export(SvnUrl from, SvnPath to, 
								 SvnOptRevision revision, 
								 bool force, SvnClientContext ctx, AprPool pool)
        {
            return InternalExport(from, to, revision, force, ctx, pool);
        }
コード例 #25
0
        public static int Status(SvnPath path,
								 SvnOptRevision revision,
								 SvnWcStatus.Func statusFunc, IntPtr statusBaton,
								 bool descend, bool getAll, bool update, bool noIgnore,
			   					 SvnClientContext ctx, AprPool pool)
        {
            int rev;
            SvnDelegate statusDelegate = new SvnDelegate(statusFunc);
            Debug.Write(String.Format("svn_client_status({0},{1},{2},{3},{4:X},{5},{6},{7},{8},{9})...",path,revision,statusFunc.Method.Name,statusBaton.ToInt32(),descend,getAll,update,noIgnore,ctx,pool));
            SvnError err = Svn.svn_client_status(out rev, path, revision,
                                                 (Svn.svn_wc_status_func_t) statusDelegate.Wrapper,
                                                 statusBaton,
                                                 (descend ? 1 : 0), (getAll ? 1 : 0),
                                                 (update ? 1 : 0), (noIgnore ? 1 : 0),
                                                 ctx, pool);
            if( !err.IsNoError )
                throw new SvnException(err);
            Debug.WriteLine(String.Format("Done({0})",rev));
            if( update )
                return(rev);
            else
                return(-1);
        }
コード例 #26
0
 public static void Export(SvnPath from, SvnPath to,
                           SvnOptRevision revision,
                           bool force, SvnClientContext ctx, AprPool pool)
 {
     InternalExport(from, to, revision, force, ctx, pool);
 }
コード例 #27
0
        protected static void InternalBlame(IAprUnmanaged pathOrUrl,
								 		  SvnOptRevision start, SvnOptRevision end, 
										  BlameReceiver receiver, IntPtr baton,
										  SvnClientContext ctx, AprPool pool)
        {
            SvnDelegate receiverDelegate = new SvnDelegate(receiver);
            Debug.WriteLine(String.Format("svn_client_blame({0},{1},{2},{3},{4:X},{5},{6})",pathOrUrl,start,end,receiver.Method.Name,baton.ToInt32(),ctx,pool));
            SvnError err = Svn.svn_client_blame(pathOrUrl.ToIntPtr(), start, end,
                                                (Svn.svn_client_blame_receiver_t)receiverDelegate.Wrapper,
                                                baton,
                                                ctx, pool);
            if( !err.IsNoError )
                throw new SvnException(err);
        }
コード例 #28
0
 public static SvnClientCommitInfo Copy(SvnUrl srcPath, SvnOptRevision srcRevision,
                                        SvnUrl dstPath,
                                        SvnClientContext ctx, AprPool pool)
 {
     return(InternalCopy(srcPath, srcRevision, dstPath, ctx, pool));
 }
コード例 #29
0
        protected static int InternalExport(IAprUnmanaged from, SvnPath to, 
										  SvnOptRevision revision, 
										  bool force, SvnClientContext ctx, AprPool pool)
        {
            int rev;
            Debug.Write(String.Format("svn_client_export({0},{1},{2},{3},{4},{5})...",from,to,revision,force,ctx,pool));
            SvnError err = Svn.svn_client_export(out rev, from.ToIntPtr(), to,
                                                 revision,
                                                 (force ? 1 :0), ctx, pool);
            if( !err.IsNoError )
                throw new SvnException(err);
            Debug.WriteLine(String.Format("Done({0})",rev));
            return(rev);
        }
コード例 #30
0
 public static void Move(SvnPath srcPath, SvnOptRevision srcRevision,
                         SvnPath dstPath, bool force,
                         SvnClientContext ctx, AprPool pool)
 {
     InternalMove(srcPath, srcRevision, dstPath, force, ctx, pool);
 }
コード例 #31
0
        protected static SvnClientCommitInfo InternalCopy(IAprUnmanaged srcPath, SvnOptRevision srcRevision,
														IAprUnmanaged dstPath,
							   							SvnClientContext ctx, AprPool pool)
        {
            IntPtr commitInfo;
            Debug.Write(String.Format("svn_client_copy({0},{1},{2},{3},{4})...",srcPath,srcRevision,dstPath,ctx,pool));
            SvnError err = Svn.svn_client_copy(out commitInfo, srcPath.ToIntPtr(), srcRevision,
                                               dstPath.ToIntPtr(),
                                               ctx, pool);
            if( !err.IsNoError )
                throw new SvnException(err);
            Debug.WriteLine(String.Format("Done({0})",commitInfo));
            return(commitInfo);
        }
コード例 #32
0
        public static AprHash PropList(SvnUrl target,
									   SvnOptRevision revision, bool recurse, 
								  	   SvnClientContext ctx, AprPool pool)
        {
            return InternalPropList(target, revision, recurse, ctx, pool);
        }
コード例 #33
0
        public static void Cat(SvnStream stream, SvnUrl pathOrUrl,
							   SvnOptRevision revision, 
							   SvnClientContext ctx, AprPool pool)
        {
            InternalCat(stream, pathOrUrl, revision, ctx, pool);
        }
コード例 #34
0
        protected static AprHash InternalPropList(IAprUnmanaged target,
									   			SvnOptRevision revision, bool recurse, 
								  	   			SvnClientContext ctx, AprPool pool)
        {
            IntPtr h;
            Debug.Write(String.Format("svn_client_proplist({0},{1},{2},{3},{4})...",target,revision,recurse,ctx,pool));
            SvnError err = Svn.svn_client_proplist(out h, target.ToIntPtr(), revision,
                                                   (recurse ? 1 : 0),
                                                   ctx, pool);
            if( !err.IsNoError )
                throw new SvnException(err);
            Debug.WriteLine(String.Format("Done({0})",h));
            return(h);
        }
コード例 #35
0
        protected static void InternalMerge(IAprUnmanaged source1, SvnOptRevision revision1,
										  IAprUnmanaged source2, SvnOptRevision revision2,
										  SvnPath targetWCPath, bool recurse,
										  bool ignoreAncestry, bool force, bool dryRun,
										  SvnClientContext ctx, AprPool pool)
        {
            Debug.WriteLine(String.Format("svn_client_merge({0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10})",source1,revision1,source2,revision2,targetWCPath,recurse,ignoreAncestry,force,dryRun,ctx,pool));
            SvnError err = Svn.svn_client_merge(source1.ToIntPtr(), revision1,
                                                source2.ToIntPtr(), revision2,
                                                targetWCPath, (recurse ? 1 : 0),
                                                (ignoreAncestry ? 1 : 0), (force ? 1 : 0),
                                                (dryRun ? 1 : 0),
                                                ctx, pool);
            if( !err.IsNoError )
                throw new SvnException(err);
        }
コード例 #36
0
        public static void Relocate(SvnPath dir, SvnUrl from, SvnUrl to,
									bool recurse,
							        SvnClientContext ctx, AprPool pool)
        {
            Debug.WriteLine(String.Format("svn_client_relocate({0},{1},{2},{3},{4},{5})",dir,from,to,recurse,ctx,pool));
            SvnError err = Svn.svn_client_relocate(dir, from, to, (recurse ? 1 : 0), ctx, pool);
            if( !err.IsNoError )
                throw new SvnException(err);
        }
コード例 #37
0
        public static void Log(AprArray targets,
							   SvnOptRevision start, SvnOptRevision end,
							   bool discoverChangedPaths, bool strictNodeHistory,
							   LogMessageReceiver receiver, IntPtr baton,
							   SvnClientContext ctx, AprPool pool)
        {
            SvnDelegate receiverDelegate = new SvnDelegate(receiver);
            Debug.WriteLine(String.Format("svn_client_log({0},{1},{2},{3},{4},{5},{6:X},{7},{8})",targets,start,end,discoverChangedPaths,strictNodeHistory,receiver.Method.Name,baton.ToInt32(),ctx,pool));
            SvnError err = Svn.svn_client_log(targets, start, end,
                                              (discoverChangedPaths ? 1 :0),
                                              (strictNodeHistory ? 1 :0),
                                              (Svn.svn_log_message_receiver_t)receiverDelegate.Wrapper,
                                              baton,
                                              ctx, pool);
            if( !err.IsNoError )
                throw new SvnException(err);
        }
コード例 #38
0
        protected static void InternalCat(SvnStream stream, IAprUnmanaged pathOrUrl,
										SvnOptRevision revision, 
										SvnClientContext ctx, AprPool pool)
        {
            Debug.WriteLine(String.Format("svn_client_cat({0},{1},{2},{3},{4})",stream,pathOrUrl,revision,ctx,pool));
            SvnError err = Svn.svn_client_cat(stream, pathOrUrl.ToIntPtr(), revision, ctx, pool);
            if( !err.IsNoError )
                throw new SvnException(err);
        }
コード例 #39
0
 public static void Copy(SvnPath srcPath, SvnOptRevision srcRevision,
                         SvnPath dstPath,
                         SvnClientContext ctx, AprPool pool)
 {
     InternalCopy(srcPath, srcRevision, dstPath, ctx, pool);
 }
コード例 #40
0
 public static AprHash PropList(SvnUrl target,
                                SvnOptRevision revision, bool recurse,
                                SvnClientContext ctx, AprPool pool)
 {
     return(InternalPropList(target, revision, recurse, ctx, pool));
 }
コード例 #41
0
        public static AprHash PropGet(string propName, SvnUrl target,
									  SvnOptRevision revision, bool recurse, 
								  	  SvnClientContext ctx, AprPool pool)
        {
            return InternalPropGet(propName, target, revision, recurse, ctx, pool);
        }
コード例 #42
0
        protected static void InternalDiff(AprArray diffOptions,
								IAprUnmanaged path1, SvnOptRevision revision1,
								IAprUnmanaged path2, SvnOptRevision revision2,
								bool recurse, bool ignoreAncestry, bool noDiffDeleted,
								AprFile outFile, AprFile errFile,  
							    SvnClientContext ctx, AprPool pool)
        {
            Debug.WriteLine(String.Format("svn_client_diff({0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11})",diffOptions,path1,revision1,path2,revision2,recurse,ignoreAncestry,noDiffDeleted,outFile,errFile,ctx,pool));
            SvnError err = Svn.svn_client_diff(diffOptions, path1.ToIntPtr(), revision1,
                                               path2.ToIntPtr(), revision2,
                                               (recurse ? 1 : 0), (ignoreAncestry ? 1 : 0),
                                               (noDiffDeleted ? 1 : 0), outFile, errFile,
                                               ctx, pool);
            if( !err.IsNoError )
                throw new SvnException(err);
        }
コード例 #43
0
 public static SvnClientCommitInfo Move(SvnUrl srcPath, SvnOptRevision srcRevision,
                                        SvnUrl dstPath, bool force,
                                        SvnClientContext ctx, AprPool pool)
 {
     return(InternalMove(srcPath, srcRevision, dstPath, force, ctx, pool));
 }
コード例 #44
0
        public static SvnClientCommitInfo Move(SvnUrl srcPath, SvnOptRevision srcRevision,
											   SvnUrl dstPath, bool force,
							   				   SvnClientContext ctx, AprPool pool)
        {
            return InternalMove(srcPath, srcRevision, dstPath, force, ctx, pool);
        }
コード例 #45
0
 public static AprHash PropGet(string propName, SvnUrl target,
                               SvnOptRevision revision, bool recurse,
                               SvnClientContext ctx, AprPool pool)
 {
     return(InternalPropGet(propName, target, revision, recurse, ctx, pool));
 }
コード例 #46
0
        public static void Move(SvnPath srcPath, SvnOptRevision srcRevision,
								SvnPath dstPath, bool force,
								SvnClientContext ctx, AprPool pool)
        {
            InternalMove(srcPath, srcRevision, dstPath, force, ctx, pool);
        }
コード例 #47
0
        public static AprHash List(SvnUrl pathOrUrl,
								   SvnOptRevision revision, bool recurse, 
								   SvnClientContext ctx, AprPool pool)
        {
            return InternalList(pathOrUrl, revision, recurse, ctx, pool);
        }
コード例 #48
0
        public static SvnClientCommitInfo Mkdir(AprArray paths,  
							   					SvnClientContext ctx, AprPool pool)
        {
            IntPtr commitInfo;
            Debug.Write(String.Format("svn_client_mkdir({0},{1},{2})...",paths,ctx,pool));
            SvnError err = Svn.svn_client_mkdir(out commitInfo, paths, ctx, pool);
            if( !err.IsNoError )
                throw new SvnException(err);
            Debug.WriteLine(String.Format("Done({0})",commitInfo));
            return(commitInfo);
        }
コード例 #49
0
        public static SvnClientCommitInfo Import(SvnPath path, SvnUrl url, bool nonrecursive,  
							   					 SvnClientContext ctx, AprPool pool)
        {
            IntPtr commitInfo;
            Debug.Write(String.Format("svn_client_import({0},{1},{2},{3},{4})...",path,url,nonrecursive,ctx,pool));
            SvnError err = Svn.svn_client_import(out commitInfo, path, url, (nonrecursive ? 1 : 0),
                                                 ctx, pool);
            if( !err.IsNoError )
                throw new SvnException(err);
            Debug.WriteLine(String.Format("Done({0})",commitInfo));
            return(commitInfo);
        }
コード例 #50
0
        public static void Merge(SvnUrl source1, SvnOptRevision revision1,
								 SvnUrl source2, SvnOptRevision revision2,
								 SvnPath targetWCPath, bool recurse,
								 bool ignoreAncestry, bool force, bool dryRun,
							     SvnClientContext ctx, AprPool pool)
        {
            InternalMerge(source1, revision1, source2, revision2, targetWCPath, recurse,
                          ignoreAncestry, force, dryRun, ctx, pool);
        }
コード例 #51
0
 public static int Export(SvnUrl from, SvnPath to,
                          SvnOptRevision revision,
                          bool force, SvnClientContext ctx, AprPool pool)
 {
     return(InternalExport(from, to, revision, force, ctx, pool));
 }
コード例 #52
0
        public static void Export(SvnPath from, SvnPath to, 
								  SvnOptRevision revision, 
								  bool force, SvnClientContext ctx, AprPool pool)
        {
            InternalExport(from, to, revision, force, ctx, pool);
        }
コード例 #53
0
 public static AprHash List(SvnUrl pathOrUrl,
                            SvnOptRevision revision, bool recurse,
                            SvnClientContext ctx, AprPool pool)
 {
     return(InternalList(pathOrUrl, revision, recurse, ctx, pool));
 }
コード例 #54
0
        public static AprHash RevPropList(SvnUrl url,
										  SvnOptRevision revision, out int setRev, 
										  SvnClientContext ctx, AprPool pool)
        {
            IntPtr h;
            Debug.Write(String.Format("svn_client_revprop_list({0},{1},{2},{3})...",url,revision,ctx,pool));
            SvnError err = Svn.svn_client_revprop_list(out h, url, revision, out setRev,
                                                       ctx, pool);
            if( !err.IsNoError )
                throw new SvnException(err);
            Debug.WriteLine(String.Format("Done({0},{1})",h,setRev));
            return(h);
        }
コード例 #55
0
 public static void Cat(SvnStream stream, SvnUrl pathOrUrl,
                        SvnOptRevision revision,
                        SvnClientContext ctx, AprPool pool)
 {
     InternalCat(stream, pathOrUrl, revision, ctx, pool);
 }
コード例 #56
0
        public static int RevPropSet(string propName, SvnString propVal,
								  	 SvnUrl url, SvnOptRevision revision, bool force,
								  	 SvnClientContext ctx, AprPool pool)
        {
            int rev;
            Debug.Write(String.Format("svn_client_revprop_set({0},{1},{2},{3},{4},{5},{6})...",propName,propVal,url,revision,force,ctx,pool));
            SvnError err = Svn.svn_client_revprop_set(propName, propVal, url, revision,
                                                      out rev, (force ? 1 : 0),
                                                      ctx, pool);
            if( !err.IsNoError )
                throw new SvnException(err);
            Debug.WriteLine(String.Format("Done({0})",rev));
            return(rev);
        }
コード例 #57
0
        public static int Checkout(SvnUrl url, SvnPath path, 
								   SvnOptRevision revision, 
								   bool recurse, SvnClientContext ctx, AprPool pool)
        {
            int rev;
            Debug.Write(String.Format("svn_client_checkout({0},{1},{2},{3},{4},{5})...",url,path,revision,recurse,ctx,pool));
            SvnError err = Svn.svn_client_checkout(out rev, url, path,
                                                   revision,
                                                   (recurse ? 1 :0), ctx, pool);
            if( !err.IsNoError )
                throw new SvnException(err);
            Debug.WriteLine(String.Format("Done({0})",rev));
            return(rev);
        }
コード例 #58
0
        public static SvnString RevPropGet(string propName, SvnUrl url,
										   SvnOptRevision revision, out int setRev, 
										   SvnClientContext ctx, AprPool pool)
        {
            IntPtr s;
            Debug.Write(String.Format("svn_client_revprop_get({0},{1},{2},{3},{4})...",propName,url,revision,ctx,pool));
            SvnError err = Svn.svn_client_revprop_get(propName, out s, url, revision, out setRev,
                                                      ctx, pool);
            if( !err.IsNoError )
                throw new SvnException(err);
            Debug.WriteLine(String.Format("Done({0},{1})",s,setRev));
            return(s);
        }