Introduce object creation interface with initial values

pkg/document/crdt/root.go

@@ -76,15 +76,41 @@ func (r *Root) FindByCreatedAt(createdAt *time.Ticket) Element {
 }
 
 // RegisterElement registers the given element to hash table.
-func (r *Root) RegisterElement(elem Element) {
-	r.elementMapByCreatedAt[elem.CreatedAt().Key()] = elem
+func (r *Root) RegisterElement(element Element) {
+	r.elementMapByCreatedAt[element.CreatedAt().Key()] = element
+
+	switch element := element.(type) {
+	case Container:
+		{
+			element.Descendants(func(elem Element, parent Container) bool {
+				r.RegisterElement(elem)
+				return false
+			})
+		}
+	}
 }
 
 // DeregisterElement deregister the given element from hash tables.
-func (r *Root) DeregisterElement(elem Element) {
-	createdAt := elem.CreatedAt().Key()
-	delete(r.elementMapByCreatedAt, createdAt)
-	delete(r.removedElementPairMapByCreatedAt, createdAt)
+func (r *Root) DeregisterElement(element Element) {
+
+	deregisterElementInternal := func(elem Element) {
+		createdAt := elem.CreatedAt().Key()
+		delete(r.elementMapByCreatedAt, createdAt)
+		delete(r.removedElementPairMapByCreatedAt, createdAt)
+	}
+
+	deregisterElementInternal(element)
+
+	switch element := element.(type) {
+	case Container:
+		{
+			element.Descendants(func(elem Element, parent Container) bool {
+				deregisterElementInternal(elem)
+				return false
+			})
+		}
+	}
+
 }
 
 // RegisterRemovedElementPair register the given element pair to hash table.
@@ -159,6 +185,7 @@ func (r *Root) GarbageLen() int {
 		switch elem := pair.elem.(type) {
 		case Container:
 			elem.Descendants(func(elem Element, parent Container) bool {
+
 				seen[elem.CreatedAt().Key()] = true
 				return false
 			})

pkg/document/json/counter.go

@@ -42,6 +42,20 @@ func NewCounter(ctx *change.Context, counter *crdt.Counter) *Counter {
 	}
 }
 
+// TempCounter is a transmission object for creating a counter inside.
+type TempCounter struct {
+	valueType crdt.CounterType
+	value     interface{}
+}
+
+// NewTempCounter creates a new instance of TempCounter.
+func NewTempCounter(t crdt.CounterType, n interface{}) *TempCounter {
+	return &TempCounter{
+		valueType: t,
+		value:     n,
+	}
+}
+
 // Increase adds an increase operations.
 // Only numeric types are allowed as operand values, excluding
 // uint64 and uintptr.

pkg/document/json/json.go

@@ -17,7 +17,13 @@
 // Package json provides the JSON document implementation.
 package json
 
-import "github.com/yorkie-team/yorkie/pkg/document/crdt"
+import (
+	gotime "time"
+
+	"github.com/yorkie-team/yorkie/pkg/document/change"
+	"github.com/yorkie-team/yorkie/pkg/document/crdt"
+	"github.com/yorkie-team/yorkie/pkg/document/time"
+)
 
 func toOriginal(elem crdt.Element) crdt.Element {
 	switch elem := elem.(type) {
@@ -37,3 +43,80 @@ func toOriginal(elem crdt.Element) crdt.Element {
 
 	panic("unsupported type")
 }
+
+func buildCRDTElement(
+	context *change.Context,
+	value interface{},
+	ticket *time.Ticket,
+) crdt.Element {
+	switch elem := value.(type) {
+	// primitive type
+	case string, int, int32, int64, float32, float64, []byte, bool, gotime.Time:
+		primitive, err := crdt.NewPrimitive(elem, ticket)
+		if err != nil {
+			panic(err)
+		}
+		return primitive
+
+	case *TreeNode:
+
+		return NewTree(context, crdt.NewTree(buildRoot(context, elem, ticket), ticket))
+
+	case *Text:
+		return NewText(context, crdt.NewText(crdt.NewRGATreeSplit(crdt.InitialTextNode()), ticket))
+	case *TempCounter:
+		switch elem.valueType {
+		case crdt.IntegerCnt:
+			counter, err := crdt.NewCounter(crdt.IntegerCnt, elem.value, ticket)
+			if err != nil {
+				panic(err)
+			}
+			return NewCounter(
+				context,
+				counter,
+			)
+		case crdt.LongCnt:
+			counter, err := crdt.NewCounter(crdt.LongCnt, elem.value, ticket)
+			if err != nil {
+				panic(err)
+			}
+			return NewCounter(
+				context,
+				counter,
+			)
+		default:
+			panic("unsupported type")
+		}
+
+	case []interface{}:
+		array := NewArray(context, crdt.NewArray(crdt.NewRGATreeList(), ticket))
+		for _, v := range elem {
+			ticket := context.IssueTimeTicket()
+			value := buildCRDTElement(context, v, ticket)
+			value = toOriginal(value)
+			if err := array.InsertAfter(array.LastCreatedAt(), value); err != nil {
+				panic(err)
+			}
+			array.context.RegisterElement(value)
+		}
+		return array
+	case map[string]interface{}:
+		obj := NewObject(context, crdt.NewObject(crdt.NewElementRHT(), ticket))
+		members := buildObjectMember(context, elem)
+
+		for key, value := range members {
+			value = toOriginal(value)
+			_ = obj.Set(key, value)
+		}
+
+		return obj
+	default:
+		// Null
+		primitive, err := crdt.NewPrimitive(nil, ticket)
+		if err != nil {
+			panic(err)
+		}
+		return primitive
+	}
+
+}

pkg/document/json/object.go

@@ -17,6 +17,7 @@
 package json
 
 import (
+	"strings"
 	gotime "time"
 
 	"github.com/yorkie-team/yorkie/pkg/document/change"
@@ -41,12 +42,28 @@ func NewObject(ctx *change.Context, root *crdt.Object) *Object {
 }
 
 // SetNewObject sets a new Object for the given key.
-func (p *Object) SetNewObject(k string) *Object {
-	v := p.setInternal(k, func(ticket *time.Ticket) crdt.Element {
-		return NewObject(p.context, crdt.NewObject(crdt.NewElementRHT(), ticket))
-	})
+func (p *Object) SetNewObject(kv ...interface{}) *Object {
+
+	switch len(kv) {
+	case 1: // key only
+		k := kv[0].(string)
+		v := p.setInternal(k, func(ticket *time.Ticket) crdt.Element {
+			return NewObject(p.context, crdt.NewObject(crdt.NewElementRHT(), ticket))
+		})
+		return v.(*Object)
+
+	case 2: // key with value
+		k := kv[0].(string)
+		v := p.setInternal(k, func(ticket *time.Ticket) crdt.Element {
+			json := kv[1].(map[string]interface{})
+			return buildCRDTElement(p.context, json, ticket)
+		})
+
+		return v.(*Object)
+	default:
+		panic("too many arguments in call to SetNewObject")
+	}
 
-	return v.(*Object)
 }
 
 // SetNewArray sets a new Array for the given key.
@@ -185,6 +202,7 @@ func (p *Object) SetDouble(k string, v float64) *Object {
 
 // SetString sets the given string for the given key.
 func (p *Object) SetString(k, v string) *Object {
+
 	p.setInternal(k, func(ticket *time.Ticket) crdt.Element {
 		primitive, err := crdt.NewPrimitive(v, ticket)
 		if err != nil {
@@ -329,25 +347,47 @@ func (p *Object) setInternal(
 	creator func(ticket *time.Ticket) crdt.Element,
 ) crdt.Element {
 	ticket := p.context.IssueTimeTicket()
-	elem := creator(ticket)
+	elem := creator(ticket) // create value -> object
+
 	value := toOriginal(elem)
 
 	copiedValue, err := value.DeepCopy()
 	if err != nil {
 		panic(err)
 	}
+
+	removed := p.Set(k, value)
+	p.context.RegisterElement(value)
+	if removed != nil {
+		p.context.RegisterRemovedElementPair(p, removed)
+	}
+
 	p.context.Push(operations.NewSet(
 		p.CreatedAt(),
 		k,
 		copiedValue,
 		ticket,
 	))
+	return elem
+}
 
-	removed := p.Set(k, value)
-	p.context.RegisterElement(value)
-	if removed != nil {
-		p.context.RegisterRemovedElementPair(p, removed)
+// return the element map of the given json
+func buildObjectMember(
+	context *change.Context,
+	json map[string]interface{},
+) map[string]crdt.Element {
+
+	members := make(map[string]crdt.Element)
+
+	for key, value := range json {
+		if strings.Contains(key, ".") {
+			panic("key must not contain the '.'.")
+		}
+
+		ticket := context.IssueTimeTicket()
+		elem := buildCRDTElement(context, value, ticket)
+		members[key] = elem
 	}
 
-	return elem
+	return members
 }

test/integration/gc_test.go

@@ -23,7 +23,6 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-
 	"github.com/yorkie-team/yorkie/pkg/document"
 	"github.com/yorkie-team/yorkie/pkg/document/json"
 	"github.com/yorkie-team/yorkie/pkg/document/presence"
@@ -430,4 +429,5 @@ func TestGarbageCollection(t *testing.T) {
 		assert.Equal(t, d1.GarbageCollect(time.MaxTicket), 3)
 		assert.Equal(t, d2.GarbageCollect(time.MaxTicket), 3)
 	})
+
 }