SYMBOL INDEX (279 symbols across 16 files)

FILE: _examples/example.go
  type Config (line 12) | type Config struct
  type handOfKing (line 29) | type handOfKing struct
  type address (line 37) | type address struct
  type character (line 44) | type character struct
  function main (line 49) | func main() {

FILE: cmd/conflv/main.go
  function init (line 19) | func init() {
  function usage (line 29) | func usage() {
  function main (line 37) | func main() {
  function printTypes (line 53) | func printTypes(md confl.MetaData) {

FILE: decode.go
  type Primitive (line 29) | type Primitive struct
  method PrimitiveDecode (line 45) | func (md *MetaData) PrimitiveDecode(primValue Primitive, v interface{}) ...
  type Decoder (line 51) | type Decoder struct
    method Decode (line 59) | func (dec *Decoder) Decode(v interface{}) error {
  function NewDecoder (line 55) | func NewDecoder(r io.Reader) *Decoder {
  function Unmarshal (line 68) | func Unmarshal(bs []byte, v interface{}) error {
  function Decode (line 109) | func Decode(data string, v interface{}) (MetaData, error) {
  function DecodeFile (line 123) | func DecodeFile(fpath string, v interface{}) (MetaData, error) {
  function DecodeReader (line 133) | func DecodeReader(r io.Reader, v interface{}) (MetaData, error) {
  method unify (line 146) | func (md *MetaData) unify(data interface{}, rv reflect.Value) error {
  method unifyStruct (line 221) | func (md *MetaData) unifyStruct(mapping interface{}, rv reflect.Value) e...
  method unifyMap (line 263) | func (md *MetaData) unifyMap(mapping interface{}, rv reflect.Value) error {
  method unifyArray (line 288) | func (md *MetaData) unifyArray(data interface{}, rv reflect.Value) error {
  method unifySlice (line 301) | func (md *MetaData) unifySlice(data interface{}, rv reflect.Value) error {
  method unifySliceArray (line 313) | func (md *MetaData) unifySliceArray(data, rv reflect.Value) error {
  method unifyDatetime (line 325) | func (md *MetaData) unifyDatetime(data interface{}, rv reflect.Value) er...
  method unifyString (line 333) | func (md *MetaData) unifyString(data interface{}, rv reflect.Value) error {
  method unifyFloat64 (line 341) | func (md *MetaData) unifyFloat64(data interface{}, rv reflect.Value) err...
  method unifyInt (line 356) | func (md *MetaData) unifyInt(data interface{}, rv reflect.Value) error {
  method unifyBool (line 403) | func (md *MetaData) unifyBool(data interface{}, rv reflect.Value) error {
  method unifyAnything (line 411) | func (md *MetaData) unifyAnything(data interface{}, rv reflect.Value) er...
  method unifyText (line 416) | func (md *MetaData) unifyText(data interface{}, v TextUnmarshaler) error {
  function rvalue (line 445) | func rvalue(v interface{}) reflect.Value {
  function indirect (line 455) | func indirect(v reflect.Value) reflect.Value {
  function isUnifiable (line 471) | func isUnifiable(rv reflect.Value) bool {
  function badtype (line 481) | func badtype(expected string, data interface{}) error {
  function mismatch (line 485) | func mismatch(user reflect.Value, expected string, data interface{}) err...

FILE: decode_meta.go
  type MetaData (line 8) | type MetaData struct
    method IsDefined (line 23) | func (md *MetaData) IsDefined(key ...string) bool {
    method Type (line 46) | func (md *MetaData) Type(key ...string) string {
    method Keys (line 85) | func (md *MetaData) Keys() []Key {
    method Undecoded (line 100) | func (md *MetaData) Undecoded() []Key {
  type Key (line 56) | type Key
    method String (line 58) | func (k Key) String() string {
    method add (line 62) | func (k Key) add(piece string) Key {
    method insert (line 69) | func (k Key) insert(piece string) Key {

FILE: decode_test.go
  function init (line 16) | func init() {
  function TestDecodeSimple (line 25) | func TestDecodeSimple(t *testing.T) {
  function TestDecodeEmbedded (line 144) | func TestDecodeEmbedded(t *testing.T) {
  function TestDecodeTableArrays (line 187) | func TestDecodeTableArrays(t *testing.T) {
  function TestDecodeCase (line 237) | func TestDecodeCase(t *testing.T) {
  function TestDecodePointers (line 305) | func TestDecodePointers(t *testing.T) {
  type sphere (line 359) | type sphere struct
  function TestDecodeSimpleArray (line 364) | func TestDecodeSimpleArray(t *testing.T) {
  function TestDecodeArrayWrongSize (line 371) | func TestDecodeArrayWrongSize(t *testing.T) {
  function TestDecodeLargeIntoSmallInt (line 378) | func TestDecodeLargeIntoSmallInt(t *testing.T) {
  function TestDecodeSizedInts (line 388) | func TestDecodeSizedInts(t *testing.T) {
  function ExampleMetaData_PrimitiveDecode (line 423) | func ExampleMetaData_PrimitiveDecode() {
  function ExampleDecode (line 487) | func ExampleDecode() {
  type duration (line 546) | type duration struct
    method UnmarshalText (line 550) | func (d *duration) UnmarshalText(text []byte) error {
  function Example_unmarshaler (line 558) | func Example_unmarshaler() {

FILE: encode.go
  type encodeError (line 17) | type encodeError struct
  function Marshal (line 39) | func Marshal(v interface{}) ([]byte, error) {
  type Encoder (line 53) | type Encoder struct
    method Encode (line 94) | func (enc *Encoder) Encode(v interface{}) error {
    method safeEncode (line 102) | func (enc *Encoder) safeEncode(key Key, rv reflect.Value) (err error) {
    method encode (line 116) | func (enc *Encoder) encode(key Key, rv reflect.Value) {
    method eElement (line 165) | func (enc *Encoder) eElement(rv reflect.Value) {
    method writeQuoted (line 213) | func (enc *Encoder) writeQuoted(s string) {
    method eArrayOrSliceElement (line 217) | func (enc *Encoder) eArrayOrSliceElement(rv reflect.Value) {
    method eArrayOfTables (line 231) | func (enc *Encoder) eArrayOfTables(key Key, rv reflect.Value) {
    method eTable (line 265) | func (enc *Encoder) eTable(key Key, rv reflect.Value) {
    method eMapOrStruct (line 286) | func (enc *Encoder) eMapOrStruct(key Key, rv reflect.Value) {
    method eMap (line 297) | func (enc *Encoder) eMap(key Key, rv reflect.Value) {
    method eStruct (line 333) | func (enc *Encoder) eStruct(key Key, rv reflect.Value) {
    method newline (line 477) | func (enc *Encoder) newline() {
    method keyEqElement (line 483) | func (enc *Encoder) keyEqElement(key Key, val reflect.Value) {
    method wf (line 494) | func (enc *Encoder) wf(format string, v ...interface{}) {
    method indentStr (line 501) | func (enc *Encoder) indentStr(key Key) string {
    method indentStrDelta (line 504) | func (enc *Encoder) indentStrDelta(key Key, delta int) string {
  function NewEncoder (line 64) | func NewEncoder(w io.Writer) *Encoder {
  function floatAddDecimal (line 206) | func floatAddDecimal(fstr string) string {
  function confTypeOfGo (line 400) | func confTypeOfGo(rv reflect.Value) confType {
  function confArrayType (line 446) | func confArrayType(rv reflect.Value) confType {
  function encPanic (line 508) | func encPanic(err error) {
  function eindirect (line 512) | func eindirect(v reflect.Value) reflect.Value {
  function isNil (line 521) | func isNil(rv reflect.Value) bool {
  function panicIfInvalidKey (line 530) | func panicIfInvalidKey(key Key, hash bool) {
  function isValidTableName (line 546) | func isValidTableName(s string) bool {
  function isValidKeyName (line 558) | func isValidKeyName(s string) bool {

FILE: encode_test.go
  function TestEncodeRoundTrip (line 17) | func TestEncodeRoundTrip(t *testing.T) {
  function TestEncodeMany (line 69) | func TestEncodeMany(t *testing.T) {
  function TestEncodeNestedTableArrays (line 405) | func TestEncodeNestedTableArrays(t *testing.T) {
  function TestEncodeArrayHashWithNormalHashOrder (line 452) | func TestEncodeArrayHashWithNormalHashOrder(t *testing.T) {
  function encodeExpected (line 474) | func encodeExpected(
  function ExampleEncoder_Encode (line 507) | func ExampleEncoder_Encode() {

FILE: encoding_types.go
  type TextMarshaler (line 15) | type TextMarshaler
  type TextUnmarshaler (line 19) | type TextUnmarshaler

FILE: encoding_types_1.1.go
  type TextMarshaler (line 10) | type TextMarshaler interface
  type TextUnmarshaler (line 16) | type TextUnmarshaler interface

FILE: fuzz.go
  function Fuzz (line 20) | func Fuzz(data []byte) int {

FILE: lex.go
  type itemType (line 30) | type itemType
  constant itemError (line 33) | itemError itemType = iota
  constant itemNIL (line 34) | itemNIL
  constant itemEOF (line 35) | itemEOF
  constant itemKey (line 36) | itemKey
  constant itemText (line 37) | itemText
  constant itemString (line 38) | itemString
  constant itemBool (line 39) | itemBool
  constant itemInteger (line 40) | itemInteger
  constant itemFloat (line 41) | itemFloat
  constant itemDatetime (line 42) | itemDatetime
  constant itemArrayStart (line 43) | itemArrayStart
  constant itemArrayEnd (line 44) | itemArrayEnd
  constant itemMapStart (line 45) | itemMapStart
  constant itemMapEnd (line 46) | itemMapEnd
  constant itemCommentStart (line 47) | itemCommentStart
  constant eof (line 51) | eof               = 0
  constant mapStart (line 52) | mapStart          = '{'
  constant mapEnd (line 53) | mapEnd            = '}'
  constant keySepEqual (line 54) | keySepEqual       = '='
  constant keySepColon (line 55) | keySepColon       = ':'
  constant arrayStart (line 56) | arrayStart        = '['
  constant arrayEnd (line 57) | arrayEnd          = ']'
  constant arrayValTerm (line 58) | arrayValTerm      = ','
  constant mapValTerm (line 59) | mapValTerm        = ','
  constant commentHashStart (line 60) | commentHashStart  = '#'
  constant commentSlashStart (line 61) | commentSlashStart = '/'
  constant dqStringStart (line 62) | dqStringStart     = '"'
  constant dqStringEnd (line 63) | dqStringEnd       = '"'
  constant sqStringStart (line 64) | sqStringStart     = '\''
  constant sqStringEnd (line 65) | sqStringEnd       = '\''
  constant optValTerm (line 66) | optValTerm        = ';'
  constant blockStart (line 67) | blockStart        = '('
  constant blockEnd (line 68) | blockEnd          = ')'
  type stateFn (line 71) | type stateFn
  type lexer (line 73) | type lexer struct
    method nextItem (line 98) | func (lx *lexer) nextItem() item {
    method push (line 121) | func (lx *lexer) push(state stateFn) {
    method pop (line 125) | func (lx *lexer) pop() stateFn {
    method emit (line 135) | func (lx *lexer) emit(typ itemType) {
    method next (line 140) | func (lx *lexer) next() (r rune) {
    method ignore (line 167) | func (lx *lexer) ignore() {
    method backup (line 172) | func (lx *lexer) backup() {
    method peek (line 183) | func (lx *lexer) peek() rune {
    method errorf (line 192) | func (lx *lexer) errorf(format string, values ...interface{}) stateFn {
    method isBool (line 625) | func (lx *lexer) isBool() bool {
  type item (line 92) | type item struct
    method String (line 991) | func (item item) String() string {
  function lex (line 109) | func lex(input string) *lexer {
  function lexTop (line 207) | func lexTop(lx *lexer) stateFn {
  function lexTopValueEnd (line 242) | func lexTopValueEnd(lx *lexer) stateFn {
  function lexKeyStart (line 269) | func lexKeyStart(lx *lexer) stateFn {
  function lexDubQuotedKey (line 298) | func lexDubQuotedKey(lx *lexer) stateFn {
  function lexQuotedKey (line 310) | func lexQuotedKey(lx *lexer) stateFn {
  function lexKey (line 323) | func lexKey(lx *lexer) stateFn {
  function lexKeyEnd (line 340) | func lexKeyEnd(lx *lexer) stateFn {
  function lexValue (line 356) | func lexValue(lx *lexer) stateFn {
  function lexArrayValue (line 403) | func lexArrayValue(lx *lexer) stateFn {
  function lexArrayValueEnd (line 433) | func lexArrayValueEnd(lx *lexer) stateFn {
  function lexArrayEnd (line 461) | func lexArrayEnd(lx *lexer) stateFn {
  function lexMapKeyStart (line 471) | func lexMapKeyStart(lx *lexer) stateFn {
  function lexMapQuotedKey (line 509) | func lexMapQuotedKey(lx *lexer) stateFn {
  function lexMapDubQuotedKey (line 521) | func lexMapDubQuotedKey(lx *lexer) stateFn {
  function lexMapKey (line 534) | func lexMapKey(lx *lexer) stateFn {
  function lexMapKeyEnd (line 547) | func lexMapKeyEnd(lx *lexer) stateFn {
  function lexMapValue (line 563) | func lexMapValue(lx *lexer) stateFn {
  function lexMapValueEnd (line 591) | func lexMapValueEnd(lx *lexer) stateFn {
  function lexMapEnd (line 618) | func lexMapEnd(lx *lexer) stateFn {
  function lexQuotedString (line 634) | func lexQuotedString(lx *lexer) stateFn {
  function lexDubQuotedString (line 650) | func lexDubQuotedString(lx *lexer) stateFn {
  function lexString (line 665) | func lexString(lx *lexer) stateFn {
  function lexDubString (line 692) | func lexDubString(lx *lexer) stateFn {
  function lexBlock (line 719) | func lexBlock(lx *lexer) stateFn {
  function lexStringEscape (line 764) | func lexStringEscape(lx *lexer) stateFn {
  function lexStringBinary (line 786) | func lexStringBinary(lx *lexer) stateFn {
  function lexNumberOrDateStart (line 803) | func lexNumberOrDateStart(lx *lexer) stateFn {
  function lexNumberOrDate (line 816) | func lexNumberOrDate(lx *lexer) stateFn {
  function lexDateAfterYear (line 837) | func lexDateAfterYear(lx *lexer) stateFn {
  function lexNumberStart (line 865) | func lexNumberStart(lx *lexer) stateFn {
  function lexNumber (line 879) | func lexNumber(lx *lexer) stateFn {
  function lexFloatStart (line 895) | func lexFloatStart(lx *lexer) stateFn {
  function lexFloat (line 906) | func lexFloat(lx *lexer) stateFn {
  function lexCommentStart (line 919) | func lexCommentStart(lx *lexer) stateFn {
  function lexComment (line 928) | func lexComment(lx *lexer) stateFn {
  function lexSkip (line 939) | func lexSkip(lx *lexer, nextState stateFn) stateFn {
  function isEndNormal (line 946) | func isEndNormal(lx *lexer, r rune) bool {
  function isEndArrayUnQuoted (line 950) | func isEndArrayUnQuoted(lx *lexer, r rune) bool {
  function isIdentifierRune (line 954) | func isIdentifierRune(r rune) bool {
  function isKeySeparator (line 967) | func isKeySeparator(r rune) bool {
  function isWhitespace (line 973) | func isWhitespace(r rune) bool {
  function isNL (line 977) | func isNL(r rune) bool {
  function isDigit (line 981) | func isDigit(r rune) bool {
  function isHexadecimal (line 985) | func isHexadecimal(r rune) bool {
  function escapeSpecial (line 995) | func escapeSpecial(c rune) string {

FILE: lex_test.go
  function expect (line 12) | func expect(t *testing.T, lx *lexer, items []item) {
  function expectError (line 41) | func expectError(t *testing.T, conf string) {
  function TestLexErrors (line 76) | func TestLexErrors(t *testing.T) {
  function TestLexBadConfString (line 82) | func TestLexBadConfString(t *testing.T) {
  function TestLexSimpleKeyStringValues (line 90) | func TestLexSimpleKeyStringValues(t *testing.T) {
  function TestLexSimpleKeyIntegerValues (line 110) | func TestLexSimpleKeyIntegerValues(t *testing.T) {
  function TestLexSimpleKeyFloatValues (line 124) | func TestLexSimpleKeyFloatValues(t *testing.T) {
  function TestLexSimpleKeyBoolValues (line 138) | func TestLexSimpleKeyBoolValues(t *testing.T) {
  function TestLexComments (line 158) | func TestLexComments(t *testing.T) {
  function TestLexArrays (line 172) | func TestLexArrays(t *testing.T) {
  function TestLexMultilineArrays (line 202) | func TestLexMultilineArrays(t *testing.T) {
  function TestLexUnterminated (line 226) | func TestLexUnterminated(t *testing.T) {
  function TestLexMultilineArraysNoSep (line 249) | func TestLexMultilineArraysNoSep(t *testing.T) {
  function TestLexSimpleMap (line 267) | func TestLexSimpleMap(t *testing.T) {
  function TestLexMultilineMap (line 294) | func TestLexMultilineMap(t *testing.T) {
  function TestLexNestedMaps (line 329) | func TestLexNestedMaps(t *testing.T) {
  function TestLexQuotedKeys (line 352) | func TestLexQuotedKeys(t *testing.T) {
  function TestLexQuotedKeysWithSpace (line 366) | func TestLexQuotedKeysWithSpace(t *testing.T) {
  function TestLexColonKeySep (line 378) | func TestLexColonKeySep(t *testing.T) {
  function TestLexWhitespaceKeySep (line 394) | func TestLexWhitespaceKeySep(t *testing.T) {
  function TestLexNestedWhitespaceMaps (line 419) | func TestLexNestedWhitespaceMaps(t *testing.T) {
  function TestLexTableOfArrays (line 446) | func TestLexTableOfArrays(t *testing.T) {
  function TestOptionalSemicolons (line 475) | func TestOptionalSemicolons(t *testing.T) {
  function TestLexSemicolonChaining (line 495) | func TestLexSemicolonChaining(t *testing.T) {
  function TestLexNonQuotedStrings (line 525) | func TestLexNonQuotedStrings(t *testing.T) {
  function TestLexMapQuotedKeys (line 559) | func TestLexMapQuotedKeys(t *testing.T) {
  function TestLexSpecialCharsMapQuotedKeys (line 574) | func TestLexSpecialCharsMapQuotedKeys(t *testing.T) {
  function TestLexDoubleNestedMapsNewLines (line 600) | func TestLexDoubleNestedMapsNewLines(t *testing.T) {
  function TestLexBlockString (line 622) | func TestLexBlockString(t *testing.T) {
  function TestLexBlockStringEOF (line 631) | func TestLexBlockStringEOF(t *testing.T) {
  function TestLexBlockStringMultiLine (line 656) | func TestLexBlockStringMultiLine(t *testing.T) {

FILE: parse.go
  type parser (line 33) | type parser struct
    method panicf (line 100) | func (p *parser) panicf(format string, v ...interface{}) {
    method next (line 106) | func (p *parser) next() item {
    method bug (line 110) | func (p *parser) bug(format string, v ...interface{}) {
    method expect (line 114) | func (p *parser) expect(typ itemType) item {
    method assertEqual (line 120) | func (p *parser) assertEqual(expected, got itemType) {
    method pushContext (line 126) | func (p *parser) pushContext(ctx interface{}) {
    method popContext (line 131) | func (p *parser) popContext() interface{} {
    method pushKey (line 142) | func (p *parser) pushKey(key string) {
    method popKey (line 146) | func (p *parser) popKey() string {
    method processItem (line 156) | func (p *parser) processItem(it item) error {
    method setValue (line 221) | func (p *parser) setValue(val interface{}) {
    method setType (line 243) | func (p *parser) setType(key string, typ confType) {
    method addImplicit (line 255) | func (p *parser) addImplicit(key Key) {
    method removeImplicit (line 260) | func (p *parser) removeImplicit(key Key) {
    method isImplicit (line 266) | func (p *parser) isImplicit(key Key) bool {
    method current (line 271) | func (p *parser) current() string {
    method replaceUnicode (line 324) | func (p *parser) replaceUnicode(s string) string {
    method asciiEscapeToUnicode (line 335) | func (p *parser) asciiEscapeToUnicode(s string) string {
  type parseError (line 63) | type parseError
    method Error (line 65) | func (pe parseError) Error() string {
  function Parse (line 69) | func Parse(data string) (map[string]interface{}, error) {
  function parse (line 77) | func parse(data string) (p *parser, err error) {
  function maybeRemoveIndents (line 282) | func maybeRemoveIndents(s string) string {
  function replaceEscapes (line 311) | func replaceEscapes(s string) string {

FILE: parse_test.go
  function test (line 11) | func test(t *testing.T, data string, ex map[string]interface{}) {
  function TestParseSimpleTopLevel (line 25) | func TestParseSimpleTopLevel(t *testing.T) {
  function TestParseSample1 (line 45) | func TestParseSample1(t *testing.T) {
  function TestParseSample2 (line 81) | func TestParseSample2(t *testing.T) {
  function TestParseSample3 (line 114) | func TestParseSample3(t *testing.T) {
  function TestParseSample4 (line 132) | func TestParseSample4(t *testing.T) {
  function TestParseSample5 (line 149) | func TestParseSample5(t *testing.T) {
  function TestBigSlices (line 159) | func TestBigSlices(t *testing.T) {

FILE: type_check.go
  type confType (line 4) | type confType interface
  function typeEqual (line 9) | func typeEqual(t1, t2 confType) bool {
  function typeIsHash (line 16) | func typeIsHash(t confType) bool {
  type confBaseType (line 20) | type confBaseType
    method typeString (line 22) | func (btype confBaseType) typeString() string {
    method String (line 26) | func (btype confBaseType) String() string {
  method typeOfPrimitive (line 46) | func (p *parser) typeOfPrimitive(lexItem item) confType {
  method typeOfArray (line 68) | func (p *parser) typeOfArray(types []confType) confType {

FILE: type_fields.go
  type field (line 17) | type field struct
  type byName (line 27) | type byName
    method Len (line 29) | func (x byName) Len() int { return len(x) }
    method Swap (line 31) | func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
    method Less (line 33) | func (x byName) Less(i, j int) bool {
  type byIndex (line 47) | type byIndex
    method Len (line 49) | func (x byIndex) Len() int { return len(x) }
    method Swap (line 51) | func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
    method Less (line 53) | func (x byIndex) Less(i, j int) bool {
  function typeFields (line 68) | func typeFields(t reflect.Type) []field {
  function dominantField (line 200) | func dominantField(fields []field) (field, bool) {
  function cachedTypeFields (line 238) | func cachedTypeFields(t reflect.Type) []field {