response.go

package response

import "strings"

//Response response
type Response struct {
	// root 数据
	Data interface{}
}

func (r *Response) Delete(pattern string) *Response {
	if pattern == ""{
		return r
	}
	root:=_Node{
		data:r.Data,
	}

	root.Pattern(pattern, func(node *_Node)bool {
		if node.parent ==nil {
			return false
		}
		parent:= node.parent
		switch parent.data.(type) {
		case []interface{}:
			index:= node.index
			sl:= parent.data.([]interface{})

			nl:=sl[:index]
			sl=append(nl,sl[index+1])
			parent.data = sl

		case map[string]interface{}:
			mp:=parent.data.(map[string]interface{})
			delete(mp,node.key)
		}
		return false
	})
	return r
}
//SetValue 设置目标值，如果目标不存在，会对路径进行创建
func (r *Response) SetValue(pattern string,value interface{}) {
	if pattern == ""{
		r.Data = value
		return
	}
	root:=_Node{
		data:r.Data,
	}
	root.Make(strings.Split(pattern,"."))

	root.Pattern(pattern, func(node *_Node)bool {

		if node.parent ==nil {
			return false
		}
		parent:= node.parent
		switch parent.data.(type) {
		case []interface{}:
			sl:= parent.data.([]interface{})
			index:= node.index
			sl[index] = value
			parent.data = sl

		case map[string]interface{}:
			mp:=parent.data.(map[string]interface{})
			mp[node.key]=value
		}
		return false
	})

}

//ReTarget 选择目标重新设置为root
func (r *Response) ReTarget(pattern string) {
	if pattern == ""{
		return
	}
	root:=_Node{
		data:r.Data,
	}

	match, _ := root.Pattern(pattern, func(node *_Node) bool {
		r.Data = node.data

		return true
	})
	if !match{
		r.Data = make(map[string]interface{})
	}
	return
}
//Group
func (r *Response) Group(path []string) {
	l:=len(path)
	if l==0{
		return
	}
	root := make(map[string]interface{})
	node:=root

	lastKey := path[l-1]
	if l>1{
		for _,key:=range path[:l-1]{
			v := make(map[string]interface{})
			node[key]=v
			node = v
		}
	}

	node[lastKey] = r.Data
	r.Data = root
}
//ReName 重命名
func (r *Response)ReName(pattern string,newName string)  {
	if pattern == ""{
		return
	}
	root:=_Node{
		data:r.Data,
	}

	root.Pattern(pattern, func(node *_Node) bool {
		if node.parent ==nil {
			return false
		}
		parent:= node.parent
		switch parent.data.(type) {
		case []interface{}:
			return false

		case map[string]interface{}:
			mp:=parent.data.(map[string]interface{})
			delete(mp,node.key)
			mp[newName]=node.data
			return false
		}
		return false
	})
}

func (r *Response)Move(source ,target string)  {

	if strings.Index(source,"*") != -1{
		return
	}
	if strings.Index(target,"*") != -1{
		return
	}
	root:=_Node{
		data:r.Data,
	}
	var oldValues *_Node
	match,_:=root.Pattern(source, func(node *_Node) bool {
		oldValues = node

		if node.parent ==nil {
			return false
		}
		parent:= node.parent
		switch parent.data.(type) {
		case []interface{}:
			index:= node.index
			sl:= parent.data.([]interface{})

			nl:=sl[:index]
			sl=append(nl,sl[index+1])
			parent.data = sl

		case map[string]interface{}:
			mp:=parent.data.(map[string]interface{})
			delete(mp,node.key)
		}
		return false
	})
	if match{
	 	r.SetValue(target,oldValues.data)
	}else{
		r.SetValue(target,nil)
	}

}