Alien-SVN
view release on metacpan or search on metacpan
src/subversion/subversion/bindings/swig/ruby/libsvn_swig_ruby/swigutil_rb.h
src/subversion/subversion/bindings/swig/ruby/svn/client.rb
src/subversion/subversion/bindings/swig/ruby/svn/commit-mailer.rb
src/subversion/subversion/bindings/swig/ruby/svn/core.rb
src/subversion/subversion/bindings/swig/ruby/svn/delta.rb
src/subversion/subversion/bindings/swig/ruby/svn/error.rb
src/subversion/subversion/bindings/swig/ruby/svn/fs.rb
src/subversion/subversion/bindings/swig/ruby/svn/info.rb
src/subversion/subversion/bindings/swig/ruby/svn/ra.rb
src/subversion/subversion/bindings/swig/ruby/svn/repos.rb
src/subversion/subversion/bindings/swig/ruby/svn/synchronizer.rb
src/subversion/subversion/bindings/swig/ruby/svn/util.rb
src/subversion/subversion/bindings/swig/ruby/svn/wc.rb
src/subversion/subversion/bindings/swig/ruby/svn_client.c
src/subversion/subversion/bindings/swig/ruby/svn_delta.c
src/subversion/subversion/bindings/swig/ruby/svn_diff.c
src/subversion/subversion/bindings/swig/ruby/svn_fs.c
src/subversion/subversion/bindings/swig/ruby/svn_ra.c
src/subversion/subversion/bindings/swig/ruby/svn_repos.c
src/subversion/subversion/bindings/swig/ruby/svn_wc.c
src/subversion/subversion/bindings/swig/ruby/test/greek_tree.rb
src/subversion/CHANGES view on Meta::CPAN
* export: allow file externals to be exported (issue #4427)
* move: fix working copy db inconsistency in cert scenarios (issue #4437)
* commit: fix an issue where mixed revision copy with non copy descendants
that shadow a not present node couldn't be committed (r1518942 et al)
* delete: properly remove move_to info when the node in its original
location is removed (r1538812 et al)
* status; fix an issue where output would vary based on if the target
was the node itself or its parent (r1544597 et al)
- Server-side bugfixes:
* ensure proper access synchronization in fsfs on Windows (r1568953 et al)
* svnadmin dump: don't let invalid mergeinfo stop dump (r1574868 et al)
* svnserve: resolve performance regression caused by iprops (r1578853 et al)
* reduce size of memory buffer when reading config files (r1581296)
* remove dead transaction if commit was blocked by hook (r1583977)
* svnrdump load: fix crash when svn:* normalization (issue #4490)
* fix memcached support (issue #4470)
* svndumpfilter: fix order of node record headers (r1578670 et al)
* mod_dav_svn: blacklist building with broken versions of httpd; 2.2.25,
2.4.5 and 2.4.6 (r1545835)
* mod_dav_svn: allow generic DAV clients to refresh locks (issue #3515)
src/subversion/CHANGES view on Meta::CPAN
* new 'Header' keyword, similar to 'Id' but with full URL (r35386)
* warn/disallow when storing plain-text passwords (r31046)
* support KWallet and GNOME keyring for password storage (r31241, -337)
* client now caches SSL client cert passphrases (issue #2489)
* add '--prefix-file' option to 'svndumpfilter' (issue #2697)
* add '--ignore-externals' option to 'svn cp' (issue #3365)
* add '--with-no-revprops' to 'svn log' (issue #3286)
* new 'svnadmin pack' command to compress FSFS filesystems
* new SVNAllowBulkUpdates mod_dav_svn directive (issue #3121)
* new public mod_dav_svn URI syntax: path?[p=PEG][&r=REV] (r34076)
* new 'svnsync info' command to show synchronization information (r35053)
* conflict resolver supports display-conflict, mine-conflict and theirs-conflict
- Client-side bugfixes:
* faulty reflexive merges (issue #2897)
* buffer overflow on a 0 byte string buffer (r35968, -74)
* conflict resolver needed more useful 'diff' option (issue #3048)
* disable username assumption (issue #2324)
* more accurate usage message for 'svn log' (r30449)
* do not repeat merge if target has explicit mergeinfo (issue #2821)
* corruption when filtering self-referential mergeinfo (r30467)
src/subversion/CHANGES view on Meta::CPAN
- Client and Server:
* fixed: hang during character translation (r23491, r23492)
* translation updates for Simplified Chinese, Japanese, and Norwegian
Developer-visible changes:
* new "make svnserveautocheck" testing target (r23558)
* fixed: ra_serf fails checkout if access to repos root is forbidden (r23846)
* fixed: svn_client_cat2() doesn't accept WORKING as a revision (r23556)
* javahl bindings:
- fixed: potential segfault in initialisation (r23383)
- fixed: SVNClientSynchronized.logMessages() isn't synchronised (r23978)
- fixed: SVNClient.info2() misreports itself as unlock in errors (r24219)
* SWIG/perl bindings:
- fixed: ra_do_{update,switch,status} don't work with Perl delta editors
(r20667, r22311)
* SWIG/python bindings:
- fixed: memory leak whenever C APIs returned errors (r23521)
* SWIG/ruby bindings:
- fixed: typos in method Svn::Wc#merge_prop_diffs and docs (r23405, -6)
src/subversion/CHANGES view on Meta::CPAN
* fixed: cannot access repositories with spaces via svn:// (issue #2612)
* fixed: passing full URL in some DAV requests, breaking proxies (r21526)
* fixed: history-tracing can fail for renamed directories (issue #2600)
* fixed: crash if interrupted while opening a working copy (r21792)
* fixed: 'svn merge' should notify about conflicted files (issue #2584)
* fixed: 'svn revert' should notify about prop-only reverts (issue #2517)
* fixed: 'svn status -u' not showing props changed on wc root (issue #2533)
* fixed: 'svn status -u' fails in a read-only working copy (r21904, -19)
* fixed: 'svn up' failing with checksum mismatch error (issue #2618)
* fixed: 'svnsync sync' copying missing implicit revprops (issue #2613)
* fixed: svnsync unable to synchronise copies of URL-unsafe paths (r22092)
* svnshell tool: support "setrev head" (r20992)
* include newest version of svnmerge.py
- Server:
* FSFS: improve detection of disk write errors (r21346)
* FSFS: prevent API violation from corrupting repository (issue #2467)
* improved error checking when running hook scripts, etc (r21483)
* mailer.py: new commit_url option links to web page for a commit (r21333)
Developer-visible changes:
src/subversion/build/ac-macros/svn-macros.m4 view on Meta::CPAN
return 1;
if (__sync_lock_test_and_set(&val, 4040) != 3030)
return 1;
mem = &tmp;
if (__sync_val_compare_and_swap(&mem, &tmp, &val) != &tmp)
return 1;
__sync_synchronize();
if (mem != &val)
return 1;
return 0;
}], [svn_cv_atomic_builtins=yes], [svn_cv_atomic_builtins=no], [svn_cv_atomic_builtins=no])])
])
src/subversion/configure view on Meta::CPAN
return 1;
if (__sync_lock_test_and_set(&val, 4040) != 3030)
return 1;
mem = &tmp;
if (__sync_val_compare_and_swap(&mem, &tmp, &val) != &tmp)
return 1;
__sync_synchronize();
if (mem != &val)
return 1;
return 0;
}
_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
svn_cv_atomic_builtins=yes
else
src/subversion/subversion/bindings/javahl/src/org/apache/subversion/javahl/NativeResources.java view on Meta::CPAN
* If the system property is not specified or cannot be loaded,
* attempt to load the library using its expected name, and the
* platform-dependent loading mechanism.
*
* @throws UnsatisfiedLinkError If the native library cannot be
* loaded.
* @throws LinkageError If the version of the loaded native
* library is not compatible with this version of JavaHL's Java
* APIs.
*/
public static synchronized void loadNativeLibrary()
{
UnsatisfiedLinkError loadException = null;
// If the user specified the fully qualified path to the
// native library, try loading that first.
try
{
String specifiedLibraryName =
System.getProperty("subversion.native.library");
if (specifiedLibraryName != null)
src/subversion/subversion/bindings/javahl/src/org/apache/subversion/javahl/types/LogDate.java view on Meta::CPAN
private final String cachedString;
private final Calendar cachedDate;
public LogDate(String datestr) throws ParseException
{
if (datestr == null || datestr.length() != 27 || datestr.charAt(26) != 'Z')
{
throw new ParseException("String is not a valid Subversion date", 0);
}
Date date;
synchronized(formatter)
{
date = formatter.parse(datestr.substring(0, 23) + " UTC");
}
this.cachedString = datestr;
cachedDate = Calendar.getInstance(UTC);
cachedDate.setTime(date);
timeMicros = cachedDate.getTimeInMillis() * 1000
+ Integer.parseInt(datestr.substring(23, 26));
}
src/subversion/subversion/bindings/javahl/src/org/tigris/subversion/javahl/LogDate.java view on Meta::CPAN
private final String cachedString;
private final Calendar cachedDate;
public LogDate(String datestr) throws ParseException
{
if (datestr == null || datestr.length() != 27 || datestr.charAt(26) != 'Z')
{
throw new ParseException("String is not a valid Subversion date", 0);
}
Date date;
synchronized(formatter)
{
date = formatter.parse(datestr.substring(0, 23) + " UTC");
}
this.cachedString = datestr;
cachedDate = Calendar.getInstance(UTC);
cachedDate.setTime(date);
timeMicros = cachedDate.getTimeInMillis() * 1000
+ Integer.parseInt(datestr.substring(23, 26));
}
src/subversion/subversion/bindings/javahl/src/org/tigris/subversion/javahl/SVNClientSynchronized.java view on Meta::CPAN
* This class provides a threadsafe wrapped for SVNClient
*/
public class SVNClientSynchronized implements SVNClientInterface
{
/**
* the wrapped object, which does all the work
*/
private SVNClient worker;
/**
* our class, we synchronize on that.
*/
static private Class clazz = SVNClientSynchronized.class;
/**
* Create our worker
*/
public SVNClientSynchronized()
{
synchronized(clazz)
{
worker = new SVNClient();
}
}
/**
* release the native peer (should not depend on finalize)
*/
public void dispose()
{
worker.dispose();
}
/**
* @return Version information about the underlying native libraries.
*/
public Version getVersion()
{
synchronized(clazz)
{
return worker.getVersion();
}
}
/**
* @return The name of the working copy's administrative
* directory, which is usually <code>.svn</code>.
* @see <a
* href="http://svn.apache.org/repos/asf/subversion/trunk/notes/asp-dot-net-hack.txt">
* Instructions on changing this as a work-around for the behavior of
* ASP.Net on Windows.</a>
* @since 1.3
*/
public String getAdminDirectoryName()
{
synchronized(clazz)
{
return worker.getAdminDirectoryName();
}
}
/**
* @param name The name of the directory to compare.
* @return Whether <code>name</code> is that of a working copy
* administrative directory.
* @since 1.3
*/
public boolean isAdminDirectory(String name)
{
synchronized(clazz)
{
return worker.isAdminDirectory(name);
}
}
/**
* Returns the last destination path submitted.
* @deprecated
* @return path in Subversion format.
*/
public String getLastPath()
{
synchronized(clazz)
{
return worker.getLastPath();
}
}
/**
* @deprecated Use {@link #status(String, int, boolean, boolean,
* boolean, boolean, StatusCallback)}
* instead.
* @since 1.0
*/
public Status[] status(String path, boolean descend, boolean onServer,
boolean getAll)
throws ClientException
{
synchronized(clazz)
{
return worker.status(path, descend, onServer, getAll);
}
}
/**
* @deprecated Use {@link #status(String, int, boolean, boolean,
* boolean, boolean, StatusCallback)}
* instead.
* @since 1.0
*/
public Status[] status(String path, boolean descend, boolean onServer,
boolean getAll, boolean noIgnore)
throws ClientException
{
synchronized(clazz)
{
return worker.status(path, descend, onServer, getAll, noIgnore);
}
}
/**
* @deprecated Use {@link #status(String, int, boolean, boolean,
* boolean, boolean, StatusCallback)}
* instead.
* @since 1.2
*/
public Status[] status(String path, boolean descend, boolean onServer,
boolean getAll, boolean noIgnore,
boolean ignoreExternals)
throws ClientException
{
synchronized(clazz)
{
return worker.status(path, descend, onServer, getAll, noIgnore,
ignoreExternals);
}
}
/**
* @since 1.5
*/
public void status(String path, int depth, boolean onServer,
boolean getAll, boolean noIgnore,
boolean ignoreExternals, String[] changelists,
StatusCallback callback)
throws ClientException
{
synchronized (clazz)
{
worker.status(path, depth, onServer, getAll, noIgnore,
ignoreExternals, changelists, callback);
}
}
/**
* @deprecated Use {@link #list(String, Revision, Revision, int, int,
* boolean, ListCallback)} instead.
* @since 1.0
*/
public DirEntry[] list(String url, Revision revision, boolean recurse)
throws ClientException
{
synchronized(clazz)
{
return worker.list(url, revision, recurse);
}
}
/**
* @deprecated Use {@link #list(String, Revision, Revision, int, int,
* boolean, ListCallback)} instead.
* @since 1.2
*/
public DirEntry[] list(String url, Revision revision, Revision pegRevision,
boolean recurse)
throws ClientException
{
synchronized(clazz)
{
return worker.list(url, revision, pegRevision, recurse);
}
}
/**
* @since 1.5
*/
public void list(String url, Revision revision, Revision pegRevision,
int depth, int direntFields, boolean fetchLocks,
ListCallback callback)
throws ClientException
{
synchronized (clazz)
{
worker.list(url, revision, pegRevision, depth, direntFields,
fetchLocks, callback);
}
}
/**
* @deprecated Use {@link #status(String, int, boolean, boolean,
* boolean, boolean, StatusCallback)}
* instead.
* @since 1.0
*/
public Status singleStatus(String path, boolean onServer)
throws ClientException
{
synchronized(clazz)
{
return worker.singleStatus(path, onServer);
}
}
/**
* @since 1.0
*/
public void username(String username)
{
synchronized(clazz)
{
worker.username(username);
}
}
/**
* @since 1.0
*/
public void password(String password)
{
synchronized(clazz)
{
worker.password(password);
}
}
/**
* @since 1.0
*/
public void setPrompt(PromptUserPassword prompt)
{
synchronized(clazz)
{
worker.setPrompt(prompt);
}
}
/**
* @deprecated Use {@link #logMessages(String, Revision, Revision, Revision,
* boolean, boolean, boolean, String[],
* long, LogMessageCallback)} instead.
* @since 1.0
*/
public LogMessage[] logMessages(String path, Revision revisionStart,
Revision revisionEnd)
throws ClientException
{
synchronized(clazz)
{
return worker.logMessages(path, revisionStart, revisionEnd, true,
false);
}
}
/**
* @deprecated Use {@link #logMessages(String, Revision, Revision, Revision,
* boolean, boolean, boolean, String[],
* long, LogMessageCallback)} instead.
* @since 1.0
*/
public LogMessage[] logMessages(String path, Revision revisionStart,
Revision revisionEnd, boolean stopOnCopy)
throws ClientException
{
synchronized(clazz)
{
return worker.logMessages(path, revisionStart, revisionEnd,
stopOnCopy, false);
}
}
/**
* @deprecated Use {@link #logMessages(String, Revision, Revision, Revision,
* boolean, boolean, boolean, String[],
* long, LogMessageCallback)} instead.
* @since 1.0
*/
public LogMessage[] logMessages(String path, Revision revisionStart,
Revision revisionEnd, boolean stopOnCopy,
boolean discoverPath)
throws ClientException
{
synchronized(clazz)
{
return worker.logMessages(path, revisionStart, revisionEnd,
stopOnCopy, discoverPath);
}
}
/**
* @deprecated Use {@link #logMessages(String, Revision, Revision, Revision,
* boolean, boolean, boolean, String[],
* long, LogMessageCallback)} instead.
* @since 1.2
*/
public LogMessage[] logMessages(String path, Revision revisionStart,
Revision revisionEnd, boolean stopOnCopy,
boolean discoverPath, long limit)
throws ClientException
{
synchronized (clazz)
{
return worker.logMessages(path, revisionStart, revisionEnd,
stopOnCopy, discoverPath, limit);
}
}
/**
* @deprecated Use {@link #logMessages(String, Revision, RevisionRange[],
* boolean, boolean, boolean, String[],
* long, LogMessageCallback)} instead.
src/subversion/subversion/bindings/javahl/src/org/tigris/subversion/javahl/SVNClientSynchronized.java view on Meta::CPAN
*/
public void logMessages(String path, Revision pegRevision,
Revision revisionStart,
Revision revisionEnd, boolean stopOnCopy,
boolean discoverPath,
boolean includeMergedRevisions,
String[] revProps, long limit,
LogMessageCallback callback)
throws ClientException
{
synchronized (clazz)
{
worker.logMessages(path, pegRevision, revisionStart,
revisionEnd, stopOnCopy, discoverPath,
includeMergedRevisions, revProps,
limit, callback);
}
}
/**
* @since 1.6
*/
public void logMessages(String path, Revision pegRevision,
RevisionRange[] revisionRanges, boolean stopOnCopy,
boolean discoverPath,
boolean includeMergedRevisions,
String[] revProps, long limit,
LogMessageCallback callback)
throws ClientException
{
synchronized (clazz)
{
worker.logMessages(path, pegRevision, revisionRanges,
stopOnCopy, discoverPath, includeMergedRevisions,
revProps, limit, callback);
}
}
/**
* @deprecated Use {@link #checkout(String, String, Revision, Revision,
* int, boolean, boolean)} instead.
* @since 1.0
*/
public long checkout(String moduleName, String destPath, Revision revision,
boolean recurse)
throws ClientException
{
synchronized(clazz)
{
return worker.checkout(moduleName, destPath, revision, recurse);
}
}
/**
* @deprecated Use {@link #checkout(String, String, Revision, Revision,
* int, boolean, boolean)} instead.
* @since 1.2
*/
public long checkout(String moduleName, String destPath, Revision revision,
Revision pegRevision, boolean recurse,
boolean ignoreExternals)
throws ClientException
{
synchronized(clazz)
{
return worker.checkout(moduleName, destPath, revision, pegRevision,
recurse, ignoreExternals);
}
}
/**
* @since 1.5
*/
public long checkout(String moduleName, String destPath, Revision revision,
Revision pegRevision, int depth,
boolean ignoreExternals,
boolean allowUnverObstructions)
throws ClientException
{
synchronized(clazz)
{
return worker.checkout(moduleName, destPath, revision, pegRevision,
depth, ignoreExternals,
allowUnverObstructions);
}
}
/**
* @deprecated Use {@link #notification2(Notify2)} instead.
* @since 1.0
*/
public void notification(Notify notify)
{
synchronized(clazz)
{
worker.notification(notify);
}
}
/**
* @since 1.2
*/
public void notification2(Notify2 notify)
{
synchronized(clazz)
{
worker.notification2(notify);
}
}
/**
* @since 1.5
*/
public void setConflictResolver(ConflictResolverCallback listener)
{
synchronized (clazz)
{
worker.setConflictResolver(listener);
}
}
/**
* @since 1.5
*/
public void setProgressListener(ProgressListener listener)
{
synchronized (clazz)
{
worker.setProgressListener(listener);
}
}
/**
* @since 1.0
*/
public void commitMessageHandler(CommitMessage messageHandler)
{
synchronized(clazz)
{
worker.commitMessageHandler(messageHandler);
}
}
/**
* @deprecated Use {@link #remove(String[], String, boolean, boolean)}
* instead.
* @since 1.0
*/
public void remove(String[] path, String message, boolean force)
throws ClientException
{
synchronized (clazz)
{
worker.remove(path, message, force);
}
}
/**
* @since 1.5
*/
public void remove(String[] path, String message, boolean force,
boolean keepLocal, Map revpropTable)
throws ClientException
{
synchronized (clazz)
{
worker.remove(path, message, force, keepLocal, revpropTable);
}
}
/**
* @deprecated Use {@link #revert(String, int)} instead.
* @since 1.0
*/
public void revert(String path, boolean recurse) throws ClientException
{
synchronized(clazz)
{
worker.revert(path, recurse);
}
}
/**
* @since 1.5
*/
public void revert(String path, int depth, String[] changelists)
throws ClientException
{
synchronized(clazz)
{
worker.revert(path, depth, changelists);
}
}
/**
* @deprecated Use {@link #add(String, int, boolean, boolean, boolean)}
* instead.
* @since 1.0
*/
public void add(String path, boolean recurse) throws ClientException
{
synchronized(clazz)
{
worker.add(path, recurse);
}
}
/**
* @deprecated Use {@link #add(String, int, boolean, boolean, boolean)}
* instead.
* @since 1.2
*/
public void add(String path, boolean recurse, boolean force)
throws ClientException
{
synchronized(clazz)
{
worker.add(path, recurse, force);
}
}
/**
* @since 1.5
*/
public void add(String path, int depth, boolean force,
boolean noIgnores, boolean addParents)
throws ClientException
{
synchronized (clazz)
{
worker.add(path, depth, force, noIgnores, addParents);
}
}
/**
* @deprecated Use {@link #update(String, Revision, int, boolean,
* boolean, boolean)} instead.
* @since 1.0
*/
public long update(String path, Revision revision, boolean recurse)
throws ClientException
{
synchronized(clazz)
{
return worker.update(path, revision, recurse);
}
}
/**
* @deprecated Use {@link #update(String[], Revision, int, boolean,
* boolean, boolean)} instead.
* @since 1.2
*/
public long[] update(String[] path, Revision revision, boolean recurse,
boolean ignoreExternals)
throws ClientException
{
synchronized(clazz)
{
return worker.update(path, revision, recurse, ignoreExternals);
}
}
/**
* @since 1.5
*/
public long update(String path, Revision revision, int depth,
boolean depthIsSticky, boolean ignoreExternals,
boolean allowUnverObstructions)
throws ClientException
{
synchronized(clazz)
{
return worker.update(path, revision, depth, depthIsSticky,
ignoreExternals, allowUnverObstructions);
}
}
/**
* @since 1.5
*/
public long[] update(String[] path, Revision revision, int depth,
boolean depthIsSticky, boolean ignoreExternals,
boolean allowUnverObstructions)
throws ClientException
{
synchronized(clazz)
{
return worker.update(path, revision, depth, depthIsSticky,
ignoreExternals, allowUnverObstructions);
}
}
/**
* @deprecated Use {@link #commit(String[], String, int, boolean, boolean,
* String[])} instead.
* @since 1.0
*/
public long commit(String[] path, String message, boolean recurse)
throws ClientException
{
synchronized (clazz)
{
return worker.commit(path, message, recurse, false);
}
}
/**
* @deprecated Use {@link #commit(String[], String, int, boolean, boolean,
* String[])} instead.
* @since 1.2
*/
public long commit(String[] path, String message, boolean recurse,
boolean noUnlock)
throws ClientException
{
synchronized (clazz)
{
return worker.commit(path, message, recurse, noUnlock);
}
}
/**
* @since 1.5
*/
public long commit(String[] path, String message, int depth,
boolean noUnlock, boolean keepChangelist,
String[] changelists, Map revpropTable)
throws ClientException
{
synchronized (clazz)
{
return worker.commit(path, message, depth, noUnlock,
keepChangelist, changelists, revpropTable);
}
}
/**
* @since 1.7
*/
public void copy(CopySource[] sources, String destPath, String message,
boolean copyAsChild, boolean makeParents,
boolean ignoreExternals, Map revpropTable)
throws ClientException
{
synchronized (clazz)
{
worker.copy(sources, destPath, message, copyAsChild,
makeParents, ignoreExternals, revpropTable);
}
}
/**
* @deprecated Use {@link #copy(CopySource[], String, String, boolean,
* boolean, boolean, Map)} instead.
* @since 1.5
*/
public void copy(CopySource[] sources, String destPath, String message,
boolean copyAsChild, boolean makeParents,
Map revpropTable)
throws ClientException
{
synchronized (clazz)
{
worker.copy(sources, destPath, message, copyAsChild,
makeParents, revpropTable);
}
}
/**
* @deprecated Use {@link #copy(CopySource[], String, String, boolean,
* boolean, boolean, Map)} instead.
* @since 1.0
*/
public void copy(String srcPath, String destPath, String message,
Revision revision) throws ClientException
{
synchronized(clazz)
{
worker.copy(srcPath, destPath, message, revision);
}
}
/**
* @since 1.5
*/
public void move(String[] srcPaths, String destPath, String message,
boolean force, boolean moveAsChild,
boolean makeParents, Map revpropTable)
throws ClientException
{
synchronized (clazz)
{
worker.move(srcPaths, destPath, message, force, moveAsChild,
makeParents, revpropTable);
}
}
/**
* @deprecated Use {@link #move(String[], String, String, boolean, boolean,
* boolean)} instead.
* @since 1.2
*/
public void move(String srcPath, String destPath, String message,
Revision revision, boolean force)
throws ClientException
{
synchronized(clazz)
{
worker.move(srcPath, destPath, message, revision, force);
}
}
/**
* @deprecated Use {@link #move(String[], String, String, boolean, boolean,
* boolean)} instead.
* @since 1.0
*/
public void move(String srcPath, String destPath, String message,
boolean force)
throws ClientException
{
synchronized(clazz)
{
worker.move(srcPath, destPath, message, force);
}
}
/**
* @since 1.5
*/
public void mkdir(String[] path, String message, boolean makeParents,
Map revpropTable)
throws ClientException
{
synchronized (clazz)
{
worker.mkdir(path, message, makeParents, revpropTable);
}
}
/**
* @deprecated Use {@link #mkdir(String[], String, boolean)} instead.
* @since 1.0
*/
public void mkdir(String[] path, String message) throws ClientException
{
synchronized(clazz)
{
worker.mkdir(path, message);
}
}
/**
* @since 1.0
*/
public void cleanup(String path) throws ClientException
{
synchronized(clazz)
{
worker.cleanup(path);
}
}
/**
* @since 1.5
*/
public void resolve(String path, int depth, int conflictResult)
throws SubversionException
{
synchronized (clazz)
{
worker.resolve(path, depth, conflictResult);
}
}
/**
* @deprecated Use {@link #resolve(String, int, int)} instead.
* @since 1.0
*/
public void resolved(String path, boolean recurse) throws ClientException
{
synchronized (clazz)
{
worker.resolved(path, recurse);
}
}
/**
* @deprecated Use {@link #doExport(String, String, Revision, Revision,
* boolean, boolean, int, String)} instead.
* @since 1.0
*/
public long doExport(String srcPath, String destPath, Revision revision,
boolean force)
throws ClientException
{
synchronized(clazz)
{
return worker.doExport(srcPath, destPath, revision, force);
}
}
/**
* @deprecated Use {@link #doExport(String, String, Revision, Revision,
* boolean, boolean, int, String)} instead.
* @since 1.2
*/
public long doExport(String srcPath, String destPath, Revision revision,
Revision pegRevision, boolean force,
boolean ignoreExternals, boolean recurse,
String nativeEOL)
throws ClientException
{
synchronized(clazz)
{
return worker.doExport(srcPath, destPath, revision, pegRevision,
force, ignoreExternals, recurse, nativeEOL);
}
}
/**
* @since 1.5
*/
public long doExport(String srcPath, String destPath, Revision revision,
Revision pegRevision, boolean force, boolean ignoreExternals,
int depth, String nativeEOL)
throws ClientException
{
synchronized (clazz)
{
return worker.doExport(srcPath, destPath, revision, pegRevision,
force, ignoreExternals, depth, nativeEOL);
}
}
/**
* @since 1.5
*/
public long doSwitch(String path, String url, Revision revision,
Revision pegRevision, int depth,
boolean depthIsSticky, boolean ignoreExternals,
boolean allowUnverObstructions)
throws ClientException
{
synchronized(clazz)
{
return worker.doSwitch(path, url, revision, pegRevision, depth,
depthIsSticky, ignoreExternals,
allowUnverObstructions);
}
}
/**
* @deprecated Use {@link #doSwitch(String, String, Revision, boolean)}
* instead.
* @since 1.0
*/
public long doSwitch(String path, String url, Revision revision,
boolean recurse)
throws ClientException
{
synchronized(clazz)
{
return worker.doSwitch(path, url, revision, recurse);
}
}
/**
* @deprecated Use {@link #doImport(String, String, String, int, boolean,
* boolean)} instead.
* @since 1.0
*/
public void doImport(String path, String url, String message,
boolean recurse)
throws ClientException
{
synchronized(clazz)
{
worker.doImport(path, url, message, recurse);
}
}
/**
* @since 1.5
*/
public void doImport(String path, String url, String message, int depth,
boolean noIgnore, boolean ignoreUnknownNodeTypes,
Map revpropTable)
throws ClientException
{
synchronized(clazz)
{
worker.doImport(path, url, message, depth, noIgnore,
ignoreUnknownNodeTypes, revpropTable);
}
}
/**
* @since 1.5
*/
public String[] suggestMergeSources(String path, Revision pegRevision)
throws SubversionException
{
synchronized (clazz)
{
return worker.suggestMergeSources(path, pegRevision);
}
}
/**
* @deprecated Use {@link #merge(String, Revision, String, Revision,
* String, boolean, int, boolean,
* boolean, boolean)} instead.
* @since 1.0
*/
public void merge(String path1, Revision revision1, String path2,
Revision revision2, String localPath, boolean force,
boolean recurse)
throws ClientException
{
synchronized(clazz)
{
worker.merge(path1, revision1, path2, revision2, localPath, force,
recurse);
}
}
/**
* @deprecated Use {@link #merge(String, Revision, String, Revision,
* String, boolean, int, boolean,
* boolean, boolean)} instead.
* @since 1.2
*/
public void merge(String path1, Revision revision1, String path2,
Revision revision2, String localPath, boolean force,
boolean recurse, boolean ignoreAncestry, boolean dryRun)
throws ClientException
{
synchronized(clazz)
{
worker.merge(path1, revision1, path2, revision2, localPath, force,
recurse, ignoreAncestry, dryRun);
}
}
/**
* @since 1.5
*/
public void merge(String path1, Revision revision1, String path2,
Revision revision2, String localPath, boolean force,
int depth, boolean ignoreAncestry, boolean dryRun,
boolean recordOnly) throws ClientException
{
synchronized (clazz)
{
worker.merge(path1, revision1, path2, revision2, localPath, force,
depth, ignoreAncestry, dryRun, recordOnly);
}
}
/**
* @deprecated Use {@link #merge(String, Revision, RevisionRange[],
* String, boolean, int, boolean,
* boolean, boolean)} instead.
* @since 1.2
*/
public void merge(String path, Revision pegRevision, Revision revision1,
Revision revision2, String localPath, boolean force,
boolean recurse, boolean ignoreAncestry, boolean dryRun)
throws ClientException
{
synchronized(clazz)
{
worker.merge(path, pegRevision, revision1, revision2, localPath,
force, recurse, ignoreAncestry, dryRun);
}
}
/**
* @since 1.5
*/
public void merge(String path, Revision pegRevision,
RevisionRange[] revisions, String localPath,
boolean force, int depth, boolean ignoreAncestry,
boolean dryRun, boolean recordOnly)
throws ClientException
{
synchronized(clazz)
{
worker.merge(path, pegRevision, revisions, localPath, force,
depth, ignoreAncestry, dryRun, recordOnly);
}
}
/**
* @since 1.5
*/
public void mergeReintegrate(String path, Revision pegRevision,
String localPath, boolean dryRun)
throws ClientException
{
synchronized(clazz)
{
worker.mergeReintegrate(path, pegRevision, localPath, dryRun);
}
}
/**
* @since 1.5
*/
public Mergeinfo getMergeinfo(String path, Revision pegRevision)
throws SubversionException
{
synchronized (clazz)
{
return worker.getMergeinfo(path, pegRevision);
}
}
/**
* @since 1.7
*/
public void getMergeinfoLog(int kind, String pathOrUrl,
Revision pegRevision, String mergeSourceUrl,
Revision srcPegRevision,
boolean discoverChangedPaths, int depth,
String[] revprops, LogMessageCallback callback)
throws ClientException
{
synchronized (clazz)
{
worker.getMergeinfoLog(kind, pathOrUrl, pegRevision, mergeSourceUrl,
srcPegRevision, discoverChangedPaths, depth,
revprops, callback);
}
}
/**
* @deprecated Use {@link #getMergeinfoLog(int, String, Revision, String,
* Revision, boolean, int,
* String[], LogMessageCallback)}
* @since 1.5
*/
public void getMergeinfoLog(int kind, String pathOrUrl,
Revision pegRevision, String mergeSourceUrl,
Revision srcPegRevision,
boolean discoverChangedPaths,
String[] revprops, LogMessageCallback callback)
throws ClientException
{
synchronized (clazz)
{
worker.getMergeinfoLog(kind, pathOrUrl, pegRevision, mergeSourceUrl,
srcPegRevision, discoverChangedPaths,
revprops, callback);
}
}
/**
* @deprecated Use {@link #diff(String, Revision, String, Revision,
* String, String, int, boolean, boolean,
* boolean)} instead.
* @since 1.0
*/
public void diff(String target1, Revision revision1, String target2,
Revision revision2, String outFileName, boolean recurse)
throws ClientException
{
synchronized(clazz)
{
worker.diff(target1, revision1, target2, revision2, outFileName,
recurse);
}
}
/**
* @deprecated Use {@link #diff(String, Revision, String, Revision,
* String, String, int, boolean, boolean,
* boolean)} instead.
* @since 1.2
*/
public void diff(String target1, Revision revision1, String target2,
Revision revision2, String outFileName, boolean recurse,
boolean ignoreAncestry, boolean noDiffDeleted,
boolean force)
throws ClientException
{
synchronized(clazz)
{
worker.diff(target1, revision1, target2, revision2, outFileName,
recurse, ignoreAncestry, noDiffDeleted, force);
}
}
/**
* @deprecated Use {@link #diff(String, Revision, String, Revision,
* String, String, int, boolean, boolean,
* boolean, boolean)} instead.
* @since 1.5
*/
public void diff(String target1, Revision revision1, String target2,
Revision revision2, String relativeToDir,
String outFileName, int depth, String[] changelists,
boolean ignoreAncestry, boolean noDiffDeleted,
boolean force)
throws ClientException
{
synchronized (clazz)
{
worker.diff(target1, revision1, target2, revision2, relativeToDir,
outFileName, depth, changelists, ignoreAncestry,
noDiffDeleted, force);
}
}
/**
* @since 1.7
*/
public void diff(String target1, Revision revision1, String target2,
Revision revision2, String relativeToDir,
String outFileName, int depth, String[] changelists,
boolean ignoreAncestry, boolean noDiffDeleted,
boolean force, boolean copiesAsAdds)
throws ClientException
{
synchronized (clazz)
{
worker.diff(target1, revision1, target2, revision2, relativeToDir,
outFileName, depth, changelists, ignoreAncestry,
noDiffDeleted, force, copiesAsAdds);
}
}
/**
* @deprecated Use {@link #diff(String, Revision, Revision, Revision,
* String, String, int, boolean, boolean,
* boolean)} instead.
* @since 1.2
*/
public void diff(String target, Revision pegRevision,
Revision startRevision, Revision endRevision,
String outFileName, boolean recurse,
boolean ignoreAncestry, boolean noDiffDeleted,
boolean force)
throws ClientException
{
synchronized(clazz)
{
worker.diff(target, pegRevision, startRevision, endRevision,
outFileName, recurse, ignoreAncestry, noDiffDeleted,
force);
}
}
/**
* @deprecated Use {@link #diff(String, Revision, Revision, Revision,
* String, String, int, boolean, boolean,
* boolean, boolean)} instead.
* @since 1.5
*/
public void diff(String target, Revision pegRevision,
Revision startRevision, Revision endRevision,
String relativeToDir, String outFileName, int depth,
String[] changelists, boolean ignoreAncestry,
boolean noDiffDeleted, boolean force)
throws ClientException
{
synchronized (clazz)
{
worker.diff(target, pegRevision, startRevision, endRevision,
relativeToDir, outFileName, depth, changelists,
ignoreAncestry, noDiffDeleted, force);
}
}
/**
* @since 1.7
*/
public void diff(String target, Revision pegRevision,
Revision startRevision, Revision endRevision,
String relativeToDir, String outFileName, int depth,
String[] changelists, boolean ignoreAncestry,
boolean noDiffDeleted, boolean force,
boolean copiesAsAdds)
throws ClientException
{
synchronized (clazz)
{
worker.diff(target, pegRevision, startRevision, endRevision,
relativeToDir, outFileName, depth, changelists,
ignoreAncestry, noDiffDeleted, force, copiesAsAdds);
}
}
/**
* @since 1.5
*/
public void diffSummarize(String target1, Revision revision1,
String target2, Revision revision2,
int depth, String[] changelists,
boolean ignoreAncestry,
DiffSummaryReceiver receiver)
throws ClientException
{
synchronized (clazz)
{
worker.diffSummarize(target1, revision1, target2, revision2,
depth, changelists, ignoreAncestry, receiver);
}
}
/**
* @since 1.5
*/
public void diffSummarize(String target, Revision pegRevision,
Revision startRevision, Revision endRevision,
int depth, String[] changelists,
boolean ignoreAncestry,
DiffSummaryReceiver receiver)
throws ClientException
{
synchronized (clazz)
{
worker.diffSummarize(target, pegRevision, startRevision,
endRevision, depth, changelists,
ignoreAncestry, receiver);
}
}
/**
* @deprecated Use {@link #properties(String, Revision, Revision,
* int, ProplistCallback)} instead.
* @since 1.0
*/
public PropertyData[] properties(String path) throws ClientException
{
synchronized(clazz)
{
return worker.properties(path);
}
}
/**
* @deprecated Use {@link #properties(String, Revision, Revision,
* int, ProplistCallback)} instead.
* @since 1.2
*/
public PropertyData[] properties(String path, Revision revision)
throws ClientException
{
synchronized(clazz)
{
return worker.properties(path, revision);
}
}
/**
* @deprecated Use {@link #properties(String, Revision, Revision,
* int, ProplistCallback)} instead.
* @since 1.2
*/
public PropertyData[] properties(String path, Revision revision,
Revision pegRevision)
throws ClientException
{
synchronized(clazz)
{
return properties(path, revision, pegRevision);
}
}
/**
* @since 1.5
*/
public void properties(String path, Revision revision,
Revision pegRevision, int depth,
String[] changelists,
ProplistCallback callback)
throws ClientException
{
synchronized (clazz)
{
worker.properties(path, revision, pegRevision, depth, changelists,
callback);
}
}
/**
* @deprecated Use {@link #propertySet(String, String, String, int,
* boolean)} instead.
* @since 1.0
*/
public void propertySet(String path, String name, String value,
boolean recurse)
throws ClientException
{
synchronized(clazz)
{
worker.propertySet(path, name, value, recurse);
}
}
/**
* @deprecated Use {@link #propertySet(String, String, String, int,
* boolean)} instead.
* @since 1.2
*/
public void propertySet(String path, String name, String value,
boolean recurse, boolean force)
throws ClientException
{
synchronized(clazz)
{
worker.propertySet(path, name, value, recurse, force);
}
}
/**
* @deprecated Use {@link #propertySet(String, String, String, int,
* boolean)} instead.
* @since 1.0
*/
public void propertySet(String path, String name, byte[] value,
boolean recurse) throws ClientException
{
synchronized(clazz)
{
worker.propertySet(path, name, value, recurse);
}
}
/**
* @deprecated Use {@link #propertySet(String, String, String, int,
* boolean)} instead.
* @since 1.2
*/
public void propertySet(String path, String name, byte[] value,
boolean recurse, boolean force)
throws ClientException
{
synchronized(clazz)
{
worker.propertySet(path, name, value, recurse, force);
}
}
/**
* @since 1.5
*/
public void propertySet(String path, String name, String value, int depth,
String[] changelists, boolean force,
Map revpropTable)
throws ClientException
{
synchronized(clazz)
{
worker.propertySet(path, name, value, depth, changelists, force,
revpropTable);
}
}
/**
* @deprecated Use {@link #propertyRemove(String, String, int)} instead.
* @since 1.0
*/
public void propertyRemove(String path, String name, boolean recurse)
throws ClientException
{
synchronized(clazz)
{
worker.propertyRemove(path, name, recurse);
}
}
/**
* @since 1.5
*/
public void propertyRemove(String path, String name, int depth,
String[] changelists)
throws ClientException
{
synchronized(clazz)
{
worker.propertyRemove(path, name, depth, changelists);
}
}
/**
* @deprecated Use {@link #propertyCreate(String, String, String, int,
* boolean)} instead.
* @since 1.0
*/
public void propertyCreate(String path, String name, String value,
boolean recurse)
throws ClientException
{
synchronized(clazz)
{
worker.propertyCreate(path, name, value, recurse);
}
}
/**
* @deprecated Use {@link #propertyCreate(String, String, String, int,
* boolean)} instead.
* @since 1.2
*/
public void propertyCreate(String path, String name, String value,
boolean recurse, boolean force)
throws ClientException
{
synchronized(clazz)
{
worker.propertyCreate(path, name, value, recurse, force);
}
}
/**
* @deprecated Use {@link #propertyCreate(String, String, String, int,
* boolean)} instead.
* @since 1.0
*/
public void propertyCreate(String path, String name, byte[] value,
boolean recurse)
throws ClientException
{
synchronized(clazz)
{
worker.propertyCreate(path, name, value, recurse);
}
}
/**
* @deprecated Use {@link #propertyCreate(String, String, String, int,
* boolean)} instead.
* @since 1.2
*/
public void propertyCreate(String path, String name, byte[] value,
boolean recurse, boolean force)
throws ClientException
{
synchronized(clazz)
{
worker.propertyCreate(path, name, value, recurse, force);
}
}
/**
* @since 1.5
*/
public void propertyCreate(String path, String name, String value,
int depth, String[] changelists, boolean force)
throws ClientException
{
synchronized(clazz)
{
worker.propertyCreate(path, name, value, depth, changelists, force);
}
}
/**
* @since 1.0
*/
public PropertyData revProperty(String path, String name, Revision rev)
throws ClientException
{
synchronized(clazz)
{
return worker.revProperty(path, name, rev);
}
}
/**
* @since 1.2
*/
public PropertyData[] revProperties(String path, Revision rev)
throws ClientException
{
synchronized(clazz)
{
return worker.revProperties(path, rev);
}
}
/**
* @since 1.2
*/
public void setRevProperty(String path, String name, Revision rev,
String value, boolean force)
throws ClientException
{
synchronized(clazz)
{
worker.setRevProperty(path, name, rev, value, force);
}
}
/**
* @since 1.6
*/
public void setRevProperty(String path, String name, Revision rev,
String value, String originalValue,
boolean force)
throws ClientException
{
synchronized(clazz)
{
worker.setRevProperty(path, name, rev, value, originalValue, force);
}
}
/**
* @deprecated Use {@link #propertyGet(String, String, Revision)} instead.
* @since 1.0
*/
public PropertyData propertyGet(String path, String name)
throws ClientException
{
synchronized(clazz)
{
return worker.propertyGet(path, name);
}
}
/**
* @since 1.2
*/
public PropertyData propertyGet(String path,
String name,
Revision revision)
throws ClientException
{
synchronized(clazz)
{
return worker.propertyGet(path, name, revision);
}
}
/**
* @since 1.2
*/
public PropertyData propertyGet(String path,
String name,
Revision revision,
Revision pegRevision)
throws ClientException
{
synchronized(clazz)
{
return worker.propertyGet(path, name, revision, pegRevision);
}
}
/**
* @deprecated Use {@link #fileContent(String, Revision, Revision)}
* instead.
* @since 1.0
*/
public byte[] fileContent(String path, Revision revision)
throws ClientException
{
synchronized(clazz)
{
return worker.fileContent(path, revision);
}
}
/**
* @since 1.2
*/
public byte[] fileContent(String path, Revision revision,
Revision pegRevision)
throws ClientException
{
synchronized(clazz)
{
return worker.fileContent(path, revision, pegRevision);
}
}
/**
* @since 1.0
*/
public void streamFileContent(String path, Revision revision,
Revision pegRevision, int bufferSize,
OutputStream stream)
throws ClientException
{
synchronized(clazz)
{
worker.streamFileContent(path, revision, pegRevision, bufferSize,
stream);
}
}
/**
* @since 1.0
*/
public void relocate(String from, String to, String path, boolean recurse)
throws ClientException
{
synchronized(clazz)
{
worker.relocate(from, to, path, recurse);
}
}
/**
* @deprecated Use {@link #blame(String, Revision, Revision, Revision,
* boolean, boolean, BlameCallback2)}
* instead.
* @since 1.0
*/
public byte[] blame(String path, Revision revisionStart,
Revision revisionEnd)
throws ClientException
{
synchronized(clazz)
{
return worker.blame(path,revisionStart, revisionEnd);
}
}
/**
* @deprecated Use {@link #blame(String, Revision, Revision, Revision,
* boolean, boolean, BlameCallback2)}
* instead.
* @since 1.0
*/
public void blame(String path,
Revision revisionStart,
Revision revisionEnd,
BlameCallback callback)
throws ClientException
{
synchronized(clazz)
{
worker.blame(path, revisionStart, revisionEnd, callback);
}
}
/**
* @deprecated Use {@link #blame(String, Revision, Revision, Revision,
* boolean, boolean, BlameCallback2)}
* instead.
* @since 1.2
*/
public void blame(String path,
Revision pegRevision,
Revision revisionStart,
Revision revisionEnd,
BlameCallback callback)
throws ClientException
{
synchronized(clazz)
{
worker.blame(path, pegRevision, revisionStart, revisionEnd,
callback);
}
}
/**
* @deprecated Use {@link #blame(String, Revision, Revision, Revision,
* boolean, boolean, BlameCallback3)}
* instead.
src/subversion/subversion/bindings/javahl/src/org/tigris/subversion/javahl/SVNClientSynchronized.java view on Meta::CPAN
*/
public void blame(String path,
Revision pegRevision,
Revision revisionStart,
Revision revisionEnd,
boolean ignoreMimeType,
boolean includeMergedRevisions,
BlameCallback2 callback)
throws ClientException
{
synchronized(clazz)
{
worker.blame(path, pegRevision, revisionStart, revisionEnd,
ignoreMimeType, includeMergedRevisions, callback);
}
}
/**
* @since 1.7
*/
public void blame(String path,
Revision pegRevision,
Revision revisionStart,
Revision revisionEnd,
boolean ignoreMimeType,
boolean includeMergedRevisions,
BlameCallback3 callback)
throws ClientException
{
synchronized(clazz)
{
worker.blame(path, pegRevision, revisionStart, revisionEnd,
ignoreMimeType, includeMergedRevisions, callback);
}
}
/**
* @since 1.0
*/
public void setConfigDirectory(String configDir) throws ClientException
{
synchronized(clazz)
{
worker.setConfigDirectory(configDir);
}
}
/**
* @since 1.0
*/
public String getConfigDirectory() throws ClientException
{
synchronized(clazz)
{
return worker.getConfigDirectory();
}
}
/**
* @since 1.0
*/
public void cancelOperation() throws ClientException
{
// this method is not synchronized, because it is designed to be called
// from another thread
worker.cancelOperation();
}
/**
* @deprecated Use {@link #info2(String, Revision, Revision, int,
* InfoCallback)} instead.
* @since 1.0
*/
public Info info(String path) throws ClientException
{
synchronized(clazz)
{
return worker.info(path);
}
}
/**
* @since 1.5
*/
public void addToChangelist(String[] paths, String changelist, int depth,
String[] changelists)
throws ClientException
{
synchronized (clazz)
{
worker.addToChangelist(paths, changelist, depth, changelists);
}
}
/**
* @since 1.5
*/
public void removeFromChangelists(String[] paths, int depth,
String[] changelists)
throws ClientException
{
synchronized (clazz)
{
worker.removeFromChangelists(paths, depth, changelists);
}
}
/**
* @since 1.5
*/
public void getChangelists(String rootPath, String[] changelists,
int depth, ChangelistCallback callback)
throws ClientException
{
synchronized (clazz)
{
worker.getChangelists(rootPath, changelists, depth, callback);
}
}
/**
* @since 1.2
*/
public void lock(String[] path, String comment, boolean force)
throws ClientException
{
synchronized(clazz)
{
worker.lock(path, comment, force);
}
}
/**
* @since 1.2
*/
public void unlock(String[] path, boolean force)
throws ClientException
{
synchronized(clazz)
{
worker.unlock(path, force);
}
}
/**
* @deprecated Use {@link #info2(String, Revision, Revision, int,
* InfoCallback)} instead.
* @since 1.2
*/
public Info2[] info2(String pathOrUrl, Revision revision,
Revision pegRevision, boolean recurse)
throws ClientException
{
synchronized(clazz)
{
return worker.info2(pathOrUrl, revision, pegRevision, recurse);
}
}
/**
* @since 1.5
*/
public void info2(String pathOrUrl, Revision revision,
Revision pegRevision, int depth, String[] changelists,
InfoCallback callback)
throws ClientException
{
synchronized (clazz)
{
worker.info2(pathOrUrl, revision, pegRevision, depth, changelists,
callback);
}
}
/**
* @since 1.2
*/
public String getVersionInfo(String path, String trailUrl,
boolean lastChanged) throws ClientException
{
synchronized(clazz)
{
return worker.getVersionInfo(path, trailUrl, lastChanged);
}
}
/**
* @since 1.7
*/
public void upgrade(String path)
throws ClientException
{
synchronized (clazz)
{
worker.upgrade(path);
}
}
}
src/subversion/subversion/include/private/svn_mutex.h view on Meta::CPAN
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* This is a simple wrapper around @c apr_thread_mutex_t and will be a
* valid identifier even if APR does not support threading.
*/
#if APR_HAS_THREADS
/** A mutex for synchronization between threads. It may be NULL, in
* which case no synchronization will take place. The latter is useful
* when implementing some functionality with optional synchronization.
*/
typedef apr_thread_mutex_t svn_mutex__t;
#else
/** Dummy definition. The content will never be actually accessed.
*/
typedef void svn_mutex__t;
#endif
src/subversion/subversion/include/private/svn_named_atomic.h view on Meta::CPAN
/** Returns #FALSE when named atomics are not available to our process
* and svn_atomic_namespace__create is likely to fail.
*
* @note The actual check will be performed only once and later
* changes in process privileges will not reflect in the outcome of future
* calls to this function.
*/
svn_boolean_t
svn_named_atomic__is_supported(void);
/** Returns #TRUE on platforms that don't need expensive synchronization
* objects to serialize access to named atomics. If this returns #FALSE,
* reading from or modifying a #svn_named_atomic__t may be as expensive
* as a file system operation.
*/
svn_boolean_t
svn_named_atomic__is_efficient(void);
/** Create a namespace (i.e. access object) with the given @a name and
* return it in @a *ns.
*
src/subversion/subversion/include/svn_delta.h view on Meta::CPAN
* directory baton UNLESS the editor has taken precautions to
* allocate it in a pool of the appropriate lifetime (the @a dir_pool
* passed to @c open_directory and @c add_directory definitely does not
* have the proper lifetime). In general, it is recommended to simply
* avoid keeping a parent directory baton in a file baton.
*
*
* <h3>Errors</h3>
*
* At least one implementation of the editor interface is
* asynchronous; an error from one operation may be detected some
* number of operations later. As a result, an editor driver must not
* assume that an error from an editing function resulted from the
* particular operation being detected. Moreover, once an editing
* function (including @c close_edit) returns an error, the edit is
* dead; the only further operation which may be called on the editor
* is @c abort_edit.
*/
typedef struct svn_delta_editor_t
{
/** Set the target revision for this edit to @a target_revision. This
src/subversion/subversion/include/svn_pools.h view on Meta::CPAN
/** Destroy a @a pool and all of its children.
*
* This define for @c svn_pool_destroy exists for symmetry and
* completeness.
*/
#define svn_pool_destroy apr_pool_destroy
/** Return a new allocator. This function limits the unused memory in the
* new allocator to #SVN_ALLOCATOR_RECOMMENDED_MAX_FREE and ensures
* proper synchronization if the allocator is used by multiple threads.
*
* If your application uses multiple threads, creating a separate
* allocator for each of these threads may not be feasible. Set the
* @a thread_safe parameter to @c TRUE in that case; otherwise, set @a
* thread_safe to @c FALSE to maximize performance.
*
* @note Even if @a thread_safe is @c TRUE, pools themselves will
* still not be thread-safe and their access may require explicit
* serialization.
*
src/subversion/subversion/libsvn_fs_fs/fs.c view on Meta::CPAN
if (status)
return svn_error_wrap_apr(status, _("Can't fetch FSFS shared data"));
ffsd = val;
if (!ffsd)
{
ffsd = apr_pcalloc(common_pool, sizeof(*ffsd));
ffsd->common_pool = common_pool;
/* POSIX fcntl locks are per-process, so we need a mutex for
intra-process synchronization when grabbing the repository write
lock. */
SVN_ERR(svn_mutex__init(&ffsd->fs_write_lock,
SVN_FS_FS__USE_LOCK_MUTEX, common_pool));
/* ... not to mention locking the txn-current file. */
SVN_ERR(svn_mutex__init(&ffsd->txn_current_lock,
SVN_FS_FS__USE_LOCK_MUTEX, common_pool));
/* We also need a mutex for synchronizing access to the active
transaction list and free transaction pointer. This one is
enabled unconditionally. */
SVN_ERR(svn_mutex__init(&ffsd->txn_list_lock,
TRUE, common_pool));
key = apr_pstrdup(common_pool, key);
status = apr_pool_userdata_set(ffsd, key, NULL, common_pool);
if (status)
return svn_error_wrap_apr(status, _("Can't store FSFS shared data"));
}
src/subversion/subversion/libsvn_fs_fs/fs.h view on Meta::CPAN
svn_boolean_t being_written;
/* The pool in which this object has been allocated; a subpool of the
common pool. */
apr_pool_t *pool;
} fs_fs_shared_txn_data_t;
/* On most operating systems apr implements file locks per process, not
per file. On Windows apr implements the locking as per file handle
locks, so we don't have to add our own mutex for just in-process
synchronization. */
/* Compare ../libsvn_subr/named_atomic.c:USE_THREAD_MUTEX */
#if APR_HAS_THREADS && !defined(WIN32)
#define SVN_FS_FS__USE_LOCK_MUTEX 1
#else
#define SVN_FS_FS__USE_LOCK_MUTEX 0
#endif
/* Private FSFS-specific data shared between all svn_fs_t objects that
relate to a particular filesystem, as identified by filesystem UUID.
Objects of this type are allocated in the common pool. */
typedef struct fs_fs_shared_data_t
{
/* A list of shared transaction objects for each transaction that is
currently active, or NULL if none are. All access to this list,
including the contents of the objects stored in it, is synchronised
under TXN_LIST_LOCK. */
fs_fs_shared_txn_data_t *txns;
/* A free transaction object, or NULL if there is no free object.
Access to this object is synchronised under TXN_LIST_LOCK. */
fs_fs_shared_txn_data_t *free_txn;
/* A lock for intra-process synchronization when accessing the TXNS list. */
svn_mutex__t *txn_list_lock;
/* A lock for intra-process synchronization when grabbing the
repository write lock. */
svn_mutex__t *fs_write_lock;
/* A lock for intra-process synchronization when locking the
txn-current file. */
svn_mutex__t *txn_current_lock;
/* The common pool, under which this object is allocated, subpools
of which are used to allocate the transaction objects. */
apr_pool_t *common_pool;
} fs_fs_shared_data_t;
/* Data structure for the 1st level DAG node cache. */
typedef struct fs_fs_dag_cache_t fs_fs_dag_cache_t;
src/subversion/subversion/libsvn_ra_serf/commit.c view on Meta::CPAN
/* Using the HTTPv1 protocol, perform a CHECKOUT of NODE_URL within the
given COMMIT_CTX. The resulting working resource will be returned in
*WORKING_URL, allocated from RESULT_POOL. All temporary allocations
are performed in SCRATCH_POOL.
### are these URLs actually repos relpath values? or fspath? or maybe
### the abspath portion of the full URL.
This function operates synchronously.
Strictly speaking, we could perform "all" of the CHECKOUT requests
when the commit starts, and only block when we need a specific
answer. Or, at a minimum, send off these individual requests async
and block when we need the answer (eg PUT or PROPPATCH).
However: the investment to speed this up is not worthwhile, given
that CHECKOUT (and the related round trip) is completely obviated
in HTTPv2.
*/
src/subversion/subversion/libsvn_ra_serf/ra_serf.h view on Meta::CPAN
/* Using CONN, fetch the properties specified by WHICH_PROPS using CONN
for URL at REVISION. The resulting properties are placed into a 2-level
hash in RESULTS, mapping NAMESPACE -> hash<PROPNAME, PROPVALUE>, which
is allocated in RESULT_POOL.
If REVISION is SVN_INVALID_REVNUM, then the properties are fetched
from HEAD for URL.
This function performs the request synchronously.
Temporary allocations are made in SCRATCH_POOL. */
svn_error_t *
svn_ra_serf__fetch_node_props(apr_hash_t **results,
svn_ra_serf__connection_t *conn,
const char *url,
svn_revnum_t revision,
const svn_ra_serf__dav_props_t *which_props,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool);
src/subversion/subversion/libsvn_ra_serf/ra_serf.h view on Meta::CPAN
/* Using CONN, fetch a DAV: property from the resource identified by URL
within REVISION. The PROPNAME may be one of:
"checked-in"
"href"
The resulting value will be allocated in RESULT_POOL, and may be NULL
if the property does not exist (note: "href" always exists).
This function performs the request synchronously.
Temporary allocations are made in SCRATCH_POOL. */
svn_error_t *
svn_ra_serf__fetch_dav_prop(const char **value,
svn_ra_serf__connection_t *conn,
const char *url,
svn_revnum_t revision,
const char *propname,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool);
src/subversion/subversion/libsvn_ra_serf/ra_serf.h view on Meta::CPAN
svn_error_t *
svn_ra_serf__probe_proxy(svn_ra_serf__session_t *serf_sess,
apr_pool_t *scratch_pool);
/* On HTTPv2 connections, run an OPTIONS request over CONN to fetch the
current youngest revnum, returning it in *YOUNGEST.
(the revnum is headers of the OPTIONS response)
This function performs the request synchronously.
All temporary allocations will be made in SCRATCH_POOL. */
svn_error_t *
svn_ra_serf__v2_get_youngest_revnum(svn_revnum_t *youngest,
svn_ra_serf__connection_t *conn,
apr_pool_t *scratch_pool);
/* On HTTPv1 connections, run an OPTIONS request over CONN to fetch the
activity collection set and return it in *ACTIVITY_URL, allocated
from RESULT_POOL.
(the activity-collection-set is in the body of the OPTIONS response)
This function performs the request synchronously.
All temporary allocations will be made in SCRATCH_POOL. */
svn_error_t *
svn_ra_serf__v1_get_activity_collection(const char **activity_url,
svn_ra_serf__connection_t *conn,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool);
/* Set @a VCC_URL to the default VCC for our repository based on @a
src/subversion/subversion/libsvn_ra_serf/ra_serf.h view on Meta::CPAN
svn_ra_serf__get_relative_path(const char **rel_path,
const char *orig_path,
svn_ra_serf__session_t *session,
svn_ra_serf__connection_t *conn,
apr_pool_t *pool);
/* Using the default connection in SESSION (conns[0]), get the youngest
revnum from the server, returning it in *YOUNGEST.
This function operates synchronously.
All temporary allocations are performed in SCRATCH_POOL. */
svn_error_t *
svn_ra_serf__get_youngest_revnum(svn_revnum_t *youngest,
svn_ra_serf__session_t *session,
apr_pool_t *scratch_pool);
/* Generate a revision-stable URL.
src/subversion/subversion/libsvn_ra_serf/ra_serf.h view on Meta::CPAN
SVN_INVALID_REVNUM, then the stable URL will refer to the youngest
revision at the time this function was called.
If URL is NULL, then the session root will be used.
The stable URL will be placed into *STABLE_URL, allocated from RESULT_POOL.
If LATEST_REVNUM is not NULL, then the revision used will be placed into
*LATEST_REVNUM. That will be equal to youngest, or the given REVISION.
This function operates synchronously, if any communication to the server
is required. Communication is needed if REVISION is SVN_INVALID_REVNUM
(to get the current youngest revnum), or if the specified REVISION is not
(yet) in our cache of baseline collections.
All temporary allocations are performed in SCRATCH_POOL. */
svn_error_t *
svn_ra_serf__get_stable_url(const char **stable_url,
svn_revnum_t *latest_revnum,
svn_ra_serf__session_t *session,
svn_ra_serf__connection_t *conn,
src/subversion/subversion/libsvn_subr/cache-inprocess.c view on Meta::CPAN
* structs, as well as the dup'd values and hash keys.
*/
apr_pool_t *cache_pool;
/* Sum of the SIZE members of all cache_entry elements that are
* accessible from HASH. This is used to make statistics available
* even if the sub-pools have already been destroyed.
*/
apr_size_t data_size;
/* A lock for intra-process synchronization to the cache, or NULL if
* the cache's creator doesn't feel the cache needs to be
* thread-safe. */
svn_mutex__t *mutex;
} inprocess_cache_t;
/* A cache page; all items on the page are allocated from the same
* pool. */
struct cache_page {
/* Pointers for the LRU list anchored at the cache's SENTINEL.
* (NULL for the PARTIAL_PAGE.) */
src/subversion/subversion/libsvn_subr/cache-membuffer.c view on Meta::CPAN
* Purely statistical information that may be used for profiling.
*/
apr_uint64_t total_writes;
/* Total number of hits since the cache's creation.
* Purely statistical information that may be used for profiling.
*/
apr_uint64_t total_hits;
#if APR_HAS_THREADS
/* A lock for intra-process synchronization to the cache, or NULL if
* the cache's creator doesn't feel the cache needs to be
* thread-safe.
*/
apr_thread_rwlock_t *lock;
/* If set, write access will wait until they get exclusive access.
* Otherwise, they will become no-ops if the segment is currently
* read-locked.
*/
svn_boolean_t allow_blocking_writes;
src/subversion/subversion/libsvn_subr/cache-membuffer.c view on Meta::CPAN
* If not, initialize a minimal cache structure.
*/
if (c[seg].data == NULL || c[seg].directory == NULL)
{
/* We are OOM. There is no need to proceed with "half a cache".
*/
return svn_error_wrap_apr(APR_ENOMEM, "OOM");
}
#if APR_HAS_THREADS
/* A lock for intra-process synchronization to the cache, or NULL if
* the cache's creator doesn't feel the cache needs to be
* thread-safe.
*/
c[seg].lock = NULL;
if (thread_safe)
{
apr_status_t status =
apr_thread_rwlock_create(&(c[seg].lock), pool);
if (status)
return svn_error_wrap_apr(status, _("Can't create cache mutex"));
src/subversion/subversion/libsvn_subr/cache_config.c view on Meta::CPAN
* Most OS restrict the number of open file handles to
* about 1000. To minimize I/O and OS overhead, values
* of 500+ can be beneficial (use svn_fs_set_cache_config()
* to change the configuration).
* When running with a huge in-process cache, this number
* has little impact on performance and a more modest
* value (< 100) may be more suitable.
*/
#if APR_HAS_THREADS
FALSE /* assume multi-threaded operation.
* Because this simply activates proper synchronization
* between threads, it is a safe default.
*/
#else
TRUE /* single-threaded is the only supported mode of operation */
#endif
};
/* Get the current FSFS cache configuration. */
const svn_cache_config_t *
svn_cache_config_get(void)
src/subversion/subversion/libsvn_subr/io.c view on Meta::CPAN
changed for various reasons (the most intrusive are virus
scanners). So, if one of these other apps has glommed onto
our file we may get an 'access denied' error.
This retry loop does not completely solve the problem (who
knows how long the other app is going to hold onto it for), but
goes a long way towards minimizing it. It is not an infinite
loop because there might really be an error.
Another reason for retrying delete operations on Windows
is that they are asynchronous -- the file or directory is not
actually deleted until the last handle to it is closed. The
retry loop cannot completely solve this problem either, but can
help mitigate it.
*/
#define RETRY_MAX_ATTEMPTS 100
#define RETRY_INITIAL_SLEEP 1000
#define RETRY_MAX_SLEEP 128000
#define RETRY_LOOP(err, expr, retry_test, sleep_test) \
do \
src/subversion/subversion/libsvn_subr/named_atomic.c view on Meta::CPAN
*
* We use a single shared memory block (memory mapped file) that will be
* created by the first user and merely mapped by all subsequent ones.
* The memory block contains an short header followed by a fixed-capacity
* array of named atomics. The number of entries currently in use is stored
* in the header part.
*
* Finding / creating the MMAP object as well as adding new array entries
* is being guarded by an APR global mutex. Since releasing the MMAP
* structure and closing the underlying does not affect other users of the
* same, cleanup will not be synchronized.
*
* The array is append-only. Once a process mapped the block into its
* address space, it may freely access any of the used entries. However,
* it must synchronize access to the volatile data within the entries.
* On Windows and where otherwise supported by GCC, lightweight "lock-free"
* synchronization will be used. Other targets serialize all access using
* a global mutex.
*
* Atomics will be identified by their name (a short string) and lookup
* takes linear time. But even that takes only about 10 microseconds for a
* full array scan -- which is in the same order of magnitude than e.g. a
* single global mutex lock / unlock pair.
*/
/* Capacity of our shared memory object, i.e. max number of named atomics
* that may be created. Should have the form 2**N - 1.
src/subversion/subversion/libsvn_subr/named_atomic.c view on Meta::CPAN
*
* (We don't call it SYNCHRONIZE because Windows has a preprocess macro by
* that name.)
*
* The default implementation will use the same mutex for initialization
* as well as any type of data access. This is quite expensive and we
* can do much better on most platforms.
*/
#if defined(WIN32) && ((_WIN32_WINNT >= 0x0502) || defined(InterlockedExchangeAdd64))
/* Interlocked API / intrinsics guarantee full data synchronization
*/
#define synched_read(mem) *mem
#define synched_write(mem, value) InterlockedExchange64(mem, value)
#define synched_add(mem, delta) InterlockedExchangeAdd64(mem, delta)
#define synched_cmpxchg(mem, value, comperand) \
InterlockedCompareExchange64(mem, value, comperand)
#define NA_SYNCHRONIZE(_atomic,op) op;
#define NA_SYNCHRONIZE_IS_FAST TRUE
src/subversion/subversion/libsvn_subr/opt.c view on Meta::CPAN
/* If the target has the same name as a Subversion
working copy administrative dir, skip it. */
base_name = svn_dirent_basename(true_target, pool);
/* FIXME:
The canonical list of administrative directory names is
maintained in libsvn_wc/adm_files.c:svn_wc_set_adm_dir().
That list can't be used here, because that use would
create a circular dependency between libsvn_wc and
libsvn_subr. Make sure changes to the lists are always
synchronized! */
if (0 == strcmp(base_name, ".svn")
|| 0 == strcmp(base_name, "_svn"))
{
err = svn_error_createf(SVN_ERR_RESERVED_FILENAME_SPECIFIED,
err, _("'%s' ends in a reserved name"),
utf8_target);
continue;
}
}
src/subversion/subversion/libsvn_subr/sqlite.c view on Meta::CPAN
#endif
/* ### simplify this. remnants of some old SQLite compat code. */
{
int ignored_err = SQLITE_OK;
SVN_ERR(exec_sql2(*db, "PRAGMA case_sensitive_like=1;", ignored_err));
}
SVN_ERR(exec_sql(*db,
/* Disable synchronization to disable the explicit disk flushes
that make Sqlite up to 50 times slower; especially on small
transactions.
This removes some stability guarantees on specific hardware
and power failures, but still guarantees atomic commits on
application crashes. With our dependency on external data
like pristine files (Wc) and revision files (repository),
we can't keep up these additional guarantees anyway.
### Maybe switch to NORMAL(1) when we use larger transaction
scopes */
"PRAGMA synchronous=OFF;"
/* Enable recursive triggers so that a user trigger will fire
in the deletion phase of an INSERT OR REPLACE statement.
Requires SQLite >= 3.6.18 */
"PRAGMA recursive_triggers=ON;"
/* Enforce current Sqlite default behavior. Some distributions
might change the Sqlite defaults without realizing how this
affects application(read: Subversion) performance/behavior. */
"PRAGMA foreign_keys=OFF;" /* SQLITE_DEFAULT_FOREIGN_KEYS*/
"PRAGMA locking_mode = NORMAL;" /* SQLITE_DEFAULT_LOCKING_MODE */
));
src/subversion/subversion/libsvn_subr/utf.c view on Meta::CPAN
handles to the first entry in the linked list of xlate handles. We don't
store the pointer to the list head directly in the hash table, since we
remove/insert entries at the head in the list in the code below, and
we can't use apr_hash_set() in each character translation because that
function allocates memory in each call where the value is non-NULL.
Since these allocations take place in a global pool, this would be a
memory leak. */
static apr_hash_t *xlate_handle_hash = NULL;
/* "1st level cache" to standard conversion maps. We may access these
* using atomic xchange ops, i.e. without further thread synchronization.
* If the respective item is NULL, fallback to hash lookup.
*/
static void * volatile xlat_ntou_static_handle = NULL;
static void * volatile xlat_uton_static_handle = NULL;
/* Clean up the xlate handle cache. */
static apr_status_t
xlate_cleanup(void *arg)
{
/* We set the cache variables to NULL so that translation works in other
src/subversion/subversion/libsvn_wc/adm_files.c view on Meta::CPAN
svn_error_t *
svn_wc_set_adm_dir(const char *name, apr_pool_t *pool)
{
/* This is the canonical list of administrative directory names.
FIXME:
An identical list is used in
libsvn_subr/opt.c:svn_opt__args_to_target_array(),
but that function can't use this list, because that use would
create a circular dependency between libsvn_wc and libsvn_subr.
Make sure changes to the lists are always synchronized! */
static const char *valid_dir_names[] = {
default_adm_dir_name,
"_svn",
NULL
};
const char **dir_name;
for (dir_name = valid_dir_names; *dir_name; ++dir_name)
if (0 == strcmp(name, *dir_name))
{
src/subversion/subversion/libsvn_wc/workqueue.h view on Meta::CPAN
svn_error_t *
svn_wc__wq_build_file_copy_translated(svn_skel_t **work_item,
svn_wc__db_t *db,
const char *local_abspath,
const char *src_abspath,
const char *dst_abspath,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool);
/* Set *WORK_ITEM to a new work item that will synchronize the
target node's readonly and executable flags with the values defined
by its properties and lock status. */
svn_error_t *
svn_wc__wq_build_sync_file_flags(svn_skel_t **work_item,
svn_wc__db_t *db,
const char *local_abspath,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool);
src/subversion/subversion/po/de.po view on Meta::CPAN
" Beachten Sie, dass sich die Änderungen dieser Zusammenführung dann\n"
" nur in Ihrer Arbeitskopie befinden und noch in das Projektarchiv\n"
" übertragen werden müssen, damit sie von anderen Benutzern gesehen\n"
" werden können. Sie können die Änderungen überprüfen und müssen\n"
" aufgetretene Konflikte auflösen, bevor Sie die Zusammenführung\n"
" übertragen.\n"
"\n"
" - Beispiel für Zusammenführung zur Reintegration -\n"
"\n"
" Der Entwicklungszweig »feature« wurde zuletzt bis zu Revision »X«\n"
" mit dem Hauptzweig »trunk« synchronisiert. Daher stellt der\n"
" Unterschied zwischen »trunk@X« und »feature@HEAD« die gesamte\n"
" Implementierung der neuen Funktion dar, und keine weiteren Änderungen.\n"
" Diese Änderungen werden nach »trunk« eingebracht.\n"
"\n"
" rW rX\n"
" trunk ------+--------------------L------------------o\n"
" \\ . ^\n"
" \\ ............. /\n"
" \\ . /\n"
" feature +--------------------------------R\n"
src/subversion/subversion/po/de.po view on Meta::CPAN
" eine Arbeitskopie des Entwicklungszweigs »feature« und führen Sie\n"
" dieses Kommando im obersten Verzeichnis aus:\n"
"\n"
" svn merge ^/feature\n"
"\n"
" Um unnötige Konflikte zu vermeiden, erfordern Zusammenführungen zur\n"
" Reintegration eine Arbeitskopie in ZIEL_AKPfad in einer einzelnen\n"
" Revision, ohne lokale Änderungen oder umgestellte Unterbäume.\n"
"\n"
" Eine Zusammenführung zur Reintegration erfordert auch, dass der\n"
" Quellzweig durchgehend mit dem dem Ziel synchronisiert ist -- im\n"
" Beispiel oben bedeutet dies, dass alle Revisionen zwischen dem\n"
" Verzweigungspunkt W und der letzten zusammengeführten Revision X\n"
" in den Entwicklungszweig zusammengeführt wurden, und es keine nicht\n"
" zusammengeführten Revisionen zwischen diesen gibt.\n"
"\n"
"\n"
" 2. Diese Form dient der Zusammenführung einzelner ausgewählter\n"
" Änderungen:\n"
"\n"
" svn merge [-c M[,N...] | -r N:M ...] QUELLE[@REV] [ZIEL_AKPfad]\n"
src/subversion/subversion/po/de.po view on Meta::CPAN
" Zwei neue Funktionen wurden in getrennten Entwicklungszweigen »foo«\n"
" und »bar« entwickelt. Danach wurde klar, dass »bar« mit »foo«\n"
" kombiniert werden sollte, vor weiterer Entwicklung und Reintegration\n"
" in den Hauptzweig »trunk«.\n"
"\n"
" Obwohl beide Entwicklungszweige von Hauptzweig »trunk« ausgehen, sind\n"
" sie nicht direkt verwandt - sie sind nicht direkte Kopien voneinander.\n"
" Eine Zusammenführung der Unterschiede zweier URLs ist notwendig.\n"
"\n"
" »bar« wurde zuvor mit »trunk« bis zu dessen Revision 500\n"
" synchronisiert. (Falls diese Revisionsnummer nicht bekannt ist, kann\n"
" sie mit den Befehlen »svn log« und/oder »svn mergeinfo« ermittelt\n"
" werden.)\n"
" Der Unterschied zwischen trunk@500 und bar@HEAD enthält also die\n"
" komplette Menge an Unterschieden, die die in diesem Zweig entwickelte\n"
" Funktion ausmachen, und keine weiteren Unterschiede. Diese Änderungen\n"
" werden jetzt auf den »bar« angewandt.\n"
"\n"
" foo +-----------------------------------o\n"
" / ^\n"
" / /\n"
src/subversion/subversion/po/de.po view on Meta::CPAN
" Benutzen Sie --force, um die Freigabe zu erzwingen.\n"
# Parts of the text (--force and --set-depth) are shared with the
# switch help. Keep it consistent.
#: ../svn/svn.c:1568
msgid ""
"Bring changes from the repository into the working copy.\n"
"usage: update [PATH...]\n"
"\n"
" If no revision is given, bring working copy up-to-date with HEAD rev.\n"
" Else synchronize working copy to revision given by -r.\n"
"\n"
" For each updated item a line will be printed with characters reporting\n"
" the action taken. These characters have the following meaning:\n"
"\n"
" A Added\n"
" D Deleted\n"
" U Updated\n"
" C Conflict\n"
" G Merged\n"
" E Existed\n"
src/subversion/subversion/po/de.po view on Meta::CPAN
" out, too, at depth=empty.\n"
"\n"
" Use the --set-depth option to set a new working copy depth on the\n"
" targets of this operation.\n"
msgstr ""
"Aktualisiert die Arbeitskopie mit Änderungen aus dem Projektarchiv.\n"
"Aufruf: update [PFAD...]\n"
"\n"
" Ist keine Revision angegeben, wird die Arbeitskopie auf den aktuellen\n"
" Stand der HEAD-Revision gebracht. Ansonsten wird die Arbeitskopie mit der\n"
" durch -r angegebenen Revision synchronisiert.\n"
"\n"
" Für jedes aktualisierte Objekt wird eine Zeile mit einem Buchstaben für die\n"
" durchgeführte Aktion ausgegeben. Diese haben die folgenden Bedeutungen\n"
"\n"
" A Added - Hinzugefügt\n"
" D Deleted - Gelöscht\n"
" U Updated - Aktualisiert\n"
" C Conflict - Konflikt\n"
" G Merged - Zusammengeführt\n"
" E Existed - Existierend\n"
src/subversion/subversion/po/de.po view on Meta::CPAN
#: ../svnserve/winservice.c:416
#, c-format
msgid "The service failed to start; an internal error occurred while starting the service"
msgstr "Der Dienst konnte nicht gestartet werden; ein interner Fehler trat beim Starten des Dienstes auf"
#: ../svnsync/svnsync.c:92
msgid ""
"usage: svnsync initialize DEST_URL SOURCE_URL\n"
"\n"
"Initialize a destination repository for synchronization from\n"
"another repository.\n"
"\n"
"If the source URL is not the root of a repository, only the\n"
"specified part of the repository will be synchronized.\n"
"\n"
"The destination URL must point to the root of a repository which\n"
"has been configured to allow revision property changes. In\n"
"the general case, the destination repository must contain no\n"
"committed revisions. Use --allow-non-empty to override this\n"
"restriction, which will cause svnsync to assume that any revisions\n"
"already present in the destination repository perfectly mirror\n"
"their counterparts in the source repository. (This is useful\n"
"when initializing a copy of a repository as a mirror of that same\n"
"repository, for example.)\n"
src/subversion/subversion/po/de.po view on Meta::CPAN
"the destination repository by any method other than 'svnsync'.\n"
"In other words, the destination repository should be a read-only\n"
"mirror of the source repository.\n"
msgstr ""
"Aufruf: svnsync initialize ZIEL_URL QUELL_URL\n"
"\n"
"Bereitet ein Zielprojektarchiv auf die Synchronisation mit einem\n"
"anderen Projektarchiv vor.\n"
"\n"
"Falls die Quell-URL nicht die Wurzel eines Projektarchivs ist, wird nur\n"
"der angegebene Teil des Projektarchivs synchronisiert.\n"
"\n"
"Die Ziel-URL muss auf die Basis eines Projektarchivs zeigen, das Änderungen an Revisionseigenschaften zulässt. Allgemein sollte das \n"
"Zielprojektarchiv keine übertragenen Revisionen enthalten. Verwenden Sie --allow-non-empty um diese Einschränkung zu umgehen. In diesem\n"
"Fall nimmt svnsync an, dass alle schon im Zielprojektarchiv vorhandenen\n"
"Revisionen ihre jeweiligen Gegenstücke in der Quelle exakt wiedergeben.\n"
"(Dies ist z.B. nützlich, wenn die Kopie eines Projektarchivs als Spiegel dieses Projektarchivs konfiguriert werden soll.)\n"
"\n"
"Übertragungen oder Eigenschaftsänderungen im Zielprojektarchiv\n"
"sollten ausschließlich mit »svnsync« vorgenommen werden.\n"
"Anders ausgedrückt stellt das Zielprojektarchiv einen Spiegel des\n"
"Quellprojektarchivs dar, auf den nur lesend zugegriffen werden darf.\n"
#: ../svnsync/svnsync.c:118
msgid ""
"usage: svnsync synchronize DEST_URL [SOURCE_URL]\n"
"\n"
"Transfer all pending revisions to the destination from the source\n"
"with which it was initialized.\n"
"\n"
"If SOURCE_URL is provided, use that as the source repository URL,\n"
"ignoring what is recorded in the destination repository as the\n"
"source URL. Specifying SOURCE_URL is recommended in particular\n"
"if untrusted users/administrators may have write access to the\n"
"DEST_URL repository.\n"
msgstr ""
"Aufruf: svnsync synchronize ZIEL_URL [QUELL_URL]\n"
"\n"
"Überträgt alle für das Zielprojektarchiv ausstehenden Revisionen\n"
"aus der Quelle, mit der die Synchronisation vorbereitet wurde.\n"
"\n"
"Falls QUELL_URL angegeben ist, wird dies als Quellprojektarchiv\n"
"verwendet, egal welche Quelle im Zielprojektarchiv konfiguriert wurde.\n"
"Die Angabe von QUELL_URL ist ratsam, falls nicht vertrauenswürdige\n"
"Benutzer oder Administratoren Schreibzugriff auf ZIEL_URL haben.\n"
"\n"
src/subversion/subversion/po/de.po view on Meta::CPAN
"Benutzer oder Administratoren Schreibzugriff auf ZIEL_URL haben.\n"
"\n"
"Die Angabe des Revisionsbereichs in der zweiten Form ist veraltet\n"
"und ist gleichbedeutend mit der Angabe der Option »-r PAR1[:PAR2]«\n"
# CHECKME: s/destination/source/?
#: ../svnsync/svnsync.c:152
msgid ""
"usage: svnsync info DEST_URL\n"
"\n"
"Print information about the synchronization destination repository\n"
"located at DEST_URL.\n"
msgstr ""
"Aufruf: svnsync info ZIEL_URL\n"
"\n"
"Gibt Informationen über das Zielprojektarchiv der Synchronisation aus,\n"
"das sich unter ZIEL_URL befindet.\n"
#: ../svnsync/svnsync.c:158
msgid ""
"usage: svnsync help [SUBCOMMAND...]\n"
src/subversion/subversion/po/de.po view on Meta::CPAN
msgid "connect to source repository with username ARG"
msgstr "verbindet mit dem Quellprojektarchiv mit dem Benutzernamen PAR"
#: ../svnsync/svnsync.c:206
msgid "connect to source repository with password ARG"
msgstr "verbindet mit dem Quellprojektarchiv mit dem Passwort PAR"
# FIXME: s/sync/synced/, option sync-username
#: ../svnsync/svnsync.c:208
msgid "connect to sync repository with username ARG"
msgstr "verbindet mit synchronisiertem Projektarchiv mit Benutzernamen PAR"
#: ../svnsync/svnsync.c:210
msgid "connect to sync repository with password ARG"
msgstr "verbindet mit synchronisiertem Projektarchiv mit Passwort PAR"
#: ../svnsync/svnsync.c:222
msgid ""
"convert translatable properties from encoding ARG\n"
" to UTF-8. If not specified, then properties are\n"
" presumed to be encoded in UTF-8."
msgstr ""
"konvertiert übersetzbare Eigenschaften vom Kodierung PAR\n"
" nach UTF-8. Wenn nicht angegeben, werden die\n"
" Eigenschaften als in UTF-8 kodiert angenommen."
src/subversion/subversion/po/de.po view on Meta::CPAN
#, c-format
msgid "NOTE: Normalized %s* properties to LF line endings (%d rev-props, %d node-props).\n"
msgstr "HINWEIS: %s* Eigenschaften nach LF-Zeilenenden normalisiert (%d Revisionseigenschaften, %d Knoteneigenschaften).\n"
#: ../svnsync/svnsync.c:753
msgid "Destination repository already contains revision history; consider using --allow-non-empty if the repository's revisions are known to mirror their respective revisions in the source repository"
msgstr "Das Zielprojektarchiv enthält schon eine Revisionsgeschichte. Sie können es mit »--allow-non-empty« versuchen, falls die Revisionen dieses Projektarchivs denen des Quellprojektarchivs genau entsprechen."
#: ../svnsync/svnsync.c:762
#, c-format
msgid "Destination repository is already synchronizing from '%s'"
msgstr "Das Zielprojektarchiv synchronisiert bereits von »%s«"
#: ../svnsync/svnsync.c:797
msgid "Destination repository has more revisions than source repository"
msgstr "Zielprojektarchiv hat mehr Revisionen als Quellprojektarchiv"
#: ../svnsync/svnsync.c:862 ../svnsync/svnsync.c:865 ../svnsync/svnsync.c:1518
#: ../svnsync/svnsync.c:1525 ../svnsync/svnsync.c:1762
#: ../svnsync/svnsync.c:1765 ../svnsync/svnsync.c:1809
#, c-format
msgid "Path '%s' is not a URL"
src/subversion/subversion/po/de.po view on Meta::CPAN
msgid "Revision being currently copied (%ld), last merged revision (%ld), and destination HEAD (%ld) are inconsistent; have you committed to the destination without using svnsync?"
msgstr "Die aktuell kopierte Revision (%ld), zuletzt zusammengeführte Revision (%ld) und Ziel-HEAD (%ld) sind inkonsistent. Haben Sie in das Ziel ohne Verwendung von svnsync übertragen?"
#: ../svnsync/svnsync.c:1453
#, c-format
msgid "Destination HEAD (%ld) is not the last merged revision (%ld); have you committed to the destination without using svnsync?"
msgstr "Ziel-HEAD (%ld) ist nicht die zuletzt zusammengeführte Revision (%ld). Haben Sie in das Ziel ohne Verwendung von svnsync übertragen?"
#: ../svnsync/svnsync.c:1576 ../svnsync/svnsync.c:1581
#, c-format
msgid "Cannot copy revprops for a revision (%ld) that has not been synchronized yet"
msgstr "Kann keine Revisionseigenschaften für eine Revision (%ld) kopieren, die noch nicht synchronisiert wurde"
#: ../svnsync/svnsync.c:1645 ../svnsync/svnsync.c:1665
#, c-format
msgid "Invalid revision number (%ld)"
msgstr "Ungültige Revisionsnummer (%ld)"
#: ../svnsync/svnsync.c:1715
msgid "Cannot specify revisions via both command-line arguments and the --revision (-r) option"
msgstr "Revisionen dürfen nicht gleichzeitig durch Argumente in der Kommandozeile und die Option »--revision« (»-r«) angegeben werden"
#: ../svnsync/svnsync.c:1723 ../svnsync/svnsync.c:2066
#, c-format
msgid "Invalid revision range '%s' provided"
msgstr "Ungültiger Revisionsbereich »%s« angegeben"
#: ../svnsync/svnsync.c:1822
#, c-format
msgid "Repository '%s' is not initialized for synchronization"
msgstr "Das Projektarchiv »%s« ist für die Synchronisation nicht initialisiert"
#. Print the info.
#: ../svnsync/svnsync.c:1828
#, c-format
msgid "Source URL: %s\n"
msgstr "Quell-URL: %s\n"
#: ../svnsync/svnsync.c:1830
#, c-format
src/subversion/subversion/po/es.po view on Meta::CPAN
"\n"
" Use --force para romper el bloqueo.\n"
#: ../svn/main.c:1136
#, fuzzy
msgid ""
"Bring changes from the repository into the working copy.\n"
"usage: update [PATH...]\n"
"\n"
" If no revision is given, bring working copy up-to-date with HEAD rev.\n"
" Else synchronize working copy to revision given by -r.\n"
"\n"
" For each updated item a line will be printed with characters reporting\n"
" the action taken. These characters have the following meaning:\n"
"\n"
" A Added\n"
" D Deleted\n"
" U Updated\n"
" C Conflict\n"
" G Merged\n"
" E Existed\n"
src/subversion/subversion/po/es.po view on Meta::CPAN
#: ../svnserve/winservice.c:416
#, c-format
msgid "The service failed to start; an internal error occurred while starting the service"
msgstr "El servicio no pudo comenzar su ejecución; un error interno sucedió al intentarlo"
#: ../svnsync/main.c:85
#, fuzzy
msgid ""
"usage: svnsync initialize DEST_URL SOURCE_URL\n"
"\n"
"Initialize a destination repository for synchronization from\n"
"another repository.\n"
"\n"
"If the source URL is not the root of a repository, only the\n"
"specified part of the repository will be synchronized.\n"
"\n"
"The destination URL must point to the root of a repository which\n"
"has been configured to allow revision property changes. In\n"
"the general case, the destination repository must contain no\n"
"committed revisions. Use --allow-non-empty to override this\n"
"restriction, which will cause svnsync to assume that any revisions\n"
"already present in the destination repository perfectly mirror\n"
"their counterparts in the source repository. (This is useful\n"
"when initializing a copy of a repository as a mirror of that same\n"
"repository, for example.)\n"
src/subversion/subversion/po/es.po view on Meta::CPAN
"El URL de destino debe apuntar a la raÃz de un repositorio en el que\n"
"no se haya hecho commit de ninguna revisión. El repositorio destinodebe permitir el cambio de propiedades de revisión.\n"
"\n"
"No se debe hacer commit ni hacer cambios en propedades revisión en el\n"
"repositorio destino que no sea mediante el uso de 'svnsync'.\n"
"En otras palabras, el repositorio destino debe ser un espejo de\n"
"sólo-lectura del repositorio origen.\n"
#: ../svnsync/main.c:110
msgid ""
"usage: svnsync synchronize DEST_URL [SOURCE_URL]\n"
"\n"
"Transfer all pending revisions to the destination from the source\n"
"with which it was initialized.\n"
"\n"
"If SOURCE_URL is provided, use that as the source repository URL,\n"
"ignoring what is recorded in the destination repository as the\n"
"source URL. Specifying SOURCE_URL is recommended in particular\n"
"if untrusted users/administrators may have write access to the\n"
"DEST_URL repository.\n"
msgstr ""
src/subversion/subversion/po/es.po view on Meta::CPAN
"if untrusted users/administrators may have write access to the\n"
"DEST_URL repository.\n"
"\n"
"Form 2 is deprecated syntax, equivalent to specifying \"-rREV[:REV2]\".\n"
msgstr ""
#: ../svnsync/main.c:142
msgid ""
"usage: svnsync info DEST_URL\n"
"\n"
"Print information about the synchronization destination repository\n"
"located at DEST_URL.\n"
msgstr ""
#: ../svnsync/main.c:148
msgid ""
"usage: svnsync help [SUBCOMMAND...]\n"
"\n"
"Describe the usage of this program or its subcommands.\n"
msgstr ""
"uso: svnsync help [SUBCOMANDO...]\n"
src/subversion/subversion/po/es.po view on Meta::CPAN
#, c-format
msgid "NOTE: Normalized %s* properties to LF line endings (%d rev-props, %d node-props).\n"
msgstr ""
#: ../svnsync/main.c:810
msgid "Destination repository already contains revision history; consider using --allow-non-empty if the repository's revisions are known to mirror their respective revisions in the source repository"
msgstr ""
#: ../svnsync/main.c:819
#, c-format
msgid "Destination repository is already synchronizing from '%s'"
msgstr "El repositorio destino ya está sincronizándose desde '%s'"
#: ../svnsync/main.c:854
#, fuzzy
msgid "Destination repository has more revisions than source repository"
msgstr "El repositorio destino no fue inicializado"
#: ../svnsync/main.c:918 ../svnsync/main.c:921 ../svnsync/main.c:1425
#: ../svnsync/main.c:1432 ../svnsync/main.c:1667 ../svnsync/main.c:1670
#: ../svnsync/main.c:1712
src/subversion/subversion/po/es.po view on Meta::CPAN
msgid "Revision being currently copied (%ld), last merged revision (%ld), and destination HEAD (%ld) are inconsistent; have you committed to the destination without using svnsync?"
msgstr "La revisión que se está copiando (%ld), la última incorporada (%ld), y la HEAD del destino (%ld) son inconsistentes; ¿hizo usted commit en el repositorio destino sin usar svnsync?"
#: ../svnsync/main.c:1360
#, c-format
msgid "Destination HEAD (%ld) is not the last merged revision (%ld); have you committed to the destination without using svnsync?"
msgstr "La revisión HEAD del destino (%ld) no es la última incorporada (%ld); ¿hizo usted commit en el repositorio destino sin usar svnsync?"
#: ../svnsync/main.c:1482 ../svnsync/main.c:1487
#, c-format
msgid "Cannot copy revprops for a revision (%ld) that has not been synchronized yet"
msgstr "No se pueden copiar revprops de una revisión (%ld) que no todavÃa no se sincronizó"
#: ../svnsync/main.c:1550 ../svnsync/main.c:1570
#, c-format
msgid "Invalid revision number (%ld)"
msgstr "Número de revisión inválido (%ld)"
#: ../svnsync/main.c:1620
msgid "Cannot specify revisions via both command-line arguments and the --revision (-r) option"
msgstr ""
#: ../svnsync/main.c:1628 ../svnsync/main.c:1961
#, fuzzy, c-format
msgid "Invalid revision range '%s' provided"
msgstr "Se especificó un número de revisión inválido"
#: ../svnsync/main.c:1724
#, c-format
msgid "Repository '%s' is not initialized for synchronization"
msgstr "El repositorio '%s' no está inicializado para sincronización"
#. Print the info.
#: ../svnsync/main.c:1733
#, c-format
msgid "Source URL: %s\n"
msgstr "URL origen: %s\n"
#: ../svnsync/main.c:1735
#, c-format
src/subversion/subversion/po/es.po view on Meta::CPAN
#~ " presente: %s\n"
#~ msgid ""
#~ "\n"
#~ "\n"
#~ msgstr ""
#~ "\n"
#~ "\n"
#~ msgid ""
#~ "usage: svnsync synchronize DEST_URL\n"
#~ "\n"
#~ "Transfer all pending revisions to the destination from the source\n"
#~ "with which it was initialized.\n"
#~ msgstr ""
#~ "uso: svnsync synchronize URL_DEST\n"
#~ "\n"
#~ "Transfiere todas las revisiones pendientes al destino desde la fuente\n"
#~ "con la que éste fue inicializado.\n"
#~ msgid "Can't find entry '%s' in '%s'"
#~ msgstr "No se puede encontrar la entrada '%s' en '%s'"
#~ msgid "Non-string as part of text delta"
#~ msgstr "Parte del delta de texto no es una cadena"
src/subversion/subversion/po/es.po view on Meta::CPAN
#~ msgid "Move will not be attempted unless forced"
#~ msgstr "El mover no se llevará a cabo a menos que se fuerce la operación"
#~ msgid "Error replacing text-base of '%s'"
#~ msgstr "Error reemplazando el archivo base de '%s'"
#~ msgid "'%s' is neither a file nor a directory"
#~ msgstr "'%s' no es ni un archivo ni un directorio"
#~ msgid "The url to synchronize from"
#~ msgstr "El url desde el cual sincronizar"
#~ msgid "Unable to determine merge source for '%s' -- please provide an explicit source"
#~ msgstr "No se pudo determinar la fuente de la fusión para '%s' -- por favor provéala explÃcitamente"
#~ msgid "Error restoring props for '%s'"
#~ msgstr "Error restituyendo propiedades de '%s'"
#~ msgid "Destination URLs are broken"
#~ msgstr "Los URLs destino están rotos"
src/subversion/subversion/po/fr.po view on Meta::CPAN
" Subversion does support merging from foreign repositories.\n"
" While all merge source URLs must point to the same repository, the merge\n"
" target working copy may come from a different repository than the source.\n"
" However, there are some caveats. Most notably, copies made in the\n"
" merge source will be transformed into plain additions in the merge\n"
" target. Also, merge-tracking is not supported for merges from foreign\n"
" repositories.\n"
msgstr ""
"Applique les différences entre deux sources à une copie de travail.\n"
"usage : 1. merge SOURCE[@REV] [CHEMIN_CT_CIBLE]\n"
" (fusion de synchronisation)\n"
" 2. merge [-c M[,N...] | -r N:M ...] SOURCE[@REV] [CHEMIN_CT_CIBLE]\n"
" (fusion cueillette)\n"
" 3. merge --reintegrate SOURCE[@REV] [CHEMIN_CT_CIBLE]\n"
" (fusion de réintégration)\n"
" 4. merge SOURCE1[@N] SOURCE2[@M] [CHEMIN_CT_CIBLE]\n"
" (fusion bi-URL)\n"
"\n"
" 1. La première forme est appelée \"synchronisation\" ou \"mise à jour\" :\n"
" Elle permet de fusionner dans une branche toutes les modifications\n"
" opérées sur son ancêtre immédiat.\n"
" svn merge SOURCE[@REV] [CHEMIN_CT_CIBLE]\n"
"\n"
" Une fusion de synchronisation récupère les dernières modifications\n"
" de la branche parente. En d'autres mots, la branche cible a été créée\n"
" en copiant une branche source, et toutes les modifications propagées\n"
" depuis sur cette source sont appliquée à la branche cible. Cette forme\n"
" utilise le suivi des fusions pour connaître les modifications déjà \n"
" incluses, donc cette opérations peut être répétée périodiquement pour\n"
" rester synchroniser par rapport à la branche source.\n"
"\n"
" SOURCE spécifie la branche à partir de laquelle les modifications vont\n"
" être récupérées, et CHEMIN_CT_CIBLE précise le chemin dans la copie\n"
" de travail vers lequel les modifications vont être appliquées.\n"
" Normallement les deux côtés doivent correspondre à la racine d'une branche.\n"
" (Si vous voulez fusionner seulement un sous-arbre, alors son chemin doit\n"
" être inclu dans SOURCE et CHEMIN_CT_CIBLE ; Cette usage est déconseillé\n"
" pour éviter des informations de fusion par sous-arbre.)\n"
"\n"
" SOURCE est habituellement une URL. Si REV est spécifiée, elle est utilisée\n"
" à la fois pour fixer SOURCE, i.e. SOURCE est cherché dans le dépôt à la\n"
" révision REV, et la fusion est jusqu'à cette révision. Si REV n'est pas\n"
" spécifiée, la dernière révision (HEAD) est prise. Si SOURCE est un chemin\n"
" dans la copie de travail, la révision de base (en générale celle de la\n"
" dernière mise à jour, i.e. \"svn up\") est utilisée.\n"
"\n"
" CHEMIN_CT_CIBLE est un chemin dans la copie de travail. Si l'argument\n"
" est absent, le répertoire courant '.' est utilisé.\n"
"\n"
" - Exemple de fusion de synchronisation -\n"
"\n"
" Une fonctionnalité est développée dans une branche \"fonction\".\n"
" Cette branche est régulièrement synchronisée avec le tronc (trunk) pour\n"
" rester à jour vis-à -vis des modifications qui y sont effectuées.\n"
"\n"
" fonction +----------------------o-----\n"
" / ^\n"
" / |\n"
" / ............. /\n"
" / / .\n"
" trunk -----+-----------G--------------D------\n"
" r100 r200\n"
"\n"
src/subversion/subversion/po/fr.po view on Meta::CPAN
" vers le tronc.\n"
"\n"
"\n"
" fonction +-------------------------------D\n"
" / . \\\n"
" / .............. \\\n"
" / . v\n"
" trunk ------+------------------G-------------------o\n"
" rW rX\n"
"\n"
" La branche \"fonction\" a été synchronisée avec son ancêtre immédiat à \n"
" la révision X. Les différences entre trunk@X et fonction@HEAD (tête)\n"
" implémentent juste la fonctionnalité et doivent être réintégrées au tronc.\n"
"\n"
" Dans le diagramme ci-dessus, G marque la partie gauche de la fusion\n"
" (trunk@X), et D la partie droite (fonction@HEAD). La différence doit\n"
" être fusionnée dans la cible.\n"
"\n"
" Pour effectuer la fusion, extraire une copie de travail du tronc (trunk),\n"
" et lancer la commande suivante sur le répertoire le plus haut de la copie\n"
" de travail :\n"
"\n"
" svn merge --reintegrate ^/fonction\n"
"\n"
" Pour éviter les conflits superflus, les fusions de réintégration requièrent\n"
" que CHEMIN_CT_CIBLE soit bien à jour, sans révisions mélangées,\n"
" modifications locales ou sous-répertoires basculés (switch).\n"
"\n"
" Les fusions de réintégration requièrent aussi que la source soit\n"
" complètement synchronisée avec la cible depuis leur point de branchement\n"
" commun. Dans l'exemple ci-dessus, cela implique que toutes les\n"
" modifications du tronc (W:X) ont été fusionnées dans la branche avant\n"
" de pouvoir faire une réintégration.\n"
"\n"
" Après une réintégration, la branche \"fonction\" ne peut *plus* être\n"
" synchronisée avec le tronc sans risques de conflits. Il est donc\n"
" préférable de recréer la branche après sa réintégration.\n"
"\n"
"\n"
" 4. La quatrième forme opère à partir de deux URLs.\n"
"\n"
" svn merge SOURCE1[@N] SOURCE2[@M] [CHEMIN_CT_CIBLE]\n"
"\n"
" Les deux sources spécifiées par les URLS sont comparées, et les\n"
" différences sont appliquées à la destination dans la copie de travail.\n"
"\n"
src/subversion/subversion/po/fr.po view on Meta::CPAN
" Si CHEMIN_CT_CIBLE n'est pas spécifié, '.' est utilisé, sauf si les\n"
" sources désignent un nom de fichier qui est dans le répertoire courant,\n"
" auquel cas les différences sont appliquées à ce répertoire.\n"
"\n"
" Les sources peuvent être des chemins dans la copie de travail, auquel\n"
" cas les URLs correspondantes sont considérées.\n"
"\n"
" Cette version de \"merge\" est la plus flexible, mais aussi la plus délicate\n"
" à utiliser. On peut en effet désigner des branches complètement\n"
" différentes. La probabilité de conflits est élevée. Dans la plupart des\n"
" cas, la synchronisation, la cueillette et la réintégration suffisent et\n"
" réduisent les risques d'erreurs.\n"
"\n"
" - Exemple de fusion à deux URLs -\n"
"\n"
" Une fonctionnalité est développée dans une branche \"fonction\".\n"
" En parallèle, la prochaine version du logiciel est développée, dans une\n"
" branche indépendante, et on souhaite y intégrer la nouvelle fonctionnalité.\n"
"\n"
" 3.x-release +-----------------------------------o\n"
" / ^\n"
" / /\n"
" / /\n"
" trunk ------+------+-----------------G> /\n"
" \\\\ . /\n"
" \\\\ ........... /\n"
" \\\\ . /\n"
" fonction +-----------------------------------D\n"
"\n"
" La branche \"fonction\" est synchronisée avec le \"trunk\", de manière\n"
" à ce que les différences entre trunk@TÊTE (G) et fonction@TÊTE (D)\n"
" implémentent juste la fonctionnalité. Ces développement sont\n"
" intégrés à la nouvelle version (3.x-release) avec la commande :\n"
"\n"
" svn merge ^/trunk ^/fonction\n"
"\n"
"\n"
" Avant ce type de fusion, il est pertinent de jeter un coup d'oeil sur\n"
" les modifications qui vont être appliquées, ce qui peut-être fait avec\n"
" la commande \"diff\" :\n"
src/subversion/subversion/po/fr.po view on Meta::CPAN
" E Existait\n"
" R Remplacé\n"
"\n"
" Ces caractères en première colonne désignent l'objet lui-même, en seconde\n"
" ses propriétés. Un 'C' en troisième colonne désigne un conflit\n"
" d'arborescence.\n"
"\n"
" NOTE : Subversion utilise la propriété svn:mergeinfo pour garder trace de\n"
" l'historique des fusions. Elle est utilisée pour déterminer quelles fusions\n"
" sont nécessaires, mais uniquement si les deux branches ont un ancêtre commun.\n"
" C'est toujours le cas avec les synchronisations ou les réintégrations.\n"
" L'option --ignore-ancestry ignore ces informations et empêche de garder\n"
" les traces des fusions effectuées.\n"
"\n"
" L'option --ignore-ancestry permet d'ignorer complètement le suivi des\n"
" révisions (propriétés svn:mergeinfo).\n"
"\n"
" - Fusion à partir d'autres dépôts -\n"
"\n"
" Subversion permet de fusionner à partir d'autres dépôts que le dépôt\n"
" de la branche. Si les deux URL doivent pointer vers le même dépôt, la\n"
src/subversion/subversion/po/fr.po view on Meta::CPAN
"usage : unlock CIBLE...\n"
"\n"
" Utiliser --force pour casser le verrou.\n"
#: ../svn/main.c:1493
msgid ""
"Bring changes from the repository into the working copy.\n"
"usage: update [PATH...]\n"
"\n"
" If no revision is given, bring working copy up-to-date with HEAD rev.\n"
" Else synchronize working copy to revision given by -r.\n"
"\n"
" For each updated item a line will be printed with characters reporting\n"
" the action taken. These characters have the following meaning:\n"
"\n"
" A Added\n"
" D Deleted\n"
" U Updated\n"
" C Conflict\n"
" G Merged\n"
" E Existed\n"
src/subversion/subversion/po/fr.po view on Meta::CPAN
#: ../svnserve/winservice.c:416
#, c-format
msgid "The service failed to start; an internal error occurred while starting the service"
msgstr "Échec au démarrage du service ; une erreur interne est intervenue"
#: ../svnsync/main.c:88
msgid ""
"usage: svnsync initialize DEST_URL SOURCE_URL\n"
"\n"
"Initialize a destination repository for synchronization from\n"
"another repository.\n"
"\n"
"If the source URL is not the root of a repository, only the\n"
"specified part of the repository will be synchronized.\n"
"\n"
"The destination URL must point to the root of a repository which\n"
"has been configured to allow revision property changes. In\n"
"the general case, the destination repository must contain no\n"
"committed revisions. Use --allow-non-empty to override this\n"
"restriction, which will cause svnsync to assume that any revisions\n"
"already present in the destination repository perfectly mirror\n"
"their counterparts in the source repository. (This is useful\n"
"when initializing a copy of a repository as a mirror of that same\n"
"repository, for example.)\n"
"\n"
"You should not commit to, or make revision property changes in,\n"
"the destination repository by any method other than 'svnsync'.\n"
"In other words, the destination repository should be a read-only\n"
"mirror of the source repository.\n"
msgstr ""
"usage : svnsync initialize DEST_URL SOURCE_URL\n"
"\n"
"Initialise un dépôt destination pour être synchronisé à partir\n"
"d'un autre dépôt.\n"
"\n"
"Si l'URL source n'est pas la racine d'un dépôt, seule la partie spécifiée\n"
"sera synchronisée.\n"
"\n"
"L'URL destination doit pointer sur la racine d'un dépôt qui autorise les\n"
"modifications des propriétés de révisions. Dans le cas général, le dépôt\n"
"destination ne doit pas contenir de révisions propagées (commit). Utilisez\n"
"l'option --allow-non-empty pour ignorer cette restriction. \"svnsync\" supposera\n"
"alors que les révisions déjà présentent dans le dépôt destination dupliquent\n"
"celles correspondantes du dépôt source. (Ce peut être utile pour initialiser\n"
"une copie d'un dépôt comme un mirroir du même dépôt, par exemple).\n"
"\n"
"Vous ne devez propager vers ou modifier des propriétés de révisions\n"
"du dépôt destination qu'avec 'svnsync'. Autrement dit, le dépôt\n"
"destination doit être un mirroir en lecture seule du dépôt source.\n"
#: ../svnsync/main.c:114
msgid ""
"usage: svnsync synchronize DEST_URL [SOURCE_URL]\n"
"\n"
"Transfer all pending revisions to the destination from the source\n"
"with which it was initialized.\n"
"\n"
"If SOURCE_URL is provided, use that as the source repository URL,\n"
"ignoring what is recorded in the destination repository as the\n"
"source URL. Specifying SOURCE_URL is recommended in particular\n"
"if untrusted users/administrators may have write access to the\n"
"DEST_URL repository.\n"
msgstr ""
"Usage : svnsync synchronize URL_DEST [URL_SOURCE]\n"
"\n"
"Tranfère toutes les révisions en attente vers la destination à partir\n"
"de la source avec laquelle elles ont été initialisées.\n"
"\n"
"Si URL_SOURCE est fournie, utilise cette URL comme source, en ignorant\n"
"donc l'initiale. Spécifier l'URL source est recommandé en particulier si\n"
"des utilisateurs ou administrateurs non fiables peuvent avoir accès en\n"
"écriture au dépôt de l'URL destination.\n"
#: ../svnsync/main.c:127
src/subversion/subversion/po/fr.po view on Meta::CPAN
"révision n'est pas spécifié, toutes les révisions de URL_DEST sont recopiées.\n"
"Noter aussi que la révision 'HEAD' est la dernière dans URL_DEST, pas\n"
"nécessairement dans URL_SOURCE.\n"
"\n"
"La seconde forme est dépréciée, équivalente à spécifier \"-rREV:REV2\".\n"
#: ../svnsync/main.c:148
msgid ""
"usage: svnsync info DEST_URL\n"
"\n"
"Print information about the synchronization destination repository\n"
"located at DEST_URL.\n"
msgstr ""
"usage : svnsync info URL_DEST\n"
"\n"
"Affiche les informations du dépôt destination d'une synchronisation\n"
"Ã URL_DEST.\n"
#: ../svnsync/main.c:154
msgid ""
"usage: svnsync help [SUBCOMMAND...]\n"
"\n"
"Describe the usage of this program or its subcommands.\n"
msgstr ""
"usage : svnsync help [SOUS_COMMANDE...]\n"
"\n"
src/subversion/subversion/po/fr.po view on Meta::CPAN
#: ../svnsync/main.c:194
msgid "connect to source repository with username ARG"
msgstr "se connecte au dépôt source avec le login ARG"
#: ../svnsync/main.c:196
msgid "connect to source repository with password ARG"
msgstr "se connecte au dépôt source avec le mot de passe ARG"
#: ../svnsync/main.c:198
msgid "connect to sync repository with username ARG"
msgstr "se connecte au dépôt synchronisé avec le login ARG"
#: ../svnsync/main.c:200
msgid "connect to sync repository with password ARG"
msgstr "se connecte au dépôt synchronisé avec le mot de passe ARG"
#: ../svnsync/main.c:212
msgid ""
"convert translatable properties from encoding ARG\n"
" to UTF-8. If not specified, then properties are\n"
" presumed to be encoded in UTF-8."
msgstr ""
"conversion des propriétés de l'encodage ARG à UTF-8.\n"
" Si non spécifié, les propriétés sont présumées encodées en UTF-8."
src/subversion/subversion/po/fr.po view on Meta::CPAN
#, c-format
msgid "NOTE: Normalized %s* properties to LF line endings (%d rev-props, %d node-props).\n"
msgstr "Note : normalisation des fins de lignes des propriétés %s* (%d de révisions, %d de nœuds).\n"
#: ../svnsync/main.c:742
msgid "Destination repository already contains revision history; consider using --allow-non-empty if the repository's revisions are known to mirror their respective revisions in the source repository"
msgstr "Le dépôt destination contient déjà des révisions ; utilisez éventuellement l'option --allow-non-empty si ces révisions correspondent à leurs contreparties dans le dépôt source"
#: ../svnsync/main.c:751
#, c-format
msgid "Destination repository is already synchronizing from '%s'"
msgstr "Le dépôt destination est déjà synchronisé à partir de '%s'"
#: ../svnsync/main.c:786
msgid "Destination repository has more revisions than source repository"
msgstr "Le dépôt destination a plus de révisions que le dépôt origine"
#: ../svnsync/main.c:851 ../svnsync/main.c:854 ../svnsync/main.c:1512
#: ../svnsync/main.c:1519 ../svnsync/main.c:1756 ../svnsync/main.c:1759
#: ../svnsync/main.c:1803
#, c-format
msgid "Path '%s' is not a URL"
src/subversion/subversion/po/fr.po view on Meta::CPAN
msgid "Revision being currently copied (%ld), last merged revision (%ld), and destination HEAD (%ld) are inconsistent; have you committed to the destination without using svnsync?"
msgstr "La révision en cours de copie (%ld), la dernière révision fusionnée (%ld), et la révision de tête de la destination (%ld) sont incohérentes. Auriez-vous propagé vers la destination sans utiliser 'svnsync' ?"
#: ../svnsync/main.c:1447
#, c-format
msgid "Destination HEAD (%ld) is not the last merged revision (%ld); have you committed to the destination without using svnsync?"
msgstr "La révisions de tête (HEAD) de la destination (%ld) n'est pas la même que la dernière révision fusionnée (%ld). Auriez-vous propagé vers la destination sans utiliser 'svnsync' ?"
#: ../svnsync/main.c:1570 ../svnsync/main.c:1575
#, c-format
msgid "Cannot copy revprops for a revision (%ld) that has not been synchronized yet"
msgstr "Impossible de copier les propriétés de révision d'une révision (%ld) non encore synchronisée"
#: ../svnsync/main.c:1639 ../svnsync/main.c:1659
#, c-format
msgid "Invalid revision number (%ld)"
msgstr "Numéro de révision invalide (%ld)"
#: ../svnsync/main.c:1709
msgid "Cannot specify revisions via both command-line arguments and the --revision (-r) option"
msgstr ""
"Impossible de spécifier les révisions à la fois en argument de la ligne de\n"
"commande et avec l'option --revision (-r)"
#: ../svnsync/main.c:1717 ../svnsync/main.c:2057
#, c-format
msgid "Invalid revision range '%s' provided"
msgstr "Intervalle de révision donné '%s' invalide"
#: ../svnsync/main.c:1817
#, c-format
msgid "Repository '%s' is not initialized for synchronization"
msgstr "Le dépôt '%s' n'est pas initialisé pour une synchronisation"
#. Print the info.
#: ../svnsync/main.c:1825
#, c-format
msgid "Source URL: %s\n"
msgstr "URL source : %s\n"
#: ../svnsync/main.c:1827
#, c-format
msgid "Source Repository UUID: %s\n"
src/subversion/subversion/po/it.po view on Meta::CPAN
"\n"
"Usa --force per forzare il blocco.\n"
#: ../svn/main.c:1136
#, fuzzy
msgid ""
"Bring changes from the repository into the working copy.\n"
"usage: update [PATH...]\n"
"\n"
" If no revision is given, bring working copy up-to-date with HEAD rev.\n"
" Else synchronize working copy to revision given by -r.\n"
"\n"
" For each updated item a line will be printed with characters reporting\n"
" the action taken. These characters have the following meaning:\n"
"\n"
" A Added\n"
" D Deleted\n"
" U Updated\n"
" C Conflict\n"
" G Merged\n"
" E Existed\n"
src/subversion/subversion/po/it.po view on Meta::CPAN
#: ../svnserve/winservice.c:416
#, c-format
msgid "The service failed to start; an internal error occurred while starting the service"
msgstr "Impossibile avviare il servizio; si è verificato un errore interno"
#: ../svnsync/main.c:85
#, fuzzy
msgid ""
"usage: svnsync initialize DEST_URL SOURCE_URL\n"
"\n"
"Initialize a destination repository for synchronization from\n"
"another repository.\n"
"\n"
"If the source URL is not the root of a repository, only the\n"
"specified part of the repository will be synchronized.\n"
"\n"
"The destination URL must point to the root of a repository which\n"
"has been configured to allow revision property changes. In\n"
"the general case, the destination repository must contain no\n"
"committed revisions. Use --allow-non-empty to override this\n"
"restriction, which will cause svnsync to assume that any revisions\n"
"already present in the destination repository perfectly mirror\n"
"their counterparts in the source repository. (This is useful\n"
"when initializing a copy of a repository as a mirror of that same\n"
"repository, for example.)\n"
src/subversion/subversion/po/it.po view on Meta::CPAN
"revisioni già committate. Inoltre devono essere consentite le modifiche \n"
"alle proprietà delle revisioni.\n"
"\n"
"Tutti i commit o le modifiche alle proprietà di revisione nel\n"
"repository di destinazione devono essere effettuati con 'svnsync'.\n"
"In altre parole, il repository di destinazione è come una copia\n"
"di sola lettura del repository di origine.\n"
#: ../svnsync/main.c:110
msgid ""
"usage: svnsync synchronize DEST_URL [SOURCE_URL]\n"
"\n"
"Transfer all pending revisions to the destination from the source\n"
"with which it was initialized.\n"
"\n"
"If SOURCE_URL is provided, use that as the source repository URL,\n"
"ignoring what is recorded in the destination repository as the\n"
"source URL. Specifying SOURCE_URL is recommended in particular\n"
"if untrusted users/administrators may have write access to the\n"
"DEST_URL repository.\n"
msgstr ""
src/subversion/subversion/po/it.po view on Meta::CPAN
"if untrusted users/administrators may have write access to the\n"
"DEST_URL repository.\n"
"\n"
"Form 2 is deprecated syntax, equivalent to specifying \"-rREV[:REV2]\".\n"
msgstr ""
#: ../svnsync/main.c:142
msgid ""
"usage: svnsync info DEST_URL\n"
"\n"
"Print information about the synchronization destination repository\n"
"located at DEST_URL.\n"
msgstr ""
#: ../svnsync/main.c:148
msgid ""
"usage: svnsync help [SUBCOMMAND...]\n"
"\n"
"Describe the usage of this program or its subcommands.\n"
msgstr ""
"uso: svnsync help [SOTTOCOMANDO...]\n"
src/subversion/subversion/po/it.po view on Meta::CPAN
#, c-format
msgid "NOTE: Normalized %s* properties to LF line endings (%d rev-props, %d node-props).\n"
msgstr ""
#: ../svnsync/main.c:810
msgid "Destination repository already contains revision history; consider using --allow-non-empty if the repository's revisions are known to mirror their respective revisions in the source repository"
msgstr ""
#: ../svnsync/main.c:819
#, c-format
msgid "Destination repository is already synchronizing from '%s'"
msgstr "Il repository di destinazione si sta già sincronizzando con '%s'"
#: ../svnsync/main.c:854
#, fuzzy
msgid "Destination repository has more revisions than source repository"
msgstr "Il repository di destinazione non è stato inizializzato"
#: ../svnsync/main.c:918 ../svnsync/main.c:921 ../svnsync/main.c:1425
#: ../svnsync/main.c:1432 ../svnsync/main.c:1667 ../svnsync/main.c:1670
#: ../svnsync/main.c:1712
src/subversion/subversion/po/it.po view on Meta::CPAN
#: ../svnsync/main.c:1360
#, c-format
msgid "Destination HEAD (%ld) is not the last merged revision (%ld); have you committed to the destination without using svnsync?"
msgstr ""
"La destinazione HEAD (%ld) non è l'ultima revisione fusa (%ld);\n"
"hai eseguito il commit alla verso la destinazione senza usare \n"
"svnsync?"
#: ../svnsync/main.c:1482 ../svnsync/main.c:1487
#, c-format
msgid "Cannot copy revprops for a revision (%ld) that has not been synchronized yet"
msgstr "Non posso copiare revprops per una revisione (%ld) che non è stata ancora sincronizzata"
#: ../svnsync/main.c:1550 ../svnsync/main.c:1570
#, c-format
msgid "Invalid revision number (%ld)"
msgstr "Numero di revisione non valido (%ld)"
#: ../svnsync/main.c:1620
msgid "Cannot specify revisions via both command-line arguments and the --revision (-r) option"
msgstr ""
#: ../svnsync/main.c:1628 ../svnsync/main.c:1961
#, fuzzy, c-format
msgid "Invalid revision range '%s' provided"
msgstr "Numero di revisione fornito non valido"
#: ../svnsync/main.c:1724
#, fuzzy, c-format
msgid "Repository '%s' is not initialized for synchronization"
msgstr "Per questa operazione è richiesto l'accesso al repository"
#. Print the info.
#: ../svnsync/main.c:1733
#, fuzzy, c-format
msgid "Source URL: %s\n"
msgstr " Percorso di origine: '%s'\n"
#: ../svnsync/main.c:1735
#, fuzzy, c-format
src/subversion/subversion/po/it.po view on Meta::CPAN
#~ msgid "Corrupt working copy: '%s' in directory '%s' (which is scheduled for replacement) has an invalid schedule"
#~ msgstr "Copia locale corrotta: '%s' nella directory '%s' (che è programmata per la sostituzione) ha una programmazione non valida"
#~ msgid "run as a windows service (SCM only)"
#~ msgstr "esegui come servizio Windows (solo SCM)"
#~ msgid "Corrupt working copy: '%s' in directory '%s' (which is scheduled for addition) is not itself scheduled for addition"
#~ msgstr "Copia locale corrotta: '%s' nella directory '%s' (che è pronta per essere aggiunta) non è a sua volta destinato ad essere aggiunto"
#~ msgid ""
#~ "usage: svnsync synchronize DEST_URL\n"
#~ "\n"
#~ "Transfer all pending revisions to the destination from the source\n"
#~ "with which it was initialized.\n"
#~ msgstr ""
#~ "utilizzo: svnsync synchronize URL_DEST\n"
#~ "\n"
#~ "Trasferisce tutte le revisioni ancora in corso dalla sorgente alla destinazione.\n"
#~ msgid "Corrupt working copy: directory '%s' has an invalid schedule"
#~ msgstr "Copia locale corrotta: la directory '%s' ha una programmazione non valida"
#~ msgid ""
#~ "usage: svnsync copy-revprops DEST_URL [REV[:REV2]]\n"
#~ "\n"
#~ "Copy the revision properties in a given range of revisions to the\n"
( run in 0.391 second using v1.01-cache-2.11-cpan-0d8aa00de5b )