Update pseudo code after discussion with @fcoriat

CObject

 class CObject<T> {
 
+  // Concordant object id
   private id: CObjectId
 
+  // Is openned in read only mode
   private readOnly: Boolean
 
+  // The encapsulated CRDT
   private crdt: DeltaCRDT<T>
 
+  // Backup for the necapsulated CRDT (used in case of transaction abort)
   private txnBackup: DeltaCRDT<T>?
 
   CObject(oid: CObjectId, crdt: DeltaCRDT<T>, readOnly: Boolean) {
     this.id = oid
     this.crdt = crdt
+    this.readOnly = readOnly
     this.txnBackup = null
   }
 
@@ -24,20 +29,26 @@ class CObject<T> {
   }
 
   fun update(args) {
-    if (NOT Global.DirtyCObjects.contains(this)) {
-      Global.DirtyCObjects.put(this.id, this)
+    if (Session.currentTransaction == null) throw Exception
+    if (this.readOnly) throw Exception
+    if (NOT ActiveSession.dirtyObjects.contains(this.id)) {
+      ActiveSession.dirtyObjects.put(this.id, this)
       this.txnBackup = this.crdt.copy()
     }
-    ts = Global.TxnEnv.tick()
-    crdt.update(args, ts)
+    // Should be integrrated to CRDTs
+    ts = ActiveSession.txnEnv.tick()
+    this.crdt.update(args, ts)
   }
 
   fun getter(args): val {
+    if (ActiveSession.currentTransaction == null) throw Exception
     return crdt.getter(args)
   }
 
   fun close() {
-    Global.Cache.remove(this.id)
+    if (NOT ActiveSession.currentTransaction == null) throw Exception
+    ActiveSession.cache.remove(this.id)
+    ActiveSession.handlers.remove(this.id)
     SERVICE.unsubscribe(this.id)
   }
 }

ClientId

-type ClientId = UUID

Collection

@@ -9,32 +9,35 @@ class Collection {
   // Static boolean used to ensure that only one collection is openned
   private static otherOpenned: Boolean = false
 
-  Collection(cid: CollectionId) {
-    if (otherOpenned == true) throw Exception
+  Collection(cid: CollectionId, readOnly: Boolean) {
+    if (Collection.otherOpenned == true) throw Exception
     Collection.otherOpenned = true
     this.id = cid
+    this.readOnly = readOnly
   }
 
   // c_open_read|write<T>
   fun open<T>(oid: String, readOnly: Boolean, handler: NotificationHandler): T {
     if (this.readOnly AND NOT readOnly) throw Exception
+    if (NOT Session.currentTransaction == null) throw Exception
+
     oid = CObjectId(this.id, oid, T)
-    if (Global.Cache.contains(oid)) return Global.Cache.get(oid)
-    crdt, _ = SERVICE.getObject(oid, TxnEnv.getState())
-    SERVICE.subscribe(oid)
+    if (ActiveSession.cache.contains(oid)) return ActiveSession.cache.get(oid)
+
+    crdt, v = SERVICE.getObject(oid, ActiveSession.txnEnv.getState())
+    ActiveSession.txnEnv.updateSate(v)
     obj = CObject<T>(oid, crdt, readOnly)
-    Global.Cache.put(oid, obj)
-    Global.Handlers.put(oid, handler)
+    ActiveSession.cache.put(oid, obj)
+    ActiveSession.handlers.put(oid, handler)
     return obj
   }
 
   // c_close_collection
   fun close() {
-    for oid in Global.Cache {
-      SERVICE.unsubscribe(oid)
-    }
-    Global.Cache.clear()
-    Global.Handlers.clear()
+    if (NOT Session.currentTransaction == null) throw Exception
+    SERVICE.unsubscribeAll()
+    ActiveSession.cache.clear()
+    ActiveSession.handlers.clear()
     Collection.otherOpenned = false
   }
 }

Global

-// Transaction environment should inherit from crdtlib.utils.Environment 
-TxnEnv: TransactionEnvironment
-
-// Map for dirty objects
-DirtyCObjects: Map<CObjectId, CObject>
-
-// Map for the cache
-Cache: Map<CObjectId, CObject>
-
-// Map for c-object handlers management
-Handlers: Map<CObjectId, NotificationHandler>

OpId

-type OpId = (TxnId, Int)

ServiceHandler

@@ -8,7 +8,7 @@ class ServiceHandler: Thread {
   fun work() {
     while (true) {
       v, oid = readMessage()
-      if (Global.Handlers.contains(oid)) {
+      if (ActiveSession.handlers.contains(oid)) {
         // call the corresponding handler
         Handlers.get(oid)(v, oid)
       }

Session

 class Session {
 
-  // Current consistency level
-  private consistency: ConsistencyLevel
-
   // The client id
   private cliendId: CliendId
 
+  // Current consistency level
+  private consistency: ConsistencyLevel?
+
   // The attached service handler
   private serviceHandler: ServiceHandler
 
-  Session(cid: ClientId) {
+  // Current running transaction
+  private currentTransaction: Transaction?
+
+  // Transaction environment should inherit from crdtlib.utils.Environment 
+  package txnEnv: TransactionEnvironment
+
+  // Map for dirty Concordant objects
+  package dirtyObjects: Map<CObjectId, CObject>
+
+  // Map for the cache of Concordant objects
+  package cache: Map<CObjectId, CObject>
+
+  // Map for Concordant object handlers management
+  package handlers: Map<CObjectId, NotificationHandler>
+
+  private Session(cid: ClientId) {
     this.clientId = cid
+    this.txnEnv = TransactionEnvironment(this.clientId)
+    this.dirtyObjects = mutableMapOf()
+    this.cache = mutableMapOf()
+    this.handlers = mutableMapOf()
+    this.serviceHandler = ServiceHandler()
+    this.serviceHandler.run()
+    this.currentTransaction = null
   }
 
   // c_begin_session
-  static fun open(dbName: String, credentials: String): Session {
+  static fun connect(dbName: String, credentials: String): Session {
+    if (NOT ActiveSession == null) throw Exception
     clientId = ClientId()
-    if (NOT SERVICE.open(dbName, credentials, clientId)) throw Exception
-    this.serviceHandler = ServiceHandler()
-    this.serviceHandler.run()
-    return Session(clientId)
+    if (NOT SERVICE.connect(dbName, credentials, clientId)) throw Exception
+    ActiveSession = Session(clientId)
+    retur ActiveSession
   }
 
   // c_pull_XX_view
   fun pull(type: ConsistencyLevel) {
-    if (consistency != null AND consistency > type) throw Exception
+    if (NOT this.currentTransaction == null) throw Exception
+    if (this.consistency != null AND this.consistency > type) throw Exception
     this.consistency = type
-    for oid in Cache {
-      crdt, v = SERVICE.getObject(oid)
-      obj = Global.Cache.get(oid)
+    for oid in this.cache {
+      crdt, v = SERVICE.getObject(oid, this.consistency)
+      obj = this.cache.get(oid)
       obj.crdt = crdt
-      Global.TxnEnv.updateSate(v)
+      this.txnEnv.updateSate(v)
     } 
   }
 
   // c_pull_XX_view(v)
   fun pull(type: ConsistencyLevel, vv: VersionVector) {
-    if (view != null AND view.type > type) throw Exception
-    if (vv < global.TxnEnv.getState()) throw Exception
-    for oid in Cache {
-      crdt, v = SERVICE.getObject(oid, vv)
-      obj = Global.Cache.get(oid)
+    if (NOT this.currentTransaction == null) throw Exception
+    if (this.consistency != null AND this.consistency > type) throw Exception
+    if (vv < this.txnEnv.getState()) throw Exception
+    this.consistency = type
+    for oid in this.cache {
+      crdt, v = SERVICE.getObject(oid, vv, this.consistency)
+      obj = this.cache.get(oid)
       obj.crdt = crdt
-      Global.TxnEnv.updateSate(v)
+      this.txnEnv.updateSate(v)
     } 
   }
   
   // c_open_collection_read|write
   fun openCollection(cid: CollectionId, readOnly: Boolean): Collection {
-    return Collection(cid)
+    if (NOT this.currentTransaction == null) throw Exception
+    return Collection(cid, readOnly)
   }
 
   // c_XX_txn
-  fun beginTransaction(body: () -> Unit) {
-    Transaction(body)
+  fun transaction(body: TransactionBody) {
+    if (NOT this.currentTransaction == null) throw Exception
+    this.currentTransaction = Transaction(body)
   }
 
   // c_end_session
   fun close() {
+    if (this.currentTransaction == null) this.currentTransaction.abort()
     SERVICE.close(clientId)
     this.serviceHandler.stop()
+    ActiveSession = null
   }
 }

Transaction

@@ -3,17 +3,12 @@ class Transaction {
   // Transaction id
   private transactionId: TxnId
 
-  // Static boolean used to ensure that only one collection is openned
-  private static otherOpenned: Boolean = false
-
   // The version vector at which the transaction has started
   private begin: VersionVector
 
   Transaction(tid: TxnId, body: TransactionBody) {
-    if (Transaction.otherOpenned) throw Exception
-    Transaction.otherOpenned = true
-    this.begin = Global.TxnEnv.getState()
-    this.transactionId = Global.TxnEnv.tickTransaction()
+    this.begin = ActiveSession.txnEnv.getState()
+    this.transactionId = ActiveSession.txnEnv.tickTransaction()
 
     try {
       // call the body function
@@ -28,22 +23,20 @@ class Transaction {
 
   // c_abort_txn
   fun abort() {
-    for obj in Global.DirtyCObjects {
+    for obj in ActiveSession.dirtyObjects {
       obj.txnAbort()
     }
-    Global.DirtyCObjects.clear()
-    Transaction.otherOpenned = false    
+    ActiveSession.dirtyObjects.clear()
   }
 
   // c_commit_txn
   fun commit() {
     SERVICE.beginTransaction(this.transactionId)
-    for obj in Global.DirtyCObjects {
+    for obj in ActiveSession.dirtyObjects {
       SERVICE.pushObject(obj.crdt.getDelta(this.begin))
       obj.txnCommit()
     }
     SERVICE.commitTransaction(this.transactionId)
-    Global.DirtyCObjects.clear()
-    Transaction.otherOpenned = false    
+    ActiveSession.dirtyObjects.clear()
   }
 }

CObjectId → utils/CObjectId

+// Concordant object unique identifiers
 type CObjectId = (CollectionId, String, Type)

utils/ClientId

+// Client unique identifiers are UUId, they can also be hierarchic
+type ClientId = UUId

CollectionId → utils/CollectionId

+// Collection unique identifiers
 type CollectionId = String

ConsistencyLevel → utils/ConsistencyLevel

+// Different types of consistency level provided by the Concordant platform
 enum ConsistencyLevel {
-  
+
   RC,
   Snapshot,
   Strong

utils/Global

+// Global variable(s)
+ActiveSession: Session? = null

NotificationHandler → utils/NotificationHandler

 // The notification handler (function) type accepted for c-objects
+// Unit == void in Kotlin
 type NotificationHandler = (VersionVector, CObjectId) -> Unit

utils/OperationId

+// Operations unique identifiers
+type OperationId = (TxnId, Int)

TransactionBody → utils/TransactionBody

 // The function type accepted for a transaction body
+// Unit == void in Kotlin
 type TransactionBody = () -> Unit

TxnId → utils/TxnId

+// Transaction unique identifiers
 type TxnId = (Int, ClientId)