org.tigris.subversion.svnclientadapter.ISVNLogMessage Java Examples

private void assertLogs(ISVNLogMessage[] logsRef, ISVNLogMessage[] logsNb) {
    assertEquals(logsRef.length, logsNb.length);
    for (int i = 0; i < logsNb.length; i++) {
        ISVNLogMessage lognb = logsNb[i];
        ISVNLogMessage logref = logsRef[i];            
        
        assertEquals(logref.getAuthor(), lognb.getAuthor());
        assertEquals(logref.getDate().toString(), lognb.getDate().toString());
        assertEquals(logref.getMessage(), lognb.getMessage());
        assertEquals(logref.getRevision(), lognb.getRevision());
        
        ISVNLogMessageChangePath[] pathsnb = lognb.getChangedPaths();
        ISVNLogMessageChangePath[] pathsref = lognb.getChangedPaths();
        assertChangePaths(pathsref, pathsnb);
    }
}
 

private static void afterCommit(Collection<SvnHook> hooks, List<File> files, String message, List<ISVNLogMessage> logs) {
    if(hooks.isEmpty()) {
        return;
    }
    List<SvnHookContext.LogEntry> entries = new ArrayList<SvnHookContext.LogEntry>(logs.size());
    for (int i = 0; i < logs.size(); i++) {
        entries.add(
            new SvnHookContext.LogEntry(
                    logs.get(i).getMessage(),
                    logs.get(i).getAuthor(),
                    logs.get(i).getRevision().getNumber(),
                    logs.get(i).getDate()));
    }
    SvnHookContext context = new SvnHookContext(files.toArray(new File[files.size()]), message, entries);
    for (SvnHook hook : hooks) {
        hook.afterCommit(context);
    }
}
 

private ISVNLogMessage[] getLogMessages() throws Exception {
	if (logMessages == null) {
		ISVNClientAdapter svnClient = null;
		try {
			svnClient = svnResource.getRepository().getSVNClient();
			IProject project = treeConflict.getResource().getProject();
			ISVNLocalResource svnProject =  SVNWorkspaceRoot.getSVNResourceFor(project);
			SVNRevision revision1 = new SVNRevision.Number(treeConflict.getConflictDescriptor().getSrcLeftVersion().getPegRevision());
			SVNRevision revision2 = new SVNRevision.Number(treeConflict.getConflictDescriptor().getSrcRightVersion().getPegRevision());
			logMessages = svnClient.getLogMessages(svnProject.getUrl(), revision1, revision2, true); 
		} catch (Exception e) {
			throw e;
		}
		finally {
			svnResource.getRepository().returnSVNClient(svnClient);
		}
	}
	return logMessages;
}
 

/**
 * Returns log message for given revision
 * @param client
 * @param file
 * @param revision
 * @return log message
 * @throws org.tigris.subversion.svnclientadapter.SVNClientException
 */
private static ISVNLogMessage getLogMessage (ISVNClientAdapter client, File file, long revision) throws SVNClientException {
    SVNRevision rev = SVNRevision.HEAD;
    ISVNLogMessage log = null;
    try {
        rev = SVNRevision.getRevision(String.valueOf(revision));
    } catch (ParseException ex) {
        Subversion.LOG.log(Level.WARNING, "" + revision, ex);
    }
    if (Subversion.LOG.isLoggable(Level.FINER)) {
        Subversion.LOG.log(Level.FINER, "{0}: getting last commit message for svn hooks", CommitAction.class.getName());
    }
    // log has to be called directly on the file
    final SVNUrl fileRepositoryUrl = SvnUtils.getRepositoryUrl(file);
    ISVNLogMessage[] ls = client.getLogMessages(fileRepositoryUrl, rev, rev);
    if (ls.length > 0) {
        log = ls[0];
    } else {
        Subversion.LOG.log(Level.WARNING, "no logs available for file {0} with repo url {1}", new Object[]{file, fileRepositoryUrl});
    }
    return log;
}
 

public ISVNLogMessage[] getLogMessages(SVNRevision pegRevision,
		SVNRevision revisionStart, SVNRevision revisionEnd,
		boolean stopOnCopy, boolean fetchChangePath, long limit, boolean includeMergedRevisions)
		throws TeamException {
   	ISVNClientAdapter svnClient = repository.getSVNClient();
	try {
		return svnClient.getLogMessages(getUrl(),
				pegRevision, revisionStart, revisionEnd, stopOnCopy, fetchChangePath,
				limit, includeMergedRevisions);
	} catch (SVNClientException e) {
		throw new TeamException("Failed in RemoteResource.getLogMessages()",
				e);
	}
	finally {
		repository.returnSVNClient(svnClient);
	}
}
 

public ISVNLogMessage[] getLogMessages(SVNRevision pegRevision,
		SVNRevision revisionStart, SVNRevision revisionEnd,
		boolean stopOnCopy, boolean fetchChangePath, long limit, boolean includeMergedRevisions)
		throws TeamException {
   	ISVNClientAdapter svnClient = getRepository().getSVNClient();
	try {
		return svnClient.getLogMessages(getFile(), pegRevision,
				revisionStart, revisionEnd, stopOnCopy, fetchChangePath,
				limit, includeMergedRevisions);
	} catch (SVNClientException e) {
		throw new TeamException("Failed in BaseResource.getLogMessages()",
				e);
	}
	finally {
		getRepository().returnSVNClient(svnClient);
	}
}
 

private String getSingleEntry(ISVNRemoteFile file, Long revLong) {
	ISVNClientAdapter client = null;
	try {
		client = file.getRepository().getSVNClient();
		SVNRevision revision = SVNRevision.getRevision(revLong.toString());
		ISVNLogMessage [] messages = client.getLogMessages(file.getRepository().getRepositoryRoot(), revision, revision, false);
		if (messages.length == 1)
			return messages[0].getMessage();
		else
			return null;
	} catch (Exception e) {
		return null;
	}
	finally {
		file.getRepository().returnSVNClient(client);
	}
}
 

/**
 * create the LogEntry for the logMessages
 * @param logMessages
 * @return
 */
public static ILogEntry[] createLogEntriesFrom(ISVNRemoteFile remoteFile, ISVNLogMessage[] logMessages, Tags[] tags, SVNUrl[] urls) {
    ILogEntry[] result = new ILogEntry[logMessages.length]; 
    for (int i = 0; i < logMessages.length;i++) {
        ISVNLogMessage logMessage = logMessages[i];
        ISVNRemoteResource correspondingResource;
        correspondingResource = new RemoteFile(
                    null,
                    remoteFile.getRepository(), 
                    urls[i], 
                    logMessage.getRevision(), 
                    logMessage.getRevision(), 
                    logMessage.getDate(), 
                    logMessage.getAuthor());  
        result[i] = new LogEntry(logMessage, remoteFile, correspondingResource, (tags[i] != null) ? tags[i].getTags() : null);
    }
    return result;
}
 

private ISVNLogMessageChangePath[] getPathsOnDemand(SVNUrl url) {
ISVNLogMessage[] tmpMessage;
ISVNClientAdapter client = null;
      try {
          client = SVNProviderPlugin.getPlugin().getSVNClient(); // errors will not log to console
          SVNProviderPlugin.disableConsoleLogging(); 
          tmpMessage = client.getLogMessages(url, getRevision(), getRevision(), true);
          SVNProviderPlugin.enableConsoleLogging(); 
       if (tmpMessage != null && tmpMessage.length > 0)
	    return tmpMessage[0].getChangedPaths();
	else
	    return null;
      } catch (Exception e) {
          SVNProviderPlugin.enableConsoleLogging(); 
          return null;
      } finally {
       SVNProviderPlugin.getPlugin().getSVNClientManager().returnSVNClient(client);
      }
  }
 

private void testMoveURL2URLPrevRevision(String srcPath,
                                         String targetFileName) throws Exception {
    createAndCommitParentFolders(srcPath);
    File file = createFile(srcPath);
    write(file, 1);
    add(file);
    commit(file);
    SVNRevision prevRev = getRevision(file);
    write(file, 2);
    commit(getWC());        
    
    File filemove = createFile(renameFile(srcPath, targetFileName));
    filemove.delete(); // we're operating with repository directly, cannot leave unversioned files lying on disk (they would be committed in the next round)
    
    ISVNClientAdapter c = getNbClient();
    c.copy(getFileUrl(file), getFileUrl(filemove), "move", prevRev);

    ISVNLogMessage[] logs = getLog(getFileUrl(filemove));
    assertEquals(((SVNRevision.Number)prevRev).getNumber() ,logs[0].getChangedPaths()[0].getCopySrcRevision().getNumber());

    InputStream is = getContent(getFileUrl(filemove));
    assertContents(is, 1);
    assertNotifiedFiles(new File[] {});        
}
 

private void testCopyURL2URLPrevRevision(String srcPath,
                                         String targetFileName) throws Exception {
    createAndCommitParentFolders(srcPath);
    File file = createFile(srcPath);
    write(file, 1);
    add(file);
    commit(file);
    SVNRevision prevRev = getRevision(file);
    write(file, 2);
    commit(getWC());

    File filecopy = createFile(renameFile(srcPath, targetFileName));
    filecopy.delete();

    ISVNClientAdapter c = getNbClient();
    c.copy(getFileUrl(file), getFileUrl(filecopy), "copy", prevRev);

    ISVNLogMessage[] logs = getLog(getFileUrl(filecopy));
    assertEquals(((SVNRevision.Number)prevRev).getNumber() ,logs[0].getChangedPaths()[0].getCopySrcRevision().getNumber());

    InputStream is = getContent(getFileUrl(filecopy));
    assertContents(is, 1);
    assertNotifiedFiles(new File[] {});
}
 

private ISVNLogMessage[] getMergeinfoLog(int kind, String target,
		SVNRevision pegRevision, SVNUrl mergeSourceUrl,
		SVNRevision srcPegRevision, boolean discoverChangedPaths)
		throws SVNClientException {
	try {
		notificationHandler
				.setCommand(ISVNNotifyListener.Command.MERGEINFO);
		String show = "";
		org.apache.subversion.javahl.types.Mergeinfo.LogKind mergeKind = org.apache.subversion.javahl.types.Mergeinfo.LogKind.eligible;
		if (kind == ISVNMergeinfoLogKind.eligible)
			show = show + " --show-revs eligible ";
		if (kind == ISVNMergeinfoLogKind.merged) {
			show = show + " --show-revs merged ";
			mergeKind = org.apache.subversion.javahl.types.Mergeinfo.LogKind.merged;
		}
		notificationHandler.logCommandLine("mergeinfo " + show
				+ mergeSourceUrl.toString() + " " + target);
		SVNLogMessageCallback worker = new SVNLogMessageCallback();
		JhlLogMessageCallback callback = new JhlLogMessageCallback(worker);
		Set<String> revProps = new HashSet<String>();
		revProps.add("svn:author");
		revProps.add("svn:date");
		revProps.add("svn:log");
		svnClient.getMergeinfoLog(mergeKind, target,
				JhlConverter.convert(pegRevision),
				mergeSourceUrl.toString(),
				JhlConverter.convert(srcPegRevision), discoverChangedPaths,
				Depth.infinity, revProps, callback);
		return worker.getLogMessages();
	} catch (ClientException e) {
		if (e.getAprError() == ErrorCodes.unsupportedFeature) {
			return this.getLogMessages(mergeSourceUrl, srcPegRevision,
					new SVNRevision.Number(0), SVNRevision.HEAD, true,
					discoverChangedPaths, 0, false);
		}
		notificationHandler.logException(e);
		throw new SVNClientException(e);
	}
}
 

public RepositoryRevision(ISVNLogMessage message, SVNUrl rootUrl, File[] selectionRoots,
        Map<String,File> pathToRoot, Map<String, SVNRevision> pegRevisions) {
    this.message = message;
    this.repositoryRootUrl = rootUrl;
    this.selectionRoots = selectionRoots;
    support = new PropertyChangeSupport(this);
    this.pathToRoot = pathToRoot;
    this.pegRevisions = pegRevisions;
    initFakeRootEvent();
}
 

private void assertLogMessage(ISVNInfo info, ISVNLogMessage logsNb, String msg, ISVNLogMessageChangePath[] changePaths) {
    assertEquals(info.getLastCommitAuthor(), logsNb.getAuthor());
    assertEquals(info.getLastChangedDate().toString(), logsNb.getDate().toString());
    assertEquals(msg, logsNb.getMessage());
    assertEquals(info.getRevision(), logsNb.getRevision());
    assertChangePaths(changePaths, logsNb.getChangedPaths());
}
 

SVNRevision getSelectedValue() {
    Object selection = resultsList.getSelectedValue();
    if(selection == null) {
        return null;
    }
    if(!(selection instanceof ISVNLogMessage)) {
        return null;
    }
    ISVNLogMessage message = (ISVNLogMessage) selection;
    return message.getRevision();
}
 

private void logLimit(Log log) throws Exception {                                
    File file = createFile("file");
    add(file);
    write(file, "1");        
    commit(file, "msg1");
    ISVNInfo info1 = getInfo(file);        
    
    write(file, "2");
    commit(file, "msg2");
    ISVNInfo info2 = getInfo(file);
    
    write(file, "3");
    commit(file, "msg3");

    ISVNLogMessage[] logsNb = null;
    switch(log) {
        case file:
            logsNb = getNbClient().getLogMessages(file, new SVNRevision.Number(0), SVNRevision.HEAD, false, true, 2);
            break;
        case url:
            logsNb = getNbClient().getLogMessages(getFileUrl(file), null, new SVNRevision.Number(0), SVNRevision.HEAD, false, true, 2);
            break;
        default:
            fail("no idea!");
    }
    
    // test
    assertEquals(2, logsNb.length);         
    String testName = getName();        
    assertLogMessage(info1, logsNb[0], "msg1",  new ISVNLogMessageChangePath[] { new ChangePath('A', "/" + testName + "/" + testName + "_wc/file", null, null) });
    assertLogMessage(info2, logsNb[1], "msg2",  new ISVNLogMessageChangePath[] { new ChangePath('M', "/" + testName + "/" + testName + "_wc/file", null, null) });
}
 

public void singleMessage(ISVNLogMessage msg) {
	super.singleMessage(msg);
	if (monitor != null && monitor.isCanceled() && !canceled) {
		try {
			svnClient.cancelOperation();
			canceled = true;
		} catch (SVNClientException e) {
			SVNUIPlugin.log(IStatus.ERROR, e.getMessage(), e);
		}
	}
}
 

public void testFolderMergeRec() throws Exception {                                        
    File folder = createFolder("folder");
    add(folder);
    commit(folder);
    assertInfo(folder, getFileUrl(folder));
    
    File foldercopy = new File(getWC(), "foldercopy");
    
    ISVNClientAdapter c = getNbClient();
    c.copy(getFileUrl(folder), getFileUrl(foldercopy), "copy", SVNRevision.HEAD);
    c.switchToUrl(folder, getFileUrl(foldercopy), SVNRevision.HEAD, true);

    assertCopy(getFileUrl(foldercopy));
    assertInfo(folder, getFileUrl(foldercopy));
    
    File folder1 = createFolder(folder, "folder1");
    File file = createFile(folder, "file");
    File file1 = createFile(folder1, "file");
    add(file);
    add(folder1);
    add(file1);
    commit(folder);
    assertTrue(file.exists());
    
    c.switchToUrl(folder, getFileUrl(folder), SVNRevision.HEAD, true);
    assertCopy(getFileUrl(folder));
    assertInfo(folder, getFileUrl(folder));        
    assertFalse(file.exists());
    assertFalse(file1.exists());
    assertFalse(folder1.exists());
    
    ISVNLogMessage[] log = getCompleteLog(getFileUrl(folder));
    c.merge(getFileUrl(foldercopy), log[0].getRevision(), getFileUrl(foldercopy), SVNRevision.HEAD, folder, false, true);
    assertTrue(file.exists());
    assertTrue(file1.exists());
    assertTrue(folder1.exists());
    assertNotifiedFiles(new File[] {file, file1, folder1});        
}
 

private ISVNLogMessage getLogMessage (File[] files, long revision) throws SVNClientException {
    ISVNLogMessage revisionLog = null;
    long maxPause = COMMIT_PAUSE;
    long nextPause = 500;
    for (int i = 0; i < files.length && revisionLog == null; ++i) {
        try {
            File f = files[i];
            // an existing file needs to be found, log over a deleted file fails
            while (!f.exists()) {
                f = f.getParentFile();
            }
            revisionLog = CommitAction.getLogMessage(client, f, revision);
        } catch (SVNClientException ex) {
            if (SvnClientExceptionHandler.isNoSuchRevision(ex.getMessage())) {
                Logger.getLogger(CommitAction.class.getName()).log(Level.INFO,
                        "After commit pause for {0} ms. No such revision {1}", //NOI18N
                        new Object[] { nextPause, revision });
                if (maxPause > 0) {
                    try {
                        Thread.sleep(nextPause);
                    } catch (InterruptedException ex1) {
                        // not interested
                    }
                    maxPause -= nextPause;
                    nextPause = nextPause * 2;
                    i--;
                    continue;
                }
            }
            if (!SvnClientExceptionHandler.isFileNotFoundInRevision(ex.getMessage())) {
                throw ex;
            }
        }
    }
    return revisionLog;
}
 

/**
   * Fetch the comment of the given SyncInfo
   * @param info info to get comment for
   * @return the comment
   */
  private String fetchComment(SVNStatusSyncInfo info) {
String fetchedComment = Policy.bind("SynchronizeView.standardIncomingChangeSetComment"); // $NON-NLS-1$
  	IResourceVariant remoteResource = info.getRemote();
  	if (remoteResource instanceof ISVNRemoteResource) {
  		ISVNRemoteResource svnRemoteResource = (ISVNRemoteResource)remoteResource;
  		ISVNClientAdapter client = null;
  		try {
		client = svnRemoteResource.getRepository().getSVNClient();
   		SVNUrl url = svnRemoteResource.getRepository().getRepositoryRoot();
   		SVNRevision rev = svnRemoteResource.getLastChangedRevision();
   		ISVNLogMessage[] logMessages = client.getLogMessages(url, rev, rev, false);
		if (logMessages.length != 0) {
			String logComment = logMessages[0].getMessage();
			if (logComment.trim().length() != 0) {
				fetchedComment = flattenComment(logComment); 
			} else {
				fetchedComment = "";
			}
		}
	} catch (SVNException e1) {
		if (!e1.operationInterrupted()) {
			SVNUIPlugin.log(e1);
		}
	} catch (SVNClientException e) {
		SVNUIPlugin.log(SVNException.wrapException(e));
	}
  		finally {
  			svnRemoteResource.getRepository().returnSVNClient(client);
  		}
 		}
  	return fetchedComment;
  }
 

private Tags[] getTags(ISVNLogMessage[] logMessages) throws NumberFormatException {
	Tags[] tags = new Tags[logMessages.length]; 
       for (int i = 0; i < logMessages.length;i++) {
       	if (tagManager != null) {
       		String rev = logMessages[i].getRevision().toString();
       		int revNo = Integer.parseInt(rev);
       		tags[i] = new Tags(tagManager.getTags(revNo));
       	}
       }
	return tags;
}
 

@Override
public ISVNLogMessage[] getLogMessages(File file, SVNRevision pegRevision, SVNRevision revStart, SVNRevision revEnd, boolean stopOnCopy, boolean fetchChangePath, long limit, boolean includeMergedRevisions) throws SVNClientException {
    LogCommand logCmd;
    ISVNInfo info = getInfoFromWorkingCopy(file);
    if (info.getSchedule().equals(SVNScheduleKind.ADD) &&
        info.getCopyUrl() != null)
    {
        logCmd = new LogCommand(info.getCopyUrl(), null, revStart, revEnd, pegRevision, stopOnCopy, fetchChangePath, limit);
    } else {
        logCmd = new LogCommand(file, revStart, revEnd, pegRevision, stopOnCopy, fetchChangePath, limit);
    }
    return getLog(logCmd);
}
 

/**
    * creates a LogEntry
    * @param logMessage
    * @param resource the corresponding remote resource or null
    * @param repository
    */
private LogEntry(
           ISVNLogMessage logMessage,
           ISVNResource resource,
           ISVNRemoteResource remoteResource,
           Alias[] tags) {
       this.logMessage = logMessage;
       this.remoteResource = remoteResource;
       this.resource = resource;
       this.tags = tags;
}
 

/**
 * create the LogEntry for the logMessages
 * @param logMessages
 * @return
 */
public static ILogEntry[] createLogEntriesFrom(ISVNRemoteFolder remoteFolder, ISVNLogMessage[] logMessages, Tags[] tags) {
    // if we get the history for a folder, we get the history for all
    // its members
	// so there is no remoteResource associated with each LogEntry
    ILogEntry[] result = new ILogEntry[logMessages.length]; 
    for (int i = 0; i < logMessages.length;i++) {
    	result[i] = new LogEntry(logMessages[i], remoteFolder, null, (tags[i] != null) ? tags[i].getTags() : null); 
    }
    return result;
}
 

public ILogEntry[] getChildMessages() {
	ISVNLogMessage[] childMessages = logMessage.getChildMessages();
	if (childMessages == null) return null;
	ILogEntry[] childEntries = new ILogEntry[childMessages.length];
	for (int i = 0; i < childMessages.length; i++) {
		childEntries[i] = new LogEntry(childMessages[i], resource, remoteResource, null);
	}
	return childEntries;
}
 

public ISVNLogMessage[] getChildMessages() {
	if (hasChildren && children != null) {
		ISVNLogMessage[] childArray = new JhlLogMessage[children.size()];
		children.toArray(childArray);
		return childArray;
	} else
		return null;
}
 

public ISVNLogMessage[] getMergeinfoLog(int kind, File path,
		SVNRevision pegRevision, SVNUrl mergeSourceUrl,
		SVNRevision srcPegRevision, boolean discoverChangedPaths)
		throws SVNClientException {
	return this.getMergeinfoLog(kind, fileToSVNPath(path, false),
			pegRevision, mergeSourceUrl, srcPegRevision,
			discoverChangedPaths);
}
 

public ISVNLogMessage[] getMergeinfoLog(int kind, SVNUrl url,
		SVNRevision pegRevision, SVNUrl mergeSourceUrl,
		SVNRevision srcPegRevision, boolean discoverChangedPaths)
		throws SVNClientException {
	return this.getMergeinfoLog(kind, url.toString(), pegRevision,
			mergeSourceUrl, srcPegRevision, discoverChangedPaths);
}
 

/**
 * execute the command
 * @param aMonitor
 * @throws SVNException
 */
public void run(IProgressMonitor aMonitor) throws SVNException {
	ISVNRepositoryLocation repository = null;
	ISVNClientAdapter svnClient = null;
    logEntries = null;
    IProgressMonitor monitor = Policy.monitorFor(aMonitor);
    monitor.beginTask(Policy.bind("RemoteFile.getLogEntries"), 100); //$NON-NLS-1$
    
    ISVNLogMessage[] logMessages;
    try {
    	if (callback == null) {
         logMessages = remoteResource.getLogMessages(
                 pegRevision,
                 revisionStart,
                 revisionEnd, 
                 stopOnCopy,
                 !SVNProviderPlugin.getPlugin().getSVNClientManager().isFetchChangePathOnDemand(),
                 limit, includeMergedRevisions);
    	} else {
    		repository = remoteResource.getRepository();
    		svnClient = repository.getSVNClient();
    		if (remoteResource instanceof BaseResource) {
    			boolean logMessagesRetrieved = false;
    			ISVNLocalResource svnResource = SVNWorkspaceRoot.getSVNResourceFor(remoteResource.getResource());
    			if (svnResource != null) {
    				LocalResourceStatus status = svnResource.getStatus();
    				if (status != null && status.isCopied()) {
    					ISVNInfo info = svnClient.getInfoFromWorkingCopy(svnResource.getFile());
    					SVNUrl copiedFromUrl = info.getCopyUrl();
    					if (copiedFromUrl != null) {
    						svnClient.getLogMessages(copiedFromUrl, SVNRevision.HEAD, revisionStart, revisionEnd, stopOnCopy, !SVNProviderPlugin.getPlugin().getSVNClientManager().isFetchChangePathOnDemand(), limit, includeMergedRevisions, ISVNClientAdapter.DEFAULT_LOG_PROPERTIES, callback);
    						logMessagesRetrieved = true;
    		        		GetRemoteResourceCommand getRemoteResourceCommand = new GetRemoteResourceCommand(remoteResource.getRepository(), copiedFromUrl, SVNRevision.HEAD);
    		        		getRemoteResourceCommand.run(null);
    		        		remoteResource = getRemoteResourceCommand.getRemoteResource();
    					}
    				}
    			}
    			if (!logMessagesRetrieved) svnClient.getLogMessages(((BaseResource)remoteResource).getFile(), pegRevision, revisionStart, revisionEnd, stopOnCopy, !SVNProviderPlugin.getPlugin().getSVNClientManager().isFetchChangePathOnDemand(), limit, includeMergedRevisions, ISVNClientAdapter.DEFAULT_LOG_PROPERTIES, callback);
    		} else {
    			svnClient.getLogMessages(remoteResource.getUrl(), pegRevision, revisionStart, revisionEnd, stopOnCopy, !SVNProviderPlugin.getPlugin().getSVNClientManager().isFetchChangePathOnDemand(), limit, includeMergedRevisions, ISVNClientAdapter.DEFAULT_LOG_PROPERTIES, callback);
    		}
    		logMessages = callback.getLogMessages();
    	}
        if (remoteResource.isFolder()) {
            logEntries = LogEntry.createLogEntriesFrom((ISVNRemoteFolder) remoteResource, logMessages, getTags(logMessages));   
        } else {
        	logEntries = LogEntry.createLogEntriesFrom((ISVNRemoteFile) remoteResource, logMessages, getTags(logMessages), getUrls(logMessages));
        }

    } catch (Exception e) {
        throw SVNException.wrapException(e);
    } finally {
    	if (repository != null) {
    		repository.returnSVNClient(svnClient);
    	}
    	monitor.done();
    }
}
 

public void addChild(ISVNLogMessage msg) {
	if (children == null)
		children = new ArrayList<ISVNLogMessage>();
	children.add(msg);
}