Update README.md

Author: Junha Yang

README.md

@@ -11,6 +11,8 @@ https://docs.rs/remote-trait-object)
 
 A simple and powerful Rust remote method invocation library based on Rust trait objects.
 
+See the [documentation](https://docs.rs/remote-trait-object).
+
 ## License
 
 Licensed under either of

remote-trait-object/README.md

@@ -9,15 +9,92 @@ https://crates.io/crates/remote-trait-object)
 https://docs.rs/remote-trait-object)
 [![chat](https://img.shields.io/discord/569610676205781012.svg?logo=discord)](https://discord.gg/xhpdXm7)
 
-This library provides a simple and powerful remote method invocation support based on Rust's trait objects.
-It sets up an connection between two contexts of `remote-trait-object` that may exist over different thread, different processes, or even different machines.
-User can freely export a _service object_, and the user of the other side will import such service as a _proxy object_.
-Both service object and proxy object are expressed in Rust trait objects, which exposes only **methods** that can be remotely served and called.
+`remote-trait-object` is a general, powerful, and simple [remote method invocation](https://en.wikipedia.org/wiki/Distributed_object_communication) library
+based on trait objects.
 
-The actual communciation upon which such connection is constructed, is abstracted with `TransportRecv` and `TransportSend`.
-The implementation of the transport must be supplied by the user, and this library itself provides nothing about the communication.
-It can be a plain in-process communication, an Ipc, or even a networking, as you implement.
+It is...
 
-## Flow
+1. Based on _services_ that can be exported and imported **as trait objects** -
+You register a service object, which is a trait object, and export it. On the other side, you import it into a proxy object, which is also a trait object.
+1. Based on a point-to-point connection - All operations are conducted upon a single connection, which has **two ends**.
+1. Easy to export and import services - During a remote method call in some service, you **can export and import another service as an argument or a return value** of the method.
+1. Independent from the transport model - The transport model is abstracted and **users must provide a concrete implementation of it**.
+1. Concurrent - you can both **call and handle remote calls concurrently**.
 
-![alt text](./flow.png "Call Flow")
+See the [documentation](https://docs.rs/remote-trait-object).
+
+## Example
+
+[This example code](https://github.com/CodeChain-io/remote-trait-object/blob/master/remote-trait-object-tests/src/simple.rs)
+briefly shows how you can use `remote-trait-object`.
+
+Note that `crate::transport::create()` is for creating the transport ends that are provided to `remote-trait-object ` contexts, which is just in-process communication for the test.
+You have to implement your own transport implementation if you're going to actually use this crate./
+
+```rust
+use remote_trait_object::*;
+
+#[service]
+pub trait CreditCard: Service {
+    fn pay(&mut self, ammount: u64) -> Result<(), ()>;
+}
+struct SomeCreditCard {
+    money: u64,
+}
+impl Service for SomeCreditCard {}
+impl CreditCard for SomeCreditCard {
+    fn pay(&mut self, ammount: u64) -> Result<(), ()> {
+        if ammount <= self.money {
+            self.money -= ammount;
+            Ok(())
+        } else {
+            Err(())
+        }
+    }
+}
+
+#[service]
+pub trait PizzaStore: Service {
+    fn order_pizza(&self, credit_card: ServiceRef<dyn CreditCard>) -> Result<String, ()>;
+}
+struct SomePizzaStore;
+impl Service for SomePizzaStore {}
+impl PizzaStore for SomePizzaStore {
+    fn order_pizza(&self, credit_card: ServiceRef<dyn CreditCard>) -> Result<String, ()> {
+        let mut credit_card_proxy: Box<dyn CreditCard> = credit_card.unwrap_import().into_proxy();
+        credit_card_proxy.pay(10)?;
+        Ok("Tasty Pizza".to_owned())
+    }
+}
+
+#[test]
+fn test() {
+    let crate::transport::TransportEnds {
+        recv1,
+        send1,
+        recv2,
+        send2,
+    } = crate::transport::create();
+
+    let _context_pizza_town = Context::with_initial_service_export(
+        Config::default_setup(),
+        send1,
+        recv1,
+        ServiceToExport::new(Box::new(SomePizzaStore) as Box<dyn PizzaStore>),
+    );
+
+    let (_context_customer, pizza_store): (_, ServiceToImport<dyn PizzaStore>) =
+        Context::with_initial_service_import(Config::default_setup(), send2, recv2);
+    let pizza_store_proxy: Box<dyn PizzaStore> = pizza_store.into_proxy();
+
+    let my_credit_card = Box::new(SomeCreditCard {
+        money: 11,
+    }) as Box<dyn CreditCard>;
+    assert_eq!(pizza_store_proxy.order_pizza(ServiceRef::create_export(my_credit_card)).unwrap(), "Tasty Pizza");
+
+    let my_credit_card = Box::new(SomeCreditCard {
+        money: 9,
+    }) as Box<dyn CreditCard>;
+    assert!(pizza_store_proxy.order_pizza(ServiceRef::create_export(my_credit_card)).is_err());
+}
+```