Introduce object creation interface with initial values

pkg/document/crdt/array.go

@@ -30,7 +30,12 @@ type Array struct {
 }
 
 // NewArray creates a new instance of Array.
-func NewArray(elements *RGATreeList, createdAt *time.Ticket) *Array {
+func NewArray(elements *RGATreeList, createdAt *time.Ticket, value ...[]Element) *Array {
+	if len(value) == 1 {
+		for _, v := range value[0] {
+			_ = elements.InsertAfter(elements.LastCreatedAt(), v)
+		}
+	}
 	return &Array{
 		elements:  elements,
 		createdAt: createdAt,

pkg/document/crdt/counter.go

@@ -153,6 +153,12 @@ func (p *Counter) ValueType() CounterType {
 	return p.valueType
 }
 
+// Value returns the value of this counter.
+// TODO(hackerwins): We need to use generics to avoid using interface{}.
+func (p *Counter) Value() interface{} {
+	return p.value
+}
+
 // Increase increases integer, long or double.
 // If the result of the operation is greater than MaxInt32 or less
 // than MinInt32, Counter's value type can be changed Integer to Long.

pkg/document/crdt/object.go

@@ -30,7 +30,12 @@ type Object struct {
 }
 
 // NewObject creates a new instance of Object.
-func NewObject(memberNodes *ElementRHT, createdAt *time.Ticket) *Object {
+func NewObject(memberNodes *ElementRHT, createdAt *time.Ticket, value ...map[string]Element) *Object {
+	if len(value) == 1 {
+		for k, v := range value[0] {
+			memberNodes.Set(k, v)
+		}
+	}
 	return &Object{
 		memberNodes: memberNodes,
 		createdAt:   createdAt,

pkg/document/crdt/root.go

@@ -54,7 +54,6 @@ func NewRoot(root *Object) *Root {
 	r.RegisterElement(root)
 
 	root.Descendants(func(elem Element, parent Container) bool {
-		r.RegisterElement(elem)
 		if elem.RemovedAt() != nil {
 			r.RegisterRemovedElementPair(parent, elem)
 		}
@@ -76,15 +75,44 @@ 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.elementMapByCreatedAt[elem.CreatedAt().Key()] = 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)
+// deregisterElement deregister the given element from hash tables.
+func (r *Root) deregisterElement(element Element) int {
+	count := 0
+
+	deregisterElementInternal := func(elem Element) {
+		createdAt := elem.CreatedAt().Key()
+		delete(r.elementMapByCreatedAt, createdAt)
+		delete(r.removedElementPairMapByCreatedAt, createdAt)
+		count++
+	}
+
+	deregisterElementInternal(element)
+
+	switch element := element.(type) {
+	case Container:
+		{
+			element.Descendants(func(elem Element, parent Container) bool {
+				deregisterElementInternal(elem)
+				return false
+			})
+		}
+	}
+
+	return count
 }
 
 // RegisterRemovedElementPair register the given element pair to hash table.
@@ -119,7 +147,7 @@ func (r *Root) GarbageCollect(ticket *time.Ticket) (int, error) {
 				return 0, err
 			}
 
-			count += r.garbageCollect(pair.elem)
+			count += r.deregisterElement(pair.elem)
 		}
 	}
 
@@ -173,23 +201,3 @@ func (r *Root) GarbageLen() int {
 
 	return count
 }
-
-func (r *Root) garbageCollect(elem Element) int {
-	count := 0
-
-	callback := func(elem Element, parent Container) bool {
-		r.DeregisterElement(elem)
-		count++
-		return false
-	}
-
-	callback(elem, nil)
-	switch elem := elem.(type) {
-	case *Object:
-		elem.Descendants(callback)
-	case *Array:
-		elem.Descendants(callback)
-	}
-
-	return count
-}

pkg/document/json/array.go

@@ -271,3 +271,18 @@ func (p *Array) moveBeforeInternal(nextCreatedAt, createdAt *time.Ticket) {
 		panic(err)
 	}
 }
+
+// buildArrayElements return the element slice of the given array.
+func buildArrayElements(
+	context *change.Context,
+	elements []interface{},
+) []crdt.Element {
+	elems := make([]crdt.Element, len(elements))
+
+	for idx, value := range elements {
+		ticket := context.IssueTimeTicket()
+		elems[idx] = buildCRDTElement(context, value, ticket)
+	}
+
+	return elems
+}

pkg/document/json/counter.go

@@ -28,18 +28,28 @@ import (
 // it is used when the user manipulates the counter from the outside.
 type Counter struct {
 	*crdt.Counter
-	context *change.Context
+	context   *change.Context
+	valueType crdt.CounterType
+	value     interface{}
 }
 
-// NewCounter create Counter instance.
-func NewCounter(ctx *change.Context, counter *crdt.Counter) *Counter {
+// NewCounter creates a new instance of Counter.
+func NewCounter(n interface{}, t crdt.CounterType) *Counter {
+	return &Counter{
+		valueType: t,
+		value:     n,
+	}
+}
+
+// Initialize initializes the Counter by the given context and counter.
+func (p *Counter) Initialize(ctx *change.Context, counter *crdt.Counter) *Counter {
 	if !counter.IsNumericType() {
 		panic("unsupported type")
 	}
-	return &Counter{
-		Counter: counter,
-		context: ctx,
-	}
+	p.Counter = counter
+	p.context = ctx
+
+	return p
 }
 
 // Increase adds an increase operations.

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,60 @@ func toOriginal(elem crdt.Element) crdt.Element {
 
 	panic("unsupported type")
 }
+
+func toElement(ctx *change.Context, elem crdt.Element) crdt.Element {
+	switch elem := elem.(type) {
+	case *crdt.Object:
+		return NewObject(ctx, elem)
+	case *crdt.Array:
+		return NewArray(ctx, elem)
+	case *crdt.Text:
+		text := NewText()
+		return text.Initialize(ctx, elem)
+	case *crdt.Counter:
+		counter := NewCounter(elem.Value(), elem.ValueType())
+		return counter.Initialize(ctx, elem)
+	case *crdt.Tree:
+		tree := NewTree()
+		return tree.Initialize(ctx, elem)
+	case *crdt.Primitive:
+		return elem
+	}
+
+	panic("unsupported type")
+}
+
+func buildCRDTElement(
+	context *change.Context,
+	value interface{},
+	ticket *time.Ticket,
+) crdt.Element {
+	switch elem := value.(type) {
+	case nil, string, int, int32, int64, float32, float64, []byte, bool, gotime.Time:
+		primitive, err := crdt.NewPrimitive(elem, ticket)
+		if err != nil {
+			panic(err)
+		}
+		return primitive
+	case *Tree:
+		crdtTree := crdt.NewTree(buildRoot(context, elem.initialRoot, ticket), ticket)
+		return crdtTree
+	case *Text:
+		return crdt.NewText(crdt.NewRGATreeSplit(crdt.InitialTextNode()), ticket)
+	case *Counter:
+		counter, err := crdt.NewCounter(elem.valueType, elem.value, ticket)
+		if err != nil {
+			panic(err)
+		}
+		return counter
+	case []interface{}:
+		array := crdt.NewArray(crdt.NewRGATreeList(), ticket, buildArrayElements(context, elem))
+		return array
+	case map[string]interface{}:
+		obj := crdt.NewObject(crdt.NewElementRHT(), ticket, buildObjectMembers(context, elem))
+		return obj
+	default:
+		panic("unsupported type")
+	}
+
+}