← Back to branch summary

~svn/ubuntu/raring/subversion/ppa

« back to all changes in this revision

Viewing changes to subversion/bindings/java/javahl/src/org/tigris/subversion/javahl/SVNClientSynchronized.java

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-12-05 01:26:14 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051205012614-qom4xfypgtsqc2xq
Tags: 1.2.3dfsg1-3ubuntu1
Merge with the final Debian release of 1.2.3dfsg1-3, bringing in
fixes to the clean target, better documentation of the libdb4.3
upgrade and build fixes to work with swig1.3_1.3.27.

Show diffs side-by-side

added added

removed removed

Lines of Context:
subversion/bindings/java/javahl/src/org/tigris/subversion/javahl/SVNClientSynchronized.java
 
1
/**
 
2
 * @copyright
 
3
 * ====================================================================
 
4
 * Copyright (c) 2003-2004 CollabNet.  All rights reserved.
 
5
 *
 
6
 * This software is licensed as described in the file COPYING, which
 
7
 * you should have received as part of this distribution.  The terms
 
8
 * are also available at http://subversion.tigris.org/license-1.html.
 
9
 * If newer versions of this license are posted there, you may use a
 
10
 * newer version instead, at your option.
 
11
 *
 
12
 * This software consists of voluntary contributions made by many
 
13
 * individuals.  For exact contribution history, see the revision
 
14
 * history and logs, available at http://subversion.tigris.org/.
 
15
 * ====================================================================
 
16
 * @endcopyright
 
17
 */
 
18
package org.tigris.subversion.javahl;
 
19
/**
 
20
 * This class provides a threadsafe wrapped for SVNClient
 
21
 */
 
22
public class SVNClientSynchronized implements SVNClientInterface
 
23
{
 
24
    /**
 
25
     * the wrapped object, which does all the work
 
26
     */
 
27
    private SVNClient worker;
 
28
 
 
29
    /**
 
30
     * our class, we synchronize on that.
 
31
     */
 
32
    static private Class clazz = SVNClientSynchronized.class;
 
33
 
 
34
    /**
 
35
     * Create our worker
 
36
     */
 
37
    public SVNClientSynchronized()
 
38
    {
 
39
        worker = new SVNClient();
 
40
    }
 
41
 
 
42
    /**
 
43
     * release the native peer (should not depend on finalize)
 
44
     */
 
45
    public void dispose()
 
46
    {
 
47
        worker.dispose();
 
48
    }
 
49
 
 
50
    /**
 
51
     * Returns the last destination path submitted.
 
52
     * @deprecated
 
53
     * @return path in Subversion format.
 
54
     */
 
55
    public String getLastPath()
 
56
    {
 
57
        synchronized(clazz)
 
58
        {
 
59
            return worker.getLastPath();
 
60
        }
 
61
    }
 
62
 
 
63
    /**
 
64
     * List a directory or file of the working copy.
 
65
     *
 
66
     * @param path      Path to explore.
 
67
     * @param descend   Recurse into subdirectories if existant.
 
68
     * @param onServer  Request status information from server.
 
69
     * @param getAll    get status for uninteristing files (unchanged).
 
70
     * @return Array of Status entries.
 
71
     */
 
72
    public Status[] status(String path, boolean descend, boolean onServer,
 
73
                           boolean getAll) throws ClientException
 
74
    {
 
75
        synchronized(clazz)
 
76
        {
 
77
            return worker.status(path, descend, onServer, getAll);
 
78
        }
 
79
    }
 
80
    /**
 
81
     * List a directory or file of the working copy.
 
82
     *
 
83
     * @param path      Path to explore.
 
84
     * @param descend   Recurse into subdirectories if existant.
 
85
     * @param onServer  Request status information from server.
 
86
     * @param getAll    get status for uninteristing files (unchanged).
 
87
     * @param noIgnore  get status for normaly ignored files and directories.
 
88
     * @return Array of Status entries.
 
89
     */
 
90
    public Status[] status(String path, boolean descend, boolean onServer,
 
91
                           boolean getAll, boolean noIgnore)
 
92
            throws ClientException
 
93
    {
 
94
        synchronized(clazz)
 
95
        {
 
96
            return worker.status(path, descend, onServer, getAll, noIgnore);
 
97
        }
 
98
    }
 
99
 
 
100
    /**
 
101
     * List a directory or file of the working copy.
 
102
     *
 
103
     * @param path            Path to explore.
 
104
     * @param descend         Recurse into subdirectories if existant.
 
105
     * @param onServer        Request status information from server.
 
106
     * @param getAll          get status for uninteristing files (unchanged).
 
107
     * @param noIgnore        get status for normaly ignored files and
 
108
     *                        directories.
 
109
     * @param ignoreExternals if externals are ignored during checkout
 
110
     * @return Array of Status entries.
 
111
     * @since 1.2
 
112
     */
 
113
    public Status[] status(String path, boolean descend, boolean onServer,
 
114
                           boolean getAll, boolean noIgnore,
 
115
                           boolean ignoreExternals) throws ClientException
 
116
    {
 
117
        synchronized(clazz)
 
118
        {
 
119
            return worker.status(path, descend, onServer, getAll, noIgnore,
 
120
                    ignoreExternals);
 
121
        }
 
122
    }
 
123
 
 
124
    /**
 
125
     * Lists the directory entries of an url on the server.
 
126
     * @param url       the url to list
 
127
     * @param revision  the revision to list
 
128
     * @param recurse   recurse into subdirectories
 
129
     * @return  Array of DirEntry objects.
 
130
     */
 
131
    public DirEntry[] list(String url, Revision revision, boolean recurse)
 
132
            throws ClientException
 
133
    {
 
134
        synchronized(clazz)
 
135
        {
 
136
            return worker.list(url, revision, recurse);
 
137
        }
 
138
    }
 
139
 
 
140
    /**
 
141
     * Lists the directory entries of an url on the server.
 
142
     *
 
143
     * @param url         the url to list
 
144
     * @param revision    the revision to list
 
145
     * @param pegRevision the revision to interpret url
 
146
     * @param recurse     recurse into subdirectories
 
147
     * @return Array of DirEntry objects.
 
148
     * @since 1.2
 
149
     */
 
150
    public DirEntry[] list(String url, Revision revision, Revision pegRevision,
 
151
                           boolean recurse) throws ClientException
 
152
    {
 
153
        synchronized(clazz)
 
154
        {
 
155
            return worker.list(url, revision, pegRevision, recurse);
 
156
        }
 
157
    }
 
158
 
 
159
    /**
 
160
     * Returns the status of a single file in the path.
 
161
     *
 
162
     * @param path      File to gather status.
 
163
     * @param onServer  Request status information from the server.
 
164
     * @return  the subversion status of the file.
 
165
     */
 
166
    public Status singleStatus(String path, boolean onServer) 
 
167
            throws ClientException
 
168
    {
 
169
        synchronized(clazz)
 
170
        {
 
171
            return worker.singleStatus(path, onServer);
 
172
        }
 
173
    }
 
174
    /**
 
175
     * Sets the username used for authentification.
 
176
     * @param username  the username
 
177
     */
 
178
    public void username(String username)
 
179
    {
 
180
        synchronized(clazz)
 
181
        {
 
182
            worker.username(username);
 
183
        }
 
184
    }
 
185
    /**
 
186
     * Sets the password used for authification.
 
187
     * @param password  the password
 
188
     */
 
189
    public void password(String password)
 
190
    {
 
191
        synchronized(clazz)
 
192
        {
 
193
            worker.password(password);
 
194
        }
 
195
    }
 
196
    /**
 
197
     * Register callback interface to supply username and password on demand
 
198
     * @param prompt the callback interface
 
199
     */
 
200
    public void setPrompt(PromptUserPassword prompt)
 
201
    {
 
202
        synchronized(clazz)
 
203
        {
 
204
            worker.setPrompt(prompt);
 
205
        }
 
206
    }
 
207
    /**
 
208
     * Retrieve the log messages for an item
 
209
     * @param path          path or url to get the log message for.
 
210
     * @param revisionStart first revision to show
 
211
     * @param revisionEnd   last revision to show
 
212
     * @return array of LogMessages
 
213
     */
 
214
    public LogMessage[] logMessages(String path, Revision revisionStart,
 
215
                                    Revision revisionEnd) throws ClientException
 
216
    {
 
217
        synchronized(clazz)
 
218
        {
 
219
            return worker.logMessages(path, revisionStart, revisionEnd, true,
 
220
                    false);
 
221
        }
 
222
    }
 
223
 
 
224
    /**
 
225
     * Retrieve the log messages for an item
 
226
     * @param path          path or url to get the log message for.
 
227
     * @param revisionStart first revision to show
 
228
     * @param revisionEnd   last revision to show
 
229
     * @param stopOnCopy    do not continue on copy operations
 
230
     * @return array of LogMessages
 
231
     */
 
232
    public LogMessage[] logMessages(String path, Revision revisionStart,
 
233
                                    Revision revisionEnd, boolean stopOnCopy)
 
234
            throws ClientException
 
235
    {
 
236
        synchronized(clazz)
 
237
        {
 
238
            return worker.logMessages(path, revisionStart, revisionEnd,
 
239
                    stopOnCopy, false);
 
240
        }
 
241
    }
 
242
 
 
243
    /**
 
244
     * Retrieve the log messages for an item
 
245
     * @param path          path or url to get the log message for.
 
246
     * @param revisionStart first revision to show
 
247
     * @param revisionEnd   last revision to show
 
248
     * @param stopOnCopy    do not continue on copy operations
 
249
     * @param discoverPath  returns the paths of the changed items in the
 
250
     *                      returned objects
 
251
     * @return array of LogMessages
 
252
     */
 
253
    public LogMessage[] logMessages(String path, Revision revisionStart,
 
254
                                    Revision revisionEnd, boolean stopOnCopy,
 
255
                                    boolean discoverPath)
 
256
            throws ClientException
 
257
    {
 
258
        synchronized(clazz)
 
259
        {
 
260
            return worker.logMessages(path, revisionStart, revisionEnd,
 
261
                    stopOnCopy, discoverPath);
 
262
        }
 
263
    }
 
264
 
 
265
    /**
 
266
     * Retrieve the log messages for an item
 
267
     * @param path          path or url to get the log message for.
 
268
     * @param revisionStart first revision to show
 
269
     * @param revisionEnd   last revision to show
 
270
     * @param stopOnCopy    do not continue on copy operations
 
271
     * @param discoverPath  returns the paths of the changed items in the
 
272
     *                      returned objects
 
273
     * @param limit         limit the number of log messages (if 0 or less no
 
274
     *                      limit)
 
275
     * @return array of LogMessages
 
276
     * @since 1.2
 
277
     */
 
278
    public LogMessage[] logMessages(String path, Revision revisionStart,
 
279
                                    Revision revisionEnd, boolean stopOnCopy,
 
280
                                    boolean discoverPath, long limit)
 
281
            throws ClientException
 
282
    {
 
283
        return worker.logMessages(path, revisionStart, revisionEnd,
 
284
                stopOnCopy, discoverPath, limit);
 
285
    }
 
286
 
 
287
    /**
 
288
     * Executes a revision checkout.
 
289
     * @param moduleName name of the module to checkout.
 
290
     * @param destPath destination directory for checkout.
 
291
     * @param revision the revision to checkout.
 
292
     * @param pegRevision the peg revision to interpret the path
 
293
     * @param recurse whether you want it to checkout files recursively.
 
294
     * @param ignoreExternals if externals are ignored during checkout
 
295
     * @exception ClientException
 
296
     * @since 1.2
 
297
     */
 
298
    public long checkout(String moduleName, String destPath, Revision revision,
 
299
                         Revision pegRevision, boolean recurse,
 
300
                         boolean ignoreExternals)
 
301
            throws ClientException
 
302
    {
 
303
        synchronized(clazz)
 
304
        {
 
305
            return worker.checkout(moduleName, destPath, revision, pegRevision,
 
306
                    recurse, ignoreExternals);
 
307
        }
 
308
    }
 
309
 
 
310
    /**
 
311
     * Executes a revision checkout.
 
312
     * @param moduleName name of the module to checkout.
 
313
     * @param destPath destination directory for checkout.
 
314
     * @param revision the revision to checkout.
 
315
     * @param recurse whether you want it to checkout files recursively.
 
316
     * @exception ClientException
 
317
     */
 
318
    public long checkout(String moduleName, String destPath, Revision revision,
 
319
                         boolean recurse)
 
320
            throws ClientException
 
321
    {
 
322
        synchronized(clazz)
 
323
        {
 
324
            return worker.checkout(moduleName, destPath, revision, recurse);
 
325
        }
 
326
    }
 
327
    /**
 
328
     * Sets the notification callback used to send processing information back
 
329
     * to the calling program.
 
330
     * @param notify listener that the SVN library should call on many
 
331
     *               file operations.
 
332
     * @deprecated use notification2 instead
 
333
     */
 
334
    public void notification(Notify notify)
 
335
    {
 
336
        synchronized(clazz)
 
337
        {
 
338
            worker.notification(notify);
 
339
        }
 
340
    }
 
341
 
 
342
    /**
 
343
     * Sets the notification callback used to send processing information back
 
344
     * to the calling program.
 
345
     *
 
346
     * @param notify listener that the SVN library should call on many
 
347
     *               file operations.
 
348
     * @since 1.2
 
349
     */
 
350
    public void notification2(Notify2 notify)
 
351
    {
 
352
        synchronized(clazz)
 
353
        {
 
354
            worker.notification2(notify);
 
355
        }
 
356
    }
 
357
 
 
358
    /**
 
359
     * Sets the commit message handler. This allows more complex commit message
 
360
     * with the list of the elements to be commited as input.
 
361
     * @param messageHandler    callback for entering commit messages
 
362
     *                          if this is set the message parameter is ignored.
 
363
     */
 
364
    public void commitMessageHandler(CommitMessage messageHandler)
 
365
    {
 
366
        synchronized(clazz)
 
367
        {
 
368
            worker.commitMessageHandler(messageHandler);
 
369
        }
 
370
    }
 
371
    /**
 
372
     * Sets a file for deletion.
 
373
     * @param path      path or url to be deleted
 
374
     * @param message   if path is a url, this will be the commit message.
 
375
     * @param force     delete even when there are local modifications.
 
376
     * @exception ClientException
 
377
     */
 
378
    public void remove(String[] path, String message, boolean force)
 
379
            throws ClientException
 
380
    {
 
381
        synchronized(clazz)
 
382
        {
 
383
            worker.remove(path, message, force);
 
384
        }
 
385
    }
 
386
    /**
 
387
     * Reverts a file to a pristine state.
 
388
     * @param path      path of the file.
 
389
     * @param recurse   recurse into subdirectories
 
390
     * @exception ClientException
 
391
     */
 
392
    public void revert(String path, boolean recurse) throws ClientException
 
393
    {
 
394
        synchronized(clazz)
 
395
        {
 
396
            worker.revert(path, recurse);
 
397
        }
 
398
    }
 
399
    /**
 
400
     * Adds a file to the repository.
 
401
     * @param path      path to be added.
 
402
     * @param recurse   recurse into subdirectories
 
403
     * @exception ClientException
 
404
     */
 
405
    public void add(String path, boolean recurse) throws ClientException
 
406
    {
 
407
        synchronized(clazz)
 
408
        {
 
409
            worker.add(path, recurse);
 
410
        }
 
411
    }
 
412
 
 
413
    /**
 
414
     * Adds a file to the repository.
 
415
     * @param path      path to be added.
 
416
     * @param recurse   recurse into subdirectories
 
417
     * @param force     if adding a directory and recurse true and path is a
 
418
     *                  directory, all not already managed files are added.
 
419
     * @exception ClientException
 
420
     * @since 1.2
 
421
     */
 
422
    public void add(String path, boolean recurse, boolean force)
 
423
            throws ClientException
 
424
    {
 
425
        synchronized(clazz)
 
426
        {
 
427
            worker.add(path, recurse, force);
 
428
        }
 
429
    }
 
430
 
 
431
    /**
 
432
     * Updates the directory or file from repository
 
433
     * @param path target file.
 
434
     * @param revision the revision number to update.
 
435
     *                 Revision.HEAD will update to the
 
436
     *                 latest revision.
 
437
     * @param recurse recursively update.
 
438
     * @exception ClientException
 
439
     */
 
440
    public long update(String path, Revision revision, boolean recurse)
 
441
            throws ClientException
 
442
    {
 
443
        synchronized(clazz)
 
444
        {
 
445
            return worker.update(path, revision, recurse);
 
446
        }
 
447
    }
 
448
 
 
449
    /**
 
450
     * Updates the directories or files from repository
 
451
     * @param path array of target files.
 
452
     * @param revision the revision number to update.
 
453
     *                 Revision.HEAD will update to the
 
454
     *                 latest revision.
 
455
     * @param recurse recursively update.
 
456
     * @param ignoreExternals if externals are ignored during update
 
457
     * @exception ClientException
 
458
     * @since 1.2
 
459
     */
 
460
    public long[] update(String[] path, Revision revision, boolean recurse,
 
461
                         boolean ignoreExternals) throws ClientException
 
462
    {
 
463
        synchronized(clazz)
 
464
        {
 
465
            return worker.update(path, revision, recurse, ignoreExternals);
 
466
        }
 
467
    }
 
468
 
 
469
    /**
 
470
     * Commits changes to the repository.
 
471
     * @param path      files to commit.
 
472
     * @param message   log message.
 
473
     * @param recurse   whether the operation should be done recursively.
 
474
     * @return Returns a long representing the revision. It returns a
 
475
     *         -1 if the revision number is invalid.
 
476
     * @exception ClientException
 
477
     */
 
478
    public long commit(String[] path, String message, boolean recurse)
 
479
            throws ClientException
 
480
    {
 
481
        synchronized(clazz)
 
482
        {
 
483
            return worker.commit(path, message, recurse, false);
 
484
        }
 
485
    }
 
486
    /**
 
487
     * Copies a versioned file with the history preserved.
 
488
     * @param srcPath   source path or url
 
489
     * @param destPath  destination path or url
 
490
     * @param message   commit message if destPath is an url
 
491
     * @param revision  source revision
 
492
     * @exception ClientException
 
493
     */
 
494
    public void copy(String srcPath, String destPath, String message,
 
495
                     Revision revision) throws ClientException
 
496
    {
 
497
        synchronized(clazz)
 
498
        {
 
499
            worker.copy(srcPath, destPath, message, revision);
 
500
        }
 
501
    }
 
502
    /**
 
503
     * Moves or renames a file.
 
504
     * @param srcPath   source path or url
 
505
     * @param destPath  destination path or url
 
506
     * @param message   commit message if destPath is an url
 
507
     * @param revision  source revision
 
508
     * @param force     even with local modifications.
 
509
     * @exception ClientException
 
510
     * @since 1.2
 
511
     */
 
512
    public void move(String srcPath, String destPath, String message,
 
513
                     Revision revision, boolean force) throws ClientException
 
514
    {
 
515
        synchronized(clazz)
 
516
        {
 
517
            worker.move(srcPath, destPath, message, revision, force);
 
518
        }
 
519
    }
 
520
 
 
521
    /**
 
522
     * Moves or renames a file.
 
523
     *
 
524
     * @param srcPath  source path or url
 
525
     * @param destPath destination path or url
 
526
     * @param message  commit message if destPath is an url
 
527
     * @param force    even with local modifications.
 
528
     * @throws ClientException
 
529
     *
 
530
     */
 
531
    public void move(String srcPath, String destPath, String message,
 
532
                     boolean force) throws ClientException
 
533
    {
 
534
        synchronized(clazz)
 
535
        {
 
536
            worker.move(srcPath, destPath, message, force);
 
537
        }
 
538
    }
 
539
 
 
540
    /**
 
541
     * Creates a directory directly in a repository or creates a
 
542
     * directory on disk and schedules it for addition.
 
543
     * @param path      directories to be created
 
544
     * @param message   commit message to used if path contains urls
 
545
     * @exception ClientException
 
546
     */
 
547
    public void mkdir(String[] path, String message) throws ClientException
 
548
    {
 
549
        synchronized(clazz)
 
550
        {
 
551
            worker.mkdir(path, message);
 
552
        }
 
553
    }
 
554
    /**
 
555
     * Recursively cleans up a local directory, finishing any
 
556
     * incomplete operations, removing lockfiles, etc.
 
557
     * @param path a local directory.
 
558
     * @exception ClientException
 
559
     */
 
560
    public void cleanup(String path) throws ClientException
 
561
    {
 
562
        synchronized(clazz)
 
563
        {
 
564
            worker.cleanup(path);
 
565
        }
 
566
    }
 
567
    /**
 
568
     * Removes the 'conflicted' state on a file.
 
569
     * @param path      path to cleanup
 
570
     * @param recurse   recurce into subdirectories
 
571
     * @exception ClientException
 
572
     */
 
573
    public void resolved(String path, boolean recurse) throws ClientException
 
574
    {
 
575
        synchronized(clazz)
 
576
        {
 
577
            worker.resolved(path,recurse);
 
578
        }
 
579
    }
 
580
    /**
 
581
     * Exports the contents of either a subversion repository into a
 
582
     * 'clean' directory (meaning a directory with no administrative
 
583
     * directories).
 
584
     * @param srcPath   the url of the repository path to be exported
 
585
     * @param destPath  a destination path that must not already exist.
 
586
     * @param revision  the revsion to be exported
 
587
     * @param force     set if it is ok to overwrite local files
 
588
     * @exception ClientException
 
589
     */
 
590
    public long doExport(String srcPath, String destPath, Revision revision,
 
591
                         boolean force) throws ClientException
 
592
    {
 
593
        synchronized(clazz)
 
594
        {
 
595
            return worker.doExport(srcPath, destPath, revision, force);
 
596
        }
 
597
    }
 
598
 
 
599
    /**
 
600
     * Exports the contents of either a subversion repository into a
 
601
     * 'clean' directory (meaning a directory with no administrative
 
602
     * directories).
 
603
     *
 
604
     * @param srcPath         the url of the repository path to be exported
 
605
     * @param destPath        a destination path that must not already exist.
 
606
     * @param revision        the revsion to be exported
 
607
     * @param pegRevision     the revision to interpret srcPath
 
608
     * @param force           set if it is ok to overwrite local files
 
609
     * @param ignoreExternals ignore external during export
 
610
     * @param recurse   recurse to subdirectories
 
611
     * @param nativeEOL       which EOL characters to use during export
 
612
     * @throws ClientException
 
613
     * @since 1.2
 
614
     */
 
615
    public long doExport(String srcPath, String destPath, Revision revision,
 
616
                         Revision pegRevision, boolean force,
 
617
                         boolean ignoreExternals, boolean recurse,
 
618
                         String nativeEOL)
 
619
            throws ClientException
 
620
    {
 
621
        synchronized(clazz)
 
622
        {
 
623
            return worker.doExport(srcPath, destPath, revision, pegRevision,
 
624
                    force, ignoreExternals, recurse, nativeEOL);
 
625
        }
 
626
    }
 
627
 
 
628
    /**
 
629
     * Update local copy to mirror a new url.
 
630
     * @param path      the working copy path
 
631
     * @param url       the new url for the working copy
 
632
     * @param revision  the new base revision of working copy
 
633
     * @param recurse   traverse into subdirectories
 
634
     * @exception ClientException
 
635
     */
 
636
    public long doSwitch(String path, String url, Revision revision,
 
637
                         boolean recurse) throws ClientException
 
638
    {
 
639
        synchronized(clazz)
 
640
        {
 
641
            return worker.doSwitch(path, url, revision, recurse);
 
642
        }
 
643
    }
 
644
    /**
 
645
     * Import a file or directory into a repository directory  at
 
646
     * head.
 
647
     * @param path      the local path
 
648
     * @param url       the target url
 
649
     * @param message   the log message.
 
650
     * @param recurse   traverse into subdirectories
 
651
     * @exception ClientException
 
652
     */
 
653
    public void doImport(String path, String url, String message,
 
654
                         boolean recurse) throws ClientException
 
655
    {
 
656
        synchronized(clazz)
 
657
        {
 
658
            worker.doImport(path, url, message, recurse);
 
659
        }
 
660
    }
 
661
    /**
 
662
     * Merge changes from two paths into a new local path.
 
663
     * @param path1         first path or url
 
664
     * @param revision1     first revision
 
665
     * @param path2         second path or url
 
666
     * @param revision2     second revision
 
667
     * @param localPath     target local path
 
668
     * @param force         overwrite local changes
 
669
     * @param recurse       traverse into subdirectories
 
670
     * @exception ClientException
 
671
     */
 
672
    public void merge(String path1, Revision revision1, String path2,
 
673
                      Revision revision2, String localPath, boolean force,
 
674
                      boolean recurse) throws ClientException
 
675
    {
 
676
        synchronized(clazz)
 
677
        {
 
678
            worker.merge(path1, revision1, path2, revision2, localPath, force,
 
679
                    recurse);
 
680
        }
 
681
    }
 
682
 
 
683
    /**
 
684
     * Merge changes from two paths into a new local path.
 
685
     *
 
686
     * @param path1          first path or url
 
687
     * @param revision1      first revision
 
688
     * @param path2          second path or url
 
689
     * @param revision2      second revision
 
690
     * @param localPath      target local path
 
691
     * @param force          overwrite local changes
 
692
     * @param recurse        traverse into subdirectories
 
693
     * @param ignoreAncestry ignore if files are not related
 
694
     * @param dryRun         do not change anything
 
695
     * @throws ClientException
 
696
     * @since 1.2
 
697
     */
 
698
    public void merge(String path1, Revision revision1, String path2,
 
699
                      Revision revision2, String localPath, boolean force,
 
700
                      boolean recurse, boolean ignoreAncestry, boolean dryRun)
 
701
            throws ClientException
 
702
    {
 
703
        synchronized(clazz)
 
704
        {
 
705
            worker.merge(path1, revision1, path2, revision2, localPath, force,
 
706
                    recurse, ignoreAncestry, dryRun);
 
707
        }
 
708
    }
 
709
 
 
710
    /**
 
711
     * Merge changes from two paths into a new local path.
 
712
     *
 
713
     * @param path           path or url
 
714
     * @param pegRevision    revision to interpret path
 
715
     * @param revision1      first revision
 
716
     * @param revision2      second revision
 
717
     * @param localPath      target local path
 
718
     * @param force          overwrite local changes
 
719
     * @param recurse        traverse into subdirectories
 
720
     * @param ignoreAncestry ignore if files are not related
 
721
     * @param dryRun         do not change anything
 
722
     * @throws ClientException
 
723
     * @since 1.2
 
724
     */
 
725
    public void merge(String path, Revision pegRevision, Revision revision1,
 
726
                      Revision revision2, String localPath, boolean force,
 
727
                      boolean recurse, boolean ignoreAncestry, boolean dryRun)
 
728
            throws ClientException
 
729
    {
 
730
        synchronized(clazz)
 
731
        {
 
732
            worker.merge(path, pegRevision, revision1, revision2, localPath,
 
733
                    force, recurse, ignoreAncestry, dryRun);
 
734
        }
 
735
    }
 
736
 
 
737
    /**
 
738
     * Display the differences between two paths
 
739
     * @param target1       first path or url
 
740
     * @param revision1     first revision
 
741
     * @param target2       second path or url
 
742
     * @param revision2     second revision
 
743
     * @param outFileName   file name where difference are written
 
744
     * @param recurse       traverse into subdirectories
 
745
     * @exception ClientException
 
746
     */
 
747
    public void diff(String target1, Revision revision1, String target2,
 
748
                     Revision revision2, String outFileName, boolean recurse)
 
749
            throws ClientException
 
750
    {
 
751
        synchronized(clazz)
 
752
        {
 
753
            worker.diff(target1, revision1, target2, revision2, outFileName,
 
754
                    recurse);
 
755
        }
 
756
    }
 
757
 
 
758
    /**
 
759
     * Display the differences between two paths
 
760
     *
 
761
     * @param target1        first path or url
 
762
     * @param revision1      first revision
 
763
     * @param target2        second path or url
 
764
     * @param revision2      second revision
 
765
     * @param outFileName    file name where difference are written
 
766
     * @param recurse        traverse into subdirectories
 
767
     * @param ignoreAncestry ignore if files are not related
 
768
     * @param noDiffDeleted  no output on deleted files
 
769
     * @param force          diff even on binary files
 
770
     * @throws ClientException
 
771
     * @since 1.2
 
772
     */
 
773
    public void diff(String target1, Revision revision1, String target2,
 
774
                     Revision revision2, String outFileName, boolean recurse,
 
775
                     boolean ignoreAncestry, boolean noDiffDeleted,
 
776
                     boolean force) throws ClientException
 
777
    {
 
778
        synchronized(clazz)
 
779
        {
 
780
            worker.diff(target1, revision1, target2, revision2, outFileName,
 
781
                    recurse, ignoreAncestry, noDiffDeleted, force);
 
782
        }
 
783
    }
 
784
 
 
785
    /**
 
786
     * Display the differences between two paths
 
787
     *
 
788
     * @param target         path or url
 
789
     * @param pegRevision    revision tointerpret target
 
790
     * @param startRevision  first Revision to compare
 
791
     * @param endRevision    second Revision to compare
 
792
     * @param outFileName    file name where difference are written
 
793
     * @param recurse        traverse into subdirectories
 
794
     * @param ignoreAncestry ignore if files are not related
 
795
     * @param noDiffDeleted  no output on deleted files
 
796
     * @param force          diff even on binary files
 
797
     * @throws ClientException
 
798
     * @since 1.2
 
799
     */
 
800
    public void diff(String target, Revision pegRevision,
 
801
                     Revision startRevision, Revision endRevision,
 
802
                     String outFileName, boolean recurse,
 
803
                     boolean ignoreAncestry, boolean noDiffDeleted,
 
804
                     boolean force) throws ClientException
 
805
    {
 
806
        synchronized(clazz)
 
807
        {
 
808
            worker.diff(target, pegRevision, startRevision, endRevision,
 
809
                    outFileName, recurse, ignoreAncestry, noDiffDeleted, force);
 
810
        }
 
811
    }
 
812
 
 
813
    /**
 
814
     * Retrieves the properties of an item
 
815
     * @param path  the path of the item
 
816
     * @return array of property objects
 
817
     */
 
818
    public PropertyData[] properties(String path) throws ClientException
 
819
    {
 
820
        synchronized(clazz)
 
821
        {
 
822
            return worker.properties(path);
 
823
        }
 
824
    }
 
825
 
 
826
    /**
 
827
     * Retrieves the properties of an item
 
828
     *
 
829
     * @param path     the path of the item
 
830
     * @param revision the revision of the item
 
831
     * @return array of property objects
 
832
     * @since 1.2
 
833
     */
 
834
    public PropertyData[] properties(String path, Revision revision)
 
835
            throws ClientException
 
836
    {
 
837
        synchronized(clazz)
 
838
        {
 
839
            return worker.properties(path, revision);
 
840
        }
 
841
    }
 
842
 
 
843
    /**
 
844
     * Retrieves the properties of an item
 
845
     *
 
846
     * @param path        the path of the item
 
847
     * @param revision    the revision of the item
 
848
     * @param pegRevision the revision to interpret path
 
849
     * @return array of property objects
 
850
     * @since 1.2
 
851
     */
 
852
    public PropertyData[] properties(String path, Revision revision,
 
853
                                     Revision pegRevision)
 
854
            throws ClientException
 
855
    {
 
856
        synchronized(clazz)
 
857
        {
 
858
            return properties(path, revision, pegRevision);
 
859
        }
 
860
    }
 
861
 
 
862
    /**
 
863
     * Sets one property of an item with a String value
 
864
     * @param path      path of the item
 
865
     * @param name      name of the property
 
866
     * @param value     new value of the property
 
867
     * @param recurse   set property also on the subdirectories
 
868
     * @throws ClientException
 
869
     */
 
870
    public void propertySet(String path, String name, String value,
 
871
                            boolean recurse) throws ClientException
 
872
    {
 
873
        synchronized(clazz)
 
874
        {
 
875
            worker.propertySet(path, name, value, recurse);
 
876
        }
 
877
    }
 
878
 
 
879
    /**
 
880
     * Sets one property of an item with a String value
 
881
     *
 
882
     * @param path    path of the item
 
883
     * @param name    name of the property
 
884
     * @param value   new value of the property
 
885
     * @param recurse set property also on the subdirectories
 
886
     * @param force   do not check if the value is valid
 
887
     * @throws ClientException
 
888
     * @since 1.2
 
889
     */
 
890
    public void propertySet(String path, String name, String value,
 
891
                            boolean recurse, boolean force)
 
892
            throws ClientException
 
893
    {
 
894
        synchronized(clazz)
 
895
        {
 
896
            worker.propertySet(path, name, value, recurse, force);
 
897
        }
 
898
    }
 
899
 
 
900
    /**
 
901
     * Sets one property of an item with a byte array value
 
902
     * @param path      path of the item
 
903
     * @param name      name of the property
 
904
     * @param value     new value of the property
 
905
     * @param recurse   set property also on the subdirectories
 
906
     * @throws ClientException
 
907
     */
 
908
    public void propertySet(String path, String name, byte[] value,
 
909
                            boolean recurse) throws ClientException
 
910
    {
 
911
        synchronized(clazz)
 
912
        {
 
913
            worker.propertySet(path, name, value, recurse);
 
914
        }
 
915
    }
 
916
 
 
917
    /**
 
918
     * Sets one property of an item with a byte array value
 
919
     *
 
920
     * @param path    path of the item
 
921
     * @param name    name of the property
 
922
     * @param value   new value of the property
 
923
     * @param recurse set property also on the subdirectories
 
924
     * @param force   do not check if the value is valid
 
925
     * @throws ClientException
 
926
     * @since 1.2
 
927
     */
 
928
    public void propertySet(String path, String name, byte[] value,
 
929
                            boolean recurse, boolean force)
 
930
            throws ClientException
 
931
    {
 
932
        synchronized(clazz)
 
933
        {
 
934
            worker.propertySet(path, name, value, recurse, force);
 
935
        }
 
936
    }
 
937
 
 
938
    /**
 
939
     * Remove one property of an item.
 
940
     * @param path      path of the item
 
941
     * @param name      name of the property
 
942
     * @param recurse   remove the property also on subdirectories
 
943
     * @throws ClientException
 
944
     */
 
945
    public void propertyRemove(String path, String name, boolean recurse)
 
946
            throws ClientException
 
947
    {
 
948
        synchronized(clazz)
 
949
        {
 
950
            worker.propertyRemove(path, name, recurse);
 
951
        }
 
952
    }
 
953
    /**
 
954
     * Create and sets one property of an item with a String value
 
955
     * @param path      path of the item
 
956
     * @param name      name of the property
 
957
     * @param value     new value of the property
 
958
     * @param recurse   set property also on the subdirectories
 
959
     * @throws ClientException
 
960
     */
 
961
    public void propertyCreate(String path, String name, String value,
 
962
                               boolean recurse) throws ClientException
 
963
    {
 
964
        synchronized(clazz)
 
965
        {
 
966
            worker.propertyCreate(path, name, value, recurse);
 
967
        }
 
968
    }
 
969
 
 
970
    /**
 
971
     * Create and sets one property of an item with a String value
 
972
     *
 
973
     * @param path    path of the item
 
974
     * @param name    name of the property
 
975
     * @param value   new value of the property
 
976
     * @param recurse set property also on the subdirectories
 
977
     * @param force   do not check if the value is valid
 
978
     * @throws ClientException
 
979
     * @since 1.2
 
980
     */
 
981
    public void propertyCreate(String path, String name, String value,
 
982
                               boolean recurse, boolean force)
 
983
            throws ClientException
 
984
    {
 
985
        synchronized(clazz)
 
986
        {
 
987
            worker.propertyCreate(path, name, value, recurse, force);
 
988
        }
 
989
    }
 
990
 
 
991
    /**
 
992
     * Create and sets one property of an item with a byte array value
 
993
     * @param path      path of the item
 
994
     * @param name      name of the property
 
995
     * @param value     new value of the property
 
996
     * @param recurse   set property also on the subdirectories
 
997
     * @throws ClientException
 
998
     */
 
999
    public void propertyCreate(String path, String name, byte[] value,
 
1000
                               boolean recurse) throws ClientException
 
1001
    {
 
1002
        synchronized(clazz)
 
1003
        {
 
1004
            worker.propertyCreate(path, name, value, recurse);
 
1005
        }
 
1006
    }
 
1007
 
 
1008
    /**
 
1009
     * Create and sets one property of an item with a byte array value
 
1010
     *
 
1011
     * @param path    path of the item
 
1012
     * @param name    name of the property
 
1013
     * @param value   new value of the property
 
1014
     * @param recurse set property also on the subdirectories
 
1015
     * @param force   do not check if the value is valid
 
1016
     * @throws ClientException
 
1017
     * @since 1.2
 
1018
     */
 
1019
    public void propertyCreate(String path, String name, byte[] value,
 
1020
                               boolean recurse, boolean force)
 
1021
            throws ClientException
 
1022
    {
 
1023
        synchronized(clazz)
 
1024
        {
 
1025
            worker.propertyCreate(path, name, value, recurse, force);
 
1026
        }
 
1027
    }
 
1028
 
 
1029
    /**
 
1030
     * Retrieve one revsision property of one item
 
1031
     * @param path      path of the item
 
1032
     * @param name      name of the property
 
1033
     * @param rev       revision to retrieve
 
1034
     * @return the Property
 
1035
     * @throws ClientException
 
1036
     */
 
1037
    public PropertyData revProperty(String path, String name, Revision rev)
 
1038
            throws ClientException
 
1039
    {
 
1040
        synchronized(clazz)
 
1041
        {
 
1042
            return worker.revProperty(path, name, rev);
 
1043
        }
 
1044
    }
 
1045
 
 
1046
    /**
 
1047
     * Retrieve all revsision properties of one item
 
1048
     *
 
1049
     * @param path path of the item
 
1050
     * @param rev  revision to retrieve
 
1051
     * @return the Properties
 
1052
     * @throws ClientException
 
1053
     * @since 1.2
 
1054
     */
 
1055
    public PropertyData[] revProperties(String path, Revision rev)
 
1056
            throws ClientException
 
1057
    {
 
1058
        synchronized(clazz)
 
1059
        {
 
1060
            return worker.revProperties(path, rev);
 
1061
        }
 
1062
    }
 
1063
 
 
1064
    /**
 
1065
     * set one revsision property of one item
 
1066
     * @param path      path of the item
 
1067
     * @param name      name of the property
 
1068
     * @param rev       revision to retrieve
 
1069
     * @param value     value of the property
 
1070
     * @param force
 
1071
     * @throws ClientException
 
1072
     * @since 1.2
 
1073
     */
 
1074
    public void setRevProperty(String path, String name, Revision rev,
 
1075
                               String value, boolean force)
 
1076
            throws ClientException
 
1077
    {
 
1078
        synchronized(clazz)
 
1079
        {
 
1080
            worker.setRevProperty(path, name, rev, value, force);
 
1081
        }
 
1082
    }
 
1083
 
 
1084
    /**
 
1085
     * Retrieve one property of one iten
 
1086
     * @param path      path of the item
 
1087
     * @param name      name of property
 
1088
     * @return the Property
 
1089
     * @throws ClientException
 
1090
     */
 
1091
    public PropertyData propertyGet(String path, String name)
 
1092
            throws ClientException
 
1093
    {
 
1094
        synchronized(clazz)
 
1095
        {
 
1096
            return worker.propertyGet(path, name);
 
1097
        }
 
1098
    }
 
1099
    /**
 
1100
     * Retrieve one property of one iten
 
1101
     *
 
1102
     * @param path     path of the item
 
1103
     * @param name     name of property
 
1104
     * @param revision revision of the item
 
1105
     * @return the Property
 
1106
     * @throws ClientException
 
1107
     * @since 1.2
 
1108
     */
 
1109
    public PropertyData propertyGet(String path, String name, Revision revision)
 
1110
            throws ClientException
 
1111
    {
 
1112
        synchronized(clazz)
 
1113
        {
 
1114
            return worker.propertyGet(path, name, revision);
 
1115
        }
 
1116
    }
 
1117
 
 
1118
    /**
 
1119
     * Retrieve one property of one iten
 
1120
     *
 
1121
     * @param path     path of the item
 
1122
     * @param name     name of property
 
1123
     * @param revision revision of the item
 
1124
     * @param pegRevision the revision to interpret path
 
1125
     * @return the Property
 
1126
     * @throws ClientException
 
1127
     * @since 1.2
 
1128
     */
 
1129
    public PropertyData propertyGet(String path, String name, Revision revision,
 
1130
                                    Revision pegRevision) throws ClientException
 
1131
    {
 
1132
        synchronized(clazz)
 
1133
        {
 
1134
            return worker.propertyGet(path, name, revision, pegRevision);
 
1135
        }
 
1136
    }
 
1137
 
 
1138
    /**
 
1139
     *  Retrieve the content of a file
 
1140
     * @param path      the path of the file
 
1141
     * @param revision  the revision to retrieve
 
1142
     * @return  the content as byte array
 
1143
     * @throws ClientException
 
1144
     */
 
1145
    public byte[] fileContent(String path, Revision revision)
 
1146
            throws ClientException
 
1147
    {
 
1148
        synchronized(clazz)
 
1149
        {
 
1150
            return worker.fileContent(path, revision);
 
1151
        }
 
1152
    }
 
1153
 
 
1154
    /**
 
1155
     * Retrieve the content of a file
 
1156
     *
 
1157
     * @param path        the path of the file
 
1158
     * @param revision    the revision to retrieve
 
1159
     * @param pegRevision the revision to interpret path
 
1160
     * @return the content as byte array
 
1161
     * @throws ClientException
 
1162
     * @since 1.2
 
1163
     */
 
1164
    public byte[] fileContent(String path, Revision revision,
 
1165
                              Revision pegRevision) throws ClientException
 
1166
    {
 
1167
        synchronized(clazz)
 
1168
        {
 
1169
            return worker.fileContent(path, revision, pegRevision);
 
1170
        }
 
1171
    }
 
1172
 
 
1173
    /**
 
1174
     * Rewrite the url's in the working copy
 
1175
     * @param from      old url
 
1176
     * @param to        new url
 
1177
     * @param path      working copy path
 
1178
     * @param recurse   recurse into subdirectories
 
1179
     * @throws ClientException
 
1180
     */
 
1181
    public void relocate(String from, String to, String path, boolean recurse)
 
1182
            throws ClientException
 
1183
    {
 
1184
        synchronized(clazz)
 
1185
        {
 
1186
            worker.relocate(from, to, path, recurse);
 
1187
        }
 
1188
    }
 
1189
    /**
 
1190
     * Return for each line of the file, the author and the revision of the
 
1191
     * last together with the content.
 
1192
     * @deprecated
 
1193
     * @param path          the path
 
1194
     * @param revisionStart the first revision to show
 
1195
     * @param revisionEnd   the last revision to show
 
1196
     * @return  the content together with author and revision of last change
 
1197
     * @throws ClientException
 
1198
     */
 
1199
    public byte[] blame(String path, Revision revisionStart,
 
1200
                        Revision revisionEnd) throws ClientException
 
1201
    {
 
1202
        synchronized(clazz)
 
1203
        {
 
1204
            return worker.blame(path,revisionStart, revisionEnd);
 
1205
        }
 
1206
    }
 
1207
    /**
 
1208
     * Retrieve the content together with the author, the revision and the date
 
1209
     * of the last change of each line
 
1210
     * @param path          the path
 
1211
     * @param revisionStart the first revision to show
 
1212
     * @param revisionEnd   the last revision to show
 
1213
     * @param callback      callback to receive the file content and the other
 
1214
     *                      information
 
1215
     * @throws ClientException
 
1216
     */
 
1217
    public void blame(String path, Revision revisionStart, Revision revisionEnd,
 
1218
                      BlameCallback callback) throws ClientException
 
1219
    {
 
1220
        synchronized(clazz)
 
1221
        {
 
1222
            worker.blame(path, revisionStart, revisionEnd, callback);
 
1223
        }
 
1224
    }
 
1225
 
 
1226
    /**
 
1227
     * Retrieve the content together with the author, the revision and the date
 
1228
     * of the last change of each line
 
1229
     * @param path          the path
 
1230
     * @param pegRevision   the revision to interpret the path
 
1231
     * @param revisionStart the first revision to show
 
1232
     * @param revisionEnd   the last revision to show
 
1233
     * @param callback      callback to receive the file content and the other
 
1234
     *                      information
 
1235
     * @throws ClientException
 
1236
     * @since 1.2
 
1237
     */
 
1238
    public void blame(String path, Revision pegRevision, Revision revisionStart,
 
1239
                      Revision revisionEnd, BlameCallback callback)
 
1240
            throws ClientException
 
1241
    {
 
1242
        synchronized(clazz)
 
1243
        {
 
1244
            worker.blame(path, pegRevision, revisionStart, revisionEnd,
 
1245
                    callback);
 
1246
        }
 
1247
    }
 
1248
 
 
1249
    /**
 
1250
     * Set directory for the configuration information
 
1251
     * @param configDir     path of the directory
 
1252
     * @throws ClientException
 
1253
     */
 
1254
    public void setConfigDirectory(String configDir) throws ClientException
 
1255
    {
 
1256
        synchronized(clazz)
 
1257
        {
 
1258
            worker.setConfigDirectory(configDir);
 
1259
        }
 
1260
    }
 
1261
    /**
 
1262
     * Get the configuration directory
 
1263
     * @return  the directory
 
1264
     * @throws ClientException
 
1265
     */
 
1266
    public String getConfigDirectory() throws ClientException
 
1267
    {
 
1268
        synchronized(clazz)
 
1269
        {
 
1270
            return worker.getConfigDirectory();
 
1271
        }
 
1272
    }
 
1273
    /**
 
1274
     * cancel the active operation
 
1275
     * @throws ClientException
 
1276
     */
 
1277
    public void cancelOperation() throws ClientException
 
1278
    {
 
1279
        // this method is not synchronized, because it is designed to be called
 
1280
        // from another thread
 
1281
        worker.cancelOperation();
 
1282
    }
 
1283
 
 
1284
    /**
 
1285
     * Retrieves the working copy information for an item
 
1286
     * @param path  path of the item
 
1287
     * @return      the information object
 
1288
     * @throws ClientException
 
1289
     */
 
1290
    public Info info(String path) throws ClientException
 
1291
    {
 
1292
        synchronized(clazz)
 
1293
        {
 
1294
            return worker.info(path);
 
1295
        }
 
1296
    }
 
1297
 
 
1298
    /**
 
1299
     * Commits changes to the repository.
 
1300
     *
 
1301
     * @param path     files to commit.
 
1302
     * @param message  log message.
 
1303
     * @param recurse  whether the operation should be done recursively.
 
1304
     * @param noUnlock do remove any locks
 
1305
     * @return Returns a long representing the revision. It returns a
 
1306
     *         -1 if the revision number is invalid.
 
1307
     * @throws ClientException
 
1308
     * @since 1.2
 
1309
     */
 
1310
    public long commit(String[] path, String message, boolean recurse,
 
1311
                       boolean noUnlock) throws ClientException
 
1312
    {
 
1313
        synchronized(clazz)
 
1314
        {
 
1315
            return worker.commit(path, message, recurse, noUnlock);
 
1316
        }
 
1317
    }
 
1318
 
 
1319
    /**
 
1320
     * Lock a working copy item
 
1321
     *
 
1322
     * @param path  path of the item
 
1323
     * @param comment
 
1324
     * @param force break an existing lock
 
1325
     * @throws ClientException
 
1326
     * @since 1.2
 
1327
     */
 
1328
    public void lock(String[] path, String comment, boolean force)
 
1329
            throws ClientException
 
1330
    {
 
1331
        synchronized(clazz)
 
1332
        {
 
1333
            worker.lock(path, comment, force);
 
1334
        }
 
1335
    }
 
1336
 
 
1337
    /**
 
1338
     * Unlock a working copy item
 
1339
     *
 
1340
     * @param path  path of the item
 
1341
     * @param force break an existing lock
 
1342
     * @throws ClientException
 
1343
     * @since 1.2
 
1344
     */
 
1345
    public void unlock(String[] path, boolean force)
 
1346
            throws ClientException
 
1347
    {
 
1348
        synchronized(clazz)
 
1349
        {
 
1350
            worker.unlock(path, force);
 
1351
        }
 
1352
    }
 
1353
 
 
1354
    /**
 
1355
     * Retrieve information about repository or working copy items.
 
1356
     *
 
1357
     * @param pathOrUrl   the path or the url of the item
 
1358
     * @param revision    the revision of the item to return
 
1359
     * @param pegRevision the revision to interpret pathOrUrl
 
1360
     * @param recurse     flag if to recurse, if the item is a directory
 
1361
     * @return the information objects
 
1362
     * @since 1.2
 
1363
     */
 
1364
    public Info2[] info2(String pathOrUrl, Revision revision,
 
1365
                         Revision pegRevision, boolean recurse)
 
1366
            throws ClientException
 
1367
    {
 
1368
        synchronized(clazz)
 
1369
        {
 
1370
            return worker.info2(pathOrUrl, revision, pegRevision, recurse);
 
1371
        }
 
1372
    }
 
1373
 
 
1374
    /**
 
1375
     *  Produce a compact "version number" for a working copy
 
1376
     * @param path          path of the working copy
 
1377
     * @param trailUrl      to detect switches of the whole working copy
 
1378
     * @param lastChanged   last changed rather than current revisions
 
1379
     * @return      the compact "version number"
 
1380
     * @throws ClientException
 
1381
     * @since 1.2
 
1382
     */
 
1383
    public String getVersionInfo(String path, String trailUrl,
 
1384
                                 boolean lastChanged) throws ClientException
 
1385
    {
 
1386
        synchronized(clazz)
 
1387
        {
 
1388
            return worker.getVersionInfo(path, trailUrl, lastChanged);
 
1389
        }
 
1390
    }
 
1391
 
 
1392
}