[fin] list.go

src/broker/modules/list.go

 package modules
 
-/*
-	Sub정보들을 관리할 list
-*/
+/* List to manage Sub information */
 
 type topicList struct {
 	head *topicNode
 }
 
 type topicNode struct {
-	topic []int64 // Encrypt된 topic
+	topic []int64 // Encrypted topic
 	next  *topicNode
 	prev  *topicNode
 	list  valueList
 }
 
 type valueNode struct {
-	val  []int64 // Encrypt된 value
+	val  []int64 // Encrypted topic
 	next *valueNode
 	prev *valueNode
 
 	// single //
-	single2sub_s  []int // (val < x) sub#
-	single2sub_es []int // (val <= x) sub#
-	single2sub_b  []int // (val > x) sub#
-	single2sub_eb []int // (val >= x) sub#
-	single2sub_e  []int // (val == x) sub#
+	single2sub_s  []int // (sub_val < pub_val) sub#s
+	single2sub_es []int // (sub_val <= pub_val) sub#s
+	single2sub_b  []int // (sub_val > pub_val) sub#s
+	single2sub_eb []int // (sub_val >= pub_val) sub#s
+	single2sub_e  []int // (sub_val == pub_val) sub#s
 
 	// range //
-	range2sub_s  []int // (val < x and ...) sub#
-	range2sub_es []int // (val <= x and ...) sub#
-	range2sub_b  []int // (val > x and ...) sub#
-	range2sub_eb []int // (val >= x and ...) sub#
+	range2sub_s  []int // (sub_val < pub_val) sub#s
+	range2sub_es []int // (sub_val <= pub_val) sub#s
+	range2sub_b  []int // (sub_val > pub_val) sub#s
+	range2sub_eb []int // (sub_val >= pub_val) sub#s
 }
 
-// ### To delete slice Array
+// To delete slice Array
 func remove(ary []int, i int) []int {
 	return append(ary[:i], ary[i+1:]...)
 }
 
+// To find a specific sub# in a value node
 func findSub(ary []int, sub int) int {
 	for i := 0; i < len(ary); i++ {
 		if ary[i] == sub {
 	return -1
 }
 
+// To add a topic node to the topic list
 func (l *topicList) addTopicNode(topic []int64){
 	newNode := &topicNode{topic, nil, nil, valueList{}}
 	if l.head == nil{
 	l.size++
 }
 
+// To check if a specific value node is empty
 func (n *valueNode) isEmpty() bool {
 	empty := true
 	if len(n.single2sub_s) != 0 {
 	return empty
 }
 
-// 노드의 operator리스트에 sub#을 in
-func (l *valueNode) insertSub(op string, sub int, issingle bool) {
+// To insert sub# into the operator list of the value node
+func (n *valueNode) insertSub(op string, sub int, issingle bool) {
 	if issingle == true {
 		switch op {
 		case "<":
-			l.single2sub_s = append(l.single2sub_s, sub)
+			n.single2sub_s = append(n.single2sub_s, sub)
 		case "<=":
-			l.single2sub_es = append(l.single2sub_es, sub)
+			n.single2sub_es = append(n.single2sub_es, sub)
 		case ">":
-			l.single2sub_b = append(l.single2sub_b, sub)
+			n.single2sub_b = append(n.single2sub_b, sub)
 		case ">=":
-			l.single2sub_eb = append(l.single2sub_eb, sub)
+			n.single2sub_eb = append(n.single2sub_eb, sub)
 		case "==":
-			l.single2sub_e = append(l.single2sub_e, sub)
+			n.single2sub_e = append(n.single2sub_e, sub)
 		}
 	} else {
 		switch op {
 		case "<":
-			l.range2sub_s = append(l.range2sub_s, sub)
+			n.range2sub_s = append(n.range2sub_s, sub)
 		case "<=":
-			l.range2sub_es = append(l.range2sub_es, sub)
+			n.range2sub_es = append(n.range2sub_es, sub)
 		case ">":
-			l.range2sub_b = append(l.range2sub_b, sub)
+			n.range2sub_b = append(n.range2sub_b, sub)
 		case ">=":
-			l.range2sub_eb = append(l.range2sub_eb, sub)
+			n.range2sub_eb = append(n.range2sub_eb, sub)
 		}
 	}
 }
 
+// To add a value node to the value list
 func (l *valueList) addValueNode(value []int64) {
 	newValNode := &valueNode{value, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil}
 	if l.head == nil{
 	l.size++
 }
 
+// To get the position of a topic node with a specific topic
 func (l *topicList) getTopicNodePos(topic []int64) *topicNode {
 	topicPtr := l.head
 	for topicPtr != nil {
 			topicPtr = topicPtr.next
 			continue
 		}
-		// * compare 완성된다면 다시보기
-		if l.CompareTopic(topicPtr.topic, topic) == 0 {
+		if Compare(topicPtr.topic, topic) == 0 {
 			return topicPtr
 		}
 		topicPtr = topicPtr.next
 	return nil
 }
 
-func (l *topicList)CompareTopic(topic1 []int64, topic2 []int64) int {
-	// 길이 같은지 체크
-	if len(topic1) != len(topic2) {
-		return -1
-	}
-	for i := 0; i < len(topic2); i++ {
-		if topic1[i] != topic2[i] {
-			return -1
-		}
-	}
-	return 0
-}
-
-func (l *valueList) getValueNodePos(value []int64, isAlpha bool) *valueNode {
+// To get the position of a value node with a specific value
+func (l *valueList) getValueNodePos(value []int64) *valueNode {
 	valPtr := l.head
 	for valPtr != nil {
 		if len(valPtr.val) == 0{
 			valPtr = valPtr.next
 			continue
 		}
-		if isAlpha{
-			if CompareAlpha(value, valPtr.val) == 0{
-				return valPtr
-			}
-		} else{
-			if CompareDigit(value[0], valPtr.val[0]) == 0{
-				return valPtr
-			}
+		if Compare(value, valPtr.val) == 0 {
+			return valPtr
 		}
 		valPtr = valPtr.next
 	}
 	return nil
 }
 
-
-func CompareDigit(value1 int64, value2 int64) int {
-	if value1 < value2 {
+// Compare ->  To compare (topics, values) in a node
+func Compare(a []int64, b []int64) int {
+	if len(a) < len(b) {
 		return 1
-	} else if value1 > value2 {
+	} else if len(a) > len(b){
 		return -1
-	}
-	return 0
-}
-
-func CompareAlpha(value1 []int64, value2 []int64) int {
-	// 길이 같은지 체크
-	if len(value1) != len(value2) {
-		return -1
-	}
-	for i := 0; i < len(value2); i++ {
-		if value1[i] != value2[i] {
-			return -1
+	} else{
+		for i := 0; i < len(a); i++{
+			if a[i] < b[i] {
+				return 1
+			} else if a[i] > b[i]{
+				return -1
+			}
 		}
+		return 0
 	}
-	return 0
-}
+}