import com.sleepycat.je.EnvironmentLockedException; //导入依赖的package包/类
public void init() throws EnvironmentLockedException, DatabaseException {
	EnvironmentConfig environmentConfig = new EnvironmentConfig();
	DatabaseConfig dbConfig = new DatabaseConfig();
	dbConfig.setAllowCreate(true);
	dbConfig.setSortedDuplicates(true);
	environmentConfig.setReadOnly(false);
	environmentConfig.setAllowCreate(true);
	// Open the environment and entity store
	if (!dataDir.exists()) {
		dataDir.mkdirs();
	}
	environment = new Environment(dataDir, environmentConfig);
	// Database database = environment.openDatabase(transaction, "BDB", dbConfig);
	this.bdb = new BdbDatabaseImpl(environment, "DEFAULT");
}
 

import com.sleepycat.je.EnvironmentLockedException; //导入依赖的package包/类
public TileDatabase(String mapSourceName, File databaseDirectory) throws IOException,
		EnvironmentLockedException, DatabaseException {
	log.debug("Opening tile store db: \"" + databaseDirectory + "\"");
	File storeDir = databaseDirectory;
	DelayedInterruptThread t = (DelayedInterruptThread) Thread.currentThread();
	try {
		t.pauseInterrupt();
		this.mapSourceName = mapSourceName;
		lastAccess = System.currentTimeMillis();

		Utilities.mkDirs(storeDir);

		env = new Environment(storeDir, envConfig);

		StoreConfig storeConfig = new StoreConfig();
		storeConfig.setAllowCreate(true);
		storeConfig.setTransactional(false);
		storeConfig.setMutations(mutations);
		store = new EntityStore(env, "TilesEntityStore", storeConfig);

		tileIndex = store.getPrimaryIndex(TileDbKey.class, TileDbEntry.class);
	} finally {
		if (t.interruptedWhilePaused())
			close();
		t.resumeInterrupt();
	}
}
 

import com.sleepycat.je.EnvironmentLockedException; //导入依赖的package包/类
public EnvironmentImpl(File envHome,
                       EnvironmentConfig envConfig,
                       EnvironmentImpl sharedCacheEnv)
    throws EnvironmentNotFoundException, EnvironmentLockedException {

    this(envHome, envConfig, sharedCacheEnv, null);
}
 

import com.sleepycat.je.EnvironmentLockedException; //导入依赖的package包/类
public InternalEnvironment(File envHome,
                           EnvironmentConfig configuration,
                           EnvironmentImpl envImpl)
    throws EnvironmentNotFoundException,
           EnvironmentLockedException,
           VersionMismatchException,
           DatabaseException,
           IllegalArgumentException {
    super(envHome, configuration, false /*openIfNeeded*/,
          null /*repConfigProxy*/, envImpl);
}
 

import com.sleepycat.je.EnvironmentLockedException; //导入依赖的package包/类
public RepImpl(File envHome,
               EnvironmentConfig envConfig,
               EnvironmentImpl sharedCacheEnv,
               RepConfigProxy repConfigProxy)
    throws EnvironmentNotFoundException, EnvironmentLockedException {

    super(envHome, envConfig, sharedCacheEnv, repConfigProxy);

    allowConvert =
        RepInternal.getAllowConvert(((ReplicationConfig) repConfigProxy));
    feederTxns = new FeederTxns(this);
    replay = new Replay(this, nameIdPair);
    nodeState = new NodeState(nameIdPair, this);
    repConfigObservers = new ArrayList<RepEnvConfigObserver>();
    addRepConfigObserver(this);

    nodeStats = new StatGroup(RepImplStatDefinition.GROUP_NAME,
                              RepImplStatDefinition.GROUP_DESC);
    hardRecoveryStat = new BooleanStat(nodeStats,
                                       RepImplStatDefinition.HARD_RECOVERY);
    hardRecoveryInfoStat =
        new StringStat(nodeStats, RepImplStatDefinition.HARD_RECOVERY_INFO,
                       "This node did not incur a hard recovery.");

    syncupProgressListener =
        ((ReplicationConfig)repConfigProxy).getSyncupProgressListener();
    logRewriteListener =
        ((ReplicationConfig)repConfigProxy).getLogFileRewriteListener();
}
 

import com.sleepycat.je.EnvironmentLockedException; //导入依赖的package包/类
private void listDbs()
    throws EnvironmentNotFoundException, EnvironmentLockedException {

    openEnv(true);

    List<String> dbNames = env.getDatabaseNames();
    Iterator<String> iter = dbNames.iterator();
    while (iter.hasNext()) {
        String name = iter.next();
        System.out.println(name);
    }
}
 

import com.sleepycat.je.EnvironmentLockedException; //导入依赖的package包/类
/**
 * Create an environment suitable for utilities. Utilities should in
 * general send trace output to the console and not to the db log.
 */
public static EnvironmentImpl makeUtilityEnvironment(File envHome,
                                                     boolean readOnly)
    throws EnvironmentNotFoundException, EnvironmentLockedException {

    EnvironmentConfig config = new EnvironmentConfig();
    config.setReadOnly(readOnly);

    /* Don't debug log to the database log. */
    config.setConfigParam(EnvironmentParams.JE_LOGGING_DBLOG.getName(),
                          "false");

    /* Don't run recovery. */
    config.setConfigParam(EnvironmentParams.ENV_RECOVERY.getName(),
                          "false");

    /* Apply the configuration in the je.properties file. */
    DbConfigManager.applyFileConfig
        (envHome, DbInternal.getProps(config), false);

    EnvironmentImpl envImpl =
        new EnvironmentImpl(envHome,
                            config,
                            null);
    envImpl.finishInit(config);

    return envImpl;
}
 

import com.sleepycat.je.EnvironmentLockedException; //导入依赖的package包/类
protected Environment initEnvironment() throws EnvironmentLockedException, DatabaseException {
	EnvironmentConfig envConfig = new EnvironmentConfig();
	envConfig.setAllowCreate(true);
	envConfig.setTransactional(true);
	envConfig.setSharedCache(true);
	envConfig.setCacheSize(sharedCacheSize);
	
	return new Environment(envDir, envConfig);
}
 

import com.sleepycat.je.EnvironmentLockedException; //导入依赖的package包/类
public Wikipedia(Conf conf) throws
		EnvironmentLockedException {
	this.env = new WEnvironment(conf) ;
}
 

import com.sleepycat.je.EnvironmentLockedException; //导入依赖的package包/类
/**
 * For internal use only.
 * @hidden
 *
 * Note that repImpl.joinGroup is a synchronized
 * method, and therefore protected against multiple concurrent attempts to
 * create a handle.
 *
 * @param envImpl is non-null only when used by EnvironmentIml to create an
 * InternalEnvironment.
 */
protected ReplicatedEnvironment(File envHome,
                                ReplicationConfig repConfig,
                                EnvironmentConfig envConfig,
                                ReplicaConsistencyPolicy consistencyPolicy,
                                QuorumPolicy initialElectionPolicy,
                                boolean joinGroup,
                                RepImpl envImplParam)
    throws EnvironmentNotFoundException,
           EnvironmentLockedException,
           ReplicaConsistencyException {

    super(envHome, envConfig, repConfig, envImplParam);

    repImpl = (RepImpl) envImpl;
    nameIdPair = repImpl.getNameIdPair();
    if (joinGroup) {
        try {
            joinGroup(consistencyPolicy, initialElectionPolicy);
        } catch (RollbackException e) {

            /*
             * Syncup failed, a hard recovery is needed. Throwing the
             * RollbackException closed the RepImpl and the EnvironmentImpl
             * Redo the creation of RepImpl and retry the join once. If the
             * second joinGroup fails, let the exception throw out to the
             * user.
             */
            envImpl = makeEnvironmentImpl(envHome, envConfig,
                                          true /*createIfNeeded*/,
                                          repConfig);
            repImpl = (RepImpl) envImpl;
            joinGroup(consistencyPolicy, initialElectionPolicy);
            repImpl.setHardRecoveryInfo(e);
        }

        /*
         * Fire a JoinGroupEvent only when the ReplicatedEnvironment is
         * successfully created for the first time.
         */
        if (repImpl.getRepNode() != null) {
            repImpl.getRepNode().
                getMonitorEventManager().notifyJoinGroup();
        }
    } else {
        /* For testing only */
        if (repImpl.getRepNode() != null) {
            throw EnvironmentFailureException.unexpectedState
                ("An earlier handle creation had resulted in the node" +
                 "joining the group");
        }
    }
}
 

import com.sleepycat.je.EnvironmentLockedException; //导入依赖的package包/类
/**
 * Start the scavenger run.
 */
@Override
public void dump()
    throws EnvironmentNotFoundException,
           EnvironmentLockedException,
           IOException {

    openEnv(false);

    envImpl = DbInternal.getEnvironmentImpl(env);
    DbConfigManager cm = envImpl.getConfigManager();
    readBufferSize = cm.getInt(EnvironmentParams.LOG_ITERATOR_READ_SIZE);

    /*
     * Find the end of the log.
     */
    LastFileReader reader = new LastFileReader(envImpl, readBufferSize);
    while (reader.readNextEntry()) {
    }

    /* Tell the fileManager where the end of the log is. */
    long lastUsedLsn = reader.getLastValidLsn();
    long nextAvailableLsn = reader.getEndOfLog();
    envImpl.getFileManager().setLastPosition(nextAvailableLsn,
                                             lastUsedLsn,
                                             reader.getPrevOffset());

    try {
        /* Pass 1: Scavenge the dbtree. */
        if (verbose) {
            System.out.println("Pass 1: " + new Date());
        }
        scavengeDbTree(lastUsedLsn, nextAvailableLsn);

        /* Pass 2: Scavenge the databases. */
        if (verbose) {
            System.out.println("Pass 2: " + new Date());
        }
        scavenge(lastUsedLsn, nextAvailableLsn);

        if (verbose) {
            System.out.println("End: " + new Date());
        }
    } finally {
        closeOutputStreams();
    }
}
 

import com.sleepycat.je.EnvironmentLockedException; //导入依赖的package包/类
/**
 * Perform the dump.
 *
 * @throws EnvironmentFailureException if an unexpected, internal or
 * environment-wide failure occurs.
 *
 * @throws IOException in subclasses.
 */
public void dump()
    throws EnvironmentNotFoundException,
           EnvironmentLockedException,
           DatabaseNotFoundException,
           IOException {

    openEnv(true);

    LoggerUtils.envLogMsg(Level.INFO, DbInternal.getEnvironmentImpl(env),
                          "DbDump.dump of " + dbName + " starting");

    DatabaseEntry foundKey = new DatabaseEntry();
    DatabaseEntry foundData = new DatabaseEntry();

    DatabaseConfig dbConfig = new DatabaseConfig();
    dbConfig.setReadOnly(true);
    DbInternal.setUseExistingConfig(dbConfig, true);
    Database db;
    try {
        db = env.openDatabase(null, dbName, dbConfig);
    } catch (DatabaseExistsException e) {
        /* Should never happen, ExclusiveCreate is false. */
        throw EnvironmentFailureException.unexpectedException(e);
    }
    dupSort = db.getConfig().getSortedDuplicates();

    printHeader(outputFile, dupSort, formatUsingPrintable);

    Cursor cursor = db.openCursor(null, null);
    while (cursor.getNext(foundKey, foundData, LockMode.DEFAULT) ==
           OperationStatus.SUCCESS) {
        dumpOne(outputFile, foundKey.getData(), formatUsingPrintable);
        dumpOne(outputFile, foundData.getData(), formatUsingPrintable);
    }
    cursor.close();
    db.close();
    outputFile.println("DATA=END");

    LoggerUtils.envLogMsg(Level.INFO, DbInternal.getEnvironmentImpl(env),
                          "DbDump.dump of " + dbName + " ending");
}
 

import com.sleepycat.je.EnvironmentLockedException; //导入依赖的package包/类
public static void main(String[] args) throws EnvironmentLockedException, DatabaseException, IOException {
	
	if (args.length != 1) {		
		System.out.println("Please specify a directory containing a fully prepared Wikipedia database") ;
		return ;
	}
	
	File envDir = new File(args[0]) ;
	
	WikipediaConfiguration conf = new WikipediaConfiguration("en", envDir) ;

	CommandLineThesaurus clt = new CommandLineThesaurus(conf) ;
	clt.start() ;
	
	
	
}
 

import com.sleepycat.je.EnvironmentLockedException; //导入依赖的package包/类
public static void main(String args[]) throws EnvironmentLockedException, ParserConfigurationException, SAXException, IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
	
	File sentenceModel = new File("models/en-sent.bin") ;
	
	
	File wikiConf = new File("configs/en.xml") ;
	
	Wikipedia wiki = new Wikipedia(wikiConf, false) ;
	
	
	
	SnippetExtractor se = new SnippetExtractor(wiki, sentenceModel) ;
	
	File artTitles = new File("data/sentenceArticles.txt") ;
	Vector<Article> articles = se.gatherArticles(artTitles) ;
	
	//se.testAllArticles(articles) ;
	
	se.testSentenceExtraction(wiki.getArticleByTitle("Carnivore")) ;
	
	
	
}
 

import com.sleepycat.je.EnvironmentLockedException; //导入依赖的package包/类
public CommandLineThesaurus(WikipediaConfiguration conf) throws EnvironmentLockedException, DatabaseException {
	
	
	
	
	wikipedia = new Wikipedia(conf, false) ;	
	input = new BufferedReader(new InputStreamReader(System.in));
	stripper = new MarkupStripper() ;
}
 

import com.sleepycat.je.EnvironmentLockedException; //导入依赖的package包/类
/**
 * Initialises a newly created Wikipedia according to the given configuration. 
 * 
 * This can be a time consuming process if the given configuration specifies databases that need to be cached to memory.
 * 
 * This preparation can be done in a separate thread if required, in which case progress can be tracked using {@link #getProgress()}, {@link #getPreparationTracker()} and {@link #isReady()}.
 *  
 * @param conf a configuration that describes where the databases are located, etc. 
 * @param threadedPreparation true if preparation (connecting to databases, caching data to memory) should be done in a separate thread, otherwise false
 * @throws EnvironmentLockedException if the underlying database environment is unavailable.
 */
public Wikipedia(WikipediaConfiguration conf, boolean threadedPreparation) throws EnvironmentLockedException{
	this.env = new WEnvironment(conf, threadedPreparation) ; 
}