gedcom - structures.go

     1  package gedcom
     2  
     3  // File automatically generated with ./genStructures.sh
     4  
     5  import "errors"
     6  
     7  // Header is a GEDCOM structure type
     8  type Header struct {
     9  	Source              HeaderSource
    10  	ReceivingSystemName ReceivingSystemName
    11  	TransmissionLDate   TransmissionDateTime
    12  	Submitter           Xref
    13  	Submission          Xref
    14  	FileName            FileName
    15  	Copyright           CopyrightGedcomFile
    16  	Version             Version
    17  	CharacterSet        CharacterSetStructure
    18  	Language            LanguageOfText
    19  	Place               HeaderPlace
    20  	ContentDescription  ContentDescription
    21  }
    22  
    23  func (s *Header) parse(l *Line, o options) error {
    24  	var SourceSet, SubmitterSet, VersionSet, CharacterSetSet, ReceivingSystemNameSet, TransmissionLDateSet, SubmissionSet, FileNameSet, CopyrightSet, LanguageSet, PlaceSet, ContentDescriptionSet bool
    25  	for _, sl := range l.Sub {
    26  		switch sl.tag {
    27  		case cSOUR:
    28  			if SourceSet {
    29  				if !o.allowMoreThanAllowed {
    30  					continue
    31  				}
    32  				return ErrContext{"Header", cSOUR, ErrSingleMultiple}
    33  			}
    34  			SourceSet = true
    35  			if err := s.Source.parse(&sl, o); err != nil {
    36  				return ErrContext{"Header", cSOUR, err}
    37  			}
    38  		case cDEST:
    39  			if ReceivingSystemNameSet {
    40  				if !o.allowMoreThanAllowed {
    41  					continue
    42  				}
    43  				return ErrContext{"Header", cDEST, ErrSingleMultiple}
    44  			}
    45  			ReceivingSystemNameSet = true
    46  			if err := s.ReceivingSystemName.parse(&sl, o); err != nil {
    47  				return ErrContext{"Header", cDEST, err}
    48  			}
    49  		case cDATE:
    50  			if TransmissionLDateSet {
    51  				if !o.allowMoreThanAllowed {
    52  					continue
    53  				}
    54  				return ErrContext{"Header", cDATE, ErrSingleMultiple}
    55  			}
    56  			TransmissionLDateSet = true
    57  			if err := s.TransmissionLDate.parse(&sl, o); err != nil {
    58  				return ErrContext{"Header", cDATE, err}
    59  			}
    60  		case cSUBM:
    61  			if SubmitterSet {
    62  				if !o.allowMoreThanAllowed {
    63  					continue
    64  				}
    65  				return ErrContext{"Header", cSUBM, ErrSingleMultiple}
    66  			}
    67  			SubmitterSet = true
    68  			if err := s.Submitter.parse(&sl, o); err != nil {
    69  				return ErrContext{"Header", cSUBM, err}
    70  			}
    71  		case cSUMB:
    72  			if SubmissionSet {
    73  				if !o.allowMoreThanAllowed {
    74  					continue
    75  				}
    76  				return ErrContext{"Header", cSUMB, ErrSingleMultiple}
    77  			}
    78  			SubmissionSet = true
    79  			if err := s.Submission.parse(&sl, o); err != nil {
    80  				return ErrContext{"Header", cSUMB, err}
    81  			}
    82  		case cFILE:
    83  			if FileNameSet {
    84  				if !o.allowMoreThanAllowed {
    85  					continue
    86  				}
    87  				return ErrContext{"Header", cFILE, ErrSingleMultiple}
    88  			}
    89  			FileNameSet = true
    90  			if err := s.FileName.parse(&sl, o); err != nil {
    91  				return ErrContext{"Header", cFILE, err}
    92  			}
    93  		case cCOPR:
    94  			if CopyrightSet {
    95  				if !o.allowMoreThanAllowed {
    96  					continue
    97  				}
    98  				return ErrContext{"Header", cCOPR, ErrSingleMultiple}
    99  			}
   100  			CopyrightSet = true
   101  			if err := s.Copyright.parse(&sl, o); err != nil {
   102  				return ErrContext{"Header", cCOPR, err}
   103  			}
   104  		case cGEDC:
   105  			if VersionSet {
   106  				if !o.allowMoreThanAllowed {
   107  					continue
   108  				}
   109  				return ErrContext{"Header", cGEDC, ErrSingleMultiple}
   110  			}
   111  			VersionSet = true
   112  			if err := s.Version.parse(&sl, o); err != nil {
   113  				return ErrContext{"Header", cGEDC, err}
   114  			}
   115  		case cCHAR:
   116  			if CharacterSetSet {
   117  				if !o.allowMoreThanAllowed {
   118  					continue
   119  				}
   120  				return ErrContext{"Header", cCHAR, ErrSingleMultiple}
   121  			}
   122  			CharacterSetSet = true
   123  			if err := s.CharacterSet.parse(&sl, o); err != nil {
   124  				return ErrContext{"Header", cCHAR, err}
   125  			}
   126  		case cLANG:
   127  			if LanguageSet {
   128  				if !o.allowMoreThanAllowed {
   129  					continue
   130  				}
   131  				return ErrContext{"Header", cLANG, ErrSingleMultiple}
   132  			}
   133  			LanguageSet = true
   134  			if err := s.Language.parse(&sl, o); err != nil {
   135  				return ErrContext{"Header", cLANG, err}
   136  			}
   137  		case cPLAC:
   138  			if PlaceSet {
   139  				if !o.allowMoreThanAllowed {
   140  					continue
   141  				}
   142  				return ErrContext{"Header", cPLAC, ErrSingleMultiple}
   143  			}
   144  			PlaceSet = true
   145  			if err := s.Place.parse(&sl, o); err != nil {
   146  				return ErrContext{"Header", cPLAC, err}
   147  			}
   148  		case cNOTE:
   149  			if ContentDescriptionSet {
   150  				if !o.allowMoreThanAllowed {
   151  					continue
   152  				}
   153  				return ErrContext{"Header", cNOTE, ErrSingleMultiple}
   154  			}
   155  			ContentDescriptionSet = true
   156  			if err := s.ContentDescription.parse(&sl, o); err != nil {
   157  				return ErrContext{"Header", cNOTE, err}
   158  			}
   159  		default:
   160  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
   161  				return ErrContext{"Header", sl.tag, ErrUnknownTag}
   162  			}
   163  			// possibly store in a Other field
   164  		}
   165  	}
   166  	if !o.allowMissingRequired {
   167  		if !SourceSet {
   168  			return ErrContext{"Header", "Source", ErrRequiredMissing}
   169  		}
   170  		if !SubmitterSet {
   171  			return ErrContext{"Header", "Submitter", ErrRequiredMissing}
   172  		}
   173  		if !VersionSet {
   174  			return ErrContext{"Header", "Version", ErrRequiredMissing}
   175  		}
   176  		if !CharacterSetSet {
   177  			return ErrContext{"Header", "CharacterSet", ErrRequiredMissing}
   178  		}
   179  	}
   180  	return nil
   181  }
   182  
   183  // HeaderSource is a GEDCOM structure type
   184  type HeaderSource struct {
   185  	SystemID      ApprovedSystemID
   186  	VersionNumber VersionNumber
   187  	Name          NameOfProduct
   188  	Business      HeaderBusiness
   189  	Data          HeaderDataSource
   190  }
   191  
   192  func (s *HeaderSource) parse(l *Line, o options) error {
   193  	if err := s.SystemID.parse(l, o); err != nil {
   194  		return ErrContext{"HeaderSource", "line_value", err}
   195  	}
   196  	var VersionNumberSet, NameSet, BusinessSet, DataSet bool
   197  	for _, sl := range l.Sub {
   198  		switch sl.tag {
   199  		case cVERS:
   200  			if VersionNumberSet {
   201  				if !o.allowMoreThanAllowed {
   202  					continue
   203  				}
   204  				return ErrContext{"HeaderSource", cVERS, ErrSingleMultiple}
   205  			}
   206  			VersionNumberSet = true
   207  			if err := s.VersionNumber.parse(&sl, o); err != nil {
   208  				return ErrContext{"HeaderSource", cVERS, err}
   209  			}
   210  		case cNAME:
   211  			if NameSet {
   212  				if !o.allowMoreThanAllowed {
   213  					continue
   214  				}
   215  				return ErrContext{"HeaderSource", cNAME, ErrSingleMultiple}
   216  			}
   217  			NameSet = true
   218  			if err := s.Name.parse(&sl, o); err != nil {
   219  				return ErrContext{"HeaderSource", cNAME, err}
   220  			}
   221  		case cCORP:
   222  			if BusinessSet {
   223  				if !o.allowMoreThanAllowed {
   224  					continue
   225  				}
   226  				return ErrContext{"HeaderSource", cCORP, ErrSingleMultiple}
   227  			}
   228  			BusinessSet = true
   229  			if err := s.Business.parse(&sl, o); err != nil {
   230  				return ErrContext{"HeaderSource", cCORP, err}
   231  			}
   232  		case cDATA:
   233  			if DataSet {
   234  				if !o.allowMoreThanAllowed {
   235  					continue
   236  				}
   237  				return ErrContext{"HeaderSource", cDATA, ErrSingleMultiple}
   238  			}
   239  			DataSet = true
   240  			if err := s.Data.parse(&sl, o); err != nil {
   241  				return ErrContext{"HeaderSource", cDATA, err}
   242  			}
   243  		default:
   244  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
   245  				return ErrContext{"HeaderSource", sl.tag, ErrUnknownTag}
   246  			}
   247  			// possibly store in a Other field
   248  		}
   249  	}
   250  	return nil
   251  }
   252  
   253  // TransmissionDateTime is a GEDCOM structure type
   254  type TransmissionDateTime struct {
   255  	TransmissionDate TransmissionDate
   256  	Time             TimeValue
   257  }
   258  
   259  func (s *TransmissionDateTime) parse(l *Line, o options) error {
   260  	if err := s.TransmissionDate.parse(l, o); err != nil {
   261  		return ErrContext{"TransmissionDateTime", "line_value", err}
   262  	}
   263  	var TimeSet bool
   264  	for _, sl := range l.Sub {
   265  		switch sl.tag {
   266  		case cTIME:
   267  			if TimeSet {
   268  				if !o.allowMoreThanAllowed {
   269  					continue
   270  				}
   271  				return ErrContext{"TransmissionDateTime", cTIME, ErrSingleMultiple}
   272  			}
   273  			TimeSet = true
   274  			if err := s.Time.parse(&sl, o); err != nil {
   275  				return ErrContext{"TransmissionDateTime", cTIME, err}
   276  			}
   277  		default:
   278  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
   279  				return ErrContext{"TransmissionDateTime", sl.tag, ErrUnknownTag}
   280  			}
   281  			// possibly store in a Other field
   282  		}
   283  	}
   284  	return nil
   285  }
   286  
   287  // HeaderBusiness is a GEDCOM structure type
   288  type HeaderBusiness struct {
   289  	NameOfBusiness NameOfBusiness
   290  	Address        AddressStructure
   291  	PhoneNumber    []PhoneNumber
   292  }
   293  
   294  func (s *HeaderBusiness) parse(l *Line, o options) error {
   295  	if err := s.NameOfBusiness.parse(l, o); err != nil {
   296  		return ErrContext{"HeaderBusiness", "line_value", err}
   297  	}
   298  	var AddressSet bool
   299  	s.PhoneNumber = make([]PhoneNumber, 0, 3)
   300  	for _, sl := range l.Sub {
   301  		switch sl.tag {
   302  		case cADDR:
   303  			if AddressSet {
   304  				if !o.allowMoreThanAllowed {
   305  					continue
   306  				}
   307  				return ErrContext{"HeaderBusiness", cADDR, ErrSingleMultiple}
   308  			}
   309  			AddressSet = true
   310  			if err := s.Address.parse(&sl, o); err != nil {
   311  				return ErrContext{"HeaderBusiness", cADDR, err}
   312  			}
   313  		case cPHON:
   314  			if len(s.PhoneNumber) == 3 {
   315  				if !o.allowMoreThanAllowed {
   316  					continue
   317  				}
   318  				return ErrContext{"HeaderBusiness", cPHON, ErrTooMany(3)}
   319  			}
   320  			var t PhoneNumber
   321  			if err := t.parse(&sl, o); err != nil {
   322  				return ErrContext{"HeaderBusiness", cPHON, err}
   323  			}
   324  			s.PhoneNumber = append(s.PhoneNumber, t)
   325  		default:
   326  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
   327  				return ErrContext{"HeaderBusiness", sl.tag, ErrUnknownTag}
   328  			}
   329  			// possibly store in a Other field
   330  		}
   331  	}
   332  	return nil
   333  }
   334  
   335  // HeaderDataSource is a GEDCOM structure type
   336  type HeaderDataSource struct {
   337  	SourceName          NameOfSourceData
   338  	PublicationDate     PublicationDate
   339  	CopyrightSourceData CopyrightSourceData
   340  }
   341  
   342  func (s *HeaderDataSource) parse(l *Line, o options) error {
   343  	if err := s.SourceName.parse(l, o); err != nil {
   344  		return ErrContext{"HeaderDataSource", "line_value", err}
   345  	}
   346  	var PublicationDateSet, CopyrightSourceDataSet bool
   347  	for _, sl := range l.Sub {
   348  		switch sl.tag {
   349  		case cDATE:
   350  			if PublicationDateSet {
   351  				if !o.allowMoreThanAllowed {
   352  					continue
   353  				}
   354  				return ErrContext{"HeaderDataSource", cDATE, ErrSingleMultiple}
   355  			}
   356  			PublicationDateSet = true
   357  			if err := s.PublicationDate.parse(&sl, o); err != nil {
   358  				return ErrContext{"HeaderDataSource", cDATE, err}
   359  			}
   360  		case cCOPR:
   361  			if CopyrightSourceDataSet {
   362  				if !o.allowMoreThanAllowed {
   363  					continue
   364  				}
   365  				return ErrContext{"HeaderDataSource", cCOPR, ErrSingleMultiple}
   366  			}
   367  			CopyrightSourceDataSet = true
   368  			if err := s.CopyrightSourceData.parse(&sl, o); err != nil {
   369  				return ErrContext{"HeaderDataSource", cCOPR, err}
   370  			}
   371  		default:
   372  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
   373  				return ErrContext{"HeaderDataSource", sl.tag, ErrUnknownTag}
   374  			}
   375  			// possibly store in a Other field
   376  		}
   377  	}
   378  	return nil
   379  }
   380  
   381  // Version is a GEDCOM structure type
   382  type Version struct {
   383  	VersionNumber VersionNumber
   384  	Form          Form
   385  }
   386  
   387  func (s *Version) parse(l *Line, o options) error {
   388  	var VersionNumberSet, FormSet bool
   389  	for _, sl := range l.Sub {
   390  		switch sl.tag {
   391  		case cVERS:
   392  			if VersionNumberSet {
   393  				if !o.allowMoreThanAllowed {
   394  					continue
   395  				}
   396  				return ErrContext{"Version", cVERS, ErrSingleMultiple}
   397  			}
   398  			VersionNumberSet = true
   399  			if err := s.VersionNumber.parse(&sl, o); err != nil {
   400  				return ErrContext{"Version", cVERS, err}
   401  			}
   402  		case cFORM:
   403  			if FormSet {
   404  				if !o.allowMoreThanAllowed {
   405  					continue
   406  				}
   407  				return ErrContext{"Version", cFORM, ErrSingleMultiple}
   408  			}
   409  			FormSet = true
   410  			if err := s.Form.parse(&sl, o); err != nil {
   411  				return ErrContext{"Version", cFORM, err}
   412  			}
   413  		default:
   414  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
   415  				return ErrContext{"Version", sl.tag, ErrUnknownTag}
   416  			}
   417  			// possibly store in a Other field
   418  		}
   419  	}
   420  	if !o.allowMissingRequired {
   421  		if !VersionNumberSet {
   422  			return ErrContext{"Version", "VersionNumber", ErrRequiredMissing}
   423  		}
   424  		if !FormSet {
   425  			return ErrContext{"Version", "Form", ErrRequiredMissing}
   426  		}
   427  	}
   428  	return nil
   429  }
   430  
   431  // CharacterSetStructure is a GEDCOM structure type
   432  type CharacterSetStructure struct {
   433  	CharacterSet  CharacterSet
   434  	VersionNumber VersionNumber
   435  }
   436  
   437  func (s *CharacterSetStructure) parse(l *Line, o options) error {
   438  	if err := s.CharacterSet.parse(l, o); err != nil {
   439  		return ErrContext{"CharacterSetStructure", "line_value", err}
   440  	}
   441  	var VersionNumberSet bool
   442  	for _, sl := range l.Sub {
   443  		switch sl.tag {
   444  		case cVERS:
   445  			if VersionNumberSet {
   446  				if !o.allowMoreThanAllowed {
   447  					continue
   448  				}
   449  				return ErrContext{"CharacterSetStructure", cVERS, ErrSingleMultiple}
   450  			}
   451  			VersionNumberSet = true
   452  			if err := s.VersionNumber.parse(&sl, o); err != nil {
   453  				return ErrContext{"CharacterSetStructure", cVERS, err}
   454  			}
   455  		default:
   456  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
   457  				return ErrContext{"CharacterSetStructure", sl.tag, ErrUnknownTag}
   458  			}
   459  			// possibly store in a Other field
   460  		}
   461  	}
   462  	return nil
   463  }
   464  
   465  // HeaderPlace is a GEDCOM structure type
   466  type HeaderPlace struct {
   467  	PlaceHierarchy PlaceHierarchy
   468  }
   469  
   470  func (s *HeaderPlace) parse(l *Line, o options) error {
   471  	var PlaceHierarchySet bool
   472  	for _, sl := range l.Sub {
   473  		switch sl.tag {
   474  		case cFORM:
   475  			if PlaceHierarchySet {
   476  				if !o.allowMoreThanAllowed {
   477  					continue
   478  				}
   479  				return ErrContext{"HeaderPlace", cFORM, ErrSingleMultiple}
   480  			}
   481  			PlaceHierarchySet = true
   482  			if err := s.PlaceHierarchy.parse(&sl, o); err != nil {
   483  				return ErrContext{"HeaderPlace", cFORM, err}
   484  			}
   485  		default:
   486  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
   487  				return ErrContext{"HeaderPlace", sl.tag, ErrUnknownTag}
   488  			}
   489  			// possibly store in a Other field
   490  		}
   491  	}
   492  	if !o.allowMissingRequired {
   493  		if !PlaceHierarchySet {
   494  			return ErrContext{"HeaderPlace", "PlaceHierarchy", ErrRequiredMissing}
   495  		}
   496  	}
   497  	return nil
   498  }
   499  
   500  // Family is a GEDCOM structure type
   501  type Family struct {
   502  	ID                 Xref
   503  	Annulment          VerifiedFamilyEventDetail
   504  	Census             VerifiedFamilyEventDetail
   505  	Divorce            VerifiedFamilyEventDetail
   506  	DivorceFiled       VerifiedFamilyEventDetail
   507  	Engagement         VerifiedFamilyEventDetail
   508  	Marriage           VerifiedFamilyEventDetail
   509  	MarriageBann       VerifiedFamilyEventDetail
   510  	MarriageContract   VerifiedFamilyEventDetail
   511  	MarriageLicense    VerifiedFamilyEventDetail
   512  	MarriageSettlement VerifiedFamilyEventDetail
   513  	Events             []FamilyEventDetail
   514  	Husband            Xref
   515  	Wife               Xref
   516  	Children           []Xref
   517  	NumChildren        CountOfChildren
   518  	Submitters         []Xref
   519  	LDSSpouseSealing   []LDSSpouseSealing
   520  	Sources            []SourceCitation
   521  	Multimedia         []MultimediaLink
   522  	Notes              []NoteStructure
   523  }
   524  
   525  func (s *Family) parse(l *Line, o options) error {
   526  	if err := s.ID.parse(&Line{line: line{value: l.xrefID}}, o); err != nil {
   527  		return ErrContext{"Family", "xrefID", err}
   528  	}
   529  	var AnnulmentSet, CensusSet, DivorceSet, DivorceFiledSet, EngagementSet, MarriageSet, MarriageBannSet, MarriageContractSet, MarriageLicenseSet, MarriageSettlementSet, HusbandSet, WifeSet, NumChildrenSet bool
   530  	for _, sl := range l.Sub {
   531  		switch sl.tag {
   532  		case cANUL:
   533  			if AnnulmentSet {
   534  				if !o.allowMoreThanAllowed {
   535  					continue
   536  				}
   537  				return ErrContext{"Family", cANUL, ErrSingleMultiple}
   538  			}
   539  			AnnulmentSet = true
   540  			if err := s.Annulment.parse(&sl, o); err != nil {
   541  				return ErrContext{"Family", cANUL, err}
   542  			}
   543  		case cCENS:
   544  			if CensusSet {
   545  				if !o.allowMoreThanAllowed {
   546  					continue
   547  				}
   548  				return ErrContext{"Family", cCENS, ErrSingleMultiple}
   549  			}
   550  			CensusSet = true
   551  			if err := s.Census.parse(&sl, o); err != nil {
   552  				return ErrContext{"Family", cCENS, err}
   553  			}
   554  		case cDIV:
   555  			if DivorceSet {
   556  				if !o.allowMoreThanAllowed {
   557  					continue
   558  				}
   559  				return ErrContext{"Family", cDIV, ErrSingleMultiple}
   560  			}
   561  			DivorceSet = true
   562  			if err := s.Divorce.parse(&sl, o); err != nil {
   563  				return ErrContext{"Family", cDIV, err}
   564  			}
   565  		case cDIVF:
   566  			if DivorceFiledSet {
   567  				if !o.allowMoreThanAllowed {
   568  					continue
   569  				}
   570  				return ErrContext{"Family", cDIVF, ErrSingleMultiple}
   571  			}
   572  			DivorceFiledSet = true
   573  			if err := s.DivorceFiled.parse(&sl, o); err != nil {
   574  				return ErrContext{"Family", cDIVF, err}
   575  			}
   576  		case cENGA:
   577  			if EngagementSet {
   578  				if !o.allowMoreThanAllowed {
   579  					continue
   580  				}
   581  				return ErrContext{"Family", cENGA, ErrSingleMultiple}
   582  			}
   583  			EngagementSet = true
   584  			if err := s.Engagement.parse(&sl, o); err != nil {
   585  				return ErrContext{"Family", cENGA, err}
   586  			}
   587  		case cMARR:
   588  			if MarriageSet {
   589  				if !o.allowMoreThanAllowed {
   590  					continue
   591  				}
   592  				return ErrContext{"Family", cMARR, ErrSingleMultiple}
   593  			}
   594  			MarriageSet = true
   595  			if err := s.Marriage.parse(&sl, o); err != nil {
   596  				return ErrContext{"Family", cMARR, err}
   597  			}
   598  		case cMARB:
   599  			if MarriageBannSet {
   600  				if !o.allowMoreThanAllowed {
   601  					continue
   602  				}
   603  				return ErrContext{"Family", cMARB, ErrSingleMultiple}
   604  			}
   605  			MarriageBannSet = true
   606  			if err := s.MarriageBann.parse(&sl, o); err != nil {
   607  				return ErrContext{"Family", cMARB, err}
   608  			}
   609  		case cMARC:
   610  			if MarriageContractSet {
   611  				if !o.allowMoreThanAllowed {
   612  					continue
   613  				}
   614  				return ErrContext{"Family", cMARC, ErrSingleMultiple}
   615  			}
   616  			MarriageContractSet = true
   617  			if err := s.MarriageContract.parse(&sl, o); err != nil {
   618  				return ErrContext{"Family", cMARC, err}
   619  			}
   620  		case cMARL:
   621  			if MarriageLicenseSet {
   622  				if !o.allowMoreThanAllowed {
   623  					continue
   624  				}
   625  				return ErrContext{"Family", cMARL, ErrSingleMultiple}
   626  			}
   627  			MarriageLicenseSet = true
   628  			if err := s.MarriageLicense.parse(&sl, o); err != nil {
   629  				return ErrContext{"Family", cMARL, err}
   630  			}
   631  		case cMARS:
   632  			if MarriageSettlementSet {
   633  				if !o.allowMoreThanAllowed {
   634  					continue
   635  				}
   636  				return ErrContext{"Family", cMARS, ErrSingleMultiple}
   637  			}
   638  			MarriageSettlementSet = true
   639  			if err := s.MarriageSettlement.parse(&sl, o); err != nil {
   640  				return ErrContext{"Family", cMARS, err}
   641  			}
   642  		case cEVEN:
   643  			var t FamilyEventDetail
   644  			if err := t.parse(&sl, o); err != nil {
   645  				return ErrContext{"Family", cEVEN, err}
   646  			}
   647  			s.Events = append(s.Events, t)
   648  		case cHUSB:
   649  			if HusbandSet {
   650  				if !o.allowMoreThanAllowed {
   651  					continue
   652  				}
   653  				return ErrContext{"Family", cHUSB, ErrSingleMultiple}
   654  			}
   655  			HusbandSet = true
   656  			if err := s.Husband.parse(&sl, o); err != nil {
   657  				return ErrContext{"Family", cHUSB, err}
   658  			}
   659  		case cWIFE:
   660  			if WifeSet {
   661  				if !o.allowMoreThanAllowed {
   662  					continue
   663  				}
   664  				return ErrContext{"Family", cWIFE, ErrSingleMultiple}
   665  			}
   666  			WifeSet = true
   667  			if err := s.Wife.parse(&sl, o); err != nil {
   668  				return ErrContext{"Family", cWIFE, err}
   669  			}
   670  		case cCHIL:
   671  			var t Xref
   672  			if err := t.parse(&sl, o); err != nil {
   673  				return ErrContext{"Family", cCHIL, err}
   674  			}
   675  			s.Children = append(s.Children, t)
   676  		case cNCHI:
   677  			if NumChildrenSet {
   678  				if !o.allowMoreThanAllowed {
   679  					continue
   680  				}
   681  				return ErrContext{"Family", cNCHI, ErrSingleMultiple}
   682  			}
   683  			NumChildrenSet = true
   684  			if err := s.NumChildren.parse(&sl, o); err != nil {
   685  				return ErrContext{"Family", cNCHI, err}
   686  			}
   687  		case cSUBM:
   688  			var t Xref
   689  			if err := t.parse(&sl, o); err != nil {
   690  				return ErrContext{"Family", cSUBM, err}
   691  			}
   692  			s.Submitters = append(s.Submitters, t)
   693  		case cSLGS:
   694  			var t LDSSpouseSealing
   695  			if err := t.parse(&sl, o); err != nil {
   696  				return ErrContext{"Family", cSLGS, err}
   697  			}
   698  			s.LDSSpouseSealing = append(s.LDSSpouseSealing, t)
   699  		case cSOUR:
   700  			var t SourceCitation
   701  			if err := t.parse(&sl, o); err != nil {
   702  				return ErrContext{"Family", cSOUR, err}
   703  			}
   704  			s.Sources = append(s.Sources, t)
   705  		case cOBJE:
   706  			var t MultimediaLink
   707  			if err := t.parse(&sl, o); err != nil {
   708  				return ErrContext{"Family", cOBJE, err}
   709  			}
   710  			s.Multimedia = append(s.Multimedia, t)
   711  		case cNOTE:
   712  			var t NoteStructure
   713  			if err := t.parse(&sl, o); err != nil {
   714  				return ErrContext{"Family", cNOTE, err}
   715  			}
   716  			s.Notes = append(s.Notes, t)
   717  		default:
   718  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
   719  				return ErrContext{"Family", sl.tag, ErrUnknownTag}
   720  			}
   721  			// possibly store in a Other field
   722  		}
   723  	}
   724  	return nil
   725  }
   726  
   727  // VerifiedFamilyEventDetail is a GEDCOM structure type
   728  type VerifiedFamilyEventDetail struct {
   729  	Verified Verified
   730  	FamilyEventDetail
   731  }
   732  
   733  func (s *VerifiedFamilyEventDetail) parse(l *Line, o options) error {
   734  	if err := s.Verified.parse(l, o); err != nil {
   735  		return ErrContext{"VerifiedFamilyEventDetail", "line_value", err}
   736  	}
   737  	return s.FamilyEventDetail.parse(l, o)
   738  }
   739  
   740  // FamilyEventDetail is a GEDCOM structure type
   741  type FamilyEventDetail struct {
   742  	HusbandAge AgeStructure
   743  	WifeAge    AgeStructure
   744  	EventDetail
   745  }
   746  
   747  func (s *FamilyEventDetail) parse(l *Line, o options) error {
   748  	var HusbandAgeSet, WifeAgeSet bool
   749  	for i := 0; i < len(l.Sub); i++ {
   750  		sl := l.Sub[i]
   751  		switch sl.tag {
   752  		case cHUSB:
   753  			if HusbandAgeSet {
   754  				if !o.allowMoreThanAllowed {
   755  					continue
   756  				}
   757  				return ErrContext{"FamilyEventDetail", cHUSB, ErrSingleMultiple}
   758  			}
   759  			HusbandAgeSet = true
   760  			if err := s.HusbandAge.parse(&sl, o); err != nil {
   761  				return ErrContext{"FamilyEventDetail", cHUSB, err}
   762  			}
   763  			l.Sub = append(l.Sub[:i], l.Sub[i+1:]...)
   764  			i--
   765  		case cWIFE:
   766  			if WifeAgeSet {
   767  				if !o.allowMoreThanAllowed {
   768  					continue
   769  				}
   770  				return ErrContext{"FamilyEventDetail", cWIFE, ErrSingleMultiple}
   771  			}
   772  			WifeAgeSet = true
   773  			if err := s.WifeAge.parse(&sl, o); err != nil {
   774  				return ErrContext{"FamilyEventDetail", cWIFE, err}
   775  			}
   776  			l.Sub = append(l.Sub[:i], l.Sub[i+1:]...)
   777  			i--
   778  		}
   779  	}
   780  	return s.EventDetail.parse(l, o)
   781  }
   782  
   783  // AgeStructure is a GEDCOM structure type
   784  type AgeStructure struct {
   785  	Age AgeAtEvent
   786  }
   787  
   788  func (s *AgeStructure) parse(l *Line, o options) error {
   789  	var AgeSet bool
   790  	for _, sl := range l.Sub {
   791  		switch sl.tag {
   792  		case cAGE:
   793  			if AgeSet {
   794  				if !o.allowMoreThanAllowed {
   795  					continue
   796  				}
   797  				return ErrContext{"AgeStructure", cAGE, ErrSingleMultiple}
   798  			}
   799  			AgeSet = true
   800  			if err := s.Age.parse(&sl, o); err != nil {
   801  				return ErrContext{"AgeStructure", cAGE, err}
   802  			}
   803  		default:
   804  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
   805  				return ErrContext{"AgeStructure", sl.tag, ErrUnknownTag}
   806  			}
   807  			// possibly store in a Other field
   808  		}
   809  	}
   810  	if !o.allowMissingRequired {
   811  		if !AgeSet {
   812  			return ErrContext{"AgeStructure", "Age", ErrRequiredMissing}
   813  		}
   814  	}
   815  	return nil
   816  }
   817  
   818  // Individual is a GEDCOM structure type
   819  type Individual struct {
   820  	ID                    Xref
   821  	RestrictionNotice     RestrictionNotice
   822  	PersonalNameStructure []PersonalNameStructure
   823  	Gender                SexValue
   824  	Birth                 VerifiedIndividualFamEventDetail
   825  	Christening           VerifiedIndividualFamEventDetail
   826  	Death                 VerifiedEventDetail
   827  	Buried                VerifiedEventDetail
   828  	Cremation             VerifiedEventDetail
   829  	Adoption              AdoptionEvent
   830  	Maptism               VerifiedEventDetail
   831  	BarMitzvah            VerifiedEventDetail
   832  	BasMitzvah            VerifiedEventDetail
   833  	Blessing              VerifiedEventDetail
   834  	AdultChristening      VerifiedEventDetail
   835  	Confirmation          VerifiedEventDetail
   836  	FirstCommunion        VerifiedEventDetail
   837  	Ordination            VerifiedEventDetail
   838  	Naturalization        VerifiedEventDetail
   839  	Emigrated             VerifiedEventDetail
   840  	Immigrated            VerifiedEventDetail
   841  	Census                VerifiedEventDetail
   842  	Probate               VerifiedEventDetail
   843  	Will                  VerifiedEventDetail
   844  	Graduated             VerifiedEventDetail
   845  	Retired               VerifiedEventDetail
   846  	Events                []IndividualEventDetail
   847  	Caste                 []CasteEvent
   848  	Description           []DescriptionEvent
   849  	ScholasticAchievement []ScholasticEvent
   850  	NationalID            []NationalIDEvent
   851  	NationalTribalOrigin  []NationalOriginEvent
   852  	CountOfChildren       []ChildrenEvent
   853  	CountOfMarriages      []MarriagesEvent
   854  	Occupation            []OccupationEvent
   855  	Possessions           []PossessionEvent
   856  	ReligiousAffiliation  []ReligiousEvent
   857  	Residences            []ResidenceEvent
   858  	SocialSecurity        []SSNEvent
   859  	NobilityTypeTitle     []NobilityEvent
   860  	ChildOf               []ChildToFamilyLink
   861  	SpouseOf              []SpouseToFamilyLink
   862  	Submitters            []Xref
   863  	Associations          []AssociationStructure
   864  	Aliases               []Xref
   865  	AncestorInterest      []Xref
   866  	DescendentInterest    []Xref
   867  	Sources               []SourceCitation
   868  	Multimedia            []MultimediaLink
   869  	Notes                 []NoteStructure
   870  	PermanentRecord       PermanentRecordFileNumber
   871  	AncestralFileNumber   AncestralFileNumber
   872  	UserReferences        []UserReferenceStructure
   873  	AutomatedRecordID     AutomatedRecordID
   874  	ChangeDate            ChangeDateStructure
   875  }
   876  
   877  func (s *Individual) parse(l *Line, o options) error {
   878  	if err := s.ID.parse(&Line{line: line{value: l.xrefID}}, o); err != nil {
   879  		return ErrContext{"Individual", "xrefID", err}
   880  	}
   881  	var RestrictionNoticeSet, GenderSet, BirthSet, ChristeningSet, DeathSet, BuriedSet, CremationSet, AdoptionSet, MaptismSet, BarMitzvahSet, BasMitzvahSet, BlessingSet, AdultChristeningSet, ConfirmationSet, FirstCommunionSet, OrdinationSet, NaturalizationSet, EmigratedSet, ImmigratedSet, CensusSet, ProbateSet, WillSet, GraduatedSet, RetiredSet, PermanentRecordSet, AncestralFileNumberSet, AutomatedRecordIDSet, ChangeDateSet bool
   882  	for _, sl := range l.Sub {
   883  		switch sl.tag {
   884  		case cRESN:
   885  			if RestrictionNoticeSet {
   886  				if !o.allowMoreThanAllowed {
   887  					continue
   888  				}
   889  				return ErrContext{"Individual", cRESN, ErrSingleMultiple}
   890  			}
   891  			RestrictionNoticeSet = true
   892  			if err := s.RestrictionNotice.parse(&sl, o); err != nil {
   893  				return ErrContext{"Individual", cRESN, err}
   894  			}
   895  		case cNAME:
   896  			var t PersonalNameStructure
   897  			if err := t.parse(&sl, o); err != nil {
   898  				return ErrContext{"Individual", cNAME, err}
   899  			}
   900  			s.PersonalNameStructure = append(s.PersonalNameStructure, t)
   901  		case cSEX:
   902  			if GenderSet {
   903  				if !o.allowMoreThanAllowed {
   904  					continue
   905  				}
   906  				return ErrContext{"Individual", cSEX, ErrSingleMultiple}
   907  			}
   908  			GenderSet = true
   909  			if err := s.Gender.parse(&sl, o); err != nil {
   910  				return ErrContext{"Individual", cSEX, err}
   911  			}
   912  		case cBIRT:
   913  			if BirthSet {
   914  				if !o.allowMoreThanAllowed {
   915  					continue
   916  				}
   917  				return ErrContext{"Individual", cBIRT, ErrSingleMultiple}
   918  			}
   919  			BirthSet = true
   920  			if err := s.Birth.parse(&sl, o); err != nil {
   921  				return ErrContext{"Individual", cBIRT, err}
   922  			}
   923  		case cCHR:
   924  			if ChristeningSet {
   925  				if !o.allowMoreThanAllowed {
   926  					continue
   927  				}
   928  				return ErrContext{"Individual", cCHR, ErrSingleMultiple}
   929  			}
   930  			ChristeningSet = true
   931  			if err := s.Christening.parse(&sl, o); err != nil {
   932  				return ErrContext{"Individual", cCHR, err}
   933  			}
   934  		case cDEAT:
   935  			if DeathSet {
   936  				if !o.allowMoreThanAllowed {
   937  					continue
   938  				}
   939  				return ErrContext{"Individual", cDEAT, ErrSingleMultiple}
   940  			}
   941  			DeathSet = true
   942  			if err := s.Death.parse(&sl, o); err != nil {
   943  				return ErrContext{"Individual", cDEAT, err}
   944  			}
   945  		case cBURI:
   946  			if BuriedSet {
   947  				if !o.allowMoreThanAllowed {
   948  					continue
   949  				}
   950  				return ErrContext{"Individual", cBURI, ErrSingleMultiple}
   951  			}
   952  			BuriedSet = true
   953  			if err := s.Buried.parse(&sl, o); err != nil {
   954  				return ErrContext{"Individual", cBURI, err}
   955  			}
   956  		case cCREM:
   957  			if CremationSet {
   958  				if !o.allowMoreThanAllowed {
   959  					continue
   960  				}
   961  				return ErrContext{"Individual", cCREM, ErrSingleMultiple}
   962  			}
   963  			CremationSet = true
   964  			if err := s.Cremation.parse(&sl, o); err != nil {
   965  				return ErrContext{"Individual", cCREM, err}
   966  			}
   967  		case cADOP:
   968  			if AdoptionSet {
   969  				if !o.allowMoreThanAllowed {
   970  					continue
   971  				}
   972  				return ErrContext{"Individual", cADOP, ErrSingleMultiple}
   973  			}
   974  			AdoptionSet = true
   975  			if err := s.Adoption.parse(&sl, o); err != nil {
   976  				return ErrContext{"Individual", cADOP, err}
   977  			}
   978  		case cBAPM:
   979  			if MaptismSet {
   980  				if !o.allowMoreThanAllowed {
   981  					continue
   982  				}
   983  				return ErrContext{"Individual", cBAPM, ErrSingleMultiple}
   984  			}
   985  			MaptismSet = true
   986  			if err := s.Maptism.parse(&sl, o); err != nil {
   987  				return ErrContext{"Individual", cBAPM, err}
   988  			}
   989  		case cBARM:
   990  			if BarMitzvahSet {
   991  				if !o.allowMoreThanAllowed {
   992  					continue
   993  				}
   994  				return ErrContext{"Individual", cBARM, ErrSingleMultiple}
   995  			}
   996  			BarMitzvahSet = true
   997  			if err := s.BarMitzvah.parse(&sl, o); err != nil {
   998  				return ErrContext{"Individual", cBARM, err}
   999  			}
  1000  		case cBASM:
  1001  			if BasMitzvahSet {
  1002  				if !o.allowMoreThanAllowed {
  1003  					continue
  1004  				}
  1005  				return ErrContext{"Individual", cBASM, ErrSingleMultiple}
  1006  			}
  1007  			BasMitzvahSet = true
  1008  			if err := s.BasMitzvah.parse(&sl, o); err != nil {
  1009  				return ErrContext{"Individual", cBASM, err}
  1010  			}
  1011  		case cBLES:
  1012  			if BlessingSet {
  1013  				if !o.allowMoreThanAllowed {
  1014  					continue
  1015  				}
  1016  				return ErrContext{"Individual", cBLES, ErrSingleMultiple}
  1017  			}
  1018  			BlessingSet = true
  1019  			if err := s.Blessing.parse(&sl, o); err != nil {
  1020  				return ErrContext{"Individual", cBLES, err}
  1021  			}
  1022  		case cCHRA:
  1023  			if AdultChristeningSet {
  1024  				if !o.allowMoreThanAllowed {
  1025  					continue
  1026  				}
  1027  				return ErrContext{"Individual", cCHRA, ErrSingleMultiple}
  1028  			}
  1029  			AdultChristeningSet = true
  1030  			if err := s.AdultChristening.parse(&sl, o); err != nil {
  1031  				return ErrContext{"Individual", cCHRA, err}
  1032  			}
  1033  		case cCONF:
  1034  			if ConfirmationSet {
  1035  				if !o.allowMoreThanAllowed {
  1036  					continue
  1037  				}
  1038  				return ErrContext{"Individual", cCONF, ErrSingleMultiple}
  1039  			}
  1040  			ConfirmationSet = true
  1041  			if err := s.Confirmation.parse(&sl, o); err != nil {
  1042  				return ErrContext{"Individual", cCONF, err}
  1043  			}
  1044  		case cFCOM:
  1045  			if FirstCommunionSet {
  1046  				if !o.allowMoreThanAllowed {
  1047  					continue
  1048  				}
  1049  				return ErrContext{"Individual", cFCOM, ErrSingleMultiple}
  1050  			}
  1051  			FirstCommunionSet = true
  1052  			if err := s.FirstCommunion.parse(&sl, o); err != nil {
  1053  				return ErrContext{"Individual", cFCOM, err}
  1054  			}
  1055  		case cORDN:
  1056  			if OrdinationSet {
  1057  				if !o.allowMoreThanAllowed {
  1058  					continue
  1059  				}
  1060  				return ErrContext{"Individual", cORDN, ErrSingleMultiple}
  1061  			}
  1062  			OrdinationSet = true
  1063  			if err := s.Ordination.parse(&sl, o); err != nil {
  1064  				return ErrContext{"Individual", cORDN, err}
  1065  			}
  1066  		case cNATU:
  1067  			if NaturalizationSet {
  1068  				if !o.allowMoreThanAllowed {
  1069  					continue
  1070  				}
  1071  				return ErrContext{"Individual", cNATU, ErrSingleMultiple}
  1072  			}
  1073  			NaturalizationSet = true
  1074  			if err := s.Naturalization.parse(&sl, o); err != nil {
  1075  				return ErrContext{"Individual", cNATU, err}
  1076  			}
  1077  		case cEMIG:
  1078  			if EmigratedSet {
  1079  				if !o.allowMoreThanAllowed {
  1080  					continue
  1081  				}
  1082  				return ErrContext{"Individual", cEMIG, ErrSingleMultiple}
  1083  			}
  1084  			EmigratedSet = true
  1085  			if err := s.Emigrated.parse(&sl, o); err != nil {
  1086  				return ErrContext{"Individual", cEMIG, err}
  1087  			}
  1088  		case cIMMI:
  1089  			if ImmigratedSet {
  1090  				if !o.allowMoreThanAllowed {
  1091  					continue
  1092  				}
  1093  				return ErrContext{"Individual", cIMMI, ErrSingleMultiple}
  1094  			}
  1095  			ImmigratedSet = true
  1096  			if err := s.Immigrated.parse(&sl, o); err != nil {
  1097  				return ErrContext{"Individual", cIMMI, err}
  1098  			}
  1099  		case cCENS:
  1100  			if CensusSet {
  1101  				if !o.allowMoreThanAllowed {
  1102  					continue
  1103  				}
  1104  				return ErrContext{"Individual", cCENS, ErrSingleMultiple}
  1105  			}
  1106  			CensusSet = true
  1107  			if err := s.Census.parse(&sl, o); err != nil {
  1108  				return ErrContext{"Individual", cCENS, err}
  1109  			}
  1110  		case cPROB:
  1111  			if ProbateSet {
  1112  				if !o.allowMoreThanAllowed {
  1113  					continue
  1114  				}
  1115  				return ErrContext{"Individual", cPROB, ErrSingleMultiple}
  1116  			}
  1117  			ProbateSet = true
  1118  			if err := s.Probate.parse(&sl, o); err != nil {
  1119  				return ErrContext{"Individual", cPROB, err}
  1120  			}
  1121  		case cWILL:
  1122  			if WillSet {
  1123  				if !o.allowMoreThanAllowed {
  1124  					continue
  1125  				}
  1126  				return ErrContext{"Individual", cWILL, ErrSingleMultiple}
  1127  			}
  1128  			WillSet = true
  1129  			if err := s.Will.parse(&sl, o); err != nil {
  1130  				return ErrContext{"Individual", cWILL, err}
  1131  			}
  1132  		case cGRAD:
  1133  			if GraduatedSet {
  1134  				if !o.allowMoreThanAllowed {
  1135  					continue
  1136  				}
  1137  				return ErrContext{"Individual", cGRAD, ErrSingleMultiple}
  1138  			}
  1139  			GraduatedSet = true
  1140  			if err := s.Graduated.parse(&sl, o); err != nil {
  1141  				return ErrContext{"Individual", cGRAD, err}
  1142  			}
  1143  		case cRETI:
  1144  			if RetiredSet {
  1145  				if !o.allowMoreThanAllowed {
  1146  					continue
  1147  				}
  1148  				return ErrContext{"Individual", cRETI, ErrSingleMultiple}
  1149  			}
  1150  			RetiredSet = true
  1151  			if err := s.Retired.parse(&sl, o); err != nil {
  1152  				return ErrContext{"Individual", cRETI, err}
  1153  			}
  1154  		case cEVEN:
  1155  			var t IndividualEventDetail
  1156  			if err := t.parse(&sl, o); err != nil {
  1157  				return ErrContext{"Individual", cEVEN, err}
  1158  			}
  1159  			s.Events = append(s.Events, t)
  1160  		case cCAST:
  1161  			var t CasteEvent
  1162  			if err := t.parse(&sl, o); err != nil {
  1163  				return ErrContext{"Individual", cCAST, err}
  1164  			}
  1165  			s.Caste = append(s.Caste, t)
  1166  		case cDSCR:
  1167  			var t DescriptionEvent
  1168  			if err := t.parse(&sl, o); err != nil {
  1169  				return ErrContext{"Individual", cDSCR, err}
  1170  			}
  1171  			s.Description = append(s.Description, t)
  1172  		case cEDUC:
  1173  			var t ScholasticEvent
  1174  			if err := t.parse(&sl, o); err != nil {
  1175  				return ErrContext{"Individual", cEDUC, err}
  1176  			}
  1177  			s.ScholasticAchievement = append(s.ScholasticAchievement, t)
  1178  		case cIDNO:
  1179  			var t NationalIDEvent
  1180  			if err := t.parse(&sl, o); err != nil {
  1181  				return ErrContext{"Individual", cIDNO, err}
  1182  			}
  1183  			s.NationalID = append(s.NationalID, t)
  1184  		case cNATI:
  1185  			var t NationalOriginEvent
  1186  			if err := t.parse(&sl, o); err != nil {
  1187  				return ErrContext{"Individual", cNATI, err}
  1188  			}
  1189  			s.NationalTribalOrigin = append(s.NationalTribalOrigin, t)
  1190  		case cNCHI:
  1191  			var t ChildrenEvent
  1192  			if err := t.parse(&sl, o); err != nil {
  1193  				return ErrContext{"Individual", cNCHI, err}
  1194  			}
  1195  			s.CountOfChildren = append(s.CountOfChildren, t)
  1196  		case cNMR:
  1197  			var t MarriagesEvent
  1198  			if err := t.parse(&sl, o); err != nil {
  1199  				return ErrContext{"Individual", cNMR, err}
  1200  			}
  1201  			s.CountOfMarriages = append(s.CountOfMarriages, t)
  1202  		case cOCCU:
  1203  			var t OccupationEvent
  1204  			if err := t.parse(&sl, o); err != nil {
  1205  				return ErrContext{"Individual", cOCCU, err}
  1206  			}
  1207  			s.Occupation = append(s.Occupation, t)
  1208  		case cPROP:
  1209  			var t PossessionEvent
  1210  			if err := t.parse(&sl, o); err != nil {
  1211  				return ErrContext{"Individual", cPROP, err}
  1212  			}
  1213  			s.Possessions = append(s.Possessions, t)
  1214  		case cRELI:
  1215  			var t ReligiousEvent
  1216  			if err := t.parse(&sl, o); err != nil {
  1217  				return ErrContext{"Individual", cRELI, err}
  1218  			}
  1219  			s.ReligiousAffiliation = append(s.ReligiousAffiliation, t)
  1220  		case cRESI:
  1221  			var t ResidenceEvent
  1222  			if err := t.parse(&sl, o); err != nil {
  1223  				return ErrContext{"Individual", cRESI, err}
  1224  			}
  1225  			s.Residences = append(s.Residences, t)
  1226  		case cSSN:
  1227  			var t SSNEvent
  1228  			if err := t.parse(&sl, o); err != nil {
  1229  				return ErrContext{"Individual", cSSN, err}
  1230  			}
  1231  			s.SocialSecurity = append(s.SocialSecurity, t)
  1232  		case cTITL:
  1233  			var t NobilityEvent
  1234  			if err := t.parse(&sl, o); err != nil {
  1235  				return ErrContext{"Individual", cTITL, err}
  1236  			}
  1237  			s.NobilityTypeTitle = append(s.NobilityTypeTitle, t)
  1238  		case cFAMC:
  1239  			var t ChildToFamilyLink
  1240  			if err := t.parse(&sl, o); err != nil {
  1241  				return ErrContext{"Individual", cFAMC, err}
  1242  			}
  1243  			s.ChildOf = append(s.ChildOf, t)
  1244  		case cFAMS:
  1245  			var t SpouseToFamilyLink
  1246  			if err := t.parse(&sl, o); err != nil {
  1247  				return ErrContext{"Individual", cFAMS, err}
  1248  			}
  1249  			s.SpouseOf = append(s.SpouseOf, t)
  1250  		case cSUBM:
  1251  			var t Xref
  1252  			if err := t.parse(&sl, o); err != nil {
  1253  				return ErrContext{"Individual", cSUBM, err}
  1254  			}
  1255  			s.Submitters = append(s.Submitters, t)
  1256  		case cASSO:
  1257  			var t AssociationStructure
  1258  			if err := t.parse(&sl, o); err != nil {
  1259  				return ErrContext{"Individual", cASSO, err}
  1260  			}
  1261  			s.Associations = append(s.Associations, t)
  1262  		case cALIA:
  1263  			var t Xref
  1264  			if err := t.parse(&sl, o); err != nil {
  1265  				return ErrContext{"Individual", cALIA, err}
  1266  			}
  1267  			s.Aliases = append(s.Aliases, t)
  1268  		case cANCI:
  1269  			var t Xref
  1270  			if err := t.parse(&sl, o); err != nil {
  1271  				return ErrContext{"Individual", cANCI, err}
  1272  			}
  1273  			s.AncestorInterest = append(s.AncestorInterest, t)
  1274  		case cDESI:
  1275  			var t Xref
  1276  			if err := t.parse(&sl, o); err != nil {
  1277  				return ErrContext{"Individual", cDESI, err}
  1278  			}
  1279  			s.DescendentInterest = append(s.DescendentInterest, t)
  1280  		case cSOUR:
  1281  			var t SourceCitation
  1282  			if err := t.parse(&sl, o); err != nil {
  1283  				return ErrContext{"Individual", cSOUR, err}
  1284  			}
  1285  			s.Sources = append(s.Sources, t)
  1286  		case cOBJE:
  1287  			var t MultimediaLink
  1288  			if err := t.parse(&sl, o); err != nil {
  1289  				return ErrContext{"Individual", cOBJE, err}
  1290  			}
  1291  			s.Multimedia = append(s.Multimedia, t)
  1292  		case cNOTE:
  1293  			var t NoteStructure
  1294  			if err := t.parse(&sl, o); err != nil {
  1295  				return ErrContext{"Individual", cNOTE, err}
  1296  			}
  1297  			s.Notes = append(s.Notes, t)
  1298  		case cRFN:
  1299  			if PermanentRecordSet {
  1300  				if !o.allowMoreThanAllowed {
  1301  					continue
  1302  				}
  1303  				return ErrContext{"Individual", cRFN, ErrSingleMultiple}
  1304  			}
  1305  			PermanentRecordSet = true
  1306  			if err := s.PermanentRecord.parse(&sl, o); err != nil {
  1307  				return ErrContext{"Individual", cRFN, err}
  1308  			}
  1309  		case cAFN:
  1310  			if AncestralFileNumberSet {
  1311  				if !o.allowMoreThanAllowed {
  1312  					continue
  1313  				}
  1314  				return ErrContext{"Individual", cAFN, ErrSingleMultiple}
  1315  			}
  1316  			AncestralFileNumberSet = true
  1317  			if err := s.AncestralFileNumber.parse(&sl, o); err != nil {
  1318  				return ErrContext{"Individual", cAFN, err}
  1319  			}
  1320  		case cREFN:
  1321  			var t UserReferenceStructure
  1322  			if err := t.parse(&sl, o); err != nil {
  1323  				return ErrContext{"Individual", cREFN, err}
  1324  			}
  1325  			s.UserReferences = append(s.UserReferences, t)
  1326  		case cRIN:
  1327  			if AutomatedRecordIDSet {
  1328  				if !o.allowMoreThanAllowed {
  1329  					continue
  1330  				}
  1331  				return ErrContext{"Individual", cRIN, ErrSingleMultiple}
  1332  			}
  1333  			AutomatedRecordIDSet = true
  1334  			if err := s.AutomatedRecordID.parse(&sl, o); err != nil {
  1335  				return ErrContext{"Individual", cRIN, err}
  1336  			}
  1337  		case cCHAN:
  1338  			if ChangeDateSet {
  1339  				if !o.allowMoreThanAllowed {
  1340  					continue
  1341  				}
  1342  				return ErrContext{"Individual", cCHAN, ErrSingleMultiple}
  1343  			}
  1344  			ChangeDateSet = true
  1345  			if err := s.ChangeDate.parse(&sl, o); err != nil {
  1346  				return ErrContext{"Individual", cCHAN, err}
  1347  			}
  1348  		default:
  1349  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  1350  				return ErrContext{"Individual", sl.tag, ErrUnknownTag}
  1351  			}
  1352  			// possibly store in a Other field
  1353  		}
  1354  	}
  1355  	return nil
  1356  }
  1357  
  1358  // VerifiedIndividualFamEventDetail is a GEDCOM structure type
  1359  type VerifiedIndividualFamEventDetail struct {
  1360  	Famc Xref
  1361  	VerifiedEventDetail
  1362  }
  1363  
  1364  func (s *VerifiedIndividualFamEventDetail) parse(l *Line, o options) error {
  1365  	var FamcSet bool
  1366  	for i := 0; i < len(l.Sub); i++ {
  1367  		sl := l.Sub[i]
  1368  		switch sl.tag {
  1369  		case cFAMC:
  1370  			if FamcSet {
  1371  				if !o.allowMoreThanAllowed {
  1372  					continue
  1373  				}
  1374  				return ErrContext{"VerifiedIndividualFamEventDetail", cFAMC, ErrSingleMultiple}
  1375  			}
  1376  			FamcSet = true
  1377  			if err := s.Famc.parse(&sl, o); err != nil {
  1378  				return ErrContext{"VerifiedIndividualFamEventDetail", cFAMC, err}
  1379  			}
  1380  			l.Sub = append(l.Sub[:i], l.Sub[i+1:]...)
  1381  			i--
  1382  		}
  1383  	}
  1384  	return s.VerifiedEventDetail.parse(l, o)
  1385  }
  1386  
  1387  // VerifiedEventDetail is a GEDCOM structure type
  1388  type VerifiedEventDetail struct {
  1389  	Verified Verified
  1390  	EventDetail
  1391  }
  1392  
  1393  func (s *VerifiedEventDetail) parse(l *Line, o options) error {
  1394  	if err := s.Verified.parse(l, o); err != nil {
  1395  		return ErrContext{"VerifiedEventDetail", "line_value", err}
  1396  	}
  1397  	return s.EventDetail.parse(l, o)
  1398  }
  1399  
  1400  // IndividualEventDetail is a GEDCOM structure type
  1401  type IndividualEventDetail struct {
  1402  	EventDetail
  1403  }
  1404  
  1405  func (s *IndividualEventDetail) parse(l *Line, o options) error {
  1406  	return s.EventDetail.parse(l, o)
  1407  }
  1408  
  1409  // AdoptionEvent is a GEDCOM structure type
  1410  type AdoptionEvent struct {
  1411  	Family AdoptionReference
  1412  	EventDetail
  1413  }
  1414  
  1415  func (s *AdoptionEvent) parse(l *Line, o options) error {
  1416  	var FamilySet bool
  1417  	for i := 0; i < len(l.Sub); i++ {
  1418  		sl := l.Sub[i]
  1419  		switch sl.tag {
  1420  		case cFAMC:
  1421  			if FamilySet {
  1422  				if !o.allowMoreThanAllowed {
  1423  					continue
  1424  				}
  1425  				return ErrContext{"AdoptionEvent", cFAMC, ErrSingleMultiple}
  1426  			}
  1427  			FamilySet = true
  1428  			if err := s.Family.parse(&sl, o); err != nil {
  1429  				return ErrContext{"AdoptionEvent", cFAMC, err}
  1430  			}
  1431  			l.Sub = append(l.Sub[:i], l.Sub[i+1:]...)
  1432  			i--
  1433  		}
  1434  	}
  1435  	return s.EventDetail.parse(l, o)
  1436  }
  1437  
  1438  // AdoptionReference is a GEDCOM structure type
  1439  type AdoptionReference struct {
  1440  	ID        Xref
  1441  	AdoptedBy AdoptedBy
  1442  }
  1443  
  1444  func (s *AdoptionReference) parse(l *Line, o options) error {
  1445  	if err := s.ID.parse(&Line{line: line{value: l.xrefID}}, o); err != nil {
  1446  		return ErrContext{"AdoptionReference", "xrefID", err}
  1447  	}
  1448  	var AdoptedBySet bool
  1449  	for _, sl := range l.Sub {
  1450  		switch sl.tag {
  1451  		case cADOP:
  1452  			if AdoptedBySet {
  1453  				if !o.allowMoreThanAllowed {
  1454  					continue
  1455  				}
  1456  				return ErrContext{"AdoptionReference", cADOP, ErrSingleMultiple}
  1457  			}
  1458  			AdoptedBySet = true
  1459  			if err := s.AdoptedBy.parse(&sl, o); err != nil {
  1460  				return ErrContext{"AdoptionReference", cADOP, err}
  1461  			}
  1462  		default:
  1463  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  1464  				return ErrContext{"AdoptionReference", sl.tag, ErrUnknownTag}
  1465  			}
  1466  			// possibly store in a Other field
  1467  		}
  1468  	}
  1469  	return nil
  1470  }
  1471  
  1472  // CasteEvent is a GEDCOM structure type
  1473  type CasteEvent struct {
  1474  	CasteName CasteName
  1475  	EventDetail
  1476  }
  1477  
  1478  func (s *CasteEvent) parse(l *Line, o options) error {
  1479  	if err := s.CasteName.parse(l, o); err != nil {
  1480  		return ErrContext{"CasteEvent", "line_value", err}
  1481  	}
  1482  	return s.EventDetail.parse(l, o)
  1483  }
  1484  
  1485  // DescriptionEvent is a GEDCOM structure type
  1486  type DescriptionEvent struct {
  1487  	PhysicalDescription PhysicalDescription
  1488  	EventDetail
  1489  }
  1490  
  1491  func (s *DescriptionEvent) parse(l *Line, o options) error {
  1492  	if err := s.PhysicalDescription.parse(l, o); err != nil {
  1493  		return ErrContext{"DescriptionEvent", "line_value", err}
  1494  	}
  1495  	return s.EventDetail.parse(l, o)
  1496  }
  1497  
  1498  // ScholasticEvent is a GEDCOM structure type
  1499  type ScholasticEvent struct {
  1500  	ScholasticAchievement ScholasticAchievement
  1501  	EventDetail
  1502  }
  1503  
  1504  func (s *ScholasticEvent) parse(l *Line, o options) error {
  1505  	if err := s.ScholasticAchievement.parse(l, o); err != nil {
  1506  		return ErrContext{"ScholasticEvent", "line_value", err}
  1507  	}
  1508  	return s.EventDetail.parse(l, o)
  1509  }
  1510  
  1511  // NationalIDEvent is a GEDCOM structure type
  1512  type NationalIDEvent struct {
  1513  	NationalIDNumber NationalIDNumber
  1514  	EventDetail
  1515  }
  1516  
  1517  func (s *NationalIDEvent) parse(l *Line, o options) error {
  1518  	if err := s.NationalIDNumber.parse(l, o); err != nil {
  1519  		return ErrContext{"NationalIDEvent", "line_value", err}
  1520  	}
  1521  	return s.EventDetail.parse(l, o)
  1522  }
  1523  
  1524  // NationalOriginEvent is a GEDCOM structure type
  1525  type NationalOriginEvent struct {
  1526  	NationalOrTribalOrigin NationalOrTribalOrigin
  1527  	EventDetail
  1528  }
  1529  
  1530  func (s *NationalOriginEvent) parse(l *Line, o options) error {
  1531  	if err := s.NationalOrTribalOrigin.parse(l, o); err != nil {
  1532  		return ErrContext{"NationalOriginEvent", "line_value", err}
  1533  	}
  1534  	return s.EventDetail.parse(l, o)
  1535  }
  1536  
  1537  // ChildrenEvent is a GEDCOM structure type
  1538  type ChildrenEvent struct {
  1539  	CountOfChildren CountOfChildren
  1540  	EventDetail
  1541  }
  1542  
  1543  func (s *ChildrenEvent) parse(l *Line, o options) error {
  1544  	if err := s.CountOfChildren.parse(l, o); err != nil {
  1545  		return ErrContext{"ChildrenEvent", "line_value", err}
  1546  	}
  1547  	return s.EventDetail.parse(l, o)
  1548  }
  1549  
  1550  // MarriagesEvent is a GEDCOM structure type
  1551  type MarriagesEvent struct {
  1552  	CountOfMarriages CountOfMarriages
  1553  	EventDetail
  1554  }
  1555  
  1556  func (s *MarriagesEvent) parse(l *Line, o options) error {
  1557  	if err := s.CountOfMarriages.parse(l, o); err != nil {
  1558  		return ErrContext{"MarriagesEvent", "line_value", err}
  1559  	}
  1560  	return s.EventDetail.parse(l, o)
  1561  }
  1562  
  1563  // OccupationEvent is a GEDCOM structure type
  1564  type OccupationEvent struct {
  1565  	Occupation Occupation
  1566  	EventDetail
  1567  }
  1568  
  1569  func (s *OccupationEvent) parse(l *Line, o options) error {
  1570  	if err := s.Occupation.parse(l, o); err != nil {
  1571  		return ErrContext{"OccupationEvent", "line_value", err}
  1572  	}
  1573  	return s.EventDetail.parse(l, o)
  1574  }
  1575  
  1576  // PossessionEvent is a GEDCOM structure type
  1577  type PossessionEvent struct {
  1578  	Possessions Possessions
  1579  	EventDetail
  1580  }
  1581  
  1582  func (s *PossessionEvent) parse(l *Line, o options) error {
  1583  	if err := s.Possessions.parse(l, o); err != nil {
  1584  		return ErrContext{"PossessionEvent", "line_value", err}
  1585  	}
  1586  	return s.EventDetail.parse(l, o)
  1587  }
  1588  
  1589  // ReligiousEvent is a GEDCOM structure type
  1590  type ReligiousEvent struct {
  1591  	ReligiousAffiliation ReligiousAffiliation
  1592  	EventDetail
  1593  }
  1594  
  1595  func (s *ReligiousEvent) parse(l *Line, o options) error {
  1596  	if err := s.ReligiousAffiliation.parse(l, o); err != nil {
  1597  		return ErrContext{"ReligiousEvent", "line_value", err}
  1598  	}
  1599  	return s.EventDetail.parse(l, o)
  1600  }
  1601  
  1602  // ResidenceEvent is a GEDCOM structure type
  1603  type ResidenceEvent struct {
  1604  	EventDetail
  1605  }
  1606  
  1607  func (s *ResidenceEvent) parse(l *Line, o options) error {
  1608  	return s.EventDetail.parse(l, o)
  1609  }
  1610  
  1611  // SSNEvent is a GEDCOM structure type
  1612  type SSNEvent struct {
  1613  	SocialSecurityNumber SocialSecurityNumber
  1614  	EventDetail
  1615  }
  1616  
  1617  func (s *SSNEvent) parse(l *Line, o options) error {
  1618  	if err := s.SocialSecurityNumber.parse(l, o); err != nil {
  1619  		return ErrContext{"SSNEvent", "line_value", err}
  1620  	}
  1621  	return s.EventDetail.parse(l, o)
  1622  }
  1623  
  1624  // NobilityEvent is a GEDCOM structure type
  1625  type NobilityEvent struct {
  1626  	NobilityTypeTitle NobilityTypeTitle
  1627  	EventDetail
  1628  }
  1629  
  1630  func (s *NobilityEvent) parse(l *Line, o options) error {
  1631  	if err := s.NobilityTypeTitle.parse(l, o); err != nil {
  1632  		return ErrContext{"NobilityEvent", "line_value", err}
  1633  	}
  1634  	return s.EventDetail.parse(l, o)
  1635  }
  1636  
  1637  // UserReferenceStructure is a GEDCOM structure type
  1638  type UserReferenceStructure struct {
  1639  	UserReferenceNumber UserReferenceNumber
  1640  	Type                UserReferenceType
  1641  }
  1642  
  1643  func (s *UserReferenceStructure) parse(l *Line, o options) error {
  1644  	if err := s.UserReferenceNumber.parse(l, o); err != nil {
  1645  		return ErrContext{"UserReferenceStructure", "line_value", err}
  1646  	}
  1647  	var TypeSet bool
  1648  	for _, sl := range l.Sub {
  1649  		switch sl.tag {
  1650  		case cTYPE:
  1651  			if TypeSet {
  1652  				if !o.allowMoreThanAllowed {
  1653  					continue
  1654  				}
  1655  				return ErrContext{"UserReferenceStructure", cTYPE, ErrSingleMultiple}
  1656  			}
  1657  			TypeSet = true
  1658  			if err := s.Type.parse(&sl, o); err != nil {
  1659  				return ErrContext{"UserReferenceStructure", cTYPE, err}
  1660  			}
  1661  		default:
  1662  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  1663  				return ErrContext{"UserReferenceStructure", sl.tag, ErrUnknownTag}
  1664  			}
  1665  			// possibly store in a Other field
  1666  		}
  1667  	}
  1668  	return nil
  1669  }
  1670  
  1671  // MultimediaRecord is a GEDCOM structure type
  1672  type MultimediaRecord struct {
  1673  	ID                Xref
  1674  	Format            MultimediaFormat
  1675  	Title             DescriptiveTitle
  1676  	Notes             []NoteStructure
  1677  	Blob              EncodedMultimediaLine
  1678  	ContinuedObject   Xref
  1679  	UserReferences    []UserReferenceStructure
  1680  	AutomatedRecordID AutomatedRecordID
  1681  	ChangeDate        ChangeDateStructure
  1682  }
  1683  
  1684  func (s *MultimediaRecord) parse(l *Line, o options) error {
  1685  	if err := s.ID.parse(&Line{line: line{value: l.xrefID}}, o); err != nil {
  1686  		return ErrContext{"MultimediaRecord", "xrefID", err}
  1687  	}
  1688  	var FormatSet, BlobSet, TitleSet, ContinuedObjectSet, AutomatedRecordIDSet, ChangeDateSet bool
  1689  	for _, sl := range l.Sub {
  1690  		switch sl.tag {
  1691  		case cFORM:
  1692  			if FormatSet {
  1693  				if !o.allowMoreThanAllowed {
  1694  					continue
  1695  				}
  1696  				return ErrContext{"MultimediaRecord", cFORM, ErrSingleMultiple}
  1697  			}
  1698  			FormatSet = true
  1699  			if err := s.Format.parse(&sl, o); err != nil {
  1700  				return ErrContext{"MultimediaRecord", cFORM, err}
  1701  			}
  1702  		case cTITLE:
  1703  			if TitleSet {
  1704  				if !o.allowMoreThanAllowed {
  1705  					continue
  1706  				}
  1707  				return ErrContext{"MultimediaRecord", cTITLE, ErrSingleMultiple}
  1708  			}
  1709  			TitleSet = true
  1710  			if err := s.Title.parse(&sl, o); err != nil {
  1711  				return ErrContext{"MultimediaRecord", cTITLE, err}
  1712  			}
  1713  		case cNOTE:
  1714  			var t NoteStructure
  1715  			if err := t.parse(&sl, o); err != nil {
  1716  				return ErrContext{"MultimediaRecord", cNOTE, err}
  1717  			}
  1718  			s.Notes = append(s.Notes, t)
  1719  		case cBLOB:
  1720  			if BlobSet {
  1721  				if !o.allowMoreThanAllowed {
  1722  					continue
  1723  				}
  1724  				return ErrContext{"MultimediaRecord", cBLOB, ErrSingleMultiple}
  1725  			}
  1726  			BlobSet = true
  1727  			if err := s.Blob.parse(&sl, o); err != nil {
  1728  				return ErrContext{"MultimediaRecord", cBLOB, err}
  1729  			}
  1730  		case cOBJE:
  1731  			if ContinuedObjectSet {
  1732  				if !o.allowMoreThanAllowed {
  1733  					continue
  1734  				}
  1735  				return ErrContext{"MultimediaRecord", cOBJE, ErrSingleMultiple}
  1736  			}
  1737  			ContinuedObjectSet = true
  1738  			if err := s.ContinuedObject.parse(&sl, o); err != nil {
  1739  				return ErrContext{"MultimediaRecord", cOBJE, err}
  1740  			}
  1741  		case cREFN:
  1742  			var t UserReferenceStructure
  1743  			if err := t.parse(&sl, o); err != nil {
  1744  				return ErrContext{"MultimediaRecord", cREFN, err}
  1745  			}
  1746  			s.UserReferences = append(s.UserReferences, t)
  1747  		case cRIN:
  1748  			if AutomatedRecordIDSet {
  1749  				if !o.allowMoreThanAllowed {
  1750  					continue
  1751  				}
  1752  				return ErrContext{"MultimediaRecord", cRIN, ErrSingleMultiple}
  1753  			}
  1754  			AutomatedRecordIDSet = true
  1755  			if err := s.AutomatedRecordID.parse(&sl, o); err != nil {
  1756  				return ErrContext{"MultimediaRecord", cRIN, err}
  1757  			}
  1758  		case cCHAN:
  1759  			if ChangeDateSet {
  1760  				if !o.allowMoreThanAllowed {
  1761  					continue
  1762  				}
  1763  				return ErrContext{"MultimediaRecord", cCHAN, ErrSingleMultiple}
  1764  			}
  1765  			ChangeDateSet = true
  1766  			if err := s.ChangeDate.parse(&sl, o); err != nil {
  1767  				return ErrContext{"MultimediaRecord", cCHAN, err}
  1768  			}
  1769  		default:
  1770  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  1771  				return ErrContext{"MultimediaRecord", sl.tag, ErrUnknownTag}
  1772  			}
  1773  			// possibly store in a Other field
  1774  		}
  1775  	}
  1776  	if !o.allowMissingRequired {
  1777  		if !FormatSet {
  1778  			return ErrContext{"MultimediaRecord", "Format", ErrRequiredMissing}
  1779  		}
  1780  		if !BlobSet {
  1781  			return ErrContext{"MultimediaRecord", "Blob", ErrRequiredMissing}
  1782  		}
  1783  	}
  1784  	return nil
  1785  }
  1786  
  1787  // NoteRecord is a GEDCOM structure type
  1788  type NoteRecord struct {
  1789  	ID                Xref
  1790  	SubmitterText     SubmitterText
  1791  	Sources           []SourceCitation
  1792  	UserReferences    []UserReferenceStructure
  1793  	AutomatedRecordID AutomatedRecordID
  1794  	ChangeDate        ChangeDateStructure
  1795  }
  1796  
  1797  func (s *NoteRecord) parse(l *Line, o options) error {
  1798  	if err := s.ID.parse(&Line{line: line{value: l.xrefID}}, o); err != nil {
  1799  		return ErrContext{"NoteRecord", "xrefID", err}
  1800  	}
  1801  	if err := s.SubmitterText.parse(l, o); err != nil {
  1802  		return ErrContext{"NoteRecord", "line_value", err}
  1803  	}
  1804  	var AutomatedRecordIDSet, ChangeDateSet bool
  1805  	for _, sl := range l.Sub {
  1806  		switch sl.tag {
  1807  		case cSOUR:
  1808  			var t SourceCitation
  1809  			if err := t.parse(&sl, o); err != nil {
  1810  				return ErrContext{"NoteRecord", cSOUR, err}
  1811  			}
  1812  			s.Sources = append(s.Sources, t)
  1813  		case cREFN:
  1814  			var t UserReferenceStructure
  1815  			if err := t.parse(&sl, o); err != nil {
  1816  				return ErrContext{"NoteRecord", cREFN, err}
  1817  			}
  1818  			s.UserReferences = append(s.UserReferences, t)
  1819  		case cRIN:
  1820  			if AutomatedRecordIDSet {
  1821  				if !o.allowMoreThanAllowed {
  1822  					continue
  1823  				}
  1824  				return ErrContext{"NoteRecord", cRIN, ErrSingleMultiple}
  1825  			}
  1826  			AutomatedRecordIDSet = true
  1827  			if err := s.AutomatedRecordID.parse(&sl, o); err != nil {
  1828  				return ErrContext{"NoteRecord", cRIN, err}
  1829  			}
  1830  		case cCHAN:
  1831  			if ChangeDateSet {
  1832  				if !o.allowMoreThanAllowed {
  1833  					continue
  1834  				}
  1835  				return ErrContext{"NoteRecord", cCHAN, ErrSingleMultiple}
  1836  			}
  1837  			ChangeDateSet = true
  1838  			if err := s.ChangeDate.parse(&sl, o); err != nil {
  1839  				return ErrContext{"NoteRecord", cCHAN, err}
  1840  			}
  1841  		default:
  1842  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  1843  				return ErrContext{"NoteRecord", sl.tag, ErrUnknownTag}
  1844  			}
  1845  			// possibly store in a Other field
  1846  		}
  1847  	}
  1848  	return nil
  1849  }
  1850  
  1851  // RepositoryRecord is a GEDCOM structure type
  1852  type RepositoryRecord struct {
  1853  	ID                Xref
  1854  	NameOfRepository  NameOfRepository
  1855  	Address           AddressStructure
  1856  	PhoneNumber       []PhoneNumber
  1857  	Notes             []NoteStructure
  1858  	UserReferences    []UserReferenceStructure
  1859  	AutomatedRecordID AutomatedRecordID
  1860  	ChangeDate        ChangeDateStructure
  1861  }
  1862  
  1863  func (s *RepositoryRecord) parse(l *Line, o options) error {
  1864  	if err := s.ID.parse(&Line{line: line{value: l.xrefID}}, o); err != nil {
  1865  		return ErrContext{"RepositoryRecord", "xrefID", err}
  1866  	}
  1867  	var NameOfRepositorySet, AddressSet, AutomatedRecordIDSet, ChangeDateSet bool
  1868  	s.PhoneNumber = make([]PhoneNumber, 0, 3)
  1869  	for _, sl := range l.Sub {
  1870  		switch sl.tag {
  1871  		case cNAME:
  1872  			if NameOfRepositorySet {
  1873  				if !o.allowMoreThanAllowed {
  1874  					continue
  1875  				}
  1876  				return ErrContext{"RepositoryRecord", cNAME, ErrSingleMultiple}
  1877  			}
  1878  			NameOfRepositorySet = true
  1879  			if err := s.NameOfRepository.parse(&sl, o); err != nil {
  1880  				return ErrContext{"RepositoryRecord", cNAME, err}
  1881  			}
  1882  		case cADDR:
  1883  			if AddressSet {
  1884  				if !o.allowMoreThanAllowed {
  1885  					continue
  1886  				}
  1887  				return ErrContext{"RepositoryRecord", cADDR, ErrSingleMultiple}
  1888  			}
  1889  			AddressSet = true
  1890  			if err := s.Address.parse(&sl, o); err != nil {
  1891  				return ErrContext{"RepositoryRecord", cADDR, err}
  1892  			}
  1893  		case cPHON:
  1894  			if len(s.PhoneNumber) == 3 {
  1895  				if !o.allowMoreThanAllowed {
  1896  					continue
  1897  				}
  1898  				return ErrContext{"RepositoryRecord", cPHON, ErrTooMany(3)}
  1899  			}
  1900  			var t PhoneNumber
  1901  			if err := t.parse(&sl, o); err != nil {
  1902  				return ErrContext{"RepositoryRecord", cPHON, err}
  1903  			}
  1904  			s.PhoneNumber = append(s.PhoneNumber, t)
  1905  		case cNOTE:
  1906  			var t NoteStructure
  1907  			if err := t.parse(&sl, o); err != nil {
  1908  				return ErrContext{"RepositoryRecord", cNOTE, err}
  1909  			}
  1910  			s.Notes = append(s.Notes, t)
  1911  		case cREFN:
  1912  			var t UserReferenceStructure
  1913  			if err := t.parse(&sl, o); err != nil {
  1914  				return ErrContext{"RepositoryRecord", cREFN, err}
  1915  			}
  1916  			s.UserReferences = append(s.UserReferences, t)
  1917  		case cRIN:
  1918  			if AutomatedRecordIDSet {
  1919  				if !o.allowMoreThanAllowed {
  1920  					continue
  1921  				}
  1922  				return ErrContext{"RepositoryRecord", cRIN, ErrSingleMultiple}
  1923  			}
  1924  			AutomatedRecordIDSet = true
  1925  			if err := s.AutomatedRecordID.parse(&sl, o); err != nil {
  1926  				return ErrContext{"RepositoryRecord", cRIN, err}
  1927  			}
  1928  		case cCHAN:
  1929  			if ChangeDateSet {
  1930  				if !o.allowMoreThanAllowed {
  1931  					continue
  1932  				}
  1933  				return ErrContext{"RepositoryRecord", cCHAN, ErrSingleMultiple}
  1934  			}
  1935  			ChangeDateSet = true
  1936  			if err := s.ChangeDate.parse(&sl, o); err != nil {
  1937  				return ErrContext{"RepositoryRecord", cCHAN, err}
  1938  			}
  1939  		default:
  1940  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  1941  				return ErrContext{"RepositoryRecord", sl.tag, ErrUnknownTag}
  1942  			}
  1943  			// possibly store in a Other field
  1944  		}
  1945  	}
  1946  	return nil
  1947  }
  1948  
  1949  // SourceRecord is a GEDCOM structure type
  1950  type SourceRecord struct {
  1951  	ID                       Xref
  1952  	Data                     SourceRecordDataStructure
  1953  	Originator               SourceOriginator
  1954  	Title                    SourceDescriptiveTitle
  1955  	FiledBy                  SourceFiledByEntry
  1956  	PublicationFacts         SourcePublicationFacts
  1957  	TextFromSource           TextFromSource
  1958  	SourceRepositoryCitation SourceRepositoryCitation
  1959  	ContinuedObject          Xref
  1960  	Notes                    []NoteStructure
  1961  	UserReferences           []UserReferenceStructure
  1962  	AutomatedRecordID        AutomatedRecordID
  1963  	ChangeDate               ChangeDateStructure
  1964  }
  1965  
  1966  func (s *SourceRecord) parse(l *Line, o options) error {
  1967  	if err := s.ID.parse(&Line{line: line{value: l.xrefID}}, o); err != nil {
  1968  		return ErrContext{"SourceRecord", "xrefID", err}
  1969  	}
  1970  	var SourceRepositoryCitationSet, DataSet, OriginatorSet, TitleSet, FiledBySet, PublicationFactsSet, TextFromSourceSet, ContinuedObjectSet, AutomatedRecordIDSet, ChangeDateSet bool
  1971  	for _, sl := range l.Sub {
  1972  		switch sl.tag {
  1973  		case cDATA:
  1974  			if DataSet {
  1975  				if !o.allowMoreThanAllowed {
  1976  					continue
  1977  				}
  1978  				return ErrContext{"SourceRecord", cDATA, ErrSingleMultiple}
  1979  			}
  1980  			DataSet = true
  1981  			if err := s.Data.parse(&sl, o); err != nil {
  1982  				return ErrContext{"SourceRecord", cDATA, err}
  1983  			}
  1984  		case cAUTH:
  1985  			if OriginatorSet {
  1986  				if !o.allowMoreThanAllowed {
  1987  					continue
  1988  				}
  1989  				return ErrContext{"SourceRecord", cAUTH, ErrSingleMultiple}
  1990  			}
  1991  			OriginatorSet = true
  1992  			if err := s.Originator.parse(&sl, o); err != nil {
  1993  				return ErrContext{"SourceRecord", cAUTH, err}
  1994  			}
  1995  		case cTITL:
  1996  			if TitleSet {
  1997  				if !o.allowMoreThanAllowed {
  1998  					continue
  1999  				}
  2000  				return ErrContext{"SourceRecord", cTITL, ErrSingleMultiple}
  2001  			}
  2002  			TitleSet = true
  2003  			if err := s.Title.parse(&sl, o); err != nil {
  2004  				return ErrContext{"SourceRecord", cTITL, err}
  2005  			}
  2006  		case cABBR:
  2007  			if FiledBySet {
  2008  				if !o.allowMoreThanAllowed {
  2009  					continue
  2010  				}
  2011  				return ErrContext{"SourceRecord", cABBR, ErrSingleMultiple}
  2012  			}
  2013  			FiledBySet = true
  2014  			if err := s.FiledBy.parse(&sl, o); err != nil {
  2015  				return ErrContext{"SourceRecord", cABBR, err}
  2016  			}
  2017  		case cPUBL:
  2018  			if PublicationFactsSet {
  2019  				if !o.allowMoreThanAllowed {
  2020  					continue
  2021  				}
  2022  				return ErrContext{"SourceRecord", cPUBL, ErrSingleMultiple}
  2023  			}
  2024  			PublicationFactsSet = true
  2025  			if err := s.PublicationFacts.parse(&sl, o); err != nil {
  2026  				return ErrContext{"SourceRecord", cPUBL, err}
  2027  			}
  2028  		case cTEXT:
  2029  			if TextFromSourceSet {
  2030  				if !o.allowMoreThanAllowed {
  2031  					continue
  2032  				}
  2033  				return ErrContext{"SourceRecord", cTEXT, ErrSingleMultiple}
  2034  			}
  2035  			TextFromSourceSet = true
  2036  			if err := s.TextFromSource.parse(&sl, o); err != nil {
  2037  				return ErrContext{"SourceRecord", cTEXT, err}
  2038  			}
  2039  		case cREPO:
  2040  			if SourceRepositoryCitationSet {
  2041  				if !o.allowMoreThanAllowed {
  2042  					continue
  2043  				}
  2044  				return ErrContext{"SourceRecord", cREPO, ErrSingleMultiple}
  2045  			}
  2046  			SourceRepositoryCitationSet = true
  2047  			if err := s.SourceRepositoryCitation.parse(&sl, o); err != nil {
  2048  				return ErrContext{"SourceRecord", cREPO, err}
  2049  			}
  2050  		case cOBJE:
  2051  			if ContinuedObjectSet {
  2052  				if !o.allowMoreThanAllowed {
  2053  					continue
  2054  				}
  2055  				return ErrContext{"SourceRecord", cOBJE, ErrSingleMultiple}
  2056  			}
  2057  			ContinuedObjectSet = true
  2058  			if err := s.ContinuedObject.parse(&sl, o); err != nil {
  2059  				return ErrContext{"SourceRecord", cOBJE, err}
  2060  			}
  2061  		case cNOTE:
  2062  			var t NoteStructure
  2063  			if err := t.parse(&sl, o); err != nil {
  2064  				return ErrContext{"SourceRecord", cNOTE, err}
  2065  			}
  2066  			s.Notes = append(s.Notes, t)
  2067  		case cREFN:
  2068  			var t UserReferenceStructure
  2069  			if err := t.parse(&sl, o); err != nil {
  2070  				return ErrContext{"SourceRecord", cREFN, err}
  2071  			}
  2072  			s.UserReferences = append(s.UserReferences, t)
  2073  		case cRIN:
  2074  			if AutomatedRecordIDSet {
  2075  				if !o.allowMoreThanAllowed {
  2076  					continue
  2077  				}
  2078  				return ErrContext{"SourceRecord", cRIN, ErrSingleMultiple}
  2079  			}
  2080  			AutomatedRecordIDSet = true
  2081  			if err := s.AutomatedRecordID.parse(&sl, o); err != nil {
  2082  				return ErrContext{"SourceRecord", cRIN, err}
  2083  			}
  2084  		case cCHAN:
  2085  			if ChangeDateSet {
  2086  				if !o.allowMoreThanAllowed {
  2087  					continue
  2088  				}
  2089  				return ErrContext{"SourceRecord", cCHAN, ErrSingleMultiple}
  2090  			}
  2091  			ChangeDateSet = true
  2092  			if err := s.ChangeDate.parse(&sl, o); err != nil {
  2093  				return ErrContext{"SourceRecord", cCHAN, err}
  2094  			}
  2095  		default:
  2096  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  2097  				return ErrContext{"SourceRecord", sl.tag, ErrUnknownTag}
  2098  			}
  2099  			// possibly store in a Other field
  2100  		}
  2101  	}
  2102  	if !o.allowMissingRequired {
  2103  		if !SourceRepositoryCitationSet {
  2104  			return ErrContext{"SourceRecord", "SourceRepositoryCitation", ErrRequiredMissing}
  2105  		}
  2106  	}
  2107  	return nil
  2108  }
  2109  
  2110  // SourceRecordDataStructure is a GEDCOM structure type
  2111  type SourceRecordDataStructure struct {
  2112  	EventsRecorded    []EventsRecordedStructure
  2113  	ResponsibleAgency ResponsibleAgency
  2114  	Notes             []NoteStructure
  2115  }
  2116  
  2117  func (s *SourceRecordDataStructure) parse(l *Line, o options) error {
  2118  	var ResponsibleAgencySet bool
  2119  	for _, sl := range l.Sub {
  2120  		switch sl.tag {
  2121  		case cEVEN:
  2122  			var t EventsRecordedStructure
  2123  			if err := t.parse(&sl, o); err != nil {
  2124  				return ErrContext{"SourceRecordDataStructure", cEVEN, err}
  2125  			}
  2126  			s.EventsRecorded = append(s.EventsRecorded, t)
  2127  		case cAGNC:
  2128  			if ResponsibleAgencySet {
  2129  				if !o.allowMoreThanAllowed {
  2130  					continue
  2131  				}
  2132  				return ErrContext{"SourceRecordDataStructure", cAGNC, ErrSingleMultiple}
  2133  			}
  2134  			ResponsibleAgencySet = true
  2135  			if err := s.ResponsibleAgency.parse(&sl, o); err != nil {
  2136  				return ErrContext{"SourceRecordDataStructure", cAGNC, err}
  2137  			}
  2138  		case cNOTE:
  2139  			var t NoteStructure
  2140  			if err := t.parse(&sl, o); err != nil {
  2141  				return ErrContext{"SourceRecordDataStructure", cNOTE, err}
  2142  			}
  2143  			s.Notes = append(s.Notes, t)
  2144  		default:
  2145  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  2146  				return ErrContext{"SourceRecordDataStructure", sl.tag, ErrUnknownTag}
  2147  			}
  2148  			// possibly store in a Other field
  2149  		}
  2150  	}
  2151  	return nil
  2152  }
  2153  
  2154  // EventsRecordedStructure is a GEDCOM structure type
  2155  type EventsRecordedStructure struct {
  2156  	DatePeriod              DatePeriod
  2157  	SourceJurisdictionPlace SourceJurisdictionPlace
  2158  }
  2159  
  2160  func (s *EventsRecordedStructure) parse(l *Line, o options) error {
  2161  	var DatePeriodSet, SourceJurisdictionPlaceSet bool
  2162  	for _, sl := range l.Sub {
  2163  		switch sl.tag {
  2164  		case cDATE:
  2165  			if DatePeriodSet {
  2166  				if !o.allowMoreThanAllowed {
  2167  					continue
  2168  				}
  2169  				return ErrContext{"EventsRecordedStructure", cDATE, ErrSingleMultiple}
  2170  			}
  2171  			DatePeriodSet = true
  2172  			if err := s.DatePeriod.parse(&sl, o); err != nil {
  2173  				return ErrContext{"EventsRecordedStructure", cDATE, err}
  2174  			}
  2175  		case cPLACE:
  2176  			if SourceJurisdictionPlaceSet {
  2177  				if !o.allowMoreThanAllowed {
  2178  					continue
  2179  				}
  2180  				return ErrContext{"EventsRecordedStructure", cPLACE, ErrSingleMultiple}
  2181  			}
  2182  			SourceJurisdictionPlaceSet = true
  2183  			if err := s.SourceJurisdictionPlace.parse(&sl, o); err != nil {
  2184  				return ErrContext{"EventsRecordedStructure", cPLACE, err}
  2185  			}
  2186  		default:
  2187  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  2188  				return ErrContext{"EventsRecordedStructure", sl.tag, ErrUnknownTag}
  2189  			}
  2190  			// possibly store in a Other field
  2191  		}
  2192  	}
  2193  	return nil
  2194  }
  2195  
  2196  // SubmissionRecord is a GEDCOM structure type
  2197  type SubmissionRecord struct {
  2198  	ID                       Xref
  2199  	NameOfFamilyFile         NameOfFamilyFile
  2200  	TempleCode               TempleCode
  2201  	GenerationsOfAncestors   GenerationsOfAncestors
  2202  	GenerationsOfDescendants GenerationsOfDescendants
  2203  	OrdinanceProcessFlag     OrdinanceProcessFlag
  2204  	AutomatedRecordID        AutomatedRecordID
  2205  }
  2206  
  2207  func (s *SubmissionRecord) parse(l *Line, o options) error {
  2208  	if err := s.ID.parse(&Line{line: line{value: l.xrefID}}, o); err != nil {
  2209  		return ErrContext{"SubmissionRecord", "xrefID", err}
  2210  	}
  2211  	var NameOfFamilyFileSet, TempleCodeSet, GenerationsOfAncestorsSet, GenerationsOfDescendantsSet, OrdinanceProcessFlagSet, AutomatedRecordIDSet bool
  2212  	for _, sl := range l.Sub {
  2213  		switch sl.tag {
  2214  		case cFAMF:
  2215  			if NameOfFamilyFileSet {
  2216  				if !o.allowMoreThanAllowed {
  2217  					continue
  2218  				}
  2219  				return ErrContext{"SubmissionRecord", cFAMF, ErrSingleMultiple}
  2220  			}
  2221  			NameOfFamilyFileSet = true
  2222  			if err := s.NameOfFamilyFile.parse(&sl, o); err != nil {
  2223  				return ErrContext{"SubmissionRecord", cFAMF, err}
  2224  			}
  2225  		case cTEMP:
  2226  			if TempleCodeSet {
  2227  				if !o.allowMoreThanAllowed {
  2228  					continue
  2229  				}
  2230  				return ErrContext{"SubmissionRecord", cTEMP, ErrSingleMultiple}
  2231  			}
  2232  			TempleCodeSet = true
  2233  			if err := s.TempleCode.parse(&sl, o); err != nil {
  2234  				return ErrContext{"SubmissionRecord", cTEMP, err}
  2235  			}
  2236  		case cANCE:
  2237  			if GenerationsOfAncestorsSet {
  2238  				if !o.allowMoreThanAllowed {
  2239  					continue
  2240  				}
  2241  				return ErrContext{"SubmissionRecord", cANCE, ErrSingleMultiple}
  2242  			}
  2243  			GenerationsOfAncestorsSet = true
  2244  			if err := s.GenerationsOfAncestors.parse(&sl, o); err != nil {
  2245  				return ErrContext{"SubmissionRecord", cANCE, err}
  2246  			}
  2247  		case cDESC:
  2248  			if GenerationsOfDescendantsSet {
  2249  				if !o.allowMoreThanAllowed {
  2250  					continue
  2251  				}
  2252  				return ErrContext{"SubmissionRecord", cDESC, ErrSingleMultiple}
  2253  			}
  2254  			GenerationsOfDescendantsSet = true
  2255  			if err := s.GenerationsOfDescendants.parse(&sl, o); err != nil {
  2256  				return ErrContext{"SubmissionRecord", cDESC, err}
  2257  			}
  2258  		case cORDI:
  2259  			if OrdinanceProcessFlagSet {
  2260  				if !o.allowMoreThanAllowed {
  2261  					continue
  2262  				}
  2263  				return ErrContext{"SubmissionRecord", cORDI, ErrSingleMultiple}
  2264  			}
  2265  			OrdinanceProcessFlagSet = true
  2266  			if err := s.OrdinanceProcessFlag.parse(&sl, o); err != nil {
  2267  				return ErrContext{"SubmissionRecord", cORDI, err}
  2268  			}
  2269  		case cRIN:
  2270  			if AutomatedRecordIDSet {
  2271  				if !o.allowMoreThanAllowed {
  2272  					continue
  2273  				}
  2274  				return ErrContext{"SubmissionRecord", cRIN, ErrSingleMultiple}
  2275  			}
  2276  			AutomatedRecordIDSet = true
  2277  			if err := s.AutomatedRecordID.parse(&sl, o); err != nil {
  2278  				return ErrContext{"SubmissionRecord", cRIN, err}
  2279  			}
  2280  		default:
  2281  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  2282  				return ErrContext{"SubmissionRecord", sl.tag, ErrUnknownTag}
  2283  			}
  2284  			// possibly store in a Other field
  2285  		}
  2286  	}
  2287  	return nil
  2288  }
  2289  
  2290  // SubmitterRecord is a GEDCOM structure type
  2291  type SubmitterRecord struct {
  2292  	ID                     Xref
  2293  	SubmitterName          SubmitterName
  2294  	Address                AddressStructure
  2295  	PhoneNumber            []PhoneNumber
  2296  	Multimedia             []MultimediaLink
  2297  	LanguagePreference     []LanguagePreference
  2298  	SubmitterRegisteredRFN SubmitterRegisteredRFN
  2299  	AutomatedRecordID      AutomatedRecordID
  2300  	ChangeDate             ChangeDateStructure
  2301  }
  2302  
  2303  func (s *SubmitterRecord) parse(l *Line, o options) error {
  2304  	if err := s.ID.parse(&Line{line: line{value: l.xrefID}}, o); err != nil {
  2305  		return ErrContext{"SubmitterRecord", "xrefID", err}
  2306  	}
  2307  	var SubmitterNameSet, AddressSet, SubmitterRegisteredRFNSet, AutomatedRecordIDSet, ChangeDateSet bool
  2308  	s.PhoneNumber = make([]PhoneNumber, 0, 3)
  2309  	s.LanguagePreference = make([]LanguagePreference, 0, 3)
  2310  	for _, sl := range l.Sub {
  2311  		switch sl.tag {
  2312  		case cNAME:
  2313  			if SubmitterNameSet {
  2314  				if !o.allowMoreThanAllowed {
  2315  					continue
  2316  				}
  2317  				return ErrContext{"SubmitterRecord", cNAME, ErrSingleMultiple}
  2318  			}
  2319  			SubmitterNameSet = true
  2320  			if err := s.SubmitterName.parse(&sl, o); err != nil {
  2321  				return ErrContext{"SubmitterRecord", cNAME, err}
  2322  			}
  2323  		case cADDR:
  2324  			if AddressSet {
  2325  				if !o.allowMoreThanAllowed {
  2326  					continue
  2327  				}
  2328  				return ErrContext{"SubmitterRecord", cADDR, ErrSingleMultiple}
  2329  			}
  2330  			AddressSet = true
  2331  			if err := s.Address.parse(&sl, o); err != nil {
  2332  				return ErrContext{"SubmitterRecord", cADDR, err}
  2333  			}
  2334  		case cPHON:
  2335  			if len(s.PhoneNumber) == 3 {
  2336  				if !o.allowMoreThanAllowed {
  2337  					continue
  2338  				}
  2339  				return ErrContext{"SubmitterRecord", cPHON, ErrTooMany(3)}
  2340  			}
  2341  			var t PhoneNumber
  2342  			if err := t.parse(&sl, o); err != nil {
  2343  				return ErrContext{"SubmitterRecord", cPHON, err}
  2344  			}
  2345  			s.PhoneNumber = append(s.PhoneNumber, t)
  2346  		case cOBJE:
  2347  			var t MultimediaLink
  2348  			if err := t.parse(&sl, o); err != nil {
  2349  				return ErrContext{"SubmitterRecord", cOBJE, err}
  2350  			}
  2351  			s.Multimedia = append(s.Multimedia, t)
  2352  		case cLANG:
  2353  			if len(s.LanguagePreference) == 3 {
  2354  				if !o.allowMoreThanAllowed {
  2355  					continue
  2356  				}
  2357  				return ErrContext{"SubmitterRecord", cLANG, ErrTooMany(3)}
  2358  			}
  2359  			var t LanguagePreference
  2360  			if err := t.parse(&sl, o); err != nil {
  2361  				return ErrContext{"SubmitterRecord", cLANG, err}
  2362  			}
  2363  			s.LanguagePreference = append(s.LanguagePreference, t)
  2364  		case cRFN:
  2365  			if SubmitterRegisteredRFNSet {
  2366  				if !o.allowMoreThanAllowed {
  2367  					continue
  2368  				}
  2369  				return ErrContext{"SubmitterRecord", cRFN, ErrSingleMultiple}
  2370  			}
  2371  			SubmitterRegisteredRFNSet = true
  2372  			if err := s.SubmitterRegisteredRFN.parse(&sl, o); err != nil {
  2373  				return ErrContext{"SubmitterRecord", cRFN, err}
  2374  			}
  2375  		case cRIN:
  2376  			if AutomatedRecordIDSet {
  2377  				if !o.allowMoreThanAllowed {
  2378  					continue
  2379  				}
  2380  				return ErrContext{"SubmitterRecord", cRIN, ErrSingleMultiple}
  2381  			}
  2382  			AutomatedRecordIDSet = true
  2383  			if err := s.AutomatedRecordID.parse(&sl, o); err != nil {
  2384  				return ErrContext{"SubmitterRecord", cRIN, err}
  2385  			}
  2386  		case cCHAN:
  2387  			if ChangeDateSet {
  2388  				if !o.allowMoreThanAllowed {
  2389  					continue
  2390  				}
  2391  				return ErrContext{"SubmitterRecord", cCHAN, ErrSingleMultiple}
  2392  			}
  2393  			ChangeDateSet = true
  2394  			if err := s.ChangeDate.parse(&sl, o); err != nil {
  2395  				return ErrContext{"SubmitterRecord", cCHAN, err}
  2396  			}
  2397  		default:
  2398  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  2399  				return ErrContext{"SubmitterRecord", sl.tag, ErrUnknownTag}
  2400  			}
  2401  			// possibly store in a Other field
  2402  		}
  2403  	}
  2404  	if !o.allowMissingRequired {
  2405  		if !SubmitterNameSet {
  2406  			return ErrContext{"SubmitterRecord", "SubmitterName", ErrRequiredMissing}
  2407  		}
  2408  	}
  2409  	return nil
  2410  }
  2411  
  2412  // AddressStructure is a GEDCOM structure type
  2413  type AddressStructure struct {
  2414  	AddressLine  AddressLine
  2415  	AddressLine1 AddressLine1
  2416  	AddressLine2 AddressLine2
  2417  	City         AddressCity
  2418  	State        AddressState
  2419  	PostalCode   AddressPostalCode
  2420  	Country      AddressCountry
  2421  }
  2422  
  2423  func (s *AddressStructure) parse(l *Line, o options) error {
  2424  	if err := s.AddressLine.parse(l, o); err != nil {
  2425  		return ErrContext{"AddressStructure", "line_value", err}
  2426  	}
  2427  	var AddressLine1Set, AddressLine2Set, CitySet, StateSet, PostalCodeSet, CountrySet bool
  2428  	for _, sl := range l.Sub {
  2429  		switch sl.tag {
  2430  		case cADR1:
  2431  			if AddressLine1Set {
  2432  				if !o.allowMoreThanAllowed {
  2433  					continue
  2434  				}
  2435  				return ErrContext{"AddressStructure", cADR1, ErrSingleMultiple}
  2436  			}
  2437  			AddressLine1Set = true
  2438  			if err := s.AddressLine1.parse(&sl, o); err != nil {
  2439  				return ErrContext{"AddressStructure", cADR1, err}
  2440  			}
  2441  		case cADR2:
  2442  			if AddressLine2Set {
  2443  				if !o.allowMoreThanAllowed {
  2444  					continue
  2445  				}
  2446  				return ErrContext{"AddressStructure", cADR2, ErrSingleMultiple}
  2447  			}
  2448  			AddressLine2Set = true
  2449  			if err := s.AddressLine2.parse(&sl, o); err != nil {
  2450  				return ErrContext{"AddressStructure", cADR2, err}
  2451  			}
  2452  		case cCITY:
  2453  			if CitySet {
  2454  				if !o.allowMoreThanAllowed {
  2455  					continue
  2456  				}
  2457  				return ErrContext{"AddressStructure", cCITY, ErrSingleMultiple}
  2458  			}
  2459  			CitySet = true
  2460  			if err := s.City.parse(&sl, o); err != nil {
  2461  				return ErrContext{"AddressStructure", cCITY, err}
  2462  			}
  2463  		case cSTAE:
  2464  			if StateSet {
  2465  				if !o.allowMoreThanAllowed {
  2466  					continue
  2467  				}
  2468  				return ErrContext{"AddressStructure", cSTAE, ErrSingleMultiple}
  2469  			}
  2470  			StateSet = true
  2471  			if err := s.State.parse(&sl, o); err != nil {
  2472  				return ErrContext{"AddressStructure", cSTAE, err}
  2473  			}
  2474  		case cPOST:
  2475  			if PostalCodeSet {
  2476  				if !o.allowMoreThanAllowed {
  2477  					continue
  2478  				}
  2479  				return ErrContext{"AddressStructure", cPOST, ErrSingleMultiple}
  2480  			}
  2481  			PostalCodeSet = true
  2482  			if err := s.PostalCode.parse(&sl, o); err != nil {
  2483  				return ErrContext{"AddressStructure", cPOST, err}
  2484  			}
  2485  		case cCTRY:
  2486  			if CountrySet {
  2487  				if !o.allowMoreThanAllowed {
  2488  					continue
  2489  				}
  2490  				return ErrContext{"AddressStructure", cCTRY, ErrSingleMultiple}
  2491  			}
  2492  			CountrySet = true
  2493  			if err := s.Country.parse(&sl, o); err != nil {
  2494  				return ErrContext{"AddressStructure", cCTRY, err}
  2495  			}
  2496  		default:
  2497  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  2498  				return ErrContext{"AddressStructure", sl.tag, ErrUnknownTag}
  2499  			}
  2500  			// possibly store in a Other field
  2501  		}
  2502  	}
  2503  	return nil
  2504  }
  2505  
  2506  // AssociationStructure is a GEDCOM structure type
  2507  type AssociationStructure struct {
  2508  	ID         Xref
  2509  	RecordType RecordType
  2510  	Relation   RelationIsDescriptor
  2511  	Notes      []NoteStructure
  2512  	Sources    []SourceCitation
  2513  }
  2514  
  2515  func (s *AssociationStructure) parse(l *Line, o options) error {
  2516  	if err := s.ID.parse(&Line{line: line{value: l.xrefID}}, o); err != nil {
  2517  		return ErrContext{"AssociationStructure", "xrefID", err}
  2518  	}
  2519  	var RecordTypeSet, RelationSet bool
  2520  	for _, sl := range l.Sub {
  2521  		switch sl.tag {
  2522  		case cTYPE:
  2523  			if RecordTypeSet {
  2524  				if !o.allowMoreThanAllowed {
  2525  					continue
  2526  				}
  2527  				return ErrContext{"AssociationStructure", cTYPE, ErrSingleMultiple}
  2528  			}
  2529  			RecordTypeSet = true
  2530  			if err := s.RecordType.parse(&sl, o); err != nil {
  2531  				return ErrContext{"AssociationStructure", cTYPE, err}
  2532  			}
  2533  		case cRELA:
  2534  			if RelationSet {
  2535  				if !o.allowMoreThanAllowed {
  2536  					continue
  2537  				}
  2538  				return ErrContext{"AssociationStructure", cRELA, ErrSingleMultiple}
  2539  			}
  2540  			RelationSet = true
  2541  			if err := s.Relation.parse(&sl, o); err != nil {
  2542  				return ErrContext{"AssociationStructure", cRELA, err}
  2543  			}
  2544  		case cNOTE:
  2545  			var t NoteStructure
  2546  			if err := t.parse(&sl, o); err != nil {
  2547  				return ErrContext{"AssociationStructure", cNOTE, err}
  2548  			}
  2549  			s.Notes = append(s.Notes, t)
  2550  		case cSOUR:
  2551  			var t SourceCitation
  2552  			if err := t.parse(&sl, o); err != nil {
  2553  				return ErrContext{"AssociationStructure", cSOUR, err}
  2554  			}
  2555  			s.Sources = append(s.Sources, t)
  2556  		default:
  2557  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  2558  				return ErrContext{"AssociationStructure", sl.tag, ErrUnknownTag}
  2559  			}
  2560  			// possibly store in a Other field
  2561  		}
  2562  	}
  2563  	if !o.allowMissingRequired {
  2564  		if !RecordTypeSet {
  2565  			return ErrContext{"AssociationStructure", "RecordType", ErrRequiredMissing}
  2566  		}
  2567  		if !RelationSet {
  2568  			return ErrContext{"AssociationStructure", "Relation", ErrRequiredMissing}
  2569  		}
  2570  	}
  2571  	return nil
  2572  }
  2573  
  2574  // ChangeDateStructure is a GEDCOM structure type
  2575  type ChangeDateStructure struct {
  2576  	Date  ChangeDateTime
  2577  	Notes []NoteStructure
  2578  }
  2579  
  2580  func (s *ChangeDateStructure) parse(l *Line, o options) error {
  2581  	var DateSet bool
  2582  	for _, sl := range l.Sub {
  2583  		switch sl.tag {
  2584  		case cDATE:
  2585  			if DateSet {
  2586  				if !o.allowMoreThanAllowed {
  2587  					continue
  2588  				}
  2589  				return ErrContext{"ChangeDateStructure", cDATE, ErrSingleMultiple}
  2590  			}
  2591  			DateSet = true
  2592  			if err := s.Date.parse(&sl, o); err != nil {
  2593  				return ErrContext{"ChangeDateStructure", cDATE, err}
  2594  			}
  2595  		case cNOTE:
  2596  			var t NoteStructure
  2597  			if err := t.parse(&sl, o); err != nil {
  2598  				return ErrContext{"ChangeDateStructure", cNOTE, err}
  2599  			}
  2600  			s.Notes = append(s.Notes, t)
  2601  		default:
  2602  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  2603  				return ErrContext{"ChangeDateStructure", sl.tag, ErrUnknownTag}
  2604  			}
  2605  			// possibly store in a Other field
  2606  		}
  2607  	}
  2608  	if !o.allowMissingRequired {
  2609  		if !DateSet {
  2610  			return ErrContext{"ChangeDateStructure", "Date", ErrRequiredMissing}
  2611  		}
  2612  	}
  2613  	return nil
  2614  }
  2615  
  2616  // ChangeDateTime is a GEDCOM structure type
  2617  type ChangeDateTime struct {
  2618  	ChangeDate ChangeDate
  2619  	Time       TimeValue
  2620  }
  2621  
  2622  func (s *ChangeDateTime) parse(l *Line, o options) error {
  2623  	if err := s.ChangeDate.parse(l, o); err != nil {
  2624  		return ErrContext{"ChangeDateTime", "line_value", err}
  2625  	}
  2626  	var TimeSet bool
  2627  	for _, sl := range l.Sub {
  2628  		switch sl.tag {
  2629  		case cTIME:
  2630  			if TimeSet {
  2631  				if !o.allowMoreThanAllowed {
  2632  					continue
  2633  				}
  2634  				return ErrContext{"ChangeDateTime", cTIME, ErrSingleMultiple}
  2635  			}
  2636  			TimeSet = true
  2637  			if err := s.Time.parse(&sl, o); err != nil {
  2638  				return ErrContext{"ChangeDateTime", cTIME, err}
  2639  			}
  2640  		default:
  2641  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  2642  				return ErrContext{"ChangeDateTime", sl.tag, ErrUnknownTag}
  2643  			}
  2644  			// possibly store in a Other field
  2645  		}
  2646  	}
  2647  	return nil
  2648  }
  2649  
  2650  // ChildToFamilyLink is a GEDCOM structure type
  2651  type ChildToFamilyLink struct {
  2652  	ID                  Xref
  2653  	PedigreeLinkageType []PedigreeLinkageType
  2654  	Notes               []NoteStructure
  2655  }
  2656  
  2657  func (s *ChildToFamilyLink) parse(l *Line, o options) error {
  2658  	if err := s.ID.parse(l, o); err != nil {
  2659  		return ErrContext{"ChildToFamilyLink", "line_value", err}
  2660  	}
  2661  	for _, sl := range l.Sub {
  2662  		switch sl.tag {
  2663  		case cPEDI:
  2664  			var t PedigreeLinkageType
  2665  			if err := t.parse(&sl, o); err != nil {
  2666  				return ErrContext{"ChildToFamilyLink", cPEDI, err}
  2667  			}
  2668  			s.PedigreeLinkageType = append(s.PedigreeLinkageType, t)
  2669  		case cNOTE:
  2670  			var t NoteStructure
  2671  			if err := t.parse(&sl, o); err != nil {
  2672  				return ErrContext{"ChildToFamilyLink", cNOTE, err}
  2673  			}
  2674  			s.Notes = append(s.Notes, t)
  2675  		default:
  2676  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  2677  				return ErrContext{"ChildToFamilyLink", sl.tag, ErrUnknownTag}
  2678  			}
  2679  			// possibly store in a Other field
  2680  		}
  2681  	}
  2682  	return nil
  2683  }
  2684  
  2685  // EventDetail is a GEDCOM structure type
  2686  type EventDetail struct {
  2687  	Type              EventDescriptor
  2688  	Date              DateValue
  2689  	Place             PlaceStructure
  2690  	Address           AddressStructure
  2691  	PhoneNumber       []PhoneNumber
  2692  	Age               AgeAtEvent
  2693  	ResponsibleAgency ResponsibleAgency
  2694  	CauseOfEvent      CauseOfEvent
  2695  	Sources           []SourceCitation
  2696  	Multimedia        []MultimediaLink
  2697  	Notes             []NoteStructure
  2698  }
  2699  
  2700  func (s *EventDetail) parse(l *Line, o options) error {
  2701  	var TypeSet, DateSet, PlaceSet, AddressSet, AgeSet, ResponsibleAgencySet, CauseOfEventSet bool
  2702  	s.PhoneNumber = make([]PhoneNumber, 0, 3)
  2703  	for _, sl := range l.Sub {
  2704  		switch sl.tag {
  2705  		case cTYPE:
  2706  			if TypeSet {
  2707  				if !o.allowMoreThanAllowed {
  2708  					continue
  2709  				}
  2710  				return ErrContext{"EventDetail", cTYPE, ErrSingleMultiple}
  2711  			}
  2712  			TypeSet = true
  2713  			if err := s.Type.parse(&sl, o); err != nil {
  2714  				return ErrContext{"EventDetail", cTYPE, err}
  2715  			}
  2716  		case cDATE:
  2717  			if DateSet {
  2718  				if !o.allowMoreThanAllowed {
  2719  					continue
  2720  				}
  2721  				return ErrContext{"EventDetail", cDATE, ErrSingleMultiple}
  2722  			}
  2723  			DateSet = true
  2724  			if err := s.Date.parse(&sl, o); err != nil {
  2725  				return ErrContext{"EventDetail", cDATE, err}
  2726  			}
  2727  		case cPLAC:
  2728  			if PlaceSet {
  2729  				if !o.allowMoreThanAllowed {
  2730  					continue
  2731  				}
  2732  				return ErrContext{"EventDetail", cPLAC, ErrSingleMultiple}
  2733  			}
  2734  			PlaceSet = true
  2735  			if err := s.Place.parse(&sl, o); err != nil {
  2736  				return ErrContext{"EventDetail", cPLAC, err}
  2737  			}
  2738  		case cADDR:
  2739  			if AddressSet {
  2740  				if !o.allowMoreThanAllowed {
  2741  					continue
  2742  				}
  2743  				return ErrContext{"EventDetail", cADDR, ErrSingleMultiple}
  2744  			}
  2745  			AddressSet = true
  2746  			if err := s.Address.parse(&sl, o); err != nil {
  2747  				return ErrContext{"EventDetail", cADDR, err}
  2748  			}
  2749  		case cPHON:
  2750  			if len(s.PhoneNumber) == 3 {
  2751  				if !o.allowMoreThanAllowed {
  2752  					continue
  2753  				}
  2754  				return ErrContext{"EventDetail", cPHON, ErrTooMany(3)}
  2755  			}
  2756  			var t PhoneNumber
  2757  			if err := t.parse(&sl, o); err != nil {
  2758  				return ErrContext{"EventDetail", cPHON, err}
  2759  			}
  2760  			s.PhoneNumber = append(s.PhoneNumber, t)
  2761  		case cAGE:
  2762  			if AgeSet {
  2763  				if !o.allowMoreThanAllowed {
  2764  					continue
  2765  				}
  2766  				return ErrContext{"EventDetail", cAGE, ErrSingleMultiple}
  2767  			}
  2768  			AgeSet = true
  2769  			if err := s.Age.parse(&sl, o); err != nil {
  2770  				return ErrContext{"EventDetail", cAGE, err}
  2771  			}
  2772  		case cAGNC:
  2773  			if ResponsibleAgencySet {
  2774  				if !o.allowMoreThanAllowed {
  2775  					continue
  2776  				}
  2777  				return ErrContext{"EventDetail", cAGNC, ErrSingleMultiple}
  2778  			}
  2779  			ResponsibleAgencySet = true
  2780  			if err := s.ResponsibleAgency.parse(&sl, o); err != nil {
  2781  				return ErrContext{"EventDetail", cAGNC, err}
  2782  			}
  2783  		case cCAUS:
  2784  			if CauseOfEventSet {
  2785  				if !o.allowMoreThanAllowed {
  2786  					continue
  2787  				}
  2788  				return ErrContext{"EventDetail", cCAUS, ErrSingleMultiple}
  2789  			}
  2790  			CauseOfEventSet = true
  2791  			if err := s.CauseOfEvent.parse(&sl, o); err != nil {
  2792  				return ErrContext{"EventDetail", cCAUS, err}
  2793  			}
  2794  		case cSOUR:
  2795  			var t SourceCitation
  2796  			if err := t.parse(&sl, o); err != nil {
  2797  				return ErrContext{"EventDetail", cSOUR, err}
  2798  			}
  2799  			s.Sources = append(s.Sources, t)
  2800  		case cOBJE:
  2801  			var t MultimediaLink
  2802  			if err := t.parse(&sl, o); err != nil {
  2803  				return ErrContext{"EventDetail", cOBJE, err}
  2804  			}
  2805  			s.Multimedia = append(s.Multimedia, t)
  2806  		case cNOTE:
  2807  			var t NoteStructure
  2808  			if err := t.parse(&sl, o); err != nil {
  2809  				return ErrContext{"EventDetail", cNOTE, err}
  2810  			}
  2811  			s.Notes = append(s.Notes, t)
  2812  		default:
  2813  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  2814  				return ErrContext{"EventDetail", sl.tag, ErrUnknownTag}
  2815  			}
  2816  			// possibly store in a Other field
  2817  		}
  2818  	}
  2819  	return nil
  2820  }
  2821  
  2822  // LDSSpouseSealing is a GEDCOM structure type
  2823  type LDSSpouseSealing struct {
  2824  	LDSSpouseSealingDateStatus LDSSpouseSealingDateStatus
  2825  	Date                       DateLDSOrd
  2826  	TempleCode                 TempleCode
  2827  	Place                      PlaceLivingOrdinance
  2828  	Sources                    []SourceCitation
  2829  	Notes                      []NoteStructure
  2830  }
  2831  
  2832  func (s *LDSSpouseSealing) parse(l *Line, o options) error {
  2833  	var LDSSpouseSealingDateStatusSet, DateSet, TempleCodeSet, PlaceSet bool
  2834  	for _, sl := range l.Sub {
  2835  		switch sl.tag {
  2836  		case cSTAT:
  2837  			if LDSSpouseSealingDateStatusSet {
  2838  				if !o.allowMoreThanAllowed {
  2839  					continue
  2840  				}
  2841  				return ErrContext{"LDSSpouseSealing", cSTAT, ErrSingleMultiple}
  2842  			}
  2843  			LDSSpouseSealingDateStatusSet = true
  2844  			if err := s.LDSSpouseSealingDateStatus.parse(&sl, o); err != nil {
  2845  				return ErrContext{"LDSSpouseSealing", cSTAT, err}
  2846  			}
  2847  		case cDATE:
  2848  			if DateSet {
  2849  				if !o.allowMoreThanAllowed {
  2850  					continue
  2851  				}
  2852  				return ErrContext{"LDSSpouseSealing", cDATE, ErrSingleMultiple}
  2853  			}
  2854  			DateSet = true
  2855  			if err := s.Date.parse(&sl, o); err != nil {
  2856  				return ErrContext{"LDSSpouseSealing", cDATE, err}
  2857  			}
  2858  		case cTEMP:
  2859  			if TempleCodeSet {
  2860  				if !o.allowMoreThanAllowed {
  2861  					continue
  2862  				}
  2863  				return ErrContext{"LDSSpouseSealing", cTEMP, ErrSingleMultiple}
  2864  			}
  2865  			TempleCodeSet = true
  2866  			if err := s.TempleCode.parse(&sl, o); err != nil {
  2867  				return ErrContext{"LDSSpouseSealing", cTEMP, err}
  2868  			}
  2869  		case cPLAC:
  2870  			if PlaceSet {
  2871  				if !o.allowMoreThanAllowed {
  2872  					continue
  2873  				}
  2874  				return ErrContext{"LDSSpouseSealing", cPLAC, ErrSingleMultiple}
  2875  			}
  2876  			PlaceSet = true
  2877  			if err := s.Place.parse(&sl, o); err != nil {
  2878  				return ErrContext{"LDSSpouseSealing", cPLAC, err}
  2879  			}
  2880  		case cSOUR:
  2881  			var t SourceCitation
  2882  			if err := t.parse(&sl, o); err != nil {
  2883  				return ErrContext{"LDSSpouseSealing", cSOUR, err}
  2884  			}
  2885  			s.Sources = append(s.Sources, t)
  2886  		case cNOTE:
  2887  			var t NoteStructure
  2888  			if err := t.parse(&sl, o); err != nil {
  2889  				return ErrContext{"LDSSpouseSealing", cNOTE, err}
  2890  			}
  2891  			s.Notes = append(s.Notes, t)
  2892  		default:
  2893  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  2894  				return ErrContext{"LDSSpouseSealing", sl.tag, ErrUnknownTag}
  2895  			}
  2896  			// possibly store in a Other field
  2897  		}
  2898  	}
  2899  	return nil
  2900  }
  2901  
  2902  // MultimediaLinkID is a GEDCOM structure type
  2903  type MultimediaLinkID struct {
  2904  	ID Xref
  2905  }
  2906  
  2907  func (s *MultimediaLinkID) parse(l *Line, o options) error {
  2908  	if err := s.ID.parse(&Line{line: line{value: l.xrefID}}, o); err != nil {
  2909  		return ErrContext{"MultimediaLinkID", "xrefID", err}
  2910  	}
  2911  	for _, sl := range l.Sub {
  2912  		if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  2913  			return ErrContext{"MultimediaLinkID", sl.tag, ErrUnknownTag}
  2914  		}
  2915  		// possibly store in a Other field
  2916  	}
  2917  	return nil
  2918  }
  2919  
  2920  // MultimediaLinkFile is a GEDCOM structure type
  2921  type MultimediaLinkFile struct {
  2922  	Format MultimediaFormat
  2923  	Title  DescriptiveTitle
  2924  	File   MultimediaFileReference
  2925  	Notes  []NoteStructure
  2926  }
  2927  
  2928  func (s *MultimediaLinkFile) parse(l *Line, o options) error {
  2929  	var FormatSet, TitleSet, FileSet bool
  2930  	for _, sl := range l.Sub {
  2931  		switch sl.tag {
  2932  		case cFORM:
  2933  			if FormatSet {
  2934  				if !o.allowMoreThanAllowed {
  2935  					continue
  2936  				}
  2937  				return ErrContext{"MultimediaLinkFile", cFORM, ErrSingleMultiple}
  2938  			}
  2939  			FormatSet = true
  2940  			if err := s.Format.parse(&sl, o); err != nil {
  2941  				return ErrContext{"MultimediaLinkFile", cFORM, err}
  2942  			}
  2943  		case cTITLE:
  2944  			if TitleSet {
  2945  				if !o.allowMoreThanAllowed {
  2946  					continue
  2947  				}
  2948  				return ErrContext{"MultimediaLinkFile", cTITLE, ErrSingleMultiple}
  2949  			}
  2950  			TitleSet = true
  2951  			if err := s.Title.parse(&sl, o); err != nil {
  2952  				return ErrContext{"MultimediaLinkFile", cTITLE, err}
  2953  			}
  2954  		case cFILE:
  2955  			if FileSet {
  2956  				if !o.allowMoreThanAllowed {
  2957  					continue
  2958  				}
  2959  				return ErrContext{"MultimediaLinkFile", cFILE, ErrSingleMultiple}
  2960  			}
  2961  			FileSet = true
  2962  			if err := s.File.parse(&sl, o); err != nil {
  2963  				return ErrContext{"MultimediaLinkFile", cFILE, err}
  2964  			}
  2965  		case cNOTE:
  2966  			var t NoteStructure
  2967  			if err := t.parse(&sl, o); err != nil {
  2968  				return ErrContext{"MultimediaLinkFile", cNOTE, err}
  2969  			}
  2970  			s.Notes = append(s.Notes, t)
  2971  		default:
  2972  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  2973  				return ErrContext{"MultimediaLinkFile", sl.tag, ErrUnknownTag}
  2974  			}
  2975  			// possibly store in a Other field
  2976  		}
  2977  	}
  2978  	if !o.allowMissingRequired {
  2979  		if !FormatSet {
  2980  			return ErrContext{"MultimediaLinkFile", "Format", ErrRequiredMissing}
  2981  		}
  2982  	}
  2983  	return nil
  2984  }
  2985  
  2986  // NoteID is a GEDCOM structure type
  2987  type NoteID struct {
  2988  	ID Xref
  2989  }
  2990  
  2991  func (s *NoteID) parse(l *Line, o options) error {
  2992  	if err := s.ID.parse(&Line{line: line{value: l.xrefID}}, o); err != nil {
  2993  		return ErrContext{"NoteID", "xrefID", err}
  2994  	}
  2995  	for _, sl := range l.Sub {
  2996  		if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  2997  			return ErrContext{"NoteID", sl.tag, ErrUnknownTag}
  2998  		}
  2999  		// possibly store in a Other field
  3000  	}
  3001  	return nil
  3002  }
  3003  
  3004  // NoteText is a GEDCOM structure type
  3005  type NoteText struct {
  3006  	SubmitterText SubmitterText
  3007  	Sources       []SourceCitation
  3008  }
  3009  
  3010  func (s *NoteText) parse(l *Line, o options) error {
  3011  	if err := s.SubmitterText.parse(l, o); err != nil {
  3012  		return ErrContext{"NoteText", "line_value", err}
  3013  	}
  3014  	for _, sl := range l.Sub {
  3015  		switch sl.tag {
  3016  		case cSOUR:
  3017  			var t SourceCitation
  3018  			if err := t.parse(&sl, o); err != nil {
  3019  				return ErrContext{"NoteText", cSOUR, err}
  3020  			}
  3021  			s.Sources = append(s.Sources, t)
  3022  		default:
  3023  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  3024  				return ErrContext{"NoteText", sl.tag, ErrUnknownTag}
  3025  			}
  3026  			// possibly store in a Other field
  3027  		}
  3028  	}
  3029  	return nil
  3030  }
  3031  
  3032  // PersonalNameStructure is a GEDCOM structure type
  3033  type PersonalNameStructure struct {
  3034  	NamePersonal  NamePersonal
  3035  	Prefix        NamePiecePrefix
  3036  	Given         NamePieceGiven
  3037  	Nickname      NamePieceNickname
  3038  	SurnamePrefix NamePieceSurnamePrefix
  3039  	Surname       NamePieceSurname
  3040  	Suffix        NamePieceSuffix
  3041  	Sources       []SourceCitation
  3042  	Notes         []NoteStructure
  3043  }
  3044  
  3045  func (s *PersonalNameStructure) parse(l *Line, o options) error {
  3046  	if err := s.NamePersonal.parse(l, o); err != nil {
  3047  		return ErrContext{"PersonalNameStructure", "line_value", err}
  3048  	}
  3049  	var PrefixSet, GivenSet, NicknameSet, SurnamePrefixSet, SurnameSet, SuffixSet bool
  3050  	for _, sl := range l.Sub {
  3051  		switch sl.tag {
  3052  		case cNPFX:
  3053  			if PrefixSet {
  3054  				if !o.allowMoreThanAllowed {
  3055  					continue
  3056  				}
  3057  				return ErrContext{"PersonalNameStructure", cNPFX, ErrSingleMultiple}
  3058  			}
  3059  			PrefixSet = true
  3060  			if err := s.Prefix.parse(&sl, o); err != nil {
  3061  				return ErrContext{"PersonalNameStructure", cNPFX, err}
  3062  			}
  3063  		case cGIVN:
  3064  			if GivenSet {
  3065  				if !o.allowMoreThanAllowed {
  3066  					continue
  3067  				}
  3068  				return ErrContext{"PersonalNameStructure", cGIVN, ErrSingleMultiple}
  3069  			}
  3070  			GivenSet = true
  3071  			if err := s.Given.parse(&sl, o); err != nil {
  3072  				return ErrContext{"PersonalNameStructure", cGIVN, err}
  3073  			}
  3074  		case cNICK:
  3075  			if NicknameSet {
  3076  				if !o.allowMoreThanAllowed {
  3077  					continue
  3078  				}
  3079  				return ErrContext{"PersonalNameStructure", cNICK, ErrSingleMultiple}
  3080  			}
  3081  			NicknameSet = true
  3082  			if err := s.Nickname.parse(&sl, o); err != nil {
  3083  				return ErrContext{"PersonalNameStructure", cNICK, err}
  3084  			}
  3085  		case cSPFX:
  3086  			if SurnamePrefixSet {
  3087  				if !o.allowMoreThanAllowed {
  3088  					continue
  3089  				}
  3090  				return ErrContext{"PersonalNameStructure", cSPFX, ErrSingleMultiple}
  3091  			}
  3092  			SurnamePrefixSet = true
  3093  			if err := s.SurnamePrefix.parse(&sl, o); err != nil {
  3094  				return ErrContext{"PersonalNameStructure", cSPFX, err}
  3095  			}
  3096  		case cSURN:
  3097  			if SurnameSet {
  3098  				if !o.allowMoreThanAllowed {
  3099  					continue
  3100  				}
  3101  				return ErrContext{"PersonalNameStructure", cSURN, ErrSingleMultiple}
  3102  			}
  3103  			SurnameSet = true
  3104  			if err := s.Surname.parse(&sl, o); err != nil {
  3105  				return ErrContext{"PersonalNameStructure", cSURN, err}
  3106  			}
  3107  		case cNSFX:
  3108  			if SuffixSet {
  3109  				if !o.allowMoreThanAllowed {
  3110  					continue
  3111  				}
  3112  				return ErrContext{"PersonalNameStructure", cNSFX, ErrSingleMultiple}
  3113  			}
  3114  			SuffixSet = true
  3115  			if err := s.Suffix.parse(&sl, o); err != nil {
  3116  				return ErrContext{"PersonalNameStructure", cNSFX, err}
  3117  			}
  3118  		case cSOUR:
  3119  			var t SourceCitation
  3120  			if err := t.parse(&sl, o); err != nil {
  3121  				return ErrContext{"PersonalNameStructure", cSOUR, err}
  3122  			}
  3123  			s.Sources = append(s.Sources, t)
  3124  		case cNOTE:
  3125  			var t NoteStructure
  3126  			if err := t.parse(&sl, o); err != nil {
  3127  				return ErrContext{"PersonalNameStructure", cNOTE, err}
  3128  			}
  3129  			s.Notes = append(s.Notes, t)
  3130  		default:
  3131  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  3132  				return ErrContext{"PersonalNameStructure", sl.tag, ErrUnknownTag}
  3133  			}
  3134  			// possibly store in a Other field
  3135  		}
  3136  	}
  3137  	return nil
  3138  }
  3139  
  3140  // PlaceStructure is a GEDCOM structure type
  3141  type PlaceStructure struct {
  3142  	Place          PlaceValue
  3143  	PlaceHierarchy PlaceHierarchy
  3144  	Sources        []SourceCitation
  3145  	Notes          []NoteStructure
  3146  }
  3147  
  3148  func (s *PlaceStructure) parse(l *Line, o options) error {
  3149  	if err := s.Place.parse(l, o); err != nil {
  3150  		return ErrContext{"PlaceStructure", "line_value", err}
  3151  	}
  3152  	var PlaceHierarchySet bool
  3153  	for _, sl := range l.Sub {
  3154  		switch sl.tag {
  3155  		case cFORM:
  3156  			if PlaceHierarchySet {
  3157  				if !o.allowMoreThanAllowed {
  3158  					continue
  3159  				}
  3160  				return ErrContext{"PlaceStructure", cFORM, ErrSingleMultiple}
  3161  			}
  3162  			PlaceHierarchySet = true
  3163  			if err := s.PlaceHierarchy.parse(&sl, o); err != nil {
  3164  				return ErrContext{"PlaceStructure", cFORM, err}
  3165  			}
  3166  		case cSOUR:
  3167  			var t SourceCitation
  3168  			if err := t.parse(&sl, o); err != nil {
  3169  				return ErrContext{"PlaceStructure", cSOUR, err}
  3170  			}
  3171  			s.Sources = append(s.Sources, t)
  3172  		case cNOTE:
  3173  			var t NoteStructure
  3174  			if err := t.parse(&sl, o); err != nil {
  3175  				return ErrContext{"PlaceStructure", cNOTE, err}
  3176  			}
  3177  			s.Notes = append(s.Notes, t)
  3178  		default:
  3179  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  3180  				return ErrContext{"PlaceStructure", sl.tag, ErrUnknownTag}
  3181  			}
  3182  			// possibly store in a Other field
  3183  		}
  3184  	}
  3185  	return nil
  3186  }
  3187  
  3188  // SourceID is a GEDCOM structure type
  3189  type SourceID struct {
  3190  	ID                  Xref
  3191  	WhereWithinSource   WhereWithinSource
  3192  	SourceCitationEvent SourceCitationEvent
  3193  	Data                SourceData
  3194  	Certainty           CertaintyAssessment
  3195  	Multimedia          []MultimediaLink
  3196  	Notes               []NoteStructure
  3197  }
  3198  
  3199  func (s *SourceID) parse(l *Line, o options) error {
  3200  	if err := s.ID.parse(&Line{line: line{value: l.xrefID}}, o); err != nil {
  3201  		return ErrContext{"SourceID", "xrefID", err}
  3202  	}
  3203  	var WhereWithinSourceSet, SourceCitationEventSet, DataSet, CertaintySet bool
  3204  	for _, sl := range l.Sub {
  3205  		switch sl.tag {
  3206  		case cPAGE:
  3207  			if WhereWithinSourceSet {
  3208  				if !o.allowMoreThanAllowed {
  3209  					continue
  3210  				}
  3211  				return ErrContext{"SourceID", cPAGE, ErrSingleMultiple}
  3212  			}
  3213  			WhereWithinSourceSet = true
  3214  			if err := s.WhereWithinSource.parse(&sl, o); err != nil {
  3215  				return ErrContext{"SourceID", cPAGE, err}
  3216  			}
  3217  		case cEVEN:
  3218  			if SourceCitationEventSet {
  3219  				if !o.allowMoreThanAllowed {
  3220  					continue
  3221  				}
  3222  				return ErrContext{"SourceID", cEVEN, ErrSingleMultiple}
  3223  			}
  3224  			SourceCitationEventSet = true
  3225  			if err := s.SourceCitationEvent.parse(&sl, o); err != nil {
  3226  				return ErrContext{"SourceID", cEVEN, err}
  3227  			}
  3228  		case cDATA:
  3229  			if DataSet {
  3230  				if !o.allowMoreThanAllowed {
  3231  					continue
  3232  				}
  3233  				return ErrContext{"SourceID", cDATA, ErrSingleMultiple}
  3234  			}
  3235  			DataSet = true
  3236  			if err := s.Data.parse(&sl, o); err != nil {
  3237  				return ErrContext{"SourceID", cDATA, err}
  3238  			}
  3239  		case cQUAY:
  3240  			if CertaintySet {
  3241  				if !o.allowMoreThanAllowed {
  3242  					continue
  3243  				}
  3244  				return ErrContext{"SourceID", cQUAY, ErrSingleMultiple}
  3245  			}
  3246  			CertaintySet = true
  3247  			if err := s.Certainty.parse(&sl, o); err != nil {
  3248  				return ErrContext{"SourceID", cQUAY, err}
  3249  			}
  3250  		case cOBJE:
  3251  			var t MultimediaLink
  3252  			if err := t.parse(&sl, o); err != nil {
  3253  				return ErrContext{"SourceID", cOBJE, err}
  3254  			}
  3255  			s.Multimedia = append(s.Multimedia, t)
  3256  		case cNOTE:
  3257  			var t NoteStructure
  3258  			if err := t.parse(&sl, o); err != nil {
  3259  				return ErrContext{"SourceID", cNOTE, err}
  3260  			}
  3261  			s.Notes = append(s.Notes, t)
  3262  		default:
  3263  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  3264  				return ErrContext{"SourceID", sl.tag, ErrUnknownTag}
  3265  			}
  3266  			// possibly store in a Other field
  3267  		}
  3268  	}
  3269  	return nil
  3270  }
  3271  
  3272  // SourceCitationEvent is a GEDCOM structure type
  3273  type SourceCitationEvent struct {
  3274  	EventTypeCitedFrom EventTypeCitedFrom
  3275  	Role               RoleInEvent
  3276  }
  3277  
  3278  func (s *SourceCitationEvent) parse(l *Line, o options) error {
  3279  	if err := s.EventTypeCitedFrom.parse(l, o); err != nil {
  3280  		return ErrContext{"SourceCitationEvent", "line_value", err}
  3281  	}
  3282  	var RoleSet bool
  3283  	for _, sl := range l.Sub {
  3284  		switch sl.tag {
  3285  		case cROLE:
  3286  			if RoleSet {
  3287  				if !o.allowMoreThanAllowed {
  3288  					continue
  3289  				}
  3290  				return ErrContext{"SourceCitationEvent", cROLE, ErrSingleMultiple}
  3291  			}
  3292  			RoleSet = true
  3293  			if err := s.Role.parse(&sl, o); err != nil {
  3294  				return ErrContext{"SourceCitationEvent", cROLE, err}
  3295  			}
  3296  		default:
  3297  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  3298  				return ErrContext{"SourceCitationEvent", sl.tag, ErrUnknownTag}
  3299  			}
  3300  			// possibly store in a Other field
  3301  		}
  3302  	}
  3303  	return nil
  3304  }
  3305  
  3306  // SourceData is a GEDCOM structure type
  3307  type SourceData struct {
  3308  	Date EntryRecordingDate
  3309  	Text []TextFromSource
  3310  }
  3311  
  3312  func (s *SourceData) parse(l *Line, o options) error {
  3313  	var DateSet bool
  3314  	for _, sl := range l.Sub {
  3315  		switch sl.tag {
  3316  		case cDATE:
  3317  			if DateSet {
  3318  				if !o.allowMoreThanAllowed {
  3319  					continue
  3320  				}
  3321  				return ErrContext{"SourceData", cDATE, ErrSingleMultiple}
  3322  			}
  3323  			DateSet = true
  3324  			if err := s.Date.parse(&sl, o); err != nil {
  3325  				return ErrContext{"SourceData", cDATE, err}
  3326  			}
  3327  		case cTEXT:
  3328  			var t TextFromSource
  3329  			if err := t.parse(&sl, o); err != nil {
  3330  				return ErrContext{"SourceData", cTEXT, err}
  3331  			}
  3332  			s.Text = append(s.Text, t)
  3333  		default:
  3334  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  3335  				return ErrContext{"SourceData", sl.tag, ErrUnknownTag}
  3336  			}
  3337  			// possibly store in a Other field
  3338  		}
  3339  	}
  3340  	return nil
  3341  }
  3342  
  3343  // SourceText is a GEDCOM structure type
  3344  type SourceText struct {
  3345  	Description SourceDescription
  3346  	Texts       []TextFromSource
  3347  	Notes       []NoteStructure
  3348  }
  3349  
  3350  func (s *SourceText) parse(l *Line, o options) error {
  3351  	if err := s.Description.parse(l, o); err != nil {
  3352  		return ErrContext{"SourceText", "line_value", err}
  3353  	}
  3354  	for _, sl := range l.Sub {
  3355  		switch sl.tag {
  3356  		case cTEXT:
  3357  			var t TextFromSource
  3358  			if err := t.parse(&sl, o); err != nil {
  3359  				return ErrContext{"SourceText", cTEXT, err}
  3360  			}
  3361  			s.Texts = append(s.Texts, t)
  3362  		case cNOTE:
  3363  			var t NoteStructure
  3364  			if err := t.parse(&sl, o); err != nil {
  3365  				return ErrContext{"SourceText", cNOTE, err}
  3366  			}
  3367  			s.Notes = append(s.Notes, t)
  3368  		default:
  3369  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  3370  				return ErrContext{"SourceText", sl.tag, ErrUnknownTag}
  3371  			}
  3372  			// possibly store in a Other field
  3373  		}
  3374  	}
  3375  	return nil
  3376  }
  3377  
  3378  // SourceRepositoryCitation is a GEDCOM structure type
  3379  type SourceRepositoryCitation struct {
  3380  	ID      Xref
  3381  	Numbers []SourceCallStructure
  3382  }
  3383  
  3384  func (s *SourceRepositoryCitation) parse(l *Line, o options) error {
  3385  	if err := s.ID.parse(&Line{line: line{value: l.xrefID}}, o); err != nil {
  3386  		return ErrContext{"SourceRepositoryCitation", "xrefID", err}
  3387  	}
  3388  	for _, sl := range l.Sub {
  3389  		switch sl.tag {
  3390  		case cCALN:
  3391  			var t SourceCallStructure
  3392  			if err := t.parse(&sl, o); err != nil {
  3393  				return ErrContext{"SourceRepositoryCitation", cCALN, err}
  3394  			}
  3395  			s.Numbers = append(s.Numbers, t)
  3396  		default:
  3397  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  3398  				return ErrContext{"SourceRepositoryCitation", sl.tag, ErrUnknownTag}
  3399  			}
  3400  			// possibly store in a Other field
  3401  		}
  3402  	}
  3403  	return nil
  3404  }
  3405  
  3406  // SourceCallStructure is a GEDCOM structure type
  3407  type SourceCallStructure struct {
  3408  	SourceCallNumber SourceCallNumber
  3409  	Type             SourceMediaType
  3410  }
  3411  
  3412  func (s *SourceCallStructure) parse(l *Line, o options) error {
  3413  	if err := s.SourceCallNumber.parse(l, o); err != nil {
  3414  		return ErrContext{"SourceCallStructure", "line_value", err}
  3415  	}
  3416  	var TypeSet bool
  3417  	for _, sl := range l.Sub {
  3418  		switch sl.tag {
  3419  		case cMEDI:
  3420  			if TypeSet {
  3421  				if !o.allowMoreThanAllowed {
  3422  					continue
  3423  				}
  3424  				return ErrContext{"SourceCallStructure", cMEDI, ErrSingleMultiple}
  3425  			}
  3426  			TypeSet = true
  3427  			if err := s.Type.parse(&sl, o); err != nil {
  3428  				return ErrContext{"SourceCallStructure", cMEDI, err}
  3429  			}
  3430  		default:
  3431  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  3432  				return ErrContext{"SourceCallStructure", sl.tag, ErrUnknownTag}
  3433  			}
  3434  			// possibly store in a Other field
  3435  		}
  3436  	}
  3437  	return nil
  3438  }
  3439  
  3440  // SpouseToFamilyLink is a GEDCOM structure type
  3441  type SpouseToFamilyLink struct {
  3442  	ID    Xref
  3443  	Notes []NoteStructure
  3444  }
  3445  
  3446  func (s *SpouseToFamilyLink) parse(l *Line, o options) error {
  3447  	if err := s.ID.parse(l, o); err != nil {
  3448  		return ErrContext{"SpouseToFamilyLink", "line_value", err}
  3449  	}
  3450  	for _, sl := range l.Sub {
  3451  		switch sl.tag {
  3452  		case cNOTE:
  3453  			var t NoteStructure
  3454  			if err := t.parse(&sl, o); err != nil {
  3455  				return ErrContext{"SpouseToFamilyLink", cNOTE, err}
  3456  			}
  3457  			s.Notes = append(s.Notes, t)
  3458  		default:
  3459  			if !o.allowMissingRequired && (len(sl.tag) < 1 || sl.tag[0] != '_') {
  3460  				return ErrContext{"SpouseToFamilyLink", sl.tag, ErrUnknownTag}
  3461  			}
  3462  			// possibly store in a Other field
  3463  		}
  3464  	}
  3465  	return nil
  3466  }
  3467  
  3468  // MultimediaLink splite between MultimediaLinkID and MultimediaLinkFile
  3469  type MultimediaLink struct {
  3470  	Data Record
  3471  }
  3472  
  3473  func (s *MultimediaLink) parse(l *Line, o options) error {
  3474  	var err error
  3475  	if l.xrefID != "" {
  3476  		t := &MultimediaLinkID{}
  3477  		err = t.parse(l, o)
  3478  		s.Data = t
  3479  	} else {
  3480  		t := &MultimediaLinkFile{}
  3481  		err = t.parse(l, o)
  3482  		s.Data = t
  3483  	}
  3484  	return err
  3485  }
  3486  
  3487  // NoteStructure splits between NoteID and NoteText
  3488  type NoteStructure struct {
  3489  	Data Record
  3490  }
  3491  
  3492  func (s *NoteStructure) parse(l *Line, o options) error {
  3493  	var err error
  3494  	if l.xrefID != "" {
  3495  		t := &NoteID{}
  3496  		err = t.parse(l, o)
  3497  		s.Data = t
  3498  	} else {
  3499  		t := &NoteText{}
  3500  		err = t.parse(l, o)
  3501  		s.Data = t
  3502  	}
  3503  	return err
  3504  }
  3505  
  3506  // SourceCitation splits between SourceID and SourceText
  3507  type SourceCitation struct {
  3508  	Data Record
  3509  }
  3510  
  3511  func (s *SourceCitation) parse(l *Line, o options) error {
  3512  	var err error
  3513  	if l.xrefID != "" {
  3514  		t := &SourceID{}
  3515  		err = t.parse(l, o)
  3516  		s.Data = t
  3517  	} else {
  3518  		t := &SourceText{}
  3519  		err = t.parse(l, o)
  3520  		s.Data = t
  3521  	}
  3522  	return err
  3523  }
  3524  
  3525  // Trailer type
  3526  type Trailer struct{}
  3527  
  3528  func (s *Trailer) parse(*Line, options) error {
  3529  	return nil
  3530  }
  3531  
  3532  // Errors
  3533  var (
  3534  	ErrRequiredMissing = errors.New("required tag missing")
  3535  	ErrSingleMultiple  = errors.New("tag was specified more than the one time allowed")
  3536  	ErrUnknownTag      = errors.New("unknown tag")
  3537  )
  3538  
  3539  // ErrContext adds context to a returned error
  3540  type ErrContext struct {
  3541  	Structure, Tag string
  3542  	Err            error
  3543  }
  3544  
  3545  // Error implements the error interface
  3546  func (e ErrContext) Error() string {
  3547  	return e.Tag + ":" + e.Err.Error()
  3548  }
  3549  
  3550  // Unwrap goes through the error list to retrieve the underlying
  3551  // (non-ErrContext) error
  3552  func (e ErrContext) Unwrap() error {
  3553  	err := e.Err
  3554  	for {
  3555  		if er, ok := err.(ErrContext); ok {
  3556  			err = er.Err
  3557  			continue
  3558  		}
  3559  		return err
  3560  	}
  3561  }
  3562  
  3563  // ErrTooMany is an error returned when too many of a particular tag exist
  3564  type ErrTooMany int
  3565  
  3566  // Error implements the error interface
  3567  func (ErrTooMany) Error() string {
  3568  	return "too many tags"
  3569  }
  3570