/* * Port for usage with qt-framework and development for kdesvn * (C) 2005-2007 by Rajko Albrecht * http://kdesvn.alwins-world.de */ /* * ==================================================================== * Copyright (c) 2002-2005 The RapidSvn Group. All rights reserved. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library (in the file LGPL.txt); if not, * write to the Free Software Foundation, Inc., 51 Franklin St, * Fifth Floor, Boston, MA 02110-1301 USA * * This software consists of voluntary contributions made by many * individuals. For exact contribution history, see the revision * history and logs, available at http://rapidsvn.tigris.org/. * ==================================================================== */ #ifndef _SVNCPP_CLIENT_H_ #define _SVNCPP_CLIENT_H_ // Ignore MSVC 6 compiler warning: debug symbol truncated #if defined (_MSC_VER) && _MSC_VER <= 1200 #pragma warning (disable: 4786) #endif // Ignore MSVC 7, 2005 & 2008 compiler warning: C++ exception specification #if defined (_MSC_VER) && _MSC_VER > 1200 && _MSC_VER <= 1550 #pragma warning (disable: 4290) #endif #include "svnqt/svnqt_defines.hpp" #include "svnqt/svnqttypes.hpp" #include "svnqt/svnstream.hpp" // qt #include #if QT_VERSION < 0x040000 #include #include #include #include #else #include #endif // svnqt #include "svnqt/context.hpp" #include "svnqt/exception.hpp" #include "svnqt/path.hpp" #include "svnqt/entry.hpp" #include "svnqt/revision.hpp" #include "svnqt/log_entry.hpp" #include "svnqt/info_entry.hpp" #include "svnqt/annotate_line.hpp" #include "svnqt/stringarray.hpp" #include "svnqt/diffoptions.hpp" #include "svnqt/conflictresult.hpp" class QStringList; namespace svn { /** Subversion client API. * * Never use an object of this as global static! This will make problems with subversion * initialize. */ class SVNQT_EXPORT Client { public: /** * Initializes the primary memory pool. */ Client(); virtual ~Client (); /** * @return returns the Client context */ virtual const ContextP getContext () const = 0; /** * sets the client context * you have to make sure the old context * is de-allocated * * @param context new context to use */ virtual void setContext (ContextP context) = 0; /** * get a real instance. Result must cleaned with delete. * \param context The context to use * \param subtype the wanted implementation - this moment only 0 allowed. * \return an instance of client or 0L if error. */ static Client*getobject(ContextP context,int subtype=0); /** * Enumerates all files/dirs at a given path. * * Throws an exception if an error occurs * * @param path Path to explore. * @param descend Recurse into subdirectories if existant. * @param get_all Return all entries, not just the interesting ones. * @param update Query the repository for updates. * @param no_ignore Disregard default and svn:ignore property ignores. * @param hide_externals don't recurse into external definitions * @param revision list specific revision when browsing remote, on working copies parameter will ignored * @param detailed_remote if on remote listing detailed item info should get if possible * that may slow so should configureable in frontends! * @return vector with Status entries. */ virtual StatusEntries status (const Path& path, Depth depth=DepthImmediates, bool get_all = true, bool update = false, bool no_ignore = false, const Revision revision = svn::Revision::HEAD, bool detailed_remote = false, bool hide_externals = false, const StringArray & changelists=StringArray() ) throw (ClientException) = 0; /** * Returns the status of a single file in the path. * * Throws an exception if an error occurs * * @param path File to gather status. * @param update if check against repository if new updates are there (for WC only) * @param revision list specific revision when browsing remote, on working copies parameter will ignored * @return a Status with Statis.isVersioned = FALSE */ virtual StatusPtr singleStatus (const Path& path,bool update=false,const Revision revision = svn::Revision::HEAD) throw (ClientException)=0; /** * Executes a revision checkout. * @param moduleName name of the module to checkout. * @param destPath destination directory for checkout. * @param revision the revision number to checkout. If the number is -1 * then it will checkout the latest revision. * @param peg Revision to look up * @param recurse whether you want it to checkout files recursively. * @param ignore_externals if true don't process externals definitions. * @exception ClientException */ virtual svn_revnum_t checkout (const Path& moduleName, const Path & destPath, const Revision & revision, const Revision & peg = Revision::UNDEFINED, svn::Depth depth=DepthInfinity, bool ignore_externals=false, bool overwrite=false ) throw (ClientException) = 0; /** * relocate wc @a from to @a to * @exception ClientException */ virtual void relocate (const Path & path, const QString &from_url, const QString &to_url, bool recurse) throw (ClientException)=0; /** * Sets a single file for deletion. * @exception ClientException */ virtual svn::Revision remove (const Path & path, bool force, bool keep_local = true, const PropertiesMap&revProps = PropertiesMap()) throw (ClientException)=0; /** * Sets files for deletion. * * @param targets targets to delete * @param force force if files are locally modified * @exception ClientException */ virtual svn::Revision remove (const Targets & targets, bool force, bool keep_local=true, const PropertiesMap&revProps=PropertiesMap()) throw (ClientException) = 0; /** * Reverts a couple of files to a pristiner state. * @exception ClientException */ virtual void revert (const Targets & targets, Depth depth, const StringArray&changelist=StringArray() ) throw (ClientException)=0; /** * Adds a file to the repository. * @param path the path to add * @param depth if @a path is a folder add items recursive depending on value if it. * @param force if true, do not error on already-versioned items. * @param no_ignore if false don't add files or directories that match ignore patterns. When build against svn 1.2 always false * @param add_parents if true, go up to the next versioned folder and add all between path and this folder. * @exception ClientException */ virtual void add (const Path & path, svn::Depth depth,bool force=false, bool no_ignore=false, bool add_parents = true) throw (ClientException)=0; /** * Updates the file or directory. * @param path targets. * @param revision the revision number to checkout. * Revision::HEAD will checkout the * latest revision. * @param depth Depthness for operation * @param ignore_externals ignore externals * @param allow_unversioned will operation not fail if there are unversioned items in tree with same name. * @exception ClientException */ virtual Revisions update (const Targets & path, const Revision & revision, Depth depth,bool ignore_externals,bool allow_unversioned, bool sticky_depth) throw (ClientException) = 0; /** * Retrieves the contents for a specific @a revision of * a @a path at @a peg_revision * * @param path path of file or directory * @param peg_revision revision to base the URL * @param revision revision to retrieve * @return contents of the file */ virtual QByteArray cat (const Path & path, const Revision & revision, const Revision & peg_revision=svn_opt_revision_unspecified) throw (ClientException)=0; /** * Retrieves the contents for a specific @a revision of * a @a path at @a peg_revision * * @param buffer Stream to store content direct * @param path path of file or directory * @param peg_revision revision to base the URL * @param revision revision to retrieve * @exception ClientException */ virtual void cat(svn::stream::SvnStream&buffer, const Path & path, const Revision & revision, const Revision & peg_revision) throw (ClientException)=0; /** * Retrieves the contents for a specific @a revision of * a @a path at @a peg_revision * * @param path path of file or directory * @param target new (local) name * @param peg_revision revision to base the URL * @param revision revision to retrieve * @param peg_revision Revision to look at */ virtual void get (const Path & path, const QString & target, const Revision & revision, const Revision & peg_revision=svn_opt_revision_unspecified) throw (ClientException)=0; /** * Retrieves the contents for a specific @a revision of * a @a path and stores the result in @a target * * @param target the container where to store the result * @param path path of file or directory * @param revisionStart revision to retrieve * @param revisionEnd revision to retrieve * @param peg indicates in which revision path is valid */ virtual void annotate (AnnotatedFile&target, const Path & path, const Revision & revisionStart, const Revision & revisionEnd, const Revision & peg = Revision::UNDEFINED, const DiffOptions&diffoptions = DiffOptions(), bool ignore_mimetypes = false, bool include_merged_revisions = false ) throw (ClientException)=0; /** * Commits changes to the repository. This usually requires * authentication, see Auth. * @return Returns revision transferred or svn::Revision::UNDEFINED if the revision number is invalid. * @param targets files to commit. * @param message log message. * @param depth whether the operation should be done recursively. * @param keep_locks if false unlock items in paths * @param changelist * @param keep_changelist * @exception ClientException */ virtual svn::Revision commit (const Targets & targets, const QString& message, svn::Depth depth,bool keep_locks=true, const svn::StringArray&contents=svn::StringArray(), const PropertiesMap&revProps=PropertiesMap(), bool keep_changelist=false ) throw (ClientException)=0; /** * Copies a versioned file with the history preserved. * @exception ClientException */ virtual svn::Revision copy (const Path & srcPath, const Revision & srcRevision, const Path & destPath) throw (ClientException)=0; /** * Copies a versioned file with the history preserved. * @since subversion 1.5 api * @see svn_client_copy4 * @exception ClientException */ virtual svn::Revision copy (const Targets & srcPath, const Revision & srcRevision, const Revision & pegRevision, const Path & destPath, bool asChild=false,bool makeParent=false,const PropertiesMap&revProps=PropertiesMap()) throw (ClientException)=0; /** * Moves or renames a file. * @exception ClientException */ virtual svn::Revision move (const Path & srcPath, const Path & destPath, bool force) throw (ClientException)=0; /** * Moves or renames a file. * @exception ClientException */ virtual svn::Revision move (const Targets & srcPath, const Path & destPath, bool force,bool asChild,bool makeParent,const PropertiesMap&revProps=PropertiesMap()) throw (ClientException)=0; /** * Creates a directory directly in a repository or creates a * directory on disk and schedules it for addition. If path * is a URL then authentication is usually required, see Auth and * the callback asks for a logmessage. With subversion 1.4 the target * must not exist (\sa svn_client_move4) * * @param path * @param message log message. if it is QString::null asks when working on repository * @param makeParent create parent folders if not existant (only when build with svn 1.5 or above) * @exception ClientException */ virtual svn::Revision mkdir (const Path & path, const QString& message, bool makeParent=true, const PropertiesMap&revProps=PropertiesMap() ) throw (ClientException)=0; /** * Creates a directory directly in a repository or creates a * directory on disk and schedules it for addition. If path * is a URL then authentication is usually required, see Auth and * the callback asks for a logmessage. * * @param targets encoded pathes to create * @param message log message. if it is QString::null asks when working on repository * @param makeParent create parent folders if not existant (only when build with svn 1.5 or above) * @exception ClientException */ virtual svn::Revision mkdir (const Targets & targets, const QString& message, bool makeParent=true, const PropertiesMap&revProps=PropertiesMap() ) throw (ClientException)=0; /** * Recursively cleans up a local directory, finishing any * incomplete operations, removing lockfiles, etc. * @param path a local directory. * @exception ClientException */ virtual void cleanup (const Path & path) throw (ClientException)=0; /** * Removes the 'conflicted' state on a file. * @exception ClientException */ virtual void resolve (const Path & path,Depth depth,const ConflictResult&resolution=ConflictResult()) throw (ClientException)=0; /** * Exports the contents of either a subversion repository into a * 'clean' directory (meaning a directory with no administrative * directories). * @exception ClientException * @param srcPath source path * @param destPath a destination path that must not already exist. * @param revision revision to use for the export * @param peg the revision where the path is first looked up when exporting from a repository. * @param overwrite overwrite existing files * @param native_eol Either "LF", "CR" or "CRLF" or NULL. * @param ignore_externals don't process externals definitions as part of this operation. * @param recurse if true, export recursively.
Otherwise, export just the directory represented by from and its immediate non-directory children. */ virtual svn_revnum_t doExport (const Path & srcPath, const Path & destPath, const Revision & revision, const Revision & peg = Revision::UNDEFINED, bool overwrite=false, const QString&native_eol=QString::null, bool ignore_externals = false, svn::Depth depth=svn::DepthInfinity ) throw (ClientException)=0; /** * Update local copy to mirror a new url. This excapsulates the * svn_client_switch() client method. * @exception ClientException */ virtual svn_revnum_t doSwitch ( const Path & path, const QString& url, const Revision & revision, Depth depth, const Revision & peg=Revision::UNDEFINED, bool sticky_depth = true, bool ignore_externals=false, bool allow_unversioned=false ) throw (ClientException)=0; /** * Import file or directory PATH into repository directory URL at * head. This usually requires authentication, see Auth. * @param path path to import * @param url * @param message log message. * @param depth kind of recurse operation * @param no_ignore if false, don't add items matching global ignore pattern (@since subversion 1.3) * @param no_unknown_nodetype if true ignore files type not known like pipes or device files (@since subversion 1.5) * @exception ClientException */ virtual svn::Revision import (const Path & path, const QString& url, const QString& message, svn::Depth depth, bool no_ignore,bool no_unknown_nodetype, const PropertiesMap&revProps=PropertiesMap()) throw (ClientException)=0; /** * Merge changes from two paths into a new local path. * @exception ClientException */ virtual void merge (const Path & path1, const Revision & revision1, const Path & path2, const Revision & revision2, const Path & localPath, bool force, Depth depth, bool notice_ancestry=false, bool dry_run=false, bool record_only=false, const StringArray&merge_options=StringArray() ) throw (ClientException)=0; virtual void merge_peg(const Path&src, const RevisionRanges&ranges, const Revision&peg, const Path&targetWc, Depth depth, bool notice_ancestry=false, bool dry_run=false, bool force=false, bool record_only=false, const StringArray&merge_options=StringArray() ) throw (ClientException)=0; virtual void merge_peg(const Path&src, const RevisionRange&range, const Revision&peg, const Path&targetWc, Depth depth, bool notice_ancestry=false, bool dry_run=false, bool force=false, const StringArray&merge_options=StringArray() ) throw (ClientException)=0; /** * Retrieve information for the given path * remote or local. * * @param path path for info * @param rec recursive (if dir) * @param rev for which revision * @param peg_revision peg revision * @return InfoEntries */ virtual InfoEntries info (const Path &path, Depth depth, const Revision & rev, const Revision & peg_revision=svn_opt_revision_unspecified, const StringArray&changelists=StringArray() ) throw (ClientException)=0; /** * Retrieve log information for the given path * Loads the log messages result set. The first * entry is the youngest revision. * * You can use the constants Revision::START and * Revision::HEAD * * @param path * @param revisionStart * @param revisionEnd * @param discoverChangedPaths * @param strictNodeHistory * @param limit the maximum log entries count. * @return a vector with log entries */ virtual LogEntriesPtr log (const Path& path, const Revision & revisionStart, const Revision & revisionEnd, const Revision & revisionPeg, bool discoverChangedPaths=false, bool strictNodeHistory=true,int limit = 0, bool include_merged_revisions = false, const StringArray&revprops=StringArray() ) throw (ClientException)=0; /** * Retrieve log information for the given path * Loads the log messages result set. Result will stored * in a map where the key is the revision number * * You can use the constants Revision::START and * Revision::HEAD * * @param path Path to make a log for * @param revisionStart * @param revisionEnd * @param target the logmap where to store the entries * @param discoverChangedPaths * @param strictNodeHistory * @param limit (ignored when subversion 1.1 API) * @return true if success */ virtual bool log (const Path& path, const Revision & revisionStart, const Revision & revisionEnd, LogEntriesMap&target, const Revision & revisionPeg=Revision::UNDEFINED, bool discoverChangedPaths=false, bool strictNodeHistory=true,int limit = 0, bool include_merged_revisions = false, const StringArray&revprops=StringArray() ) throw (ClientException)=0; /** * Produce diff output which describes the delta between * @a path/@a revision1 and @a path/@a revision2. @a path * can be either a working-copy path or a URL. * * A ClientException will be thrown if either @a revision1 or * @a revision2 has an `unspecified' or unrecognized `kind'. * * @param tmpPath prefix for a temporary directory needed by diff. * Filenames will have ".tmp" and similar added to this prefix in * order to ensure uniqueness. * @param path path of the file. * @param revision1 one of the revisions to check. * @param revision2 the other revision. * @param recurse whether the operation should be done recursively. * @param ignoreAncestry whether the files will be checked for * relatedness. * @param noDiffDeleted if true, no diff output will be generated on deleted files. * @param ignore_contenttype if true generate diff even the items are marked as binaries * @param extra extra options for diff ("-b", "-w","--ignore-eol-style") * @return delta between the files * @exception ClientException */ virtual QByteArray diff_peg(const Path & tmpPath, const Path & path,const Path&relativeTo, const Revision & revision1, const Revision & revision2, const Revision& peg_revision, Depth depth, bool ignoreAncestry, bool noDiffDeleted,bool ignore_contenttype, const StringArray&extra, const StringArray&changelists ) throw (ClientException)=0; /** * Same as other diff but extra options always set to empty list. */ virtual QByteArray diff_peg (const Path & tmpPath, const Path & path,const Path&relativeTo, const Revision & revision1, const Revision & revision2, const Revision& peg_revision, Depth depth, bool ignoreAncestry, bool noDiffDeleted,bool ignore_contenttype) throw (ClientException)=0; /** * Produce diff output which describes the delta between * @a path1/@a revision1 and @a path2/@a revision2. @a path2 * can be either a working-copy path or a URL. * * A ClientException will be thrown if either @a revision1 or * @a revision2 has an `unspecified' or unrecognized `kind'. * * @param tmpPath prefix for a temporary directory needed by diff. * Filenames will have ".tmp" and similar added to this prefix in * order to ensure uniqueness. * @param path1 first file or folder to diff. * @param path2 second file or folder to diff. * @param revision1 one of the revisions to check (path1). * @param revision2 the other revision (path2). * @param recurse whether the operation should be done recursively. * @param ignoreAncestry whether the files will be checked for * relatedness. * @param noDiffDeleted if true, no diff output will be generated on deleted files. * @param ignore_contenttype if true generate diff even the items are marked as binaries * @param extra extra options for diff ("-b", "-w","--ignore-eol-style") * @return delta between the files * @exception ClientException */ virtual QByteArray diff (const Path & tmpPath, const Path & path1,const Path & path2,const Path&relativeTo, const Revision & revision1, const Revision & revision2, Depth depth, bool ignoreAncestry, bool noDiffDeleted,bool ignore_contenttype, const StringArray&extra, const StringArray&changelists ) throw (ClientException)=0; /** * Same as other diff but extra options and changelists always set to empty list. */ virtual QByteArray diff (const Path & tmpPath, const Path & path1,const Path & path2,const Path&relativeTo, const Revision & revision1, const Revision & revision2, Depth depth, bool ignoreAncestry, bool noDiffDeleted,bool ignore_contenttype) throw (ClientException)=0; /** * lists entries in @a pathOrUrl no matter whether local or * repository * * If checking for locks is activated, it lists the locks inside repository, not locks inside * working copy! * @param pathOrUrl * @param revision * @param peg at wich revision path exists * @param depth @sa depth * @param retrieve_locks check for REPOSITORY locks while listing. * @return a vector of directory entries, each with * a relative path (only filename). In subversion >= 1.4 an entry without a name is returned, too. This * is the searched directory (done in subversion itself) */ virtual DirEntries list (const Path& pathOrUrl, const Revision& revision, const Revision& peg, svn::Depth depth,bool retrieve_locks) throw (ClientException)=0; /** * lists properties in @a path no matter whether local or * repository * * @param path * @param revision * @param peg most case should set to @a revision * @param recurse * @return PropertiesList */ virtual PathPropertiesMapListPtr proplist(const Path &path, const Revision &revision, const Revision &peg, Depth depth=DepthEmpty, const StringArray&changelists=StringArray() )=0; /** * lists one property in @a path no matter whether local or * repository * * @param propName * @param path * @param revision * @param peg most case should set to @a revision * @param recurse * @return PathPropertiesMapList and revision where the properties are taken from (svn 1.5) or undefined revision (prior 1.5) */ virtual QPair propget(const QString& propName, const Path &path, const Revision &revision, const Revision &peg, Depth depth = svn::DepthEmpty, const StringArray&changelists=StringArray()) = 0; /** * set property in @a path no matter whether local or * repository * * @param path * @param revision * @param propName * @param propValue * @param recurse * @param skip_checks if true skip validity checks * @return PropertiesList */ virtual void propset(const QString& propName, const QString& propValue, const Path &path, Depth depth=DepthEmpty, bool skip_checks=false, const Revision&base_revision=Revision::UNDEFINED, const StringArray&changelists=StringArray(), const PropertiesMap&revProps=PropertiesMap() ) = 0; /** * delete property in @a path no matter whether local or * repository * * @param propName * @param path * @param revision * @param recurse */ virtual void propdel(const QString& propName, const Path &path, Depth depth=DepthEmpty, bool skip_check=false, const Revision&base_revision=Revision::UNDEFINED, const StringArray&changelists=StringArray())=0; /** * lists revision properties in @a path no matter whether local or * repository * * @param path * @param revision * @return PropertiesList */ virtual QPair revproplist(const Path &path, const Revision &revision)=0; /** * lists one revision property in @a path no matter whether local or * repository * * @param propName * @param path * @param revision * @return PropertiesList */ virtual QPair revpropget(const QString& propName, const Path &path, const Revision &revision)=0; /** * set revision property in @a path no matter whether local or * repository * * @param propName * @param propValue * @param path * @param revision * @param force * @return Revision */ virtual QLONG revpropset(const QString& propName, const QString& propValue, const Path &path, const Revision &revision, bool force=false)=0; /** * delete revision property in @a path no matter whether local or * repository * * @param propName * @param path * @param revision * @param force * @return Revision */ virtual QLONG revpropdel(const QString& propName, const Path &path, const Revision &revision, bool force=false) = 0; /** * lock files in repository or working copy * @param targets items to be locked * @param message if non null stored with each lock in repository * @param steal_lock if true locks in wc will stolen. * @since subversion 1.2 */ virtual void lock (const Targets & targets, const QString& message, bool steal_lock) throw (ClientException)=0; /** * unlock files in repository or working copy * @param targets items to unlock * @param break_lock ignore any errors */ virtual void unlock (const Targets&targets, bool break_lock) throw (ClientException)=0; virtual void url2Revision(const QString&revstring, Revision&start,Revision&end)=0; virtual void url2Revision(const QString&revstring, Revision&start)=0; private: /** * disallow assignment operator */ Client & operator= (const Client &); /** * disallow copy constructor */ Client (const Client &); }; } #endif /* ----------------------------------------------------------------- * local variables: * eval: (load-file "../../rapidsvn-dev.el") * end: */