README

INI

GitHub Workflow Status codecov GoDoc Sourcegraph

Package ini provides INI file read and write functionality in Go.

Features

  • Load from multiple data sources(file, []byte, io.Reader and io.ReadCloser) with overwrites.
  • Read with recursion values.
  • Read with parent-child sections.
  • Read with auto-increment key names.
  • Read with multiple-line values.
  • Read with tons of helper methods.
  • Read and convert values to Go types.
  • Read and WRITE comments of sections and keys.
  • Manipulate sections, keys and comments with ease.
  • Keep sections and keys in order as you parse and save.

Installation

The minimum requirement of Go is 1.6.

$ go get gopkg.in/ini.v1

Please add -u flag to update in the future.

Getting Help

License

This project is under Apache v2 License. See the LICENSE file for the full license text.

Expand ▾ Collapse ▴

Documentation

Overview

    Package ini provides INI file read and write functionality in Go.

    Index

    Constants

    View Source
    const (
    	// Deprecated: Use "DefaultSection" instead.
    	DEFAULT_SECTION = DefaultSection
    )
    View Source
    const (
    	// DefaultSection is the name of default section. You can use this constant or the string literal.
    	// In most of cases, an empty string is all you need to access the section.
    	DefaultSection = "DEFAULT"
    )

    Variables

    View Source
    var (
    	// LineBreak is the delimiter to determine or compose a new line.
    	// This variable will be changed to "\r\n" automatically on Windows at package init time.
    	LineBreak = "\n"
    
    	// DefaultHeader explicitly writes default section header.
    	DefaultHeader = false
    
    	// PrettySection indicates whether to put a line between sections.
    	PrettySection = true
    	// PrettyFormat indicates whether to align "=" sign with spaces to produce pretty output
    	// or reduce all possible spaces for compact format.
    	PrettyFormat = true
    	// PrettyEqual places spaces around "=" sign even when PrettyFormat is false.
    	PrettyEqual = false
    	// DefaultFormatLeft places custom spaces on the left when PrettyFormat and PrettyEqual are both disabled.
    	DefaultFormatLeft = ""
    	// DefaultFormatRight places custom spaces on the right when PrettyFormat and PrettyEqual are both disabled.
    	DefaultFormatRight = ""
    )
    View Source
    var (
    	// Deprecated: AllCapsUnderscore converts to format ALL_CAPS_UNDERSCORE.
    	AllCapsUnderscore = SnackCase
    )

    Functions

    func IsErrDelimiterNotFound

    func IsErrDelimiterNotFound(err error) bool

      IsErrDelimiterNotFound returns true if the given error is an instance of ErrDelimiterNotFound.

      func MapTo

      func MapTo(v, source interface{}, others ...interface{}) error

        MapTo maps data sources to given struct.

        func MapToWithMapper

        func MapToWithMapper(v interface{}, mapper NameMapper, source interface{}, others ...interface{}) error

          MapToWithMapper maps data sources to given struct with name mapper.

          func ReflectFrom

          func ReflectFrom(cfg *File, v interface{}) error

            ReflectFrom reflects data sources from given struct.

            func ReflectFromWithMapper

            func ReflectFromWithMapper(cfg *File, v interface{}, mapper NameMapper) error

              ReflectFromWithMapper reflects data sources from given struct with name mapper.

              func StrictMapTo

              func StrictMapTo(v, source interface{}, others ...interface{}) error

                StrictMapTo maps data sources to given struct in strict mode, which returns all possible error including value parsing error.

                func StrictMapToWithMapper

                func StrictMapToWithMapper(v interface{}, mapper NameMapper, source interface{}, others ...interface{}) error

                  StrictMapToWithMapper maps data sources to given struct with name mapper in strict mode, which returns all possible error including value parsing error.

                  Types

                  type DebugFunc

                  type DebugFunc func(message string)

                    DebugFunc is the type of function called to log parse events.

                    type ErrDelimiterNotFound

                    type ErrDelimiterNotFound struct {
                    	Line string
                    }

                      ErrDelimiterNotFound indicates the error type of no delimiter is found which there should be one.

                      func (ErrDelimiterNotFound) Error

                      func (err ErrDelimiterNotFound) Error() string

                      type File

                      type File struct {
                      
                      	// Should make things safe, but sometimes doesn't matter.
                      	BlockMode bool
                      
                      	NameMapper
                      	ValueMapper
                      	// contains filtered or unexported fields
                      }

                        File represents a combination of one or more INI files in memory.

                        func Empty

                        func Empty(opts ...LoadOptions) *File

                          Empty returns an empty file object.

                          func InsensitiveLoad

                          func InsensitiveLoad(source interface{}, others ...interface{}) (*File, error)

                            InsensitiveLoad has exactly same functionality as Load function except it forces all section and key names to be lowercased.

                            func Load

                            func Load(source interface{}, others ...interface{}) (*File, error)

                              Load loads and parses from INI data sources. Arguments can be mixed of file name with string type, or raw data in []byte. It will return error if list contains nonexistent files.

                              func LoadSources

                              func LoadSources(opts LoadOptions, source interface{}, others ...interface{}) (_ *File, err error)

                                LoadSources allows caller to apply customized options for loading from data source(s).

                                func LooseLoad

                                func LooseLoad(source interface{}, others ...interface{}) (*File, error)

                                  LooseLoad has exactly same functionality as Load function except it ignores nonexistent files instead of returning error.

                                  func ShadowLoad

                                  func ShadowLoad(source interface{}, others ...interface{}) (*File, error)

                                    ShadowLoad has exactly same functionality as Load function except it allows have shadow keys.

                                    func (*File) Append

                                    func (f *File) Append(source interface{}, others ...interface{}) error

                                      Append appends one or more data sources and reloads automatically.

                                      func (*File) ChildSections

                                      func (f *File) ChildSections(name string) []*Section

                                        ChildSections returns a list of child sections of given section name.

                                        func (*File) DeleteSection

                                        func (f *File) DeleteSection(name string)

                                          DeleteSection deletes a section or all sections with given name.

                                          func (*File) DeleteSectionWithIndex

                                          func (f *File) DeleteSectionWithIndex(name string, index int) error

                                            DeleteSectionWithIndex deletes a section with given name and index.

                                            func (*File) GetSection

                                            func (f *File) GetSection(name string) (*Section, error)

                                              GetSection returns section by given name.

                                              func (*File) MapTo

                                              func (f *File) MapTo(v interface{}) error

                                                MapTo maps file to given struct.

                                                func (*File) NewRawSection

                                                func (f *File) NewRawSection(name, body string) (*Section, error)

                                                  NewRawSection creates a new section with an unparseable body.

                                                  func (*File) NewSection

                                                  func (f *File) NewSection(name string) (*Section, error)

                                                    NewSection creates a new section.

                                                    func (*File) NewSections

                                                    func (f *File) NewSections(names ...string) (err error)

                                                      NewSections creates a list of sections.

                                                      func (*File) ReflectFrom

                                                      func (f *File) ReflectFrom(v interface{}) error

                                                        ReflectFrom reflects file from given struct.

                                                        func (*File) Reload

                                                        func (f *File) Reload() (err error)

                                                          Reload reloads and parses all data sources.

                                                          func (*File) SaveTo

                                                          func (f *File) SaveTo(filename string) error

                                                            SaveTo writes content to file system.

                                                            func (*File) SaveToIndent

                                                            func (f *File) SaveToIndent(filename, indent string) error

                                                              SaveToIndent writes content to file system with given value indention.

                                                              func (*File) Section

                                                              func (f *File) Section(name string) *Section

                                                                Section assumes named section exists and returns a zero-value when not.

                                                                func (*File) SectionStrings

                                                                func (f *File) SectionStrings() []string

                                                                  SectionStrings returns list of section names.

                                                                  func (*File) SectionWithIndex

                                                                  func (f *File) SectionWithIndex(name string, index int) *Section

                                                                    SectionWithIndex assumes named section exists and returns a new section when not.

                                                                    func (*File) Sections

                                                                    func (f *File) Sections() []*Section

                                                                      Sections returns a list of Section stored in the current instance.

                                                                      func (*File) SectionsByName

                                                                      func (f *File) SectionsByName(name string) ([]*Section, error)

                                                                        SectionsByName returns all sections with given name.

                                                                        func (*File) StrictMapTo

                                                                        func (f *File) StrictMapTo(v interface{}) error

                                                                          StrictMapTo maps file to given struct in strict mode, which returns all possible error including value parsing error.

                                                                          func (*File) WriteTo

                                                                          func (f *File) WriteTo(w io.Writer) (int64, error)

                                                                            WriteTo writes file content into io.Writer.

                                                                            func (*File) WriteToIndent

                                                                            func (f *File) WriteToIndent(w io.Writer, indent string) (int64, error)

                                                                              WriteToIndent writes content into io.Writer with given indention. If PrettyFormat has been set to be true, it will align "=" sign with spaces under each section.

                                                                              type Key

                                                                              type Key struct {
                                                                              	Comment string
                                                                              	// contains filtered or unexported fields
                                                                              }

                                                                                Key represents a key under a section.

                                                                                func (*Key) AddNestedValue

                                                                                func (k *Key) AddNestedValue(val string) error

                                                                                  AddNestedValue adds a nested value to the key.

                                                                                  func (*Key) AddShadow

                                                                                  func (k *Key) AddShadow(val string) error

                                                                                    AddShadow adds a new shadow key to itself.

                                                                                    func (*Key) Bool

                                                                                    func (k *Key) Bool() (bool, error)

                                                                                      Bool returns bool type value.

                                                                                      func (*Key) Bools

                                                                                      func (k *Key) Bools(delim string) []bool

                                                                                        Bools returns list of bool divided by given delimiter. Any invalid input will be treated as zero value.

                                                                                        func (*Key) Duration

                                                                                        func (k *Key) Duration() (time.Duration, error)

                                                                                          Duration returns time.Duration type value.

                                                                                          func (*Key) Float64

                                                                                          func (k *Key) Float64() (float64, error)

                                                                                            Float64 returns float64 type value.

                                                                                            func (*Key) Float64s

                                                                                            func (k *Key) Float64s(delim string) []float64

                                                                                              Float64s returns list of float64 divided by given delimiter. Any invalid input will be treated as zero value.

                                                                                              func (*Key) In

                                                                                              func (k *Key) In(defaultVal string, candidates []string) string

                                                                                                In always returns value without error, it returns default value if error occurs or doesn't fit into candidates.

                                                                                                func (*Key) InFloat64

                                                                                                func (k *Key) InFloat64(defaultVal float64, candidates []float64) float64

                                                                                                  InFloat64 always returns value without error, it returns default value if error occurs or doesn't fit into candidates.

                                                                                                  func (*Key) InInt

                                                                                                  func (k *Key) InInt(defaultVal int, candidates []int) int

                                                                                                    InInt always returns value without error, it returns default value if error occurs or doesn't fit into candidates.

                                                                                                    func (*Key) InInt64

                                                                                                    func (k *Key) InInt64(defaultVal int64, candidates []int64) int64

                                                                                                      InInt64 always returns value without error, it returns default value if error occurs or doesn't fit into candidates.

                                                                                                      func (*Key) InTime

                                                                                                      func (k *Key) InTime(defaultVal time.Time, candidates []time.Time) time.Time

                                                                                                        InTime always parses with RFC3339 format and returns value without error, it returns default value if error occurs or doesn't fit into candidates.

                                                                                                        func (*Key) InTimeFormat

                                                                                                        func (k *Key) InTimeFormat(format string, defaultVal time.Time, candidates []time.Time) time.Time

                                                                                                          InTimeFormat always parses with given format and returns value without error, it returns default value if error occurs or doesn't fit into candidates.

                                                                                                          func (*Key) InUint

                                                                                                          func (k *Key) InUint(defaultVal uint, candidates []uint) uint

                                                                                                            InUint always returns value without error, it returns default value if error occurs or doesn't fit into candidates.

                                                                                                            func (*Key) InUint64

                                                                                                            func (k *Key) InUint64(defaultVal uint64, candidates []uint64) uint64

                                                                                                              InUint64 always returns value without error, it returns default value if error occurs or doesn't fit into candidates.

                                                                                                              func (*Key) Int

                                                                                                              func (k *Key) Int() (int, error)

                                                                                                                Int returns int type value.

                                                                                                                func (*Key) Int64

                                                                                                                func (k *Key) Int64() (int64, error)

                                                                                                                  Int64 returns int64 type value.

                                                                                                                  func (*Key) Int64s

                                                                                                                  func (k *Key) Int64s(delim string) []int64

                                                                                                                    Int64s returns list of int64 divided by given delimiter. Any invalid input will be treated as zero value.

                                                                                                                    func (*Key) Ints

                                                                                                                    func (k *Key) Ints(delim string) []int

                                                                                                                      Ints returns list of int divided by given delimiter. Any invalid input will be treated as zero value.

                                                                                                                      func (*Key) MustBool

                                                                                                                      func (k *Key) MustBool(defaultVal ...bool) bool

                                                                                                                        MustBool always returns value without error, it returns false if error occurs.

                                                                                                                        func (*Key) MustDuration

                                                                                                                        func (k *Key) MustDuration(defaultVal ...time.Duration) time.Duration

                                                                                                                          MustDuration always returns value without error, it returns zero value if error occurs.

                                                                                                                          func (*Key) MustFloat64

                                                                                                                          func (k *Key) MustFloat64(defaultVal ...float64) float64

                                                                                                                            MustFloat64 always returns value without error, it returns 0.0 if error occurs.

                                                                                                                            func (*Key) MustInt

                                                                                                                            func (k *Key) MustInt(defaultVal ...int) int

                                                                                                                              MustInt always returns value without error, it returns 0 if error occurs.

                                                                                                                              func (*Key) MustInt64

                                                                                                                              func (k *Key) MustInt64(defaultVal ...int64) int64

                                                                                                                                MustInt64 always returns value without error, it returns 0 if error occurs.

                                                                                                                                func (*Key) MustString

                                                                                                                                func (k *Key) MustString(defaultVal string) string

                                                                                                                                  MustString returns default value if key value is empty.

                                                                                                                                  func (*Key) MustTime

                                                                                                                                  func (k *Key) MustTime(defaultVal ...time.Time) time.Time

                                                                                                                                    MustTime always parses with RFC3339 format and returns value without error, it returns zero value if error occurs.

                                                                                                                                    func (*Key) MustTimeFormat

                                                                                                                                    func (k *Key) MustTimeFormat(format string, defaultVal ...time.Time) time.Time

                                                                                                                                      MustTimeFormat always parses with given format and returns value without error, it returns zero value if error occurs.

                                                                                                                                      func (*Key) MustUint

                                                                                                                                      func (k *Key) MustUint(defaultVal ...uint) uint

                                                                                                                                        MustUint always returns value without error, it returns 0 if error occurs.

                                                                                                                                        func (*Key) MustUint64

                                                                                                                                        func (k *Key) MustUint64(defaultVal ...uint64) uint64

                                                                                                                                          MustUint64 always returns value without error, it returns 0 if error occurs.

                                                                                                                                          func (*Key) Name

                                                                                                                                          func (k *Key) Name() string

                                                                                                                                            Name returns name of key.

                                                                                                                                            func (*Key) NestedValues

                                                                                                                                            func (k *Key) NestedValues() []string

                                                                                                                                              NestedValues returns nested values stored in the key. It is possible returned value is nil if no nested values stored in the key.

                                                                                                                                              func (*Key) RangeFloat64

                                                                                                                                              func (k *Key) RangeFloat64(defaultVal, min, max float64) float64

                                                                                                                                                RangeFloat64 checks if value is in given range inclusively, and returns default value if it's not.

                                                                                                                                                func (*Key) RangeInt

                                                                                                                                                func (k *Key) RangeInt(defaultVal, min, max int) int

                                                                                                                                                  RangeInt checks if value is in given range inclusively, and returns default value if it's not.

                                                                                                                                                  func (*Key) RangeInt64

                                                                                                                                                  func (k *Key) RangeInt64(defaultVal, min, max int64) int64

                                                                                                                                                    RangeInt64 checks if value is in given range inclusively, and returns default value if it's not.

                                                                                                                                                    func (*Key) RangeTime

                                                                                                                                                    func (k *Key) RangeTime(defaultVal, min, max time.Time) time.Time

                                                                                                                                                      RangeTime checks if value with RFC3339 format is in given range inclusively, and returns default value if it's not.

                                                                                                                                                      func (*Key) RangeTimeFormat

                                                                                                                                                      func (k *Key) RangeTimeFormat(format string, defaultVal, min, max time.Time) time.Time

                                                                                                                                                        RangeTimeFormat checks if value with given format is in given range inclusively, and returns default value if it's not.

                                                                                                                                                        func (*Key) SetValue

                                                                                                                                                        func (k *Key) SetValue(v string)

                                                                                                                                                          SetValue changes key value.

                                                                                                                                                          func (*Key) StrictBools

                                                                                                                                                          func (k *Key) StrictBools(delim string) ([]bool, error)

                                                                                                                                                            StrictBools returns list of bool divided by given delimiter or error on first invalid input.

                                                                                                                                                            func (*Key) StrictFloat64s

                                                                                                                                                            func (k *Key) StrictFloat64s(delim string) ([]float64, error)

                                                                                                                                                              StrictFloat64s returns list of float64 divided by given delimiter or error on first invalid input.

                                                                                                                                                              func (*Key) StrictInt64s

                                                                                                                                                              func (k *Key) StrictInt64s(delim string) ([]int64, error)

                                                                                                                                                                StrictInt64s returns list of int64 divided by given delimiter or error on first invalid input.

                                                                                                                                                                func (*Key) StrictInts

                                                                                                                                                                func (k *Key) StrictInts(delim string) ([]int, error)

                                                                                                                                                                  StrictInts returns list of int divided by given delimiter or error on first invalid input.

                                                                                                                                                                  func (*Key) StrictTimes

                                                                                                                                                                  func (k *Key) StrictTimes(delim string) ([]time.Time, error)

                                                                                                                                                                    StrictTimes parses with RFC3339 format and returns list of time.Time divided by given delimiter or error on first invalid input.

                                                                                                                                                                    func (*Key) StrictTimesFormat

                                                                                                                                                                    func (k *Key) StrictTimesFormat(format, delim string) ([]time.Time, error)

                                                                                                                                                                      StrictTimesFormat parses with given format and returns list of time.Time divided by given delimiter or error on first invalid input.

                                                                                                                                                                      func (*Key) StrictUint64s

                                                                                                                                                                      func (k *Key) StrictUint64s(delim string) ([]uint64, error)

                                                                                                                                                                        StrictUint64s returns list of uint64 divided by given delimiter or error on first invalid input.

                                                                                                                                                                        func (*Key) StrictUints

                                                                                                                                                                        func (k *Key) StrictUints(delim string) ([]uint, error)

                                                                                                                                                                          StrictUints returns list of uint divided by given delimiter or error on first invalid input.

                                                                                                                                                                          func (*Key) String

                                                                                                                                                                          func (k *Key) String() string

                                                                                                                                                                            String returns string representation of value.

                                                                                                                                                                            func (*Key) Strings

                                                                                                                                                                            func (k *Key) Strings(delim string) []string

                                                                                                                                                                              Strings returns list of string divided by given delimiter.

                                                                                                                                                                              func (*Key) StringsWithShadows

                                                                                                                                                                              func (k *Key) StringsWithShadows(delim string) []string

                                                                                                                                                                                StringsWithShadows returns list of string divided by given delimiter. Shadows will also be appended if any.

                                                                                                                                                                                func (*Key) Time

                                                                                                                                                                                func (k *Key) Time() (time.Time, error)

                                                                                                                                                                                  Time parses with RFC3339 format and returns time.Time type value.

                                                                                                                                                                                  func (*Key) TimeFormat

                                                                                                                                                                                  func (k *Key) TimeFormat(format string) (time.Time, error)

                                                                                                                                                                                    TimeFormat parses with given format and returns time.Time type value.

                                                                                                                                                                                    func (*Key) Times

                                                                                                                                                                                    func (k *Key) Times(delim string) []time.Time

                                                                                                                                                                                      Times parses with RFC3339 format and returns list of time.Time divided by given delimiter. Any invalid input will be treated as zero value (0001-01-01 00:00:00 +0000 UTC).

                                                                                                                                                                                      func (*Key) TimesFormat

                                                                                                                                                                                      func (k *Key) TimesFormat(format, delim string) []time.Time

                                                                                                                                                                                        TimesFormat parses with given format and returns list of time.Time divided by given delimiter. Any invalid input will be treated as zero value (0001-01-01 00:00:00 +0000 UTC).

                                                                                                                                                                                        func (*Key) Uint

                                                                                                                                                                                        func (k *Key) Uint() (uint, error)

                                                                                                                                                                                          Uint returns uint type valued.

                                                                                                                                                                                          func (*Key) Uint64

                                                                                                                                                                                          func (k *Key) Uint64() (uint64, error)

                                                                                                                                                                                            Uint64 returns uint64 type value.

                                                                                                                                                                                            func (*Key) Uint64s

                                                                                                                                                                                            func (k *Key) Uint64s(delim string) []uint64

                                                                                                                                                                                              Uint64s returns list of uint64 divided by given delimiter. Any invalid input will be treated as zero value.

                                                                                                                                                                                              func (*Key) Uints

                                                                                                                                                                                              func (k *Key) Uints(delim string) []uint

                                                                                                                                                                                                Uints returns list of uint divided by given delimiter. Any invalid input will be treated as zero value.

                                                                                                                                                                                                func (*Key) ValidBools

                                                                                                                                                                                                func (k *Key) ValidBools(delim string) []bool

                                                                                                                                                                                                  ValidBools returns list of bool divided by given delimiter. If some value is not 64-bit unsigned integer, then it will not be included to result list.

                                                                                                                                                                                                  func (*Key) ValidFloat64s

                                                                                                                                                                                                  func (k *Key) ValidFloat64s(delim string) []float64

                                                                                                                                                                                                    ValidFloat64s returns list of float64 divided by given delimiter. If some value is not float, then it will not be included to result list.

                                                                                                                                                                                                    func (*Key) ValidInt64s

                                                                                                                                                                                                    func (k *Key) ValidInt64s(delim string) []int64

                                                                                                                                                                                                      ValidInt64s returns list of int64 divided by given delimiter. If some value is not 64-bit integer, then it will not be included to result list.

                                                                                                                                                                                                      func (*Key) ValidInts

                                                                                                                                                                                                      func (k *Key) ValidInts(delim string) []int

                                                                                                                                                                                                        ValidInts returns list of int divided by given delimiter. If some value is not integer, then it will not be included to result list.

                                                                                                                                                                                                        func (*Key) ValidTimes

                                                                                                                                                                                                        func (k *Key) ValidTimes(delim string) []time.Time

                                                                                                                                                                                                          ValidTimes parses with RFC3339 format and returns list of time.Time divided by given delimiter.

                                                                                                                                                                                                          func (*Key) ValidTimesFormat

                                                                                                                                                                                                          func (k *Key) ValidTimesFormat(format, delim string) []time.Time

                                                                                                                                                                                                            ValidTimesFormat parses with given format and returns list of time.Time divided by given delimiter.

                                                                                                                                                                                                            func (*Key) ValidUint64s

                                                                                                                                                                                                            func (k *Key) ValidUint64s(delim string) []uint64

                                                                                                                                                                                                              ValidUint64s returns list of uint64 divided by given delimiter. If some value is not 64-bit unsigned integer, then it will not be included to result list.

                                                                                                                                                                                                              func (*Key) ValidUints

                                                                                                                                                                                                              func (k *Key) ValidUints(delim string) []uint

                                                                                                                                                                                                                ValidUints returns list of uint divided by given delimiter. If some value is not unsigned integer, then it will not be included to result list.

                                                                                                                                                                                                                func (*Key) Validate

                                                                                                                                                                                                                func (k *Key) Validate(fn func(string) string) string

                                                                                                                                                                                                                  Validate accepts a validate function which can return modifed result as key value.

                                                                                                                                                                                                                  func (*Key) Value

                                                                                                                                                                                                                  func (k *Key) Value() string

                                                                                                                                                                                                                    Value returns raw value of key for performance purpose.

                                                                                                                                                                                                                    func (*Key) ValueWithShadows

                                                                                                                                                                                                                    func (k *Key) ValueWithShadows() []string

                                                                                                                                                                                                                      ValueWithShadows returns raw values of key and its shadows if any.

                                                                                                                                                                                                                      type LoadOptions

                                                                                                                                                                                                                      type LoadOptions struct {
                                                                                                                                                                                                                      	// Loose indicates whether the parser should ignore nonexistent files or return error.
                                                                                                                                                                                                                      	Loose bool
                                                                                                                                                                                                                      	// Insensitive indicates whether the parser forces all section and key names to lowercase.
                                                                                                                                                                                                                      	Insensitive bool
                                                                                                                                                                                                                      	// InsensitiveSections indicates whether the parser forces all section to lowercase.
                                                                                                                                                                                                                      	InsensitiveSections bool
                                                                                                                                                                                                                      	// InsensitiveKeys indicates whether the parser forces all key names to lowercase.
                                                                                                                                                                                                                      	InsensitiveKeys bool
                                                                                                                                                                                                                      	// IgnoreContinuation indicates whether to ignore continuation lines while parsing.
                                                                                                                                                                                                                      	IgnoreContinuation bool
                                                                                                                                                                                                                      	// IgnoreInlineComment indicates whether to ignore comments at the end of value and treat it as part of value.
                                                                                                                                                                                                                      	IgnoreInlineComment bool
                                                                                                                                                                                                                      	// SkipUnrecognizableLines indicates whether to skip unrecognizable lines that do not conform to key/value pairs.
                                                                                                                                                                                                                      	SkipUnrecognizableLines bool
                                                                                                                                                                                                                      	// ShortCircuit indicates whether to ignore other configuration sources after loaded the first available configuration source.
                                                                                                                                                                                                                      	ShortCircuit bool
                                                                                                                                                                                                                      	// AllowBooleanKeys indicates whether to allow boolean type keys or treat as value is missing.
                                                                                                                                                                                                                      	// This type of keys are mostly used in my.cnf.
                                                                                                                                                                                                                      	AllowBooleanKeys bool
                                                                                                                                                                                                                      	// AllowShadows indicates whether to keep track of keys with same name under same section.
                                                                                                                                                                                                                      	AllowShadows bool
                                                                                                                                                                                                                      	// AllowNestedValues indicates whether to allow AWS-like nested values.
                                                                                                                                                                                                                      	// Docs: http://docs.aws.amazon.com/cli/latest/topic/config-vars.html#nested-values
                                                                                                                                                                                                                      	AllowNestedValues bool
                                                                                                                                                                                                                      	// AllowPythonMultilineValues indicates whether to allow Python-like multi-line values.
                                                                                                                                                                                                                      	// Docs: https://docs.python.org/3/library/configparser.html#supported-ini-file-structure
                                                                                                                                                                                                                      	// Relevant quote:  Values can also span multiple lines, as long as they are indented deeper
                                                                                                                                                                                                                      	// than the first line of the value.
                                                                                                                                                                                                                      	AllowPythonMultilineValues bool
                                                                                                                                                                                                                      	// SpaceBeforeInlineComment indicates whether to allow comment symbols (\# and \;) inside value.
                                                                                                                                                                                                                      	// Docs: https://docs.python.org/2/library/configparser.html
                                                                                                                                                                                                                      	// Quote: Comments may appear on their own in an otherwise empty line, or may be entered in lines holding values or section names.
                                                                                                                                                                                                                      	// In the latter case, they need to be preceded by a whitespace character to be recognized as a comment.
                                                                                                                                                                                                                      	SpaceBeforeInlineComment bool
                                                                                                                                                                                                                      	// UnescapeValueDoubleQuotes indicates whether to unescape double quotes inside value to regular format
                                                                                                                                                                                                                      	// when value is surrounded by double quotes, e.g. key="a \"value\"" => key=a "value"
                                                                                                                                                                                                                      	UnescapeValueDoubleQuotes bool
                                                                                                                                                                                                                      	// UnescapeValueCommentSymbols indicates to unescape comment symbols (\# and \;) inside value to regular format
                                                                                                                                                                                                                      	// when value is NOT surrounded by any quotes.
                                                                                                                                                                                                                      	// Note: UNSTABLE, behavior might change to only unescape inside double quotes but may noy necessary at all.
                                                                                                                                                                                                                      	UnescapeValueCommentSymbols bool
                                                                                                                                                                                                                      	// UnparseableSections stores a list of blocks that are allowed with raw content which do not otherwise
                                                                                                                                                                                                                      	// conform to key/value pairs. Specify the names of those blocks here.
                                                                                                                                                                                                                      	UnparseableSections []string
                                                                                                                                                                                                                      	// KeyValueDelimiters is the sequence of delimiters that are used to separate key and value. By default, it is "=:".
                                                                                                                                                                                                                      	KeyValueDelimiters string
                                                                                                                                                                                                                      	// KeyValueDelimiterOnWrite is the delimiter that are used to separate key and value output. By default, it is "=".
                                                                                                                                                                                                                      	KeyValueDelimiterOnWrite string
                                                                                                                                                                                                                      	// ChildSectionDelimiter is the delimiter that is used to separate child sections. By default, it is ".".
                                                                                                                                                                                                                      	ChildSectionDelimiter string
                                                                                                                                                                                                                      	// PreserveSurroundedQuote indicates whether to preserve surrounded quote (single and double quotes).
                                                                                                                                                                                                                      	PreserveSurroundedQuote bool
                                                                                                                                                                                                                      	// DebugFunc is called to collect debug information (currently only useful to debug parsing Python-style multiline values).
                                                                                                                                                                                                                      	DebugFunc DebugFunc
                                                                                                                                                                                                                      	// ReaderBufferSize is the buffer size of the reader in bytes.
                                                                                                                                                                                                                      	ReaderBufferSize int
                                                                                                                                                                                                                      	// AllowNonUniqueSections indicates whether to allow sections with the same name multiple times.
                                                                                                                                                                                                                      	AllowNonUniqueSections bool
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        LoadOptions contains all customized options used for load data source(s).

                                                                                                                                                                                                                        type NameMapper

                                                                                                                                                                                                                        type NameMapper func(string) string

                                                                                                                                                                                                                          NameMapper represents a ini tag name mapper.

                                                                                                                                                                                                                          var (
                                                                                                                                                                                                                          	// SnackCase converts to format SNACK_CASE.
                                                                                                                                                                                                                          	SnackCase NameMapper = func(raw string) string {
                                                                                                                                                                                                                          		newstr := make([]rune, 0, len(raw))
                                                                                                                                                                                                                          		for i, chr := range raw {
                                                                                                                                                                                                                          			if isUpper := 'A' <= chr && chr <= 'Z'; isUpper {
                                                                                                                                                                                                                          				if i > 0 {
                                                                                                                                                                                                                          					newstr = append(newstr, '_')
                                                                                                                                                                                                                          				}
                                                                                                                                                                                                                          			}
                                                                                                                                                                                                                          			newstr = append(newstr, unicode.ToUpper(chr))
                                                                                                                                                                                                                          		}
                                                                                                                                                                                                                          		return string(newstr)
                                                                                                                                                                                                                          	}
                                                                                                                                                                                                                          	// TitleUnderscore converts to format title_underscore.
                                                                                                                                                                                                                          	TitleUnderscore NameMapper = func(raw string) string {
                                                                                                                                                                                                                          		newstr := make([]rune, 0, len(raw))
                                                                                                                                                                                                                          		for i, chr := range raw {
                                                                                                                                                                                                                          			if isUpper := 'A' <= chr && chr <= 'Z'; isUpper {
                                                                                                                                                                                                                          				if i > 0 {
                                                                                                                                                                                                                          					newstr = append(newstr, '_')
                                                                                                                                                                                                                          				}
                                                                                                                                                                                                                          				chr -= 'A' - 'a'
                                                                                                                                                                                                                          			}
                                                                                                                                                                                                                          			newstr = append(newstr, chr)
                                                                                                                                                                                                                          		}
                                                                                                                                                                                                                          		return string(newstr)
                                                                                                                                                                                                                          	}
                                                                                                                                                                                                                          )

                                                                                                                                                                                                                            Built-in name getters.

                                                                                                                                                                                                                            type Parser

                                                                                                                                                                                                                            type Parser func(str string) (interface{}, error)

                                                                                                                                                                                                                            type Section

                                                                                                                                                                                                                            type Section struct {
                                                                                                                                                                                                                            	Comment string
                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              Section represents a config section.

                                                                                                                                                                                                                              func (*Section) Body

                                                                                                                                                                                                                              func (s *Section) Body() string

                                                                                                                                                                                                                                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 (*Section) ChildSections

                                                                                                                                                                                                                                func (s *Section) ChildSections() []*Section

                                                                                                                                                                                                                                  ChildSections returns a list of child sections of current section. For example, "[parent.child1]" and "[parent.child12]" are child sections of section "[parent]".

                                                                                                                                                                                                                                  func (*Section) DeleteKey

                                                                                                                                                                                                                                  func (s *Section) DeleteKey(name string)

                                                                                                                                                                                                                                    DeleteKey deletes a key from section.

                                                                                                                                                                                                                                    func (*Section) GetKey

                                                                                                                                                                                                                                    func (s *Section) GetKey(name string) (*Key, error)

                                                                                                                                                                                                                                      GetKey returns key in section by given name.

                                                                                                                                                                                                                                      func (*Section) HasKey

                                                                                                                                                                                                                                      func (s *Section) HasKey(name string) bool

                                                                                                                                                                                                                                        HasKey returns true if section contains a key with given name.

                                                                                                                                                                                                                                        func (*Section) HasValue

                                                                                                                                                                                                                                        func (s *Section) HasValue(value string) bool

                                                                                                                                                                                                                                          HasValue returns true if section contains given raw value.

                                                                                                                                                                                                                                          func (*Section) Haskey

                                                                                                                                                                                                                                          func (s *Section) Haskey(name string) bool

                                                                                                                                                                                                                                            Deprecated: Use "HasKey" instead.

                                                                                                                                                                                                                                            func (*Section) Key

                                                                                                                                                                                                                                            func (s *Section) Key(name string) *Key

                                                                                                                                                                                                                                              Key assumes named Key exists in section and returns a zero-value when not.

                                                                                                                                                                                                                                              func (*Section) KeyStrings

                                                                                                                                                                                                                                              func (s *Section) KeyStrings() []string

                                                                                                                                                                                                                                                KeyStrings returns list of key names of section.

                                                                                                                                                                                                                                                func (*Section) Keys

                                                                                                                                                                                                                                                func (s *Section) Keys() []*Key

                                                                                                                                                                                                                                                  Keys returns list of keys of section.

                                                                                                                                                                                                                                                  func (*Section) KeysHash

                                                                                                                                                                                                                                                  func (s *Section) KeysHash() map[string]string

                                                                                                                                                                                                                                                    KeysHash returns keys hash consisting of names and values.

                                                                                                                                                                                                                                                    func (*Section) MapTo

                                                                                                                                                                                                                                                    func (s *Section) MapTo(v interface{}) error

                                                                                                                                                                                                                                                      MapTo maps section to given struct.

                                                                                                                                                                                                                                                      func (*Section) Name

                                                                                                                                                                                                                                                      func (s *Section) Name() string

                                                                                                                                                                                                                                                        Name returns name of Section.

                                                                                                                                                                                                                                                        func (*Section) NewBooleanKey

                                                                                                                                                                                                                                                        func (s *Section) NewBooleanKey(name string) (*Key, error)

                                                                                                                                                                                                                                                          NewBooleanKey creates a new boolean type key to given section.

                                                                                                                                                                                                                                                          func (*Section) NewKey

                                                                                                                                                                                                                                                          func (s *Section) NewKey(name, val string) (*Key, error)

                                                                                                                                                                                                                                                            NewKey creates a new key to given section.

                                                                                                                                                                                                                                                            func (*Section) ParentKeys

                                                                                                                                                                                                                                                            func (s *Section) ParentKeys() []*Key

                                                                                                                                                                                                                                                              ParentKeys returns list of keys of parent section.

                                                                                                                                                                                                                                                              func (*Section) ReflectFrom

                                                                                                                                                                                                                                                              func (s *Section) ReflectFrom(v interface{}) error

                                                                                                                                                                                                                                                                ReflectFrom reflects section from given struct. It overwrites existing ones.

                                                                                                                                                                                                                                                                func (*Section) SetBody

                                                                                                                                                                                                                                                                func (s *Section) SetBody(body string)

                                                                                                                                                                                                                                                                  SetBody updates body content only if section is raw.

                                                                                                                                                                                                                                                                  func (*Section) StrictMapTo

                                                                                                                                                                                                                                                                  func (s *Section) StrictMapTo(v interface{}) error

                                                                                                                                                                                                                                                                    StrictMapTo maps section to given struct in strict mode, which returns all possible error including value parsing error.

                                                                                                                                                                                                                                                                    type StructReflector

                                                                                                                                                                                                                                                                    type StructReflector interface {
                                                                                                                                                                                                                                                                    	ReflectINIStruct(*File) error
                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                      StructReflector is the interface implemented by struct types that can extract themselves into INI objects.

                                                                                                                                                                                                                                                                      type ValueMapper

                                                                                                                                                                                                                                                                      type ValueMapper func(string) string

                                                                                                                                                                                                                                                                        ValueMapper represents a mapping function for values, e.g. os.ExpandEnv