[revise] rename & revise func

src/broker/modules/list.go

 	Sub정보들을 관리할 list
 */
 
-type NameList struct {
-	head *NameNode
-	tail *NameNode
+type topicList struct {
+	head *topicNode
+	tail *topicNode
 	size int
 }
 
-type NameNode struct {
+type topicNode struct {
 	topic []int64 // Encrypt된 topic
-	next  *NameNode
-	prev  *NameNode
-	list  List
+	next  *topicNode
+	prev  *topicNode
+	list  valueList
 }
 
-type List struct {
-	head *Node
-	tail *Node
+type valueList struct {
+	head *valueNode
+	tail *valueNode
 	size int
 }
 
-type Node struct {
+type valueNode struct {
 	val  []int64 // Encrypt된 value
-	next *Node
-	prev *Node
+	next *valueNode
+	prev *valueNode
 
 	// single //
 	single2sub_s  []int // (val < x) sub#
 	return -1
 }
 
-func (n *Node) isempty() bool {
+func (l *topicList) addTopicNode(topic []int64){
+	newNode := &topicNode{topic, nil, nil, valueList{}}
+	if l.head == nil{
+		l.head = newNode
+		l.tail = l.head
+	} else{
+		newNode.prev = l.tail
+		l.tail.next = newNode
+		l.tail = newNode
+	}
+	l.size++
+}
+
+func (n *valueNode) isEmpty() bool {
 	empty := true
 	if len(n.single2sub_s) != 0 {
 		empty = false
 }
 
 // 노드의 operator리스트에 sub#을 in
-func (l *Node) insert_Sub(op string, sub int, issingle bool) {
+func (l *valueNode) insertSub(op string, sub int, issingle bool) {
 	if issingle == true {
 		switch op {
 		case "<":
 	}
 }
 
-func (l *List) add_ValueNode(value []int64) {
-	newValNode := &Node{value, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil}
-	l.tail.next = newValNode
-	l.tail = newValNode
+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.head = newValNode
+		l.tail = l.head
+	} else{
+		newValNode.prev = l.tail
+		l.tail.next = newValNode
+		l.tail = newValNode
+	}
 	l.size++
 }
 
-func (l *List) getPos(value []int64) *Node {
-	valptr := l.head
-	for valptr != nil {
+func (l *topicList) getTopicNodePos(topic []int64) *topicNode {
+	topicPtr := l.head
+	for topicPtr != nil {
+		if len(topicPtr.topic) == 0{
+			topicPtr = topicPtr.next
+			continue
+		}
 		// * compare 완성된다면 다시보기
-		if compare(valptr.val, value) == 0 { // value와 같은 val을 갖는 노드가 존재한다면
-			return valptr
+		if l.CompareTopic(topicPtr.topic, topic) == 0 {
+			return topicPtr
 		}
-		valptr = valptr.next
+		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 {
+	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
+			}
+		}
+		valPtr = valPtr.next
+	}
+	return nil
+}
+
+
+func CompareDigit(value1 int64, value2 int64) int {
+	if value1 < value2 {
+		return 1
+	} else if value1 > value2 {
+		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
+		}
+	}
+	return 0
+}