leobot

section.go (6059B)

---

 // Copyright 2014 Unknwon
 //
 // Licensed under the Apache License, Version 2.0 (the "License"): you may
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 // License for the specific language governing permissions and limitations
 // under the License.
 
 package ini
 
 import (
 	"errors"
 	"fmt"
 	"strings"
 )
 
 // Section represents a config section.
 type Section struct {
 	f        *File
 	Comment  string
 	name     string
 	keys     map[string]*Key
 	keyList  []string
 	keysHash map[string]string
 
 	isRawSection bool
 	rawBody      string
 }
 
 func newSection(f *File, name string) *Section {
 	return &Section{
 		f:        f,
 		name:     name,
 		keys:     make(map[string]*Key),
 		keyList:  make([]string, 0, 10),
 		keysHash: make(map[string]string),
 	}
 }
 
 // Name returns name of Section.
 func (s *Section) Name() string {
 	return s.name
 }
 
 // Body returns rawBody of Section if the section was marked as unparseable.
 // It still follows the other rules of the INI format surrounding leading/trailing whitespace.
 func (s *Section) Body() string {
 	return strings.TrimSpace(s.rawBody)
 }
 
 // SetBody updates body content only if section is raw.
 func (s *Section) SetBody(body string) {
 	if !s.isRawSection {
 		return
 	}
 	s.rawBody = body
 }
 
 // NewKey creates a new key to given section.
 func (s *Section) NewKey(name, val string) (*Key, error) {
 	if len(name) == 0 {
 		return nil, errors.New("error creating new key: empty key name")
 	} else if s.f.options.Insensitive || s.f.options.InsensitiveKeys {
 		name = strings.ToLower(name)
 	}
 
 	if s.f.BlockMode {
 		s.f.lock.Lock()
 		defer s.f.lock.Unlock()
 	}
 
 	if inSlice(name, s.keyList) {
 		if s.f.options.AllowShadows {
 			if err := s.keys[name].addShadow(val); err != nil {
 				return nil, err
 			}
 		} else {
 			s.keys[name].value = val
 			s.keysHash[name] = val
 		}
 		return s.keys[name], nil
 	}
 
 	s.keyList = append(s.keyList, name)
 	s.keys[name] = newKey(s, name, val)
 	s.keysHash[name] = val
 	return s.keys[name], nil
 }
 
 // NewBooleanKey creates a new boolean type key to given section.
 func (s *Section) NewBooleanKey(name string) (*Key, error) {
 	key, err := s.NewKey(name, "true")
 	if err != nil {
 		return nil, err
 	}
 
 	key.isBooleanType = true
 	return key, nil
 }
 
 // GetKey returns key in section by given name.
 func (s *Section) GetKey(name string) (*Key, error) {
 	if s.f.BlockMode {
 		s.f.lock.RLock()
 	}
 	if s.f.options.Insensitive || s.f.options.InsensitiveKeys {
 		name = strings.ToLower(name)
 	}
 	key := s.keys[name]
 	if s.f.BlockMode {
 		s.f.lock.RUnlock()
 	}
 
 	if key == nil {
 		// Check if it is a child-section.
 		sname := s.name
 		for {
 			if i := strings.LastIndex(sname, s.f.options.ChildSectionDelimiter); i > -1 {
 				sname = sname[:i]
 				sec, err := s.f.GetSection(sname)
 				if err != nil {
 					continue
 				}
 				return sec.GetKey(name)
 			}
 			break
 		}
 		return nil, fmt.Errorf("error when getting key of section %q: key %q not exists", s.name, name)
 	}
 	return key, nil
 }
 
 // HasKey returns true if section contains a key with given name.
 func (s *Section) HasKey(name string) bool {
 	key, _ := s.GetKey(name)
 	return key != nil
 }
 
 // Deprecated: Use "HasKey" instead.
 func (s *Section) Haskey(name string) bool {
 	return s.HasKey(name)
 }
 
 // HasValue returns true if section contains given raw value.
 func (s *Section) HasValue(value string) bool {
 	if s.f.BlockMode {
 		s.f.lock.RLock()
 		defer s.f.lock.RUnlock()
 	}
 
 	for _, k := range s.keys {
 		if value == k.value {
 			return true
 		}
 	}
 	return false
 }
 
 // Key assumes named Key exists in section and returns a zero-value when not.
 func (s *Section) Key(name string) *Key {
 	key, err := s.GetKey(name)
 	if err != nil {
 		// It's OK here because the only possible error is empty key name,
 		// but if it's empty, this piece of code won't be executed.
 		key, _ = s.NewKey(name, "")
 		return key
 	}
 	return key
 }
 
 // Keys returns list of keys of section.
 func (s *Section) Keys() []*Key {
 	keys := make([]*Key, len(s.keyList))
 	for i := range s.keyList {
 		keys[i] = s.Key(s.keyList[i])
 	}
 	return keys
 }
 
 // ParentKeys returns list of keys of parent section.
 func (s *Section) ParentKeys() []*Key {
 	var parentKeys []*Key
 	sname := s.name
 	for {
 		if i := strings.LastIndex(sname, s.f.options.ChildSectionDelimiter); i > -1 {
 			sname = sname[:i]
 			sec, err := s.f.GetSection(sname)
 			if err != nil {
 				continue
 			}
 			parentKeys = append(parentKeys, sec.Keys()...)
 		} else {
 			break
 		}
 
 	}
 	return parentKeys
 }
 
 // KeyStrings returns list of key names of section.
 func (s *Section) KeyStrings() []string {
 	list := make([]string, len(s.keyList))
 	copy(list, s.keyList)
 	return list
 }
 
 // KeysHash returns keys hash consisting of names and values.
 func (s *Section) KeysHash() map[string]string {
 	if s.f.BlockMode {
 		s.f.lock.RLock()
 		defer s.f.lock.RUnlock()
 	}
 
 	hash := make(map[string]string, len(s.keysHash))
 	for key, value := range s.keysHash {
 		hash[key] = value
 	}
 	return hash
 }
 
 // DeleteKey deletes a key from section.
 func (s *Section) DeleteKey(name string) {
 	if s.f.BlockMode {
 		s.f.lock.Lock()
 		defer s.f.lock.Unlock()
 	}
 
 	for i, k := range s.keyList {
 		if k == name {
 			s.keyList = append(s.keyList[:i], s.keyList[i+1:]...)
 			delete(s.keys, name)
 			delete(s.keysHash, name)
 			return
 		}
 	}
 }
 
 // ChildSections returns a list of child sections of current section.
 // For example, "[parent.child1]" and "[parent.child12]" are child sections
 // of section "[parent]".
 func (s *Section) ChildSections() []*Section {
 	prefix := s.name + s.f.options.ChildSectionDelimiter
 	children := make([]*Section, 0, 3)
 	for _, name := range s.f.sectionList {
 		if strings.HasPrefix(name, prefix) {
 			children = append(children, s.f.sections[name]...)
 		}
 	}
 	return children
 }