Moscato_Messaging_Middleware/subscription.go

package modules

import (
	"errors"
	"fmt"
)

type sub_manager struct {

	// NameList의 노드들이 각각의 list를 갖음
	list NameList

	/* sub# 관리 */
	count_sub  int             // Subscription #
	emptylist  []int           // To administrate sub #
	num2sub    map[int]MsgUnit // num2sub[sub#] = msg
	sub2num    map[MsgUnit]int // delete시에 관리를 위해
	israngesub map[int]bool    // delete시에 관리를 위해
}

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

	name := msg.(*SubscriptionMsg).subscription
	value := msg.(*SubscriptionMsg).value
	subnumber := 0

	fmt.Println("name = ", name, " value = ", value) // for debuging

	// * 1. 들어온 Msg -> sub#, sub# -> Msg로 매핑
	if len(manager.emptylist) == 0 {
		manager.num2sub[manager.count_sub] = msg
		manager.sub2num[msg] = manager.count_sub
		subnumber = manager.count_sub
		manager.count_sub++
	} else {
		subidx := manager.emptylist[len(manager.emptylist)-1]
		manager.emptylist = manager.emptylist[:len(manager.emptylist)-1]
		manager.num2sub[subidx] = msg
		manager.sub2num[msg] = subidx
		subnumber = subidx
	}

	// * 2. value가 연산식인지 확인
	isformula := check_Subtype(value)

	// * 3. Sub 추가
	nameidx := manager.list.head
	findOk := false

	// * namelist에서 name찾고, 없으면 추가
	for nameidx != nil {
		// *  compare함수 구현되기 전 임시로 끼어넣은 것 (이 부분은 secure.go 완성되면 다시 확인)
		if compare(nameidx.name, name) == 1 {
			findOk = true
			break
		}
		nameidx = nameidx.next
	}

	newNode := &NameNode{name, nil, List{}}
	if findOk == false {
		manager.list.tail.next = newNode
		manager.list.tail = newNode
		manager.list.size++
		nameidx = manager.list.tail
	}

	// * list[name]에 value추가
	if isformula == false { // 단순 매칭이라면
		valptr := nameidx.list.head

		for valptr != nil {
			// * 이 부분도 compare함수 구현하면 다시봐야함
			if compare(valptr.val, conv(value)) == 1{ // value와 같은 val을 갖는 노드가 존재한다면
				valptr.single2sub_e = append(valptr.single2sub_e, subnumber)
				return nil // 제대로 insert된 것
			}
			valptr=valptr.next
		}
		
		// value와 일치하는 노드가 x -> 추가
		newValNode := & Node{conv(value)}
		newValNode.single2sub_e = append(newValNode.single2sub_e, subnumber)  
		nameidx.list.tail.next = newValNode
		nameidx.list.tail = newValNode
		nameidx.list.size++
	} else{ // 연산식이라면
			
	}

	return nil
}


// * string형태로 암호화 되어있는 value -> int64[]로 변환(임시) 
func conv(val string) []int64{
	var ret := [] int64
	return ret
}

// * 암호화된 두 value 비교함수 (임시)
func compare(v1 []int64, v2 []int64) int {
	return 1
}

//	* ### To delete sub#
func (manager *sub_manager) delete(subnumber int) error {
	s := errors.New("!23")
	return s
}

func check_Subtype(value []string) bool {
	if len(value) == 1 {
		return false
	} else {
		return true
	}
}