[fix] duplicated push at sub2node

src/broker/modules/subscription.go

 
 // Structure for managing subscriptions
 type sub_manager struct {
-	list 	   	topicList			// Data Structure for Manage TopicNode
+	list 	   	topicList		// Data Structure for Manage TopicNode
 	count_sub  	int                 // Subscription#
 	emptylist  	[]int               // For administrate Subscription#(Deleted)
 	ip2sub     	map[string][]int    // For mapping {ip : Sub#s List}
 					valPtr := node.valNodeList[0]
 					if Compare(valPtr.val ,value) == 0{
 						op := operator[0]
-						cnt += findOperatorList(op, valPtr, sub, true)
+						cnt += valPtr.findOperatorList(op, sub, true)
 					}
-				} else { // value가 숫자일 때
+				} else {
 					leftop := operator[0]
 					logicalop := operator[1]
 					rightop := operator[2]
 
 					if Compare(nodeValList, value) == 0 {
 						if logicalop == "&&" {
-							cnt += findOperatorList(leftop, leftValuePtr, sub, false)
-							cnt += findOperatorList(rightop, rightValuePtr, sub, false)
+							cnt += leftValuePtr.findOperatorList(leftop, sub, false)
+							cnt += rightValuePtr.findOperatorList(rightop, sub, false)
 						} else {
-							cnt += findOperatorList(leftop, leftValuePtr, sub, true)
-							cnt += findOperatorList(rightop, rightValuePtr, sub, true)
+							cnt += leftValuePtr.findOperatorList(leftop, sub, true)
+							cnt += rightValuePtr.findOperatorList(rightop, sub, true)
 						}
 					}
 				}
 	return canFind
 }
 
-// op와 같은 node내의 operator리스트에서 sub가 있다면 리턴
-func findOperatorList(op string, node *valueNode, sub int, issingle bool) int {
-	ret := -1
-	if issingle == true {
-		switch op {
-		case "<":
-			ret = findSub(node.single2sub_s, sub)
-		case "<=":
-			ret = findSub(node.single2sub_es, sub)
-		case ">":
-			ret = findSub(node.single2sub_b, sub)
-		case ">=":
-			ret = findSub(node.single2sub_eb, sub)
-		case "==":
-			ret = findSub(node.single2sub_e, sub)
-		}
-	} else {
-		switch op {
-		case "<":
-			ret = findSub(node.range2sub_s, sub)
-		case "<=":
-			ret = findSub(node.range2sub_es, sub)
-		case ">":
-			ret = findSub(node.range2sub_b, sub)
-		case ">=":
-			ret = findSub(node.range2sub_eb, sub)
-		}
-	}
-	if ret < 0{
-		return 0
-	} else{
-		return 1
-	}
-}
-
-//	### To Insert sub#
+// To Insert sub#
 func (manager *sub_manager) addSubscription(msg MsgUnit) error {
-
 	topic := msg.(SubscriptionMsg).Topic
 	value := msg.(SubscriptionMsg).Value
 	operator := msg.(SubscriptionMsg).Operator
 	// 1. Mapping incoming IP address to sub #
 	if len(manager.emptylist) == 0 {
 		subnumber = manager.count_sub
-		manager.ip2sub[msg.(SubscriptionMsg).From] = append(manager.ip2sub[msg.(SubscriptionMsg).From], manager.count_sub)
+		manager.ip2sub[msg.(SubscriptionMsg).From] = append(manager.ip2sub[msg.(SubscriptionMsg).From], subnumber)
 		manager.sub2ip[subnumber] = msg.(SubscriptionMsg).From
 		manager.count_sub++
 	} else {
 		manager.sub2ip[subnumber] = msg.(SubscriptionMsg).From
 	}
 
-	nameptr := manager.list.head
-	findOk := false
+	topicptr := manager.list.head
+	existTopic := false
 
-	// * 2. Add Subscription
+	// 2. Add Subscription
 
-	// Find name in namelist, add if not found
-	for nameptr != nil {
-		if Compare(nameptr.topic, topic) == 0 {
-			findOk = true
+	// Find topic in topiclist, add if not found
+	for topicptr != nil {
+		if Compare(topicptr.topic, topic) == 0 {
+			existTopic = true
 			break
 		}
-		nameptr = nameptr.next
+		topicptr = topicptr.next
 	}
 
-
-	if !findOk {
+	if !existTopic {
 		manager.list.addTopicNode(topic)
-		nameptr = manager.list.tail
+		topicptr = manager.list.tail
 	}
 
 	var addValNodeList []*valueNode
 
-	// Add Value to list[name]
-	if len(operator) == 1 { // if single expression
-		valptr := nameptr.list.getValueNodePos(value)
+	// if single expression
+	if len(operator) == 1 {
+		valptr := topicptr.list.getValueNodePos(value)
+		op := operator[0]
+
 		if valptr == nil {
-			nameptr.list.addValueNode(value)
-			valptr = nameptr.list.tail
+			topicptr.list.addValueNode(value)
+			valptr = topicptr.list.tail
 		}
+
 		addValNodeList = append(addValNodeList, valptr)
 		manager.sub2node[subnumber] = append(manager.sub2node[subnumber], nodeInfo{addValNodeList, topic})
 		manager.israngesub[subnumber] = false
-		valptr.insertSub(operator[0], subnumber, true)
+		valptr.insertSub(op, subnumber, true)
+
 		return nil // AddSubscription ok
 	} else {
-		// {">" "&&" "<"}
-		// For compound expressions bounded by '&&' and '||'
-		// (ex) { (234 < x) && (x <= 1293) } , { (234 < x) || ( x < 1293) }
+		// if Multi expression
+		// (ex) : { (234 < x) && (x <= 1293) } , { (234 < x) || (x < 1293) }
 
-		logical_operator := operator[1]
+		leftOperator := operator[0]
+		logicalOperator := operator[1] // For compound expressions bounded by '&&' and '||'
+		rightOperator := operator[2]
 
-		// Find ValueNode = (namelist[name].list.val == Value)
-		valptr1 := nameptr.list.getValueNodePos([]int64{value[0]})
-		valptr2 := nameptr.list.getValueNodePos([]int64{value[1]})
+		// Find ValueNode = (topiclist[topic].list.val == value)
+		valptr1 := topicptr.list.getValueNodePos([]int64{value[0]})
+		valptr2 := topicptr.list.getValueNodePos([]int64{value[1]})
 
 		if valptr1 == nil {
-			nameptr.list.addValueNode([]int64{value[0]})
-			valptr1 = nameptr.list.tail
+			topicptr.list.addValueNode([]int64{value[0]})
+			valptr1 = topicptr.list.tail
 		}
 		if valptr2 == nil {
-			nameptr.list.addValueNode([]int64{value[1]})
-			valptr2 = nameptr.list.tail
+			topicptr.list.addValueNode([]int64{value[1]})
+			valptr2 = topicptr.list.tail
 		}
+
 		addValNodeList = append(addValNodeList, valptr1)
 		addValNodeList = append(addValNodeList, valptr2)
 		manager.sub2node[subnumber] = append(manager.sub2node[subnumber], nodeInfo{addValNodeList, topic})
-		manager.sub2node[subnumber] = append(manager.sub2node[subnumber], nodeInfo{addValNodeList, topic})
 
-		if logical_operator == "&&" {
+		if logicalOperator == "&&" {
 			// If they are enclosed in '&&' -> Insert Value to range_operator_list
 			manager.israngesub[subnumber] = true
-			valptr1.insertSub(operator[0], subnumber, false)
-			valptr2.insertSub(operator[2], subnumber, false)
+			valptr1.insertSub(leftOperator, subnumber, false)
+			valptr2.insertSub(rightOperator, subnumber, false)
 
 		} else {
 			// if they are enclosed in '||' -> Insert Value to single_operator_list
 			manager.israngesub[subnumber] = false
-			valptr1.insertSub(operator[0], subnumber, true)
-			valptr2.insertSub(operator[2], subnumber, true)
+			valptr1.insertSub(leftOperator, subnumber, true)
+			valptr2.insertSub(rightOperator, subnumber, true)
 		}
-
 		return nil // addSubscription ok
 	}
 	return errors.New("Can't addSubscription")
 }
 
-// To delete subscription
+// To delete subscriptions
 func (manager *sub_manager) delete(from string) error {
-
 	ip := from
 	cand := manager.ip2sub[ip]
 
 	for i := 0; i < len(cand); i++ {
-
 		sub := cand[i]
+
 		for j := 0; j < len(manager.sub2node[sub]); j++ {
 			nodeinfo := manager.sub2node[sub][j]
 			node := nodeinfo.valNodeList
 						node[k].single2sub_e = remove(node[k].single2sub_e, pos)
 						manager.emptylist = append(manager.emptylist, sub)
 					}
-
 				}
 			}
 		}