staros/sysconf/sysconf.go

package sysconf

import (
	"bytes"
	"errors"
	"fmt"
	"io/ioutil"
	"reflect"
	"strconv"
	"strings"
	"sync"
)

type SysConf struct {
	Data        []*SysSegment
	segmap      map[string]int64
	segId       int64
	HaveSegMent bool //是否有节这个概念
	SegStart    string
	SegEnd      string
	CommentFlag []string //评论标识符，如#
	EqualFlag   string   //赋值标识符，如=
	ValueFlag   string   //值标识符，如"
	EscapeFlag  string   //转义字符
	CommentCR   bool     //评论是否能与value同一行，true不行，false可以
	SpaceStr    string   //美化符号
	lock        sync.RWMutex
}

type SysSegment struct {
	Name string
	//nodeMap
	Comment  string
	NodeData []*SysNode
	nodeId   int64
	nodeMap  map[string]int64
	lock     sync.RWMutex
}

type SysNode struct {
	Key     string
	Value   []string
	Comment string
	NoValue bool
	lock    sync.RWMutex
}

func NewIni() *SysConf {
	ini := NewSysConf("=")
	ini.CommentCR = true
	ini.CommentFlag = []string{"#", ";"}
	ini.HaveSegMent = true
	ini.SegStart = "["
	ini.SegEnd = "]"
	ini.SpaceStr = " "
	ini.EscapeFlag = "\\"
	return ini
}

func NewSysConf(EqualFlag string) *SysConf {
	syscnf := new(SysConf)
	syscnf.EqualFlag = EqualFlag
	return syscnf
}

// NewLinuxConf sysctl.conf like file
func NewLinuxConf(EqualFlag string) *SysConf {
	syscnf := new(SysConf)
	syscnf.EqualFlag = EqualFlag
	syscnf.HaveSegMent = false
	syscnf.CommentCR = true
	syscnf.CommentFlag = []string{"#"}
	return syscnf
}

func (syscfg *SysConf) ParseFromFile(filepath string) error {
	data, err := ioutil.ReadFile(filepath)
	if err != nil {
		return err
	}
	return syscfg.Parse(data)
}

// Parse 生成INI文件结构
func (syscfg *SysConf) Parse(data []byte) error {
	syscfg.lock.Lock()
	defer syscfg.lock.Unlock()
	if syscfg.HaveSegMent && (syscfg.SegStart == "" || syscfg.SegEnd == "") {
		return errors.New("SegMent Start or End Flag Not Allowed!")
	}
	if !syscfg.CommentCR {
		return syscfg.parseNOCRComment(data)
	}
	return syscfg.parseCRComment(data)
}

func (syscfg *SysConf) parseNOCRComment(data []byte) error { //允许comment在同一行
	data = bytes.TrimSpace(data)
	dataLists := bytes.Split(data, []byte("\n"))
	seg := new(SysSegment)
	seg.nodeMap = make(map[string]int64)
	syscfg.segmap = make(map[string]int64)
	if syscfg.HaveSegMent {
		seg.Name = "unnamed"
	}
	syscfg.segId = 0
	var node *SysNode
	for _, v1 := range dataLists {
		var (
			isSegStart bool   = false
			isEscape   bool   = false
			isEqual    bool   = false
			isComment  bool   = false
			tsuMo      string = ""
		)
		cowStr := strings.TrimSpace(string(v1))
		for i := 0; i < len(cowStr); i++ {
			runeStr := cowStr[i : i+1] //当前字符，rune扫描
			if runeStr == syscfg.EscapeFlag && (!isEscape) {
				isEscape = true
				continue
			}
			if runeStr == syscfg.SegStart && (!isEscape) {

				isSegStart = true
				continue
			}
			if runeStr == syscfg.SegEnd && (!isEscape) {
				isSegStart = false
				//New segment start from here
				if seg.Name == "unnamed" && len(seg.NodeData) == 0 {
					seg.Name = tsuMo
					tsuMo = ""
					continue
				}
				syscfg.segmap[seg.Name] = syscfg.segId
				syscfg.segId++
				syscfg.Data = append(syscfg.Data, seg)
				seg = new(SysSegment)
				seg.nodeMap = make(map[string]int64)
				seg.Name = tsuMo
				tsuMo = ""
				continue
			}
			if isSegStart {
				tsuMo += runeStr
				if isEscape {
					isEscape = false
				}
				continue
			}
			if syscfg.EqualFlag == runeStr && (!isEscape) && (!isEqual) {
				key := strings.TrimSpace(tsuMo)
				if val, ok := seg.nodeMap[key]; ok {
					node = seg.NodeData[val]
				} else {
					node = new(SysNode)
					node.Key = key
					seg.nodeMap[node.Key] = seg.nodeId
					seg.nodeId++
					seg.NodeData = append(seg.NodeData, node)
				}
				tsuMo = ""
				isEqual = true
				if syscfg.ValueFlag != "" {
					nokoriStr := strings.TrimSpace(cowStr[i+1:])
					isFound := false
					isValue := false
					for k4, v4 := range nokoriStr {
						if string([]rune{v4}) == syscfg.ValueFlag {
							isValue = !isValue
						}
						if SliceIn(syscfg.CommentFlag, string([]rune{v4})) && !isValue {
							val := nokoriStr[:k4]
							isFound = true
							startFinder := strings.Index(val, syscfg.ValueFlag)
							endFinder := strings.LastIndex(val, syscfg.ValueFlag)
							if !((startFinder == -1 || endFinder == -1) || (endFinder-startFinder <= 0)) {
								node.Value = append(node.Value, strings.TrimSpace(val[startFinder+1:endFinder]))
							}
							node.Comment = nokoriStr[k4+1:] + "\n"
						}
					}
					if !isFound {
						startFinder := strings.Index(nokoriStr, syscfg.ValueFlag)
						endFinder := strings.LastIndex(nokoriStr, syscfg.ValueFlag)
						if (startFinder == -1 || endFinder == -1) || (endFinder-startFinder <= 0) {
							break
						}
						node.Value = append(node.Value, strings.TrimSpace(nokoriStr[startFinder+1:endFinder]))
					}
					break
				}
				continue
			}
			if SliceIn(syscfg.CommentFlag, runeStr) && (!isEscape) {
				isComment = true
				if seg.nodeId == 0 {
					seg.Comment += strings.TrimSpace(cowStr[i+1:]) + "\n"
					break
				}
				if tsuMo != "" {
					node.Value = append(node.Value, strings.TrimSpace(tsuMo))
					tsuMo = ""
				}
				node.Comment += strings.TrimSpace(cowStr[i+1:]) + "\n"
				break
			}
			isEscape = false
			tsuMo += runeStr
		}
		if isEqual && tsuMo != "" {
			node.Value = append(node.Value, strings.TrimSpace(tsuMo))
		}
		if !isEqual && tsuMo != "" && !isComment {
			node = new(SysNode)
			node.Key = tsuMo
			seg.nodeMap[node.Key] = seg.nodeId
			seg.nodeId++
			seg.NodeData = append(seg.NodeData, node)
			node.NoValue = true
		}
	}
	if seg != nil {
		syscfg.segmap[seg.Name] = syscfg.segId
		syscfg.segId++
		syscfg.Data = append(syscfg.Data, seg)
	}
	return nil
}

func (syscfg *SysConf) parseCRComment(data []byte) error { //不允许comment在同一行
	data = bytes.TrimSpace(data)
	dataLists := bytes.Split(data, []byte("\n"))
	seg := new(SysSegment)
	seg.nodeMap = make(map[string]int64)
	syscfg.segmap = make(map[string]int64)
	if syscfg.HaveSegMent {
		seg.Name = "unnamed"
	}
	syscfg.segId = 0
	var node *SysNode
	for _, v1 := range dataLists {
		var (
			isSegStart bool   = false
			isEscape   bool   = false
			isEqual    bool   = false
			isComment  bool   = false
			tsuMo      string = ""
		)
		cowStr := strings.TrimSpace(string(v1))
		for i := 0; i < len(cowStr); i++ {
			runeStr := cowStr[i : i+1] //当前字符，rune扫描
			if runeStr == syscfg.EscapeFlag && (!isEscape) {
				isEscape = true
				continue
			}
			if runeStr == syscfg.SegStart && (!isEscape) {

				isSegStart = true
				continue
			}
			if runeStr == syscfg.SegEnd && (!isEscape) {
				isSegStart = false
				//New segment start from here
				if seg.Name == "unnamed" && len(seg.NodeData) == 0 {
					seg.Name = tsuMo
					tsuMo = ""
					break
				}
				syscfg.segmap[seg.Name] = syscfg.segId
				syscfg.segId++
				syscfg.Data = append(syscfg.Data, seg)
				seg = new(SysSegment)
				seg.nodeMap = make(map[string]int64)
				seg.Name = tsuMo
				tsuMo = ""
				break
			}
			if isSegStart {
				tsuMo += runeStr
				if isEscape {
					isEscape = false
				}
				continue
			}
			if syscfg.EqualFlag == runeStr && (!isEscape) && (!isEqual) {
				key := strings.TrimSpace(tsuMo)
				if val, ok := seg.nodeMap[key]; ok {
					node = seg.NodeData[val]
				} else {
					node = new(SysNode)
					node.Key = key
					seg.nodeMap[node.Key] = seg.nodeId
					seg.nodeId++
					seg.NodeData = append(seg.NodeData, node)
				}
				tsuMo = ""
				isEqual = true
				if syscfg.ValueFlag == "" {
					node.Value = append(node.Value, TrimEscape(strings.TrimSpace(cowStr[i+1:]), syscfg.EscapeFlag))
				} else {
					nokoriStr := strings.TrimSpace(cowStr[i+1:])
					startFinder := strings.Index(nokoriStr, syscfg.ValueFlag)
					endFinder := strings.LastIndex(nokoriStr, syscfg.ValueFlag)
					if (startFinder == -1 || endFinder == -1) || (endFinder-startFinder <= 0) {
						break
					}
					node.Value = append(node.Value, strings.TrimSpace(nokoriStr[startFinder+1:endFinder]))
				}
				break
			}
			if SliceIn(syscfg.CommentFlag, runeStr) && (!isEscape) {
				isComment = true
				tsuMo = ""
				if seg.nodeId == 0 {
					seg.Comment += strings.TrimSpace(cowStr[i+1:]) + "\n"
					break
				}
				node.Comment += strings.TrimSpace(cowStr[i+1:]) + "\n"
				break
			}
			isEscape = false
			tsuMo += runeStr
		}
		if !isEqual && tsuMo != "" && !isComment {
			node = new(SysNode)
			node.Key = tsuMo
			seg.nodeMap[node.Key] = seg.nodeId
			seg.nodeId++
			seg.NodeData = append(seg.NodeData, node)
			node.NoValue = true
		}
	}
	if seg != nil {
		syscfg.segmap[seg.Name] = syscfg.segId
		syscfg.segId++
		syscfg.Data = append(syscfg.Data, seg)
	}
	return nil
}

func (syscfg *SysConf) Build() []byte {
	syscfg.lock.Lock()
	defer syscfg.lock.Unlock()
	var outPut string
	for _, v := range syscfg.Data {
		if v == nil {
			continue
		}
		if syscfg.HaveSegMent {
			outPut += syscfg.SegStart + v.Name + syscfg.SegEnd + "\n"
		}
		if v.Comment != "" {
			v.Comment = v.Comment[:len(v.Comment)-1]
			comment := strings.Split(v.Comment, "\n")
			for _, vc := range comment {
				if vc != "" {
					outPut += syscfg.CommentFlag[0] + vc + "\n"
				} else {
					outPut += "\n"
				}
			}
		}
		for _, v2 := range v.NodeData {
			if v2 == nil {
				continue
			}
			if v2.NoValue {
				outPut += v2.Key + "\n"
			} else {
				for _, v3 := range v2.Value {
					if syscfg.ValueFlag != "" {
						outPut += v2.Key + syscfg.SpaceStr + syscfg.EqualFlag + syscfg.SpaceStr + syscfg.ValueFlag + v3 + syscfg.ValueFlag + "\n"
					} else {
						outPut += v2.Key + syscfg.SpaceStr + syscfg.EqualFlag + syscfg.SpaceStr + syscfg.addEscape(v3) + "\n"
					}
				}
				if len(v2.Value) == 0 {
					outPut += v2.Key + syscfg.SpaceStr + syscfg.EqualFlag + "\n"
				}
				if v2.Comment != "" {
					v2.Comment = v2.Comment[:len(v2.Comment)-1]
					comment := strings.Split(v2.Comment, "\n")
					for _, vc := range comment {
						if vc != "" {
							outPut += syscfg.CommentFlag[0] + vc + "\n"
						} else {
							outPut += "\n"
						}
					}
				}
			}
		}
	}
	return []byte(outPut)
}

func (syscfg *SysConf) addEscape(str string) string {
	str = strings.ReplaceAll(str, syscfg.EscapeFlag, syscfg.EscapeFlag+syscfg.EscapeFlag)
	str = strings.ReplaceAll(str, syscfg.EqualFlag, syscfg.EscapeFlag+syscfg.EqualFlag)
	str = strings.ReplaceAll(str, syscfg.SegStart, syscfg.EscapeFlag+syscfg.SegStart)
	str = strings.ReplaceAll(str, syscfg.SegEnd, syscfg.EscapeFlag+syscfg.SegEnd)
	for _, v := range syscfg.CommentFlag {
		str = strings.ReplaceAll(str, v, syscfg.EscapeFlag+v)
	}
	return str
}

func (syscfg *SysConf) Reverse() {
	syscfg.lock.Lock()
	defer syscfg.lock.Unlock()
	for _, v := range syscfg.Data {
		if v == nil {
			continue
		}
		var (
			NodeData []*SysNode
			nodeId   int64
			nodeMap  map[string]int64
		)
		nodeMap = make(map[string]int64)
		for _, v2 := range v.NodeData {
			if v2 == nil {
				continue
			}
			for _, v3 := range v2.Value {
				var node *SysNode
				if val, ok := nodeMap[v3]; ok {
					node = NodeData[val]
				} else {
					node = new(SysNode)
					node.Key = v3
					NodeData = append(NodeData, node)
					nodeMap[v3] = nodeId
					nodeId++
				}
				node.Value = append(node.Value, strings.TrimSpace(v2.Key))
				node.Comment += v2.Comment
			}
			v.NodeData = NodeData
			v.nodeId = nodeId
			v.nodeMap = nodeMap
		}
	}
}

func TrimEscape(text, escape string) string {
	var isEscape bool = false
	var outPut []rune
	if escape == "" {
		return text
	}
	text = strings.TrimSpace(text)
	for _, v := range text {
		if v == []rune(escape)[0] && !isEscape {
			isEscape = true
			continue
		}
		outPut = append(outPut, v)
	}
	return string(outPut)
}

func SliceIn(slice interface{}, data interface{}) bool {
	typed := reflect.ValueOf(slice)
	if typed.Kind() == reflect.Slice || typed.Kind() == reflect.Array {
		for i := 0; i < typed.Len(); i++ {
			if typed.Index(i).Interface() == data {
				return true
			}
		}
	}
	return false
}

// Unmarshal 输出结果到结构体中
func (cfg *SysConf) Unmarshal(ins interface{}) error {
	var structSet func(t reflect.Type, v reflect.Value,oriSeg string) error
	t := reflect.TypeOf(ins)
	v := reflect.ValueOf(ins).Elem()
	if v.Kind() != reflect.Struct {
		return errors.New("Not a Struct")
	}
	if t.Kind() != reflect.Ptr || !v.CanSet() {
		return errors.New("Cannot Write!")
	}
	t = t.Elem()
	structSet = func(t reflect.Type, v reflect.Value,oriSeg string) error {
		for i := 0; i < t.NumField(); i++ {
			tp := t.Field(i)
			vl := v.Field(i)
			if !vl.CanSet() {
				continue
			}
			if vl.Type().Kind() == reflect.Struct {
				structSet(vl.Type(), vl,tp.Tag.Get("seg"))
				continue
			}
			seg := tp.Tag.Get("seg")
			key := tp.Tag.Get("key")
			if oriSeg!="" {
				seg=oriSeg
			}
			if seg == "" || key == "" {
				continue
			}
			if _, ok := cfg.segmap[seg]; !ok {
				continue
			}
			segs := cfg.Data[cfg.segmap[seg]]
			if segs.Get(key) == "" {
				continue
			}
			switch vl.Kind() {
			case reflect.String:
				vl.SetString(segs.Get(key))
			case reflect.Int, reflect.Int32, reflect.Int64:
				vl.SetInt(segs.Int64(key))
			case reflect.Float32, reflect.Float64:
				vl.SetFloat(segs.Float64(key))
			case reflect.Bool:
				vl.SetBool(segs.Bool(key))
			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
				vl.SetUint(uint64(segs.Int64(key)))
			default:
				continue
			}
		}
		return nil
	}
	return structSet(t, v,"")
}

// Marshal 输出结果到结构体中
func (cfg *SysConf) Marshal(ins interface{}) ([]byte, error) {
	var structSet func(t reflect.Type, v reflect.Value,oriSeg string)
	t := reflect.TypeOf(ins)
	v := reflect.ValueOf(ins)
	if v.Kind() != reflect.Struct {
		return nil, errors.New("Not a Struct")
	}
	if t.Kind() == reflect.Ptr {
		t = t.Elem()
		v = v.Elem()
	}
	structSet = func(t reflect.Type, v reflect.Value,oriSeg string) {
		for i := 0; i < t.NumField(); i++ {
			var seg, key, comment string = "", "", ""
			tp := t.Field(i)
			vl := v.Field(i)
			if vl.Type().Kind() == reflect.Struct {
				structSet(vl.Type(), vl,tp.Tag.Get("seg"))
				continue
			}
			seg = tp.Tag.Get("seg")
			key = tp.Tag.Get("key")
			comment = tp.Tag.Get("comment")
			if oriSeg != "" {
				seg=oriSeg
			}
			if seg == "" || key == "" {
				continue
			}
			if _, ok := cfg.segmap[seg]; !ok {
				cfg.AddSeg(seg)
			}
			cfg.Seg(seg).Set(key, fmt.Sprint(vl), comment)
		}

	}
	structSet(t, v,"")
	return cfg.Build(), nil
}

func (syscfg *SysConf) Seg(name string) *SysSegment {
	if _, ok := syscfg.segmap[name]; !ok {
		return nil
	}
	seg := syscfg.Data[syscfg.segmap[name]]
	return seg
}

func (syscfg *SysConf) AddSeg(name string) *SysSegment {
	syscfg.lock.Lock()
	defer syscfg.lock.Unlock()
	if _, ok := syscfg.segmap[name]; !ok {
		newseg := new(SysSegment)
		newseg.Name = name
		newseg.nodeMap = make(map[string]int64)
		syscfg.Data = append(syscfg.Data, newseg)
		syscfg.segId++
		if syscfg.segmap == nil {
			syscfg.segId = 0
			syscfg.segmap = make(map[string]int64)
		}
		syscfg.segmap[newseg.Name] = syscfg.segId
		return newseg
	}
	seg := syscfg.Data[syscfg.segmap[name]]
	return seg
}

func (syscfg *SysConf) DeleteSeg(name string) error {
	syscfg.lock.Lock()
	defer syscfg.lock.Unlock()
	if _, ok := syscfg.segmap[name]; !ok {
		return errors.New("Seg Not Exists")
	}
	syscfg.Data[syscfg.segmap[name]] = nil
	delete(syscfg.segmap, name)
	return nil
}

func (syscfg *SysSegment) GetComment(key string) string {
	if v, ok := syscfg.nodeMap[key]; !ok {
		return ""
	} else {
		return syscfg.NodeData[v].Comment
	}
}

func (syscfg *SysSegment) SetComment(key, comment string) error {
	syscfg.lock.Lock()
	defer syscfg.lock.Unlock()
	if v, ok := syscfg.nodeMap[key]; !ok {
		return errors.New("Key Not Exists")
	} else {
		syscfg.NodeData[v].Comment = comment
		return nil
	}
}

func (syscfg *SysSegment) Exist(key string) bool {
	if _, ok := syscfg.nodeMap[key]; !ok {
		return false
	} else {
		return true
	}
}

func (syscfg *SysSegment) Get(key string) string {
	if v, ok := syscfg.nodeMap[key]; !ok {
		return ""
	} else {
		if len(syscfg.NodeData[v].Value) >= 1 {
			return syscfg.NodeData[v].Value[0]
		}
	}
	return ""
}

func (syscfg *SysSegment) GetAll(key string) []string {
	if v, ok := syscfg.nodeMap[key]; !ok {
		return []string{}
	} else {
		return syscfg.NodeData[v].Value
	}
}

func (syscfg *SysSegment) Int(key string) int {
	val := syscfg.Get(key)
	if val == "" {
		return 0
	}
	res, _ := strconv.Atoi(val)
	return res
}

func (syscfg *SysSegment) Int64(key string) int64 {
	val := syscfg.Get(key)
	if val == "" {
		return 0
	}
	res, _ := strconv.ParseInt(val, 10, 64)
	return res
}

func (syscfg *SysSegment) Int32(key string) int32 {
	val := syscfg.Get(key)
	if val == "" {
		return 0
	}
	res, _ := strconv.ParseInt(val, 10, 32)
	return int32(res)
}

func (syscfg *SysSegment) Float64(key string) float64 {
	val := syscfg.Get(key)
	if val == "" {
		return 0
	}
	res, _ := strconv.ParseFloat(val, 64)
	return res
}

func (syscfg *SysSegment) Float32(key string) float32 {
	val := syscfg.Get(key)
	if val == "" {
		return 0
	}
	res, _ := strconv.ParseFloat(val, 32)
	return float32(res)
}

func (syscfg *SysSegment) Bool(key string) bool {
	val := syscfg.Get(key)
	if val == "" {
		return false
	}
	res, _ := strconv.ParseBool(val)
	return res
}

func (syscfg *SysSegment) SetBool(key string, value bool, comment string) error {
	res := strconv.FormatBool(value)
	return syscfg.Set(key, res, comment)
}

func (syscfg *SysSegment) SetFloat64(key string, prec int, value float64, comment string) error {
	res := strconv.FormatFloat(value, 'f', prec, 64)
	return syscfg.Set(key, res, comment)
}

func (syscfg *SysSegment) SetFloat32(key string, prec int, value float32, comment string) error {
	res := strconv.FormatFloat(float64(value), 'f', prec, 32)
	return syscfg.Set(key, res, comment)
}

func (syscfg *SysSegment) SetUint64(key string, value uint64, comment string) error {
	res := strconv.FormatUint(value, 10)
	return syscfg.Set(key, res, comment)
}

func (syscfg *SysSegment) SetInt64(key string, value int64, comment string) error {
	res := strconv.FormatInt(value, 10)
	return syscfg.Set(key, res, comment)
}

func (syscfg *SysSegment) SetInt32(key string, value int32, comment string) error {
	res := strconv.FormatInt(int64(value), 10)
	return syscfg.Set(key, res, comment)
}

func (syscfg *SysSegment) SetInt(key string, value int, comment string) error {
	res := strconv.Itoa(value)
	return syscfg.Set(key, res, comment)
}

func (syscfg *SysSegment) Set(key, value, comment string) error {
	syscfg.lock.Lock()
	defer syscfg.lock.Unlock()
	if v, ok := syscfg.nodeMap[key]; !ok {
		node := new(SysNode)
		node.Key = key
		node.Value = append(node.Value, value)
		node.Comment = comment
		syscfg.NodeData = append(syscfg.NodeData, node)
		syscfg.nodeMap[key] = syscfg.nodeId
		syscfg.nodeId++
		return nil
	} else {
		syscfg.NodeData[v].Value = []string{value}
		if comment != "" {
			syscfg.NodeData[v].Comment = comment
		}
	}
	return nil
}
func (syscfg *SysSegment) SetAll(key string, value []string, comment string) error {
	syscfg.lock.Lock()
	defer syscfg.lock.Unlock()
	if v, ok := syscfg.nodeMap[key]; !ok {
		node := new(SysNode)
		node.Key = key
		node.Value = value
		node.Comment = comment
		syscfg.NodeData = append(syscfg.NodeData, node)
		syscfg.nodeMap[key] = syscfg.nodeId
		syscfg.nodeId++
		return nil
	} else {
		syscfg.NodeData[v].Value = value
		if comment != "" {
			syscfg.NodeData[v].Comment = comment
		}
	}
	return nil
}
func (syscfg *SysSegment) AddValue(key, value, comment string) error {
	syscfg.lock.Lock()
	defer syscfg.lock.Unlock()
	if v, ok := syscfg.nodeMap[key]; !ok {
		node := new(SysNode)
		node.Key = key
		node.Value = append(node.Value, value)
		node.Comment = comment
		syscfg.NodeData = append(syscfg.NodeData, node)
		syscfg.nodeMap[key] = syscfg.nodeId
		syscfg.nodeId++
		return nil
	} else {
		syscfg.NodeData[v].Value = append(syscfg.NodeData[v].Value, value)
		if comment != "" {
			syscfg.NodeData[v].Comment = comment
		}
	}
	return nil
}

func (syscfg *SysSegment) Delete(key string) error {
	syscfg.lock.Lock()
	defer syscfg.lock.Unlock()
	if v, ok := syscfg.nodeMap[key]; !ok {
		return errors.New("Key not exists!")
	} else {
		if syscfg.NodeData[v].Comment != "" {
			cmtSet := false
			for j := v - 1; j >= 0; j-- {
				if syscfg.NodeData[j] != nil {
					syscfg.NodeData[j].Comment += syscfg.NodeData[v].Comment
					cmtSet = true
					break
				}
			}
			if !cmtSet {
				syscfg.Comment += syscfg.NodeData[v].Comment
			}
		}
		syscfg.NodeData[v] = nil
		delete(syscfg.nodeMap, key)
	}
	return nil
}

func (syscfg *SysSegment) DeleteValue(key string, Value string) error {
	syscfg.lock.Lock()
	defer syscfg.lock.Unlock()
	if v, ok := syscfg.nodeMap[key]; !ok {
		return errors.New("Key not exists!")
	} else {
		data := syscfg.NodeData[v].Value
		var vals []string
		for _, v := range data {
			if v != Value {
				vals = append(vals, v)
			}
		}
		syscfg.NodeData[v].Value = vals
	}
	return nil
}