initial commit

Author: null-char

go.mod

@@ -0,0 +1,3 @@
+module github.com/null-char/transact
+
+go 1.15

main.go

@@ -0,0 +1,5 @@
+package main
+
+func main() {
+
+}

manager/manager.go

@@ -0,0 +1,80 @@
+package manager
+
+import (
+	"fmt"
+
+	s "github.com/null-char/transact/store"
+)
+
+// Transaction consists of a next pointer which points to the next transaction in the stack
+// (nil if current Transaction is at the top) and a local store which resembles the data that needs to be updated
+// into our global store if the transaction is committed.
+type Transaction struct {
+	localStore *s.Store
+	parent     *Transaction
+}
+
+// TransactionManager manages the transaction stack
+type TransactionManager struct {
+	globalStore       *s.Store
+	transactions      *Transaction
+	activeTransaction *Transaction // represents top of the stack
+	numTransactions   uint
+}
+
+// Empty returns a bool indicating whether or not the transaction stack is empty (no ongoing transactions)
+func (tm TransactionManager) Empty() bool {
+	return tm.transactions == nil
+}
+
+// getActiveStore returns the global store if there are no active transactions and the local store (of the active transaction) if there is one
+func (tm TransactionManager) getActiveStore() *s.Store {
+	if tm.Empty() {
+		return tm.globalStore
+	}
+
+	return tm.activeTransaction.localStore
+}
+
+// PushTransaction pushes a new transaction onto the stack inheriting the local store of its parent (if it has a parent)
+func (tm *TransactionManager) PushTransaction() {
+	if tm.Empty() {
+		t := &Transaction{localStore: s.MakeNewStore(), parent: nil}
+		tm.transactions = t
+		tm.activeTransaction = t
+	} else {
+		store := s.MakeNewStore()
+
+		// We duplicate the data of our parent here
+		for _, pair := range tm.activeTransaction.localStore.GetKVPairs() {
+			store.Set(pair.First, pair.Second)
+		}
+
+		t := &Transaction{localStore: store}
+		t.parent = tm.activeTransaction
+		tm.activeTransaction = t
+	}
+
+	tm.numTransactions++
+}
+
+// PopTransaction pops the active transaction (top of the stack) if there is one otherwise we have a stack underflow so we just log some error
+func (tm *TransactionManager) PopTransaction() {
+	if tm.Empty() {
+		fmt.Println("ERROR: There are no transactions to pop. Stack is empty.")
+	} else {
+		tm.activeTransaction = tm.activeTransaction.parent
+		tm.numTransactions--
+	}
+
+}
+
+func (tm *TransactionManager) Set(key string, value s.Mappable) {
+	s := tm.getActiveStore()
+	s.Set(key, value)
+}
+
+func (tm *TransactionManager) Get(key string) (s.Mappable, bool) {
+	s := tm.getActiveStore()
+	return s.Get(key)
+}

store/store.go

@@ -0,0 +1,55 @@
+package store
+
+// Store consists of a map which maps to Mappable values including methods to manipulate the map data
+type Store struct {
+	data map[Key]Value
+}
+
+// MakeNewStore constructs a new key value store
+func MakeNewStore() *Store {
+	s := &Store{}
+	return s
+}
+
+// Set sets a new key value pair or updates it if the key already exists
+func (s *Store) Set(key Key, value Value) {
+	s.data[key] = value
+}
+
+// Get fetches the Mappable value if the key mapping exists
+func (s Store) Get(key Key) (Value, bool) {
+	value, ok := s.data[key]
+	return value, ok
+}
+
+// Delete will remove the key value mapping associated with the provided key. Returns a status indicating a no-op if false (key mapping does not exist)
+func (s *Store) Delete(key Key) bool {
+	// delete is a no-op if there is no such key so we need to manually check if key exists
+	_, ok := s.Get(key)
+	delete(s.data, key)
+	return ok
+}
+
+// Count returns an uint representing the number of times the provided value mapping exists in the store
+func (s Store) Count(value Value) uint {
+	var count uint = 0
+
+	for _, v := range s.data {
+		if v == value {
+			count++
+		}
+	}
+
+	return count
+}
+
+// GetKVPairs returns a slice of key value pairs with first field indicating the key and second field indicating the value
+func (s Store) GetKVPairs() []KVPair {
+	var pairs []KVPair = make([]KVPair, 0, len(s.data))
+
+	for k, v := range s.data {
+		pairs = append(pairs, KVPair{First: k, Second: v})
+	}
+
+	return pairs
+}

store/types.go

@@ -0,0 +1,27 @@
+package store
+
+// NOTE: We provide dummy methods just so that we can have a shared interface between these types
+// You can think of it as a weird way of achieving union types in Go since we don't have generics (yet)
+
+// Mappable denotes all the value types that can be mapped to our store (global and local)
+type Mappable interface {
+	isMappable()
+}
+
+// Number is a Mappable with underlying type int
+type Number int
+
+func (n Number) isMappable()
+
+// String is a Mappable with underlying type string
+type String string
+
+func (s String) isMappable()
+
+type Key = string
+type Value = Mappable
+
+type KVPair struct {
+	First  Key
+	Second Value
+}

utils/printer.go

@@ -0,0 +1,19 @@
+package utils
+
+import (
+	"fmt"
+
+	s "github.com/null-char/transact/store"
+)
+
+// PrintValue formats and prints a mappable value
+func PrintValue(v s.Mappable) {
+	switch v := v.(type) {
+	case s.Number:
+		fmt.Printf("(integer) %d \n", v)
+	case s.String:
+		fmt.Printf("(string) %s \n", v)
+	default:
+		fmt.Printf("(unknown) %v \n", v)
+	}
+}