Moscato_Messaging_Middleware/src/broker/modules/subscription.go

package modules

import (
	"errors"
	"fmt"
)

type sub_manager struct {
	list topicList

	/* Manage sub# */
	count_sub  int                  // Subscription #
	emptylist  []int                // To administrate sub #
	ip2sub     map[string][]int     // ip2sub[ip] = sub# ...
	sub2ip     map[int]string       // sub2ip[sub#] = ip
	sub2node   map[int][]*valueNode // sub2node[sub#] = node_addr ...
	israngesub map[int]bool         // To manage when deleted
}

func (manager *sub_manager) Initialize() {
	// Some initialize
	manager.ip2sub = make(map[string][]int)
	manager.sub2ip = make(map[int]string)
	manager.sub2node = make(map[int][]*valueNode)
	manager.israngesub = make(map[int]bool)
}

func newSubmng() *sub_manager {
	subMng := &sub_manager{}
	subMng.Initialize()
	return subMng
}

//	### To Insert sub#
func (manager *sub_manager) addSubscription(msg MsgUnit) error {

	topic := msg.(SubscriptionMsg).Topic
	value := msg.(SubscriptionMsg).Value
	operator := msg.(SubscriptionMsg).Operator
	subnumber := 0
	// * 1. Mapping incoming IP address to sub #

	fmt.Println("add sub st")
	fmt.Println("sub val", value)

	if len(manager.emptylist) == 0 {
		subnumber = manager.count_sub
		manager.ip2sub[msg.(SubscriptionMsg).From] = append(manager.ip2sub[msg.(SubscriptionMsg).From], manager.count_sub)
		manager.sub2ip[subnumber] = msg.(SubscriptionMsg).From
		manager.count_sub++
	} else {
		subnumber := manager.emptylist[len(manager.emptylist)-1]
		manager.emptylist = manager.emptylist[:len(manager.emptylist)-1]
		manager.ip2sub[msg.(SubscriptionMsg).From] = append(manager.ip2sub[msg.(SubscriptionMsg).From], subnumber)
		manager.sub2ip[subnumber] = msg.(SubscriptionMsg).From
	}

	nameptr := manager.list.head
	findOk := false

	// * 2. Add Subscription

	// Find name in namelist, add if not found
	for nameptr != nil {
		if Compare(nameptr.topic, topic) == 0 {
			findOk = true
			break
		}
		nameptr = nameptr.next
	}

	if !findOk {
		manager.list.addTopicNode(topic)
		nameptr = manager.list.tail
	}

	// Add Value to list[name]
	if len(operator) == 1 { // if single expression
		valptr := nameptr.list.getValueNodePos(value)
		if valptr == nil {
			nameptr.list.addValueNode(value)
			valptr = nameptr.list.tail
		}

		manager.sub2node[subnumber] = append(manager.sub2node[subnumber], valptr)
		valptr.insertSub(operator[0], subnumber, true)
		return nil // AddSubscription ok
	} else {

		// For compound expressions bounded by '&&' and '||'
		// (ex) { (234 < x) && (x <= 1293) } , { (234 < x) || ( x < 1293) }
		logical_operator := operator[2]

		// Find ValueNode = (namelist[name].list.val == Value)
		valptr1 := nameptr.list.getValueNodePos([]int64{value[0]})
		valptr2 := nameptr.list.getValueNodePos([]int64{value[2]})

		if valptr1 == nil {
			nameptr.list.addValueNode([]int64{value[0]})
			valptr1 = nameptr.list.tail
		}
		if valptr2 == nil {
			nameptr.list.addValueNode([]int64{value[2]})
			valptr2 = nameptr.list.tail
		}

		manager.sub2node[subnumber] = append(manager.sub2node[subnumber], valptr1)
		manager.sub2node[subnumber] = append(manager.sub2node[subnumber], valptr2)

		if logical_operator == "&&" {
			// If they are enclosed in '&&' -> Insert Value to range_operator_list
			manager.israngesub[subnumber] = true
			valptr1.insertSub(operator[0], subnumber, false)
			valptr2.insertSub(operator[4], subnumber, false)

		} else {
			// if they are enclosed in '||' -> Insert Value to single_operator_list
			valptr1.insertSub(operator[0], subnumber, true)
			valptr2.insertSub(operator[4], subnumber, true)
		}

		return nil // addSubscription ok
	}
	return errors.New("Can't addSubscription")
}

// To delete subscription
func (manager *sub_manager) delete(from string) error {

	ip := from
	cand := manager.ip2sub[ip]

	for i := 0; i < len(cand); i++ {

		sub := cand[i]
		node := manager.sub2node[sub]

		if manager.israngesub[sub] {
			for j := 0; j < len(node); j++ {
				pos := findSub(node[j].range2sub_s, sub)
				if pos != -1 {
					node[j].range2sub_s = remove(node[j].range2sub_s, pos)
					manager.emptylist = append(manager.emptylist, sub)
				}

				pos = findSub(node[j].range2sub_es, sub)
				if pos != -1 {
					node[j].range2sub_es = remove(node[j].range2sub_es, pos)
					manager.emptylist = append(manager.emptylist, sub)
				}

				pos = findSub(node[j].range2sub_b, sub)
				if pos != -1 {
					node[j].range2sub_b = remove(node[j].range2sub_b, pos)
					manager.emptylist = append(manager.emptylist, sub)
				}

				pos = findSub(node[j].range2sub_eb, sub)
				if pos != -1 {
					node[j].range2sub_eb = remove(node[j].range2sub_eb, pos)
					manager.emptylist = append(manager.emptylist, sub)
				}

				isempty := node[j].isEmpty()

				// Delete if Value Node is empty
				if isempty && node[j] != nil {
					prev_node := node[j].prev
					next_node := node[j].next

					prev_node.next = node[j].next
					next_node.prev = node[j].prev
				}
			}
		} else {
			for j := 0; j < len(node); j++ {
				pos := findSub(node[j].single2sub_s, sub)
				if pos != -1 {
					node[j].single2sub_s = remove(node[j].single2sub_s, pos)
					manager.emptylist = append(manager.emptylist, sub)
				}

				pos = findSub(node[j].single2sub_es, sub)
				if pos != -1 {
					node[j].single2sub_es = remove(node[j].single2sub_es, pos)
					manager.emptylist = append(manager.emptylist, sub)
				}

				pos = findSub(node[j].single2sub_b, sub)
				if pos != -1 {
					node[j].single2sub_b = remove(node[j].single2sub_b, pos)
					manager.emptylist = append(manager.emptylist, sub)
				}

				pos = findSub(node[j].single2sub_eb, sub)
				if pos != -1 {
					node[j].single2sub_eb = remove(node[j].single2sub_eb, pos)
					manager.emptylist = append(manager.emptylist, sub)
				}

				pos = findSub(node[j].single2sub_e, sub)
				if pos != -1 {
					node[j].single2sub_e = remove(node[j].single2sub_e, pos)
					manager.emptylist = append(manager.emptylist, sub)
				}

				isempty := node[j].isEmpty()

				// Delete if Value Node is empty
				if isempty && node[j] != nil {
					prevNode := node[j].prev
					nextNode := node[j].next

					prevNode.next = node[j].next
					nextNode.prev = node[j].prev
				}
			}
		}
	}
	manager.ip2sub[ip] = nil // Delete sub#s mapped to Ip address
	return nil
}