Java FSRepositoryFactory类代码示例

import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory; //导入依赖的package包/类
public static void setupLibrary(String url) {
	// For using over http:// and https://
	if (url.startsWith("http://") || url.startsWith("https://")) {
		DAVRepositoryFactory.setup();
	}

	// For using over http:// and https://
	if (url.startsWith("svn")) {
		SVNRepositoryFactoryImpl.setup();
	}

	// For using over file:///
	if (url.startsWith("file://")) {
		FSRepositoryFactory.setup();
	}
}
 

import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory; //导入依赖的package包/类
/**
 * Initializes the library to work with a repository either via svn:// (and
 * svn+ssh://) or via http:// (and https://)
 */
private static void initialize()
{
    if ( initialized )
    {
        return;
    }

    /*
     * for DAV (over http and https)
     */
    DAVRepositoryFactory.setup();

    /*
    * for svn (over svn and svn+ssh)
    */
    SVNRepositoryFactoryImpl.setup();

    /*
     * for file
     */
    FSRepositoryFactory.setup();
    initialized = true;
}
 

import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory; //导入依赖的package包/类
/**
 * Set up repository. This method also determines the head revision of the
 * repository.
 * 
 * @throws ConQATException
 *             if setup fails.
 */
protected SVNRepository createRepository() throws ConQATException {
	DAVRepositoryFactory.setup();
	FSRepositoryFactory.setup();
	
	try {
		SVNRepository repository = SVNRepositoryFactory.create(SVNURL
				.parseURIEncoded(url));

		ISVNAuthenticationManager authManager;
		if (userName != null) {
			authManager = SVNWCUtil.createDefaultAuthenticationManager(
					userName, password);
		} else {
			authManager = SVNWCUtil.createDefaultAuthenticationManager();
		}
		repository.setAuthenticationManager(authManager);

		return repository;

	} catch (SVNException e) {
		throw new ConQATException(e);
	}
}
 

import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory; //导入依赖的package包/类
/**
 * Initializes the library to work with a repository via
 * different protocols.
 */
private static void setupLibrary() {
    /*
     * For using over http:// and https://
     */
    DAVRepositoryFactory.setup();
    /*
     * For using over svn:// and svn+xxx://
     */
    SVNRepositoryFactoryImpl.setup();

    /*
     * For using over file:///
     */
    FSRepositoryFactory.setup();
}
 

import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory; //导入依赖的package包/类
public static void iniciaRepositorio(String url) {

        String[] partes = url.split(":");

        if (partes.length > 1) {
            if (partes[0].equals("http") || partes[0].equals("https")) {
                DAVRepositoryFactory.setup();
            } else if (partes[0].equals("file")) {
                FSRepositoryFactory.setup();
            } else {
                SVNRepositoryFactoryImpl.setup();
            }
        } else {
            throw new IndexOutOfBoundsException("URL inválida.");
        }
    }
 

import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory; //导入依赖的package包/类
public synchronized void initRepositoryFactory(final String repositoryUrl) {
    if (repositoryUrl.matches("^file://.*$") && !FSRepositoryInitialized) {
        System.out.println("----------------> Initializing FSRepositoryFactory");
        FSRepositoryFactory.setup();
        FSRepositoryInitialized = true;

    } else if (repositoryUrl.matches("^https?://.*$") && !DAVRepositoryInitialized) {
        System.out.println("----------------> Initializing DAVRepositoryFactory");
        DAVRepositoryFactory.setup();
        DAVRepositoryInitialized = true;

    } else if (repositoryUrl.matches("^svn(\\+.+)?://.*$") && !SVNRepositoryInitialized) {
        System.out.println("----------------> Initializing SVNRepositoryFactory");
        SVNRepositoryFactoryImpl.setup();
        DAVRepositoryInitialized = true;
    }
}
 

import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory; //导入依赖的package包/类
@BeforeClass
public static void setUpClass() throws Exception {
    System.out.println("ESTABELECENDO O SVN");
    /*
     * Para uso sobre http:// e https://
     */
    DAVRepositoryFactory.setup();
    /*
     * Para uso sobre svn:// e svn+xxx://
     */
    SVNRepositoryFactoryImpl.setup();
    /*
     * Para uso sobre  file:///
     */
    FSRepositoryFactory.setup();
    System.out.println("SVN ESTABELECIDO");
}
 

import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory; //导入依赖的package包/类
private static void setupLibrary() {
	/*
	 * For using over http:// and https://
	 */
	DAVRepositoryFactory.setup();
	/*
	 * For using over svn:// and svn+xxx://
	 */
	SVNRepositoryFactoryImpl.setup();

	/*
	 * For using over file:///
	 */
	FSRepositoryFactory.setup();
}
 

import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory; //导入依赖的package包/类
private void setupType(final String url) throws SVNException {
    svnurl = SVNURL.parseURIDecoded(url);

    if (url.startsWith("http")) {
        DAVRepositoryFactory.setup();
        repository = SVNRepositoryFactory.create(svnurl);
    } else if (url.startsWith("svn")) {
        SVNRepositoryFactoryImpl.setup();
        repository = SVNRepositoryFactory.create(svnurl);
    } else {
        FSRepositoryFactory.setup();
        repository = SVNRepositoryFactory.create(svnurl);
    }
}
 

import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory; //导入依赖的package包/类
private static void setupLibrary() {
    /*
     * For using over http:// and https://
     */
    DAVRepositoryFactory.setup();
    /*
     * For using over svn:// and svn+xxx://
     */
    SVNRepositoryFactoryImpl.setup();
    
    /*
     * For using over file:///
     */
    FSRepositoryFactory.setup();
}
 

import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory; //导入依赖的package包/类
public static SCMStatus doStatus(File baseDir) throws RuntimeException {
    // initialize SVNKit to work through file:/// protocol
    FSRepositoryFactory.setup();

    SVNClientManager clientManager = SVNClientManager.newInstance();
    SVNStatusClient statusClient = clientManager.getStatusClient();
    Map<String, Boolean> map = new HashMap<String, Boolean>();
    ISVNStatusHandler handler = new StatusHandler(baseDir, map);

    try {
        statusClient.doStatus(baseDir,
            SVNRevision.WORKING,
            SVNDepth.INFINITY,
            false /* remote */,
            true /* reportAll */,
            false /* includeIgnored */,
            false /* collectParentExternals */,
            handler, null);
    } catch (SVNException svne) {
        throw new RuntimeException(svne);
    }

    int counter = 0;
    for (Boolean b : map.values()) {
        if (b == Boolean.TRUE) {
            counter++;
        }
    }

    log.info("-----------------------------------------------------------------------------------------------");
    log.info("PROJECT IS UNDER SVN: Files tracked by svn ({}) won't be overwritten/deleted by Celerio", counter);
    log.info("-----------------------------------------------------------------------------------------------");

    return new SCMStatus(map);
}
 

import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory; //导入依赖的package包/类
/**
 * Initialises repository to accept requests for svn protocol.
 */
public SvnRepository() {
  super();
  FSRepositoryFactory.setup();
  DAVRepositoryFactory.setup();
  SVNRepositoryFactoryImpl.setup();
  try {
    Manifest manifest = getManifest(this.getClass());
    Attributes attributes = manifest.getMainAttributes();
    Message.info("IvySvn Build-Version: " + attributes.getValue("Build-Version"));
    Message.info("IvySvn Build-DateTime: " + attributes.getValue("Build-DateTime"));
  } catch (IOException e) {
    Message.warn("Could not load manifest: " + e.getMessage());
  }
}
 

import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory; //导入依赖的package包/类
@Before
public void setUp() throws SVNException {
  FSRepositoryFactory.setup();
  DAVRepositoryFactory.setup();
  SVNRepositoryFactoryImpl.setup();
  testTempFolder.mkdirs();
  creatIvyRepositoryRoot();
  ivyRepositoryRootURL = SVNURL.parseURIEncoded(ivyRepositoryRoot);
  readRepository = SvnUtils.createRepository(ivyRepositoryRootURL, svnUserName, svnPassword, null, null, -1, null,
      null, false);
  svnDAO = new SvnDao(readRepository);
}
 

import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory; //导入依赖的package包/类
public static void setupLibrary() {
	DAVRepositoryFactory.setup();
	SVNRepositoryFactoryImpl.setup();
	FSRepositoryFactory.setup();
}
 

import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory; //导入依赖的package包/类
/***

	     * 通过不同的协议初始化版本库

	     */

	    private static void setupLibrary() {

	       // 对于使用http://和https：//

	       DAVRepositoryFactory.setup();

	       //对于使用svn：/ /和svn+xxx：/ /

	       SVNRepositoryFactoryImpl.setup();

	       //对于使用file://

	       FSRepositoryFactory.setup();

	}