import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
private void loadGraph() {
    final File f = new File(graphLocation);
    if (f.exists() && f.isFile()) {
        try {
            if (graphFormat.equals("graphml")) {
                io(IoCore.graphml()).readGraph(graphLocation);
            } else if (graphFormat.equals("graphson")) {
                io(IoCore.graphson()).readGraph(graphLocation);
            } else if (graphFormat.equals("gryo")) {
                io(IoCore.gryo()).readGraph(graphLocation);
            } else {
                io(IoCore.createIoBuilder(graphFormat)).readGraph(graphLocation);
            }
        } catch (Exception ex) {
            throw new RuntimeException(String.format("Could not load graph at %s with %s", graphLocation, graphFormat), ex);
        }
    }
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
public boolean loadGraph(String name)
{
  tg = TinkerGraph.open() ;
  
  try
  {
    tg.io(IoCore.graphml()).readGraph(name);
  }
  catch( IOException e )
  {
    System.out.println("GraphStats - GraphML file not found");
    return false;
  }
  g = tg.traversal();
  return true;
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
public boolean loadGraph(String name)
{
  tg = TinkerGraph.open() ;
  
  try
  {
    tg.io(IoCore.graphml()).readGraph(name);
  }
  catch( IOException e )
  {
    System.out.println("GraphStats - Air routes GraphML file not found");
    return false;
  }
  g = tg.traversal();
  return true;
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
private void saveGraph() {
    final File f = new File(graphLocation);
    if (f.exists()) {
        f.delete();
    } else {
        final File parent = f.getParentFile();
        if (!parent.exists()) {
            parent.mkdirs();
        }
    }

    try {
        if (graphFormat.equals("graphml")) {
            io(IoCore.graphml()).writeGraph(graphLocation);
        } else if (graphFormat.equals("graphson")) {
            io(IoCore.graphson()).writeGraph(graphLocation);
        } else if (graphFormat.equals("gryo")) {
            io(IoCore.gryo()).writeGraph(graphLocation);
        } else {
            io(IoCore.createIoBuilder(graphFormat)).writeGraph(graphLocation);
        }
    } catch (Exception ex) {
        throw new RuntimeException(String.format("Could not save graph at %s with %s", graphLocation, graphFormat), ex);
    }
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
private void loadGraph() {
	final File f = new File(graphLocation);
    if (f.exists() && f.isFile()) {
        try {
            if (graphFormat.equals("graphml")) {
                io(IoCore.graphml()).readGraph(graphLocation);
            } else if (graphFormat.equals("graphson")) {
                io(IoCore.graphson()).readGraph(graphLocation);
            } else if (graphFormat.equals("gryo")) {
                io(IoCore.gryo()).readGraph(graphLocation);
            } else {
                io(IoCore.createIoBuilder(graphFormat)).readGraph(graphLocation);
            }
        } catch (Exception ex) {
            throw new RuntimeException(String.format("Could not load graph at %s with %s", graphLocation, graphFormat), ex);
        }
    }
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
private void saveGraph() {
	
	final File f = new File(graphLocation);
    if (f.exists()) {
        f.delete();
    } else {
        final File parent = f.getParentFile();
        if (!parent.exists()) {
            parent.mkdirs();
        }
    }

    try {
        if (graphFormat.equals("graphml")) {
            io(IoCore.graphml()).writeGraph(graphLocation);
        } else if (graphFormat.equals("graphson")) {
            io(IoCore.graphson()).writeGraph(graphLocation);
        } else if (graphFormat.equals("gryo")) {
            io(IoCore.gryo()).writeGraph(graphLocation);
        } else {
            io(IoCore.createIoBuilder(graphFormat)).writeGraph(graphLocation);
        }
    } catch (Exception ex) {
        throw new RuntimeException(String.format("Could not save graph at %s with %s", graphLocation, graphFormat), ex);
    }
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
@Override
public void persistModel() throws IOException, XMLStreamException, ClassNotFoundException, IllegalAccessException,
		InstantiationException {
	final TinkerGraphFormat format = gc.getGraphFormat();
	Builder<?> builder = null;
	switch (format) {
	case GRAPHML:
		builder = IoCore.graphml();
		break;
	case GRAPHSON:
		builder = IoCore.graphson();
		break;
	case GRYO:
		builder = IoCore.gryo();
		break;
	default:
		throw new UnsupportedOperationException("Format " + format + " is not supported.");
	}

	final String postfix = "-tinkerpop." + format.toString().toLowerCase();
	final String fileName = gc.getConfigBase().getModelPathWithoutExtension() + postfix;
	graph.io(builder).writeGraph(fileName);
	graph.close();
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
public String writeGraph() {
  java.io.OutputStream output = new java.io.OutputStream() {
    private StringBuilder stringBuilder = new StringBuilder();
    @Override
    public void write(int chr) throws java.io.IOException {
      stringBuilder.append((char) chr );
    }

    @Override
    public String toString() {
      return stringBuilder.toString();
    }
  };
  try {
    graph.io(IoCore.graphson()).writer().create().writeGraph(output, graph);
  } catch (java.io.IOException e) {
    e.printStackTrace();
  }

  String wellformedJson = "[" + String.join(",\n", (CharSequence[]) output.toString().split("\n")) + "]";
  com.google.gson.Gson gson = new GsonBuilder().setPrettyPrinting().create();
  com.google.gson.JsonParser jp = new JsonParser();
  com.google.gson.JsonElement je = jp.parse(wellformedJson);
  return gson.toJson(je);
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
private void saveGraph() {
    final File f = new File(graphLocation);
    if (f.exists()) {
        f.delete();
    } else {
        final File parent = f.getParentFile();

        // the parent would be null in the case of an relative path if the graphLocation was simply: "f.gryo"
        if (parent != null && !parent.exists()) {
            parent.mkdirs();
        }
    }

    try {
        if (graphFormat.equals("graphml")) {
            io(IoCore.graphml()).writeGraph(graphLocation);
        } else if (graphFormat.equals("graphson")) {
            io(IoCore.graphson()).writeGraph(graphLocation);
        } else if (graphFormat.equals("gryo")) {
            io(IoCore.gryo()).writeGraph(graphLocation);
        } else {
            io(IoCore.createIoBuilder(graphFormat)).writeGraph(graphLocation);
        }
    } catch (Exception ex) {
        throw new RuntimeException(String.format("Could not save graph at %s with %s", graphLocation, graphFormat), ex);
    }
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
@Test
public void shouldSerializeTinkerGraphToGryo() throws Exception {
    final TinkerGraph graph = TinkerFactory.createModern();
    try (final ByteArrayOutputStream out = new ByteArrayOutputStream()) {
        graph.io(IoCore.gryo()).writer().create().writeObject(out, graph);
        final byte[] b = out.toByteArray();
        try (final ByteArrayInputStream inputStream = new ByteArrayInputStream(b)) {
            final TinkerGraph target = graph.io(IoCore.gryo()).reader().create().readObject(inputStream, TinkerGraph.class);
            IoTest.assertModernGraph(target, true, false);
        }
    }
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
@Test
public void shouldSerializeTinkerGraphWithMultiPropertiesToGryo() throws Exception {
    final TinkerGraph graph = TinkerFactory.createTheCrew();
    try (final ByteArrayOutputStream out = new ByteArrayOutputStream()) {
        graph.io(IoCore.gryo()).writer().create().writeObject(out, graph);
        final byte[] b = out.toByteArray();
        try (final ByteArrayInputStream inputStream = new ByteArrayInputStream(b)) {
            final TinkerGraph target = graph.io(IoCore.gryo()).reader().create().readObject(inputStream, TinkerGraph.class);
            IoTest.assertCrewGraph(target, false);
        }
    }
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
@Test
public void shouldSerializeTinkerGraphToGraphSON() throws Exception {
    final TinkerGraph graph = TinkerFactory.createModern();
    try (final ByteArrayOutputStream out = new ByteArrayOutputStream()) {
        graph.io(IoCore.graphson()).writer().create().writeObject(out, graph);
        try (final ByteArrayInputStream inputStream = new ByteArrayInputStream(out.toByteArray())) {
            final TinkerGraph target = graph.io(IoCore.graphson()).reader().create().readObject(inputStream, TinkerGraph.class);
            IoTest.assertModernGraph(target, true, false);
        }
    }
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
@Test
public void shouldSerializeTinkerGraphWithMultiPropertiesToGraphSON() throws Exception {
    final TinkerGraph graph = TinkerFactory.createTheCrew();
    try (final ByteArrayOutputStream out = new ByteArrayOutputStream()) {
        graph.io(IoCore.graphson()).writer().create().writeObject(out, graph);
        try (final ByteArrayInputStream inputStream = new ByteArrayInputStream(out.toByteArray())) {
            final TinkerGraph target = graph.io(IoCore.graphson()).reader().create().readObject(inputStream, TinkerGraph.class);
            IoTest.assertCrewGraph(target, false);
        }
    }
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
@Test
public void shouldSerializeTinkerGraphToGraphSONWithTypes() throws Exception {
    final TinkerGraph graph = TinkerFactory.createModern();
    final Mapper<ObjectMapper> mapper = graph.io(IoCore.graphson()).mapper().typeInfo(TypeInfo.PARTIAL_TYPES).create();
    try (final ByteArrayOutputStream out = new ByteArrayOutputStream()) {
        final GraphWriter writer = GraphSONWriter.build().mapper(mapper).create();
        writer.writeObject(out, graph);
        try (final ByteArrayInputStream inputStream = new ByteArrayInputStream(out.toByteArray())) {
            final GraphReader reader = GraphSONReader.build().mapper(mapper).create();
            final TinkerGraph target = reader.readObject(inputStream, TinkerGraph.class);
            IoTest.assertModernGraph(target, true, false);
        }
    }
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
@Override
public void setup(final Map<String,Object> config) {
    logger.info("Initializing authentication with the {}", SimpleAuthenticator.class.getName());

    if (null == config) {
        throw new IllegalArgumentException(String.format(
                "Could not configure a %s - provide a 'config' in the 'authentication' settings",
                SimpleAuthenticator.class.getName()));
    }

    if (!config.containsKey(CONFIG_CREDENTIALS_DB)) {
        throw new IllegalStateException(String.format(
                "Credentials configuration missing the %s key that points to a graph config file", CONFIG_CREDENTIALS_DB));
    }

    final Graph graph = GraphFactory.open((String) config.get(CONFIG_CREDENTIALS_DB));

    if (graph instanceof TinkerGraph) {
        // have to create the indices because they are not stored in gryo
        final TinkerGraph tinkerGraph = (TinkerGraph) graph;
        tinkerGraph.createIndex(PROPERTY_USERNAME, Vertex.class);

        // we deprecated credentialsLocation, but we still need to support it.  if it is present as a key, we can
        // load the data as we always did.
        if (config.containsKey(CONFIG_CREDENTIALS_LOCATION)) {
            logger.warn("Using {} configuration option which is deprecated - prefer including the location of the credentials graph data in the TinkerGraph config file.");
            final String location = (String) config.get(CONFIG_CREDENTIALS_LOCATION);
            try {
                tinkerGraph.io(IoCore.gryo()).readGraph(location);
            } catch (IOException e) {
                logger.warn("Could not read credentials graph from {} - authentication is enabled, but with an empty user database", location);
            }
        }
    }

    credentialStore = CredentialGraph.credentials(graph);
    logger.info("CredentialGraph initialized at {}", credentialStore);
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
private Pair<StarGraph, Integer> serializeDeserialize(final StarGraph starGraph) {
    final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    try {
        graph.io(IoCore.gryo()).writer().create().writeObject(outputStream, starGraph);
        return Pair.with(graph.io(IoCore.gryo()).reader().create().readObject(new ByteArrayInputStream(outputStream.toByteArray()), StarGraph.class), outputStream.size());
    } catch (IOException ioe) {
        throw new RuntimeException(ioe);
    }
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
@Test
public void shouldSerializeTinkerGraphToGraphSONWithTypes() throws Exception {
    final TinkerGraph graph = TinkerFactory.createModern();
    final Mapper<ObjectMapper> mapper = graph.io(IoCore.graphson()).mapper().embedTypes(true).create();
    try (final ByteArrayOutputStream out = new ByteArrayOutputStream()) {
        final GraphWriter writer = GraphSONWriter.build().mapper(mapper).create();
        writer.writeObject(out, graph);
        try (final ByteArrayInputStream inputStream = new ByteArrayInputStream(out.toByteArray())) {
            final GraphReader reader = GraphSONReader.build().mapper(mapper).create();
            final TinkerGraph target = reader.readObject(inputStream, TinkerGraph.class);
            IoTest.assertModernGraph(target, true, false);
        }
    }
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
public void loadFromDisk(final String file) {
  try {
    System.out.println("loading db from " + file + "...");
    graph.io(IoCore.gryo()).readGraph(file);
  } catch (final IOException e) {
    throw new RuntimeException(e);
  }
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
private void saveToDisk(final String file) {
  if (file != null) {
    System.out.println("storing db to " + file + "...");
    try {
      graph.io(IoCore.gryo()).writeGraph(file);
    } catch (final IOException e) {
      throw new RuntimeException(e);
    }
  }
}
 

import org.apache.tinkerpop.gremlin.structure.io.IoCore; //导入依赖的package包/类
@Override
public void exportToGson(OutputStream os) throws IOException {

    GraphSONMapper mapper = getGraph().io(IoCore.graphson()).mapper().create();
    GraphSONWriter.Builder builder = GraphSONWriter.build();
    builder.mapper(mapper);
    GraphSONWriter writer = builder.create();
    writer.writeGraph(os, getGraph());
}