import org.neo4j.kernel.impl.util.StringLogger; //导入依赖的package包/类
Collection<KernelExtension<?>> loadExtensionConfigurations( StringLogger msgLog )
{
    Collection<KernelExtension<?>> loadedExtensions = new ArrayList<KernelExtension<?>>();
    for ( KernelExtension<?> extension : Service.load( KernelExtension.class ) )
    {
        try
        {
            extension.loadConfiguration( this );
            loadedExtensions.add( extension );
        }
        catch ( Throwable t )
        {
            msgLog.logMessage( "Failed to init extension " + extension, t, true );
        }
    }
    return loadedExtensions;
}
 

import org.neo4j.kernel.impl.util.StringLogger; //导入依赖的package包/类
void loadExtensions( Collection<KernelExtension<?>> loadedExtensions, StringLogger msgLog )
{
    for ( KernelExtension<?> extension : loadedExtensions )
    {
        try
        {
            @SuppressWarnings( "hiding" ) Object state = extension.load( this );
            if ( state != null )
            {
                setState( extension, state );
            }
            msgLog.logMessage( "Extension " + extension + " loaded ok", true );
        }
        catch ( Throwable cause )
        {
            msgLog.logMessage( "Failed to load extension " + extension, cause, true );
        }
    }
}
 

import org.neo4j.kernel.impl.util.StringLogger; //导入依赖的package包/类
synchronized void shutdown( StringLogger msgLog )
{
    try
    {
        for ( Map.Entry<KernelExtension<?>, Object> loaded : state.entrySet() )
        {
            try
            {
                unload( loaded.getKey(), loaded.getValue() );
            }
            catch ( Throwable cause )
            {
                msgLog.logMessage( "Error unloading " + loaded, cause, true );
            }
        }
    }
    finally
    {
        state.clear();
        removeInstance( instanceId );
    }
}
 

import org.neo4j.kernel.impl.util.StringLogger; //导入依赖的package包/类
@Override
public void stop()
{
    if ( txLog != null )
    {
        try
        {
            txLog.close();
        }
        catch ( IOException e )
        {
            log.log( Level.WARNING, "Unable to close tx log[" + txLog.getName() + "]", e );
        }
    }
    msgLog.logMessage( "TM shutting down", true );
    StringLogger.close( txLogDir );
}
 

import org.neo4j.kernel.impl.util.StringLogger; //导入依赖的package包/类
XaLogicalLog( String fileName, XaResourceManager xaRm, XaCommandFactory cf,
    XaTransactionFactory xaTf, Map<Object,Object> config )
{
    this.fileName = fileName;
    this.xaRm = xaRm;
    this.cf = cf;
    this.xaTf = xaTf;
    this.logBufferFactory = (LogBufferFactory) config.get( LogBufferFactory.class );
    log = Logger.getLogger( this.getClass().getName() + File.separator + fileName );
    sharedBuffer = ByteBuffer.allocateDirect( 9 + Xid.MAXGTRIDSIZE
        + Xid.MAXBQUALSIZE * 10 );
    storeDir = (String) config.get( "store_dir" );
    msgLog = StringLogger.getLogger( storeDir);

    // We should turn keep-logs on if there are previous logs around,
    // this so that e.g. temporary shell sessions or operations don't create
    // holes in the log history, because it's just annoying.
    keepLogs = hasPreviousLogs();
}
 

import org.neo4j.kernel.impl.util.StringLogger; //导入依赖的package包/类
void loadIndexImplementations( IndexManagerImpl indexes, StringLogger msgLog )
{
    for ( IndexProvider index : Service.load( IndexProvider.class ) )
    {
        try
        {
            indexes.addProvider( index.identifier(), index.load( this ) );
        }
        catch ( Throwable cause )
        {
            msgLog.logMessage( "Failed to load index provider " + index.identifier(), cause );
        }
    }
}
 

import org.neo4j.kernel.impl.util.StringLogger; //导入依赖的package包/类
TxManager( String txLogDir, KernelPanicEventGenerator kpe, TxFinishHook finishHook )
{
    this.txLogDir = txLogDir;
    this.msgLog = StringLogger.getLogger( txLogDir );
    this.kpe = kpe;
    this.finishHook = finishHook;
}
 

import org.neo4j.kernel.impl.util.StringLogger; //导入依赖的package包/类
synchronized void setLogicalLog( XaLogicalLog log )
{
    this.log = log;
    if ( log != null )
    {
        this.msgLog = log.getStringLogger();
    }
    else
    {
        this.msgLog = StringLogger.SYSTEM;
    }
}
 

import org.neo4j.kernel.impl.util.StringLogger; //导入依赖的package包/类
public BatchInserterImpl( String storeDir,
    Map<String,String> stringParams )
{
    rejectAutoUpgrade( stringParams );
    msgLog = StringLogger.getLogger( storeDir );
    Map<Object,Object> params = getDefaultParams();
    params.put( Config.USE_MEMORY_MAPPED_BUFFERS, "false" );
    boolean dump = Boolean.parseBoolean( stringParams.get( Config.DUMP_CONFIGURATION ) );
    new AutoConfigurator( storeDir, false, dump ).configure( params );
    for ( Map.Entry<String,String> entry : stringParams.entrySet() )
    {
        params.put( entry.getKey(), entry.getValue() );
    }
    this.storeDir = storeDir;
    this.idGeneratorFactory = CommonFactories.defaultIdGeneratorFactory();
    params.put( IdGeneratorFactory.class, idGeneratorFactory );
    params.put( FileSystemAbstraction.class, CommonFactories.defaultFileSystemAbstraction() );
    String store = fixPath( storeDir, params );
    params.put( "neo_store", store );
    if ( dump )
    {
        Config.dumpConfiguration( params );
    }
    msgLog.logMessage( Thread.currentThread() + " Starting BatchInserter(" + this + ")" );
    neoStore = new NeoStore( params );
    if ( !neoStore.isStoreOk() )
    {
        throw new IllegalStateException( storeDir + " store is not cleanly shutdown." );
    }
    neoStore.makeStoreOk();
    PropertyIndexData[] indexes =
        getPropertyIndexStore().getPropertyIndexes( 10000 );
    indexHolder = new PropertyIndexHolder( indexes );
    RelationshipTypeData[] types =
        getRelationshipTypeStore().getRelationshipTypes();
    typeHolder = new RelationshipTypeHolder( types );
    graphDbService = new BatchGraphDatabaseImpl( this );
    indexStore = new IndexStore( storeDir );
}
 

import org.neo4j.kernel.impl.util.StringLogger; //导入依赖的package包/类
public void shutdown()
{
    graphDbService.clearCaches();
    neoStore.close();
    msgLog.logMessage( Thread.currentThread() + " Clean shutdown on BatchInserter(" + this + ")", true );
    StringLogger.close( storeDir );
}
 

import org.neo4j.kernel.impl.util.StringLogger; //导入依赖的package包/类
private void loadIdGenerator()
{
    try
    {
        if ( !isReadOnly() || isBackupSlave() )
        {
            openIdGenerator();
        }
        else
        {
            openReadOnlyIdGenerator( getEffectiveRecordSize());
        }
    }
    catch ( InvalidIdGeneratorException e )
    {
        setStoreNotOk( e );
    }
    finally
    {
        if ( !getStoreOk() )
        {
            if ( getConfig() != null )
            {
                String storeDir = (String) getConfig().get( "store_dir" );
                StringLogger msgLog = StringLogger.getLogger( storeDir );
                msgLog.logMessage( getStorageFileName() + " non clean shutdown detected", true );
            }
        }
    }
}
 

import org.neo4j.kernel.impl.util.StringLogger; //导入依赖的package包/类
/**
 * 
 * @param dbService
 * @param KG 
 */
public static void importFromN4j(GraphDatabaseService dbService, KnowledgeGraph KG) {
    ExecutionResult result;
    ExecutionEngine engine = new ExecutionEngine(dbService, StringLogger.SYSTEM);
    
    try(Transaction importDb = dbService.beginTx()) {
        result = engine.execute("start n=node(*) return n");
        scala.collection.immutable.Vector<Object> results = result.columnAs("n").toVector();
        
        for(int i = 0; i < results.length(); i++) {
            org.neo4j.graphdb.Node node = (org.neo4j.graphdb.Node) results.getElem(i, 0);
            
            switch((String) node.getProperty("type")) {
                case "HumanAgent":
                    Agent a = new HumanAgent((String) node.getProperty("name"));
                    a.setId((int) node.getProperty("id"));
                    KG.addResource(a);
                    break;
                    
                case "ArtificialAgent":
                    Agent aa = new ArtificialAgent((String) node.getProperty("name"));
                    aa.setId((int) node.getProperty("id"));
                    KG.addResource(aa);
                    break;
                    
                case "Topic":
                    Topic t = new Topic((String) node.getProperty("name"));
                    t.setId((int) node.getProperty("id"));
                    KG.addResource(t);
                    break;
                    
                case "Document":
                    Document d = new Document((String) node.getProperty("name"));
                    d.setId((int) node.getProperty("id"));
                    KG.addResource(d);
                    break;
            }
            
            if(((String) node.getProperty("type")).contains("Viewpoint")) {
                ConnectedViewpoint v;
                Agent emitter = null;
                ArrayList<Resource> o = new ArrayList<>();

                Iterable<Relationship> expressesRels =  node.getRelationships(N4jEdgeType.EXPRESSES_VIEWPOINT);
                for(Relationship expressesRel : expressesRels)
                    emitter = (Agent) KG.getNamedObject((String) expressesRel.getOtherNode(node).getProperty("name"));

                Iterable<Relationship> connectorRels =  node.getRelationships(N4jEdgeType.VIEWPOINT_CONNECTOR);
                for(Relationship connectorRel : connectorRels)
                    o.add(KG.getNamedObject((String) connectorRel.getOtherNode(node).getProperty("name")));

                v = ViewpointFactory.newInstance(emitter, o.get(0), o.get(1), (String) node.getProperty("type"), ViewpointPolarity.POSITIVE);
                emitter.getPerspective().addViewpoint(v);
                v.setCorrespondingNode(node);
                KG.addViewpoint(v);
                break;
            }
            
        }
        
        importDb.success();
    }
}
 

import org.neo4j.kernel.impl.util.StringLogger; //导入依赖的package包/类
public ZmqServer(GraphDatabaseService db, StringLogger logger, HostnamePort hostnamePort, Integer numThreads) {
}
 

import org.neo4j.kernel.impl.util.StringLogger; //导入依赖的package包/类
StringLogger getStringLogger()
{
    return msgLog;
}
 

import org.neo4j.kernel.impl.util.StringLogger; //导入依赖的package包/类
/**
 * Constructor used by the Neo4j kernel to create datasources.
 *
 * @param params
 *            A map containing configuration parameters
 */
public XaDataSource( Map<?,?> params ) throws InstantiationException
{
    String storeDir = (String) params.get( "store_dir" );
    msgLog = StringLogger.getLogger( storeDir );
}
 

import org.neo4j.kernel.impl.util.StringLogger; //导入依赖的package包/类
/**
 * Creates a new Executor wich queries the given database.
 * 
 * @param db
 */
public Neo4JExecutor(Neo4JConnection db) {
	cypher = new ExecutionEngine(db.getConnection(), StringLogger.DEV_NULL);
}
 

import org.neo4j.kernel.impl.util.StringLogger; //导入依赖的package包/类
StringLogger getStringLogger();