Updated readme with diagram

Author: jepp3

README.md

@@ -1,98 +1,124 @@
 [![Build Status](https://travis-ci.org/code-brewery/untappd.svg?branch=master)](https://travis-ci.org/code-brewery/java-ormen)
 [![codecov.io](http://codecov.io/github/code-brewery/java-ormen/coverage.svg?branch=master)](http://codecov.io/github/code-brewery/java-ormen?branch=master)
 # java-ormen
-Java-ormen is an Object relation mapping library for REST API:s in Java. It is designed to build applications that are powered by a RESTful API instead of a database. 
+Java-ormen is an Object relation mapping library for REST API:s in Java. It is designed to build applications that are powered by a RESTful API instead of a database. This might be be useful when developing micro service oriented software.  
 
-Thos async library purpose is to allow Java applications to easily execute HTTP requests over an REST API, and create an abstraction on top of REST, so that only the CRUD operations are exposed.  
+The library's purpose is to allow Java applications to easily execute HTTP requests over an REST API. This will be achieved by create an abstraction on top of the REST calls, so the developer can invoke crud methods on Java POJOS.  
 
-The library has been designed using the Java CompletableFuture. If you you don't need a ascynchronous library you can tell the library to execute query's synchronous.  
+Many ORM librarys restricts the user to do certain tasks (filtering etc etc). This api lets the user to write an own APIImplementation, so its possible to customize the library for different rest API:s. The library can talk with different rest api's with different behavior at the same time. 
+
+The library uses the Jackson ObjectMapper, so its possible to use jackson annotations to describe how objects shall be marshalled and unmarshalled. The JSONConverter are optional, and can be removed for something else, if needed ( its up to the APIImplementation ). 
+
+The library strives for creating immutable objects. This means that you can have control over your objects. But ofcourse, its impossible to make it immutable , if your code isn't.
 
-The library uses the Jackson ObjectMapper, so its possible to use jackson annotations to describe how objects shall be marshalled and unmarshalled. 
 
-The library strives for creating immutable objects. This means that you can have control over your objects. 
 
 ## Usage
 
-Lets say that we have a REST API that exposes CRUD Operations for fetching Dog´s. Well dogs can bark, so we will use dogs in this example.
+One just simply do the following:
+ 
+define your model. Remember to use the resourceUrl annotation to specify the endpoint for the dog model. We need a default constructor for jackson json reflection. 
+Observe that we give the DogModel an Finder. It will give the model powers to retrive all dogs,with an static invocation from the code. 
 
-As an developer you will probably create some POJOś as an a java representation of the Dogs. Then you will probably write some kind of handler that takes these POJO instance´s and sends them
+```java
 
-back and forth the REST API. Well, you will not need to do that any longer. 
+@ResourceUrl(url = "dogs")
+public class DogModel extends Model {
 
+    private String name;
 
-One just simply do the following:
- 
-Start of by creating a normal POJO, but we will make sure it extends RestModel. This will give the POJO super powers ( almost ).  Well it will give the pojo possibility interact with an rest api. 
- 
-The Rest model gives you 4 public methods for interacting with the rest api, one for each CRUD operation. The good part here is that these methods returns a Completable future. 
+    private int age;
 
-Look at the comments, it will give you some hints about what information you need to provide for successfully send requests over rest. 
 
-```java
+    public DogModel(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
 
-public class MockRestModel extends RESTModel {
+    DogModel() {
+        this.name ="";
+        this.age = 0;
+    }
 
-    /**
-    * Default constructor, this is needed by the jackson json mapper. so always include it.
-    **/
-    public MockRestModel() {
-        this.name = "";
+    public int getAge() {
+        return age;
     }
 
-    public MockRestModel(String name) {
-        this.name = name;
+    public void setAge(int age) {
+        this.age = age;
     }
-    /**
-    *
-    * The return value of this method will indicate the resource url. The resource url points to the collection of resources that the pojo targets
-    **/
+    // override this method. You will return the identifying value for a specific model here. ( id or something like that ) 
     @Override
-    String resourceUrl() {
-        return "dogs";
+    public String getIdentifierValue() {
+        return name;
     }
-    /**
-    * This method returns the identifying data for this resource.  for example this might be this.id or this.name or something else. 
-    * 
-    **/
-    @Override
-    String identifierValue() {
-
-        return "identifier";
 
+    public String getName() {
+        return name;
     }
 
+    public void setName(String name) {
+        this.name = name;
+    }
 
+    public static final Finder find = new Finder(DogModel.class);
 }
+
+
 ```
 
-The good part with this model is that we will not need to write any marshall or unmarshalling logic. This is handled by the RestModel class. But if you get into trouble you can use jackson json annotations on your fields. For example there might be times when you want to exclude some data from de json marshalling, or perhaps rename.  
+The good part with this model is that we will not need to write any marshall or unmarshalling logic. This is handled behind the sceens. But if you get into trouble you can use jackson json annotations on your fields. For example there might be times when you want to exclude some data from de json marshalling, or perhaps rename some data.
 
 
-So now we have created a model. Its now time to use it to fetch data. Simply write the following in your code. Remember, these operations are async so we will add a sleep in the end ( only for educational purpose ).
+So now we have created a model. Its now time to use it to fetch data. Simply do the following. 
 
 
 ```java
 
+        apiConfig = new ApiConfig.ConfigBuilder().apiLocation("api").port("8081").host("localhost").build();
 
-        // 1. create a dog
-        DogModel pluto = new DogModel();
+        DogModel model = new DogModel("pluto",4);
 
-        // 2. start to fetch the dog, take care of the completable future.
-        CompletableFuture<RESTModel> futurePluto = pluto.fetch();
+        DogModel  modelWhenSaved  = (DogModel) model.save();
 
 
-        future.thenApply(result -> isDone(result));      // sync callback
-
-        Thread.sleep(4000);
-        System.out.println("dying");
+        // or why not try to delete a dog
+        
+        model.delete();
+        
+        // or fetch
+        
+        fetchedModel = model.fetch();
+        
+        
+        // or update 
+        
+        updatedModelFromBackend = model.delete();
+        
+        // why not fetch all dogs? 
+        
+        List<Model> listOfDogs = DogModel.find.all();
 
+        
+        
 
 
 ```
 
-In the code above, the dog model will call the rest api when the fetch method is invoked. A CompletableFuture is returned, and we can work with that future as an promise.  
+In the code above, the dog model will call the rest api when the fetch method is invoked. A Dog is returned when data is expected to change.  
+
+
 
+## contribute? 
 
+Sure, no problem! Contributions are welcome!
+
+## Library Structure
+
+The library is very lightweight and only consists of a few classes, displayed here. 
+![logo](https://raw.githubusercontent.com/code-brewery/java-ormen/pictures/diagram.png)
+
+ 
 
 # LICENSE
 The MIT License (MIT)