restructure documentation (#198)

* restructure documentation

* restructure

* fix typo

* fix typo

Author: maxkernbach

docs/Drivers/Java/Reference/AQL.md

@@ -0,0 +1,44 @@
+# AQL
+
+## Executing an AQL statement
+
+Every AQL operations works with POJOs (e.g. MyObject), VelocyPack (VPackSlice) and Json (String).
+
+E.g. get all Simpsons aged 3 or older in ascending order:
+
+```Java
+  arangoDB.createDatabase("myDatabase");
+  ArangoDatabase db = arangoDB.db("myDatabase");
+
+  db.createCollection("myCollection");
+  ArangoCollection collection = db.collection("myCollection");
+
+  collection.insertDocument(new MyObject("Homer", 38));
+  collection.insertDocument(new MyObject("Marge", 36));
+  collection.insertDocument(new MyObject("Bart", 10));
+  collection.insertDocument(new MyObject("Lisa", 8));
+  collection.insertDocument(new MyObject("Maggie", 2));
+
+  Map<String, Object> bindVars = new HashMap<>();
+  bindVars.put("age", 3);
+
+  ArangoCursor<MyObject> cursor = db.query(query, bindVars, null, MyObject.class);
+
+  for(; cursor.hasNext;) {
+    MyObject obj = cursor.next();
+    System.out.println(obj.getName());
+  }
+```
+
+or return the AQL result as VelocyPack:
+
+```Java
+  ArangoCursor<VPackSlice> cursor = db.query(query, bindVars, null, VPackSlice.class);
+
+  for(; cursor.hasNext;) {
+    VPackSlice obj = cursor.next();
+    System.out.println(obj.get("name").getAsString());
+  }
+```
+
+**Note**: The parameter `type` in `query()` has to match the result of the query, otherwise you get an VPackParserException. E.g. you set `type` to `BaseDocument` or a POJO and the query result is an array or simple type, you get an VPackParserException caused by VPackValueTypeException: Expecting type OBJECT.

docs/Drivers/Java/Reference/DatabaseCollection.md

@@ -0,0 +1,37 @@
+# Manipulating databases
+
+## create database
+
+```Java
+  // create database
+  arangoDB.createDatabase("myDatabase");
+```
+
+## drop database
+
+```Java
+  // drop database
+  arangoDB.db("myDatabase").drop();
+```
+
+# Manipulating collections
+
+## create collection
+
+```Java
+  // create collection
+  arangoDB.db("myDatabase").createCollection("myCollection", null);
+```
+
+## drop collection
+
+```Java
+  // delete collection
+  arangoDB.db("myDatabase").collection("myCollection").drop();
+```
+
+## truncate collection
+
+```Java
+  arangoDB.db("myDatabase").collection("myCollection").truncate();
+```

docs/Drivers/Java/Reference/Document.md

@@ -0,0 +1,96 @@
+# Basic Document operations
+
+Every document operations works with POJOs (e.g. MyObject), VelocyPack (VPackSlice) and Json (String).
+
+For the next examples we use a small object:
+
+```Java
+  public class MyObject {
+
+    private String key;
+    private String name;
+    private int age;
+
+    public MyObject(String name, int age) {
+      this();
+      this.name = name;
+      this.age = age;
+    }
+
+    public MyObject() {
+      super();
+    }
+
+    /*
+     *  + getter and setter
+     */
+
+  }
+```
+
+## insert document
+
+```Java
+  MyObject myObject = new MyObject("Homer", 38);
+  arangoDB.db("myDatabase").collection("myCollection").insertDocument(myObject);
+```
+
+When creating a document, the attributes of the object will be stored as key-value pair
+E.g. in the previous example the object was stored as follows:
+
+```properties
+  "name" : "Homer"
+  "age" : "38"
+```
+
+## delete document
+
+```Java
+  arangoDB.db("myDatabase").collection("myCollection").deleteDocument(myObject.getKey());
+```
+
+## update document
+
+```Java
+  arangoDB.db("myDatabase").collection("myCollection").updateDocument(myObject.getKey(), myUpdatedObject);
+```
+
+## replace document
+
+```Java
+  arangoDB.db("myDatabase").collection("myCollection").replaceDocument(myObject.getKey(), myObject2);
+```
+
+## read document as JavaBean
+
+```Java
+  MyObject document = arangoDB.db("myDatabase").collection("myCollection").getDocument(myObject.getKey(), MyObject.class);
+  document.getName();
+  document.getAge();
+```
+
+## read document as VelocyPack
+
+```Java
+  VPackSlice document = arangoDB.db("myDatabase").collection("myCollection").getDocument(myObject.getKey(), VPackSlice.class);
+  document.get("name").getAsString();
+  document.get("age").getAsInt();
+```
+
+## read document as Json
+
+```Java
+  String json = arangoDB.db("myDatabase").collection("myCollection").getDocument(myObject.getKey(), String.class);
+```
+
+## read document by key
+
+```Java
+  arangoDB.db("myDatabase").collection("myCollection").getDocument("myKey", MyObject.class);
+```
+
+## read document by id
+
+```Java
+  arangoDB.db("myDatabase").getDocument("myCollection/myKey", MyObject.class);
+```

docs/Drivers/Java/Reference/Foxx.md

@@ -0,0 +1,8 @@
+# Foxx
+
+## call a service
+
+```Java
+  Request request = new Request("mydb", RequestType.GET, "/my/foxx/service")
+  Response response = arangoDB.execute(request);
+```

docs/Drivers/Java/Reference/Graph.md

@@ -0,0 +1,57 @@
+# Graphs
+
+The driver supports the [graph api](https://docs.arangodb.com/HTTP/Gharial/index.html).
+
+Some of the basic graph operations are described in the following:
+
+## add graph
+
+A graph consists of vertices and edges (stored in collections). Which collections are used within a graph is defined via edge definitions. A graph can contain more than one edge definition, at least one is needed.
+
+```Java
+  Collection<EdgeDefinition> edgeDefinitions = new ArrayList<>();
+  EdgeDefinition edgeDefinition = new EdgeDefinition();
+  // define the edgeCollection to store the edges
+  edgeDefinition.collection("myEdgeCollection");
+  // define a set of collections where an edge is going out...
+  edgeDefinition.from("myCollection1", "myCollection2");
+
+  // repeat this for the collections where an edge is going into
+  edgeDefinition.to("myCollection1", "myCollection3");
+
+  edgeDefinitions.add(edgeDefinition);
+
+  // A graph can contain additional vertex collections, defined in the set of orphan collections
+  GraphCreateOptions options = new GraphCreateOptions();
+  options.orphanCollections("myCollection4", "myCollection5");
+
+  // now it's possible to create a graph
+  arangoDB.db("myDatabase").createGraph("myGraph", edgeDefinitions, options);
+```
+
+## delete graph
+
+A graph can be deleted by its name
+
+```Java
+  arangoDB.db("myDatabase").graph("myGraph").drop();
+```
+
+## add vertex
+
+Vertices are stored in the vertex collections defined above.
+
+```Java
+  MyObject myObject1 = new MyObject("Homer", 38);
+  MyObject myObject2 = new MyObject("Marge", 36);
+  arangoDB.db("myDatabase").graph("myGraph").vertexCollection("collection1").insertVertex(myObject1, null);
+  arangoDB.db("myDatabase").graph("myGraph").vertexCollection("collection3").insertVertex(myObject2, null);
+```
+
+## add edge
+
+Now an edge can be created to set a relation between vertices
+
+```Java
+  arangoDB.db("myDatabase").graph("myGraph").edgeCollection("myEdgeCollection").insertEdge(myEdgeObject, null);
+```

docs/Drivers/Java/Reference/MultiDocument.md

@@ -0,0 +1,41 @@
+# Multi Document operations
+
+## insert documents
+
+```Java
+  Collection<MyObject> documents = new ArrayList<>;
+  documents.add(myObject1);
+  documents.add(myObject2);
+  documents.add(myObject3);
+  arangoDB.db("myDatabase").collection("myCollection").insertDocuments(documents);
+```
+
+## delete documents
+
+```Java
+  Collection<String> keys = new ArrayList<>;
+  keys.add(myObject1.getKey());
+  keys.add(myObject2.getKey());
+  keys.add(myObject3.getKey());
+  arangoDB.db("myDatabase").collection("myCollection").deleteDocuments(keys);
+```
+
+## update documents
+
+```Java
+  Collection<MyObject> documents = new ArrayList<>;
+  documents.add(myObject1);
+  documents.add(myObject2);
+  documents.add(myObject3);
+  arangoDB.db("myDatabase").collection("myCollection").updateDocuments(documents);
+```
+
+## replace documents
+
+```Java
+  Collection<MyObject> documents = new ArrayList<>;
+  documents.add(myObject1);
+  documents.add(myObject2);
+  documents.add(myObject3);
+  arangoDB.db("myDatabase").collection("myCollection").replaceDocuments(documents);
+```