gedcom: github.com/elliotchance/gedcom Index | Files | Directories

package gedcom

import "github.com/elliotchance/gedcom"

Copying

All nodes (since they implement the Node interface) also implement the NodeCopier interface which provides the ShallowCopy() function.

A shallow copy returns a new node with all the same properties, but no children.

On the other hand there is a DeepCopy function which returns a new node with all recursive children also copied. This ensures that the new returned node can be manipulated without affecting the original node or any of its children.

Dates

Dates in GEDCOM files can be very complex as they can cater for many scenarios:

1. Incomplete, like "Dec 1943"

2. Anchored, like "Aft. 3 Sep 2003" or "Before 1923"

3. Ranges, like "Bet. 4 Apr 1823 and 8 Apr 1823"

4. Phrases, like "(Foo Bar)"

This package provides a very rich API for dealing with all kind of dates in a meaningful and sensible way. Some notable features include:

1. All dates, even though that specify an specific day have a minimum and maximum value that are their true bounds. This is especially important for larger date ranges like the whole month of "Jun 1945".

2. Upper and lower bounds of dates can be converted to the native Go time.Time object.

3. There is a Years function that provides a convenient way to normalise a date range into a number for easier distance and comparison measurements.

4. Algorithms for calculating the similarity of dates on a configurable parabola.

Decoding a Document

Decoding a GEDCOM stream:

ged := "0 HEAD\n1 CHAR UTF-8"

decoder := gedcom.NewDecoder(strings.NewReader(ged))
document, err := decoder.Decode()
if err != nil {
  panic(err)
}

If you are reading from a file you can use NewDocumentFromGEDCOMFile:

document, err := gedcom.NewDocumentFromGEDCOMFile("family.ged")
if err != nil {
    panic(err)
}

Package gedcom contains functionality for encoding, decoding, traversing, manipulating and comparing of GEDCOM data.

Installation

You can download the latest binaries for macOS, Windows and Linux on the Releases page: https://github.com/elliotchance/gedcom/releases

This will not require you to install Go or any other dependencies.

If you wish to build it from source you must install the dependencies with:

dep ensure

Traversing a Document

On top of the raw document is a powerful API that takes care of the complex traversing of the Document. Here is a simple example:

for _, individual := range document.Individuals() {
  fmt.Println(individual.Name().String())
}

Some of the nodes in a GEDCOM file have been replaced with more function rich types, such as names, dates, families and more.

Encoding a Document

buf := bytes.NewBufferString("")

encoder := NewEncoder(buf, doc)
err := encoder.Encode()
if err != nil {
  panic(err)
}

If you need the GEDCOM data as a string you can simply using fmt.Stringer:

data := document.String()

Filtering and Tree Walking

The Filter function recursively removes or manipulates nodes with a FilterFunction:

newNodes := gedcom.Filter(node, func (node gedcom.Node) (gedcom.Node, bool) {
  if node.Tag().Is(gedcom.TagIndividual) {
    // false means it will not traverse children, since an
    // individual can never be inside of another individual.
    return node, false
  }

  return nil, false
})

// Remove all tags that are not official.
newNodes := gedcom.Filter(node, gedcom.OfficialTagFilter())

Some examples of Filter functions include BlacklistTagFilter, OfficialTagFilter, SimpleNameFilter and WhitelistTagFilter.

Merging

There are several functions available that handle different kinds of merging:

- MergeNodes(left, right Node) Node: returns a new node that merges children from both nodes.

- MergeNodeSlices(left, right Nodes, mergeFn MergeFunction) Nodes: merges two slices based on the mergeFn. This allows more advanced merging when dealing with slices of nodes.

- MergeDocuments(left, right *Document, mergeFn MergeFunction) *Document: creates a new document with their respective nodes merged. You can use IndividualBySurroundingSimilarityMergeFunction with this to merge individuals, rather than just appending them all.

The MergeFunction is a type that can be received in some of the merging functions. The closure determines if two nodes should be merged and what the result would be. Alternatively it can also describe when two nodes should not be merged.

You may certainly create your own MergeFunction, but there are some that are already included:

- IndividualBySurroundingSimilarityMergeFunction creates a MergeFunction that will merge individuals if their surrounding similarity is at least minimumSimilarity.

- EqualityMergeFunction is a MergeFunction that will return a merged node if the node are considered equal (with Equals).

Equality

Node.Equals performs a shallow comparison between two nodes. The implementation is different depending on the types of nodes being compared. You should see the specific documentation for the Node.

Equality is not to be confused with the Is function seen on some of the nodes, such as Date.Is. The Is function is used to compare exact raw values in nodes.

DeepEqual tests if left and right are recursively equal.

Comparing and Diffing

CompareNodes recursively compares two nodes. For example:

0 INDI @P3@           |  0 INDI @P4@
1 NAME John /Smith/   |  1 NAME J. /Smith/
1 BIRT                |  1 BIRT
2 DATE 3 SEP 1943     |  2 DATE Abt. Sep 1943
1 DEAT                |  1 BIRT
2 PLAC England        |  2 DATE 3 SEP 1943
1 BIRT                |  1 DEAT
2 DATE Abt. Oct 1943  |  2 DATE Aft. 2001
                      |  2 PLAC Surry, England

Produces a *NodeDiff than can be rendered with the String method:

LR 0 INDI @P3@
L  1 NAME John /Smith/
LR 1 BIRT
L  2 DATE Abt. Oct 1943
LR 2 DATE 3 SEP 1943
 R 2 DATE Abt. Sep 1943
LR 1 DEAT
L  2 PLAC England
 R 2 DATE Aft. 2001
 R 2 PLAC Surry, England
 R 1 NAME J. /Smith/

Index

Package Files

age.go age_constraint.go baptism_node.go birth_node.go burial_node.go child_born_before_parent_warning.go child_node.go child_nodes.go copy.go countries.go date.go date_constraint.go date_node.go date_nodes.go date_range.go date_range_comparison.go dater.go death_node.go decoder.go doc.go document.go document_noder.go duration.go encoder.go entity_map.go equal.go errors.go event_node.go family_node.go family_noder.go family_nodes.go familysearch_id_node.go filter.go filter_flags.go flatten.go format_node.go gedcomer.go husband_node.go individual_comparison.go individual_node.go individual_node_pair.go individual_node_pairs.go individual_nodes.go jaro.go latitude_node.go longitude_node.go map_node.go merge.go name_format.go name_node.go name_type.go nickname_node.go node.go node_diff.go node_set.go noder.go nodes.go note_node.go number.go object_mapper.go phonetic_variation_node.go place_node.go placer.go progress.go residence_node.go romanized_variation_node.go sex_node.go siblings_born_too_close_warning.go similarity_options.go simple_document_node.go simple_node.go source_node.go string_set.go surrounding_similarity.go tag.go type_node.go unique_id_node.go unparsable_date_warning.go util.go uuid.go warner.go warning.go warnings.go wife_node.go years.go

Constants

const (
    DateWordsBetween = "Bet.|bet|between|from"
    DateWordsAnd     = "and|to|-"
    DateWordsAbout   = "Abt.|abt|about|c.|ca|ca.|cca|cca.|circa"
    DateWordsAfter   = "Aft.|aft|after"
    DateWordsBefore  = "Bef.|bef|before"
)

The constants are used in regular expressions and documented on DateNode.

Pipes are used to separate the values to make the options easier to use in regular expressions. The first value of each constant is important as it is the default when converting back to a string.

const (
    // There is no constraint. The date is at the value specified.
    DateConstraintExact = DateConstraint(iota)

    // The date is approximate. There is no defined error margin (how much the
    // date may be off by) but in mose cases it is save to assume it is
    // proportional to how precise the date is. That is, usually a date that
    // provides a day, month and year will have a smaller error margin than a
    // day that only provides a year.
    DateConstraintAbout

    // The real date is before the specified date value. This often (but not
    // always) follows the same proportional rules as DateConstraintApprox.
    DateConstraintBefore

    // The real date is after the specified date value. This often (but not
    // always) follows the same proportional rules as DateConstraintApprox.
    DateConstraintAfter
)
const (
    // DateRangeComparisonInvalid is only used in cases of an error.
    DateRangeComparisonInvalid = DateRangeComparison(iota)

    // Equal means that both date ranges are exactly the same in start and end
    // date, or they have an equivalent other value:
    //
    //   Yes:
    //     3 Sep 1943            3 Sep 1943
    //     Sep 1943 - Mar 1944   Sep 1943 - Mar 1944
    //     (world war 2)         (world war 2)
    //
    //   No:
    //     3 Sep 1943            Sep 1943
    //     Sep 1943 - Mar 1944   Sep 1943 - 3 Mar 1944
    //     (world war 2)         (world war 1)
    //
    DateRangeComparisonEqual = iota

    // Inside means that the right operand is both smaller and encapsulated by
    // the greater range in both directions of the left operand. The Start and
    // End derivatives represent if certain boundaries are also equal.
    //
    //   Yes:
    //     3 Sep 1943 - 20 Sep 1943   5 Sep 1943 - 17 Sep 1943
    //     Sep 1943                   3 Sep 1943 - 20 Sep 1943
    //   No:
    //     3 Sep 1943 - 20 Sep 1943   1 Sep 1943 - 5 Sep 1943
    //     Sep 1943                   20 Sep 1943 - 10 Oct 1943
    //     (world war 2)              (world war 2)
    //
    DateRangeComparisonInside      = iota
    DateRangeComparisonInsideStart = iota
    DateRangeComparisonInsideEnd   = iota

    // Outside means that the right operand is larger in both directions. The
    // opposite of Inside. The Start and End derivatives represent if certain
    // boundaries are also equal.
    //
    //   Yes:
    //     3 Sep 1943 - 20 Sep 1943   1 Sep 1943 - 25 Sep 1943
    //     Sep 1943                   14 Jul 1943 - 10 Oct 1943
    //   No:
    //     3 Sep 1943 - 20 Sep 1943   1 Sep 1943 - 5 Sep 1943
    //     Sep 1943                   20 Sep 1943 - 10 Oct 1943
    //     (world war 2)              (world war 2)
    //
    DateRangeComparisonOutside      = iota
    DateRangeComparisonOutsideStart = iota
    DateRangeComparisonOutsideEnd   = iota

    // PartiallyBefore means the right operand range surrounds the start of the
    // left operand.
    //
    //   Yes:
    //     3 Sep 1943 - 20 Sep 1943   1 Sep 1943 - 5 Sep 1943
    //     Sep 1943                   14 Jul 1943 - 10 Sep 1943
    //   No:
    //     3 Sep 1943 - 20 Sep 1943   1 Sep 1943 - 25 Sep 1943
    //     Sep 1943                   20 Sep 1943 - 10 Oct 1943
    //     (world war 2)              (world war 2)
    //
    DateRangeComparisonPartiallyBefore = iota

    // PartiallyAfter means the right operand range surrounds the end of the
    // left operand.
    //
    //   Yes:
    //     3 Sep 1943 - 20 Sep 1943   17 Sep 1943 - 25 Sep 1943
    //     Sep 1943                   10 Sep 1943 - 10 Oct 1943
    //   No:
    //     3 Sep 1943 - 20 Sep 1943   10 Sep 1943 - 15 Sep 1943
    //     Sep 1943                   20 Sep 1943 - 25 Sep 1943
    //     (world war 2)              (world war 2)
    //
    DateRangeComparisonPartiallyAfter = iota

    // Before means the right operand range starts before the left operand's
    // before, but ends at the same value as the start of the left operand.
    //
    //   Yes:
    //     3 Sep 1943 - 20 Sep 1943   1 Sep 1943 - 3 Sep 1943
    //     Sep 1943                   14 Jul 1943 - 1 Sep 1943
    //   No:
    //     3 Sep 1943 - 20 Sep 1943   1 Sep 1943 - 4 Sep 1943
    //     Sep 1943                   14 Jul 1943 - 10 Sep 1943
    //     (world war 2)              (world war 2)
    //
    DateRangeComparisonBefore = iota

    // After means the right operand starts at the end of the left operand and
    // ends somewhere thereafter.
    //
    //   Yes:
    //     3 Sep 1943 - 20 Sep 1943   20 Sep 1943 - 25 Sep 1943
    //     Sep 1943                   30 Sep 1943 - 10 Oct 1943
    //   No:
    //     3 Sep 1943 - 20 Sep 1943   19 Sep 1943 - 25 Sep 1943
    //     Sep 1943                   20 Sep 1943 - 25 Sep 1943
    //     (world war 2)              (world war 2)
    //
    DateRangeComparisonAfter = iota

    // EntirelyBefore means that the full range of the right operand is before
    // any of the range of the left operand.
    //
    //   Yes:
    //     3 Sep 1943 - 20 Sep 1943   1 Sep 1943 - 2 Sep 1943
    //     Sep 1943                   3 Jul 1943 - 10 Jul 1943
    //   No:
    //     3 Sep 1943 - 20 Sep 1943   19 Sep 1943 - 25 Sep 1943
    //     Sep 1943                   20 Sep 1943 - 25 Sep 1943
    //     (world war 2)              (world war 2)
    //
    DateRangeComparisonEntirelyBefore = iota

    // EntirelyAfter means that the full range of the right operand is after
    // any of the range of the left operand.
    //
    //   Yes:
    //     3 Sep 1943 - 20 Sep 1943   25 Sep 1943 - 30 Sep 1943
    //     Sep 1943                   3 Oct 1943 - 10 Oct 1943
    //   No:
    //     3 Sep 1943 - 20 Sep 1943   19 Sep 1943 - 25 Sep 1943
    //     Sep 1943                   20 Sep 1943 - 25 Sep 1943
    //     (world war 2)              (world war 2)
    //
    DateRangeComparisonEntirelyAfter = iota
)

Each of the constants below represent how the ranges cross over. See DateRangeComparison for a visual explanation.

const (
    DefaultJaroWinklerBoostThreshold = 0.0
    DefaultJaroWinklerPrefixSize     = 8
)

Theses constants are used with JaroWinkler. They have been calculated using the gedcomtune command.

const (
    NameTypeNormal      = NameType("")
    NameTypeMarriedName = NameType("married")
    NameTypeAlsoKnownAs = NameType("aka")
    NameTypeMaidenName  = NameType("maiden")
    NameTypeNickname    = NameType("nick")
)
const (
    // Phonetic method for sounding Korean glifs.
    PhoneticVariationTypeHangul = "hangul"

    // Hiragana and/or Katakana characters were used in sounding the Kanji
    // character used by japanese.
    PhoneticVariationTypeKana = "kana"
)

Indicates the method used in transforming the text to the phonetic variation.

These constants can be used for PhoneticVariationNode.Type.Value. The value is not limited to these constants. Any user defined value is also valid.

const (
    RomanizedVariationTypePinyin    = "pinyin"
    RomanizedVariationTypeRomaji    = "romaji"
    RomanizedVariationTypeWadegiles = "wadegiles"
)

Indicates the method used in transforming the text to a romanized variation.

These constants can be used for RomanizedVariationNode.Type.Value. The value is not limited to these constants. Any user defined value is also valid.

const (
    SexMale    = "M"
    SexFemale  = "F"
    SexUnknown = "U"
)
const DefaultMaxLivingAge = 100.0

DefaultMaxLivingAge is used when creating a new document. See Document.MaxLivingAge for a full description.

const DefaultMaxYearsForSimilarity = float64(3)

DefaultMaxYearsForSimilarity is a sensible default for the Similarity function (maxYears) when comparing dates. The importance of maxYears is explained in DateNode.Similarity.

Unless you need to ensure similarity values are retained correctly through versions you should use this constant instead of specifying a raw value to DateNode.Similarity. This value may change in time if a more accurate default is found.

The gedcomtune tool was used to find an ideal value for this. Generally speaking 2 - 3 years yielded much the same result. Any further in either direction led to a drop in accuracy for matching individuals.

const DefaultMinimumSimilarity = 0.733

DefaultMinimumSimilarity is a sensible value to provide to the minimumSimilarity parameter of IndividualNodes.Similarity.

It is quite possible that this value will change in the future if a more accurate figure is found or the algorithm is generally tuned with different weightings.

The value was chosen by running comparison experiments with gedcomtune, a tool to try and find ideal values for constants like this.

const NoIndent = -1

NoIndent can be used with GEDCOMLine and GEDCOMString so that the output does not contain the indent-levels.

const Year = time.Duration(float64(time.Hour) * 24 * 365.25)

Year is an approximation for the duration of a year.

This should not be used in calculations that require more than month-level precision.

A year is approximated at 365.25 to take into account leap years.

Variables

var (
    // A short name of a title, description, or name.
    TagAbbreviation = newTag("ABBR", "Abbreviation", tagOptionNone, tagSortIndividualInfo)

    // The contemporary place, usually required for postal purposes, of an
    // individual, a submitter of information, a repository, a business, a
    // school, or a company.
    TagAddress = newTag("ADDR", "Address", tagOptionNone, tagSortIndividualInfo)

    // The first line of an address.
    TagAddress1 = newTag("ADR1", "Address Line 1", tagOptionNone, tagSortIndividualInfo)

    // The second line of an address.
    TagAddress2 = newTag("ADR2", "Address Line 2", tagOptionNone, tagSortIndividualInfo)

    // Pertaining to creation of a child-parent relationship that does not exist
    // biologically.
    TagAdoption = newTag("ADOP", "Adoption", tagOptionEvent, tagSortIndividualEvents)

    // Ancestral File Number, a unique permanent record file number of an
    // individual record stored in Ancestral File.
    TagAncestralFileNumber = newTag("AFN", "Ancestral File Number", tagOptionNone, tagSortIndividualInfo)

    // The age of the individual at the time an event occurred, or the age
    // listed in the document.
    TagAge = newTag("AGE", "Age", tagOptionNone, tagSortIndividualInfo)

    // The institution or individual having authority and/or responsibility to
    // manage or govern.
    TagAgency = newTag("AGNC", "Agency", tagOptionNone, tagSortIndividualInfo)

    // An indicator to link different record descriptions of a person who may be
    // the same person.
    TagAlias = newTag("ALIA", "Alias", tagOptionNone, tagSortIndividualInfo)

    // Pertaining to forbearers of an individual.
    TagAncestors = newTag("ANCE", "Ancestors", tagOptionNone, tagSortIndividualInfo)

    // Indicates an interest in additional research for ancestors of this
    // individual. (See also DESI)
    TagAncestorsInterest = newTag("ANCI", "Ancestors Interest", tagOptionNone, tagSortIndividualInfo)

    // Declaring a marriage void from the beginning (never existed).
    TagAnnulment = newTag("ANUL", "Annulment", tagOptionEvent, tagSortIndividualEvents)

    // An indicator to link friends, neighbors, relatives, or associates of an
    // individual.
    TagAssociates = newTag("ASSO", "Associates", tagOptionNone, tagSortIndividualInfo)

    // The name of the individual who created or compiled information.
    TagAuthor = newTag("AUTH", "Author", tagOptionNone, tagSortIndividualInfo)

    // The event of baptism performed at age eight or later by priesthood
    // authority of the LDS Church. (See also BAPM)
    TagLDSBaptism = newTag("BAPL", "LDS Baptism", tagOptionEvent, tagSortIndividualEvents)

    // See BaptismNode.
    TagBaptism = newTag("BAPM", "Baptism", tagOptionEvent, tagSortIndividualEvents)

    // The ceremonial event held when a Jewish boy reaches age 13.
    TagBarMitzvah = newTag("BARM", "Bar Mitzvah", tagOptionEvent, tagSortIndividualEvents)

    // The ceremonial event held when a Jewish girl reaches age 13, also known
    // as "Bat Mitzvah."
    TagBasMitzvah = newTag("BASM", "Bas Mitzvah", tagOptionEvent, tagSortIndividualEvents)

    // See BirthNode.
    TagBirth = newTag("BIRT", "Birth", tagOptionEvent, tagSortIndividualBirth)

    // A religious event of bestowing divine care or intercession. Sometimes
    // given in connection with a naming ceremony.
    TagBlessing = newTag("BLES", "Blessing", tagOptionEvent, tagSortIndividualEvents)

    // A grouping of data used as input to a multimedia system that processes
    // binary data to represent images, sound, and video. Deleted in Gedcom
    // 5.5.1
    TagBinaryObject = newTag("BLOB", "Binary Object", tagOptionNone, tagSortIndividualInfo)

    // See BurialNode.
    TagBurial = newTag("BURI", "Burial", tagOptionEvent, tagSortIndividualBurial)

    // The number used by a repository to identify the specific items in its
    // collections.
    TagCallNumber = newTag("CALN", "Call Number", tagOptionNone, tagSortIndividualInfo)

    // The name of an individual's rank or status in society, based on racial or
    // religious differences, or differences in wealth, inherited rank,
    // profession, occupation, etc.
    TagCaste = newTag("CAST", "Caste", tagOptionNone, tagSortIndividualInfo)

    // A description of the cause of the associated event or fact, such as the
    // cause of death.
    TagCause = newTag("CAUS", "Cause", tagOptionNone, tagSortIndividualInfo)

    // The event of the periodic count of the population for a designated
    // locality, such as a national or state Census.
    TagCensus = newTag("CENS", "Census", tagOptionEvent, tagSortIndividualEvents)

    // Indicates a change, correction, or modification. Typically used in
    // connection with a DATE to specify when a change in information occurred.
    TagChange = newTag("CHAN", "Change", tagOptionNone, tagSortIndividualInfo)

    // An indicator of the character set used in writing this automated
    // information.
    TagCharacterSet = newTag("CHAR", "Character Set", tagOptionNone, tagSortIndividualInfo)

    // See ChildNode.
    TagChild = newTag("CHIL", "Child", tagOptionNone, tagSortIndividualInfo)

    // The religious event (not LDS) of baptizing and/or naming a child.
    TagChristening = newTag("CHR", "Christening", tagOptionEvent, tagSortIndividualEvents)

    // The religious event (not LDS) of baptizing and/or naming an adult person.
    TagAdultChristening = newTag("CHRA", "Adult Christening", tagOptionEvent, tagSortIndividualEvents)

    // A lower level jurisdictional unit. Normally an incorporated municipal
    // unit.
    TagCity = newTag("CITY", "City", tagOptionNone, tagSortIndividualInfo)

    // An indicator that additional data belongs to the superior value. The
    // information from the CONC value is to be connected to the value of the
    // superior preceding line without a space and without a carriage return
    // and/or new line character. Values that are split for a CONC tag must
    // always be split at a non-space. If the value is split on a space the
    // space will be lost when concatenation takes place. This is because of the
    // treatment that spaces get as a GEDCOM delimiter, many GEDCOM values are
    // trimmed of trailing spaces and some systems look for the first non-space
    // starting after the tag to determine the beginning of the value.
    TagConcatenation = newTag("CONC", "Concatenation", tagOptionNone, tagSortIndividualInfo)

    // The religious event (not LDS) of conferring the gift of the Holy Ghost
    // and, among protestants, full church membership.
    TagConfirmation = newTag("CONF", "Confirmation", tagOptionEvent, tagSortIndividualEvents)

    // The religious event by which a person receives membership in the LDS
    // Church.
    TagLDSConfirmation = newTag("CONL", "LDS Confirmation", tagOptionEvent, tagSortIndividualEvents)

    //  An indicator that additional data belongs to the superior value. The
    // information from the CONT value is to be connected to the value of the
    // superior preceding line with a carriage return and/or new line character.
    // Leading spaces could be important to the formatting of the resultant
    // text. When importing values from CONT lines the reader should assume only
    // one delimiter character following the CONT tag. Assume that the rest of
    // the leading spaces are to be a part of the value.
    TagContinued = newTag("CONT", "Continued", tagOptionNone, tagSortIndividualInfo)

    // A statement that accompanies data to protect it from unlawful duplication
    // and distribution.
    TagCopyright = newTag("COPR", "Copyright", tagOptionNone, tagSortIndividualInfo)

    // A name of an institution, agency, corporation, or company.
    TagCorporate = newTag("CORP", "Corporate", tagOptionNone, tagSortIndividualInfo)

    // Disposal of the remains of a person's body by fire.
    TagCremation = newTag("CREM", "Cremation", tagOptionEvent, tagSortIndividualEvents)

    // The name or code of the country.
    TagCountry = newTag("CTRY", "Country", tagOptionNone, tagSortIndividualInfo)

    // Pertaining to stored automated information.
    TagData = newTag("DATA", "Data", tagOptionNone, tagSortIndividualInfo)

    // The time of an event in a calendar format.
    TagDate = newTag("DATE", "Date", tagOptionNone, tagSortIndividualInfo)

    // See DeathNode.
    TagDeath = newTag("DEAT", "Death", tagOptionEvent, tagSortIndividualDeath)

    // Pertaining to offspring of an individual.
    TagDescendants = newTag("DESC", "Descendants", tagOptionNone, tagSortIndividualInfo)

    // Indicates an interest in research to identify additional descendants of
    // this individual. (See also ANCI)
    TagDescendantsInterest = newTag("DESI", "Descendants Interest", tagOptionNone, tagSortIndividualInfo)

    // A system receiving data.
    TagDestination = newTag("DEST", "Destination", tagOptionNone, tagSortIndividualInfo)

    // An event of dissolving a marriage through civil action.
    TagDivorce = newTag("DIV", "Divorce", tagOptionEvent, tagSortIndividualEvents)

    // An event of filing for a divorce by a spouse.
    TagDivorceFiled = newTag("DIVF", "Divorce Filed", tagOptionEvent, tagSortIndividualEvents)

    // The physical characteristics of a person, place, or thing.
    TagPhysicalDescription = newTag("DSCR", "Physical Description", tagOptionNone, tagSortIndividualInfo)

    // Indicator of a level of education attained.
    TagEducation = newTag("EDUC", "Education", tagOptionNone, tagSortIndividualInfo)

    // An electronic address that can be used for contact such as an email
    // address. New in Gedcom 5.5.1.
    TagEmail = newTag("EMAIL", "Email", tagOptionNone, tagSortIndividualInfo)

    // An event of leaving one's homeland with the intent of residing elsewhere.
    TagEmigration = newTag("EMIG", "Emigration", tagOptionEvent, tagSortIndividualEvents)

    // A religious event where an endowment ordinance for an individual was
    // performed by priesthood authority in an LDS temple.
    TagEndowment = newTag("ENDL", "Endowment", tagOptionEvent, tagSortIndividualEvents)

    // An event of recording or announcing an agreement between two people to
    // become married.
    TagEngagement = newTag("ENGA", "Engagement", tagOptionEvent, tagSortIndividualEvents)

    // See EventNode.
    TagEvent = newTag("EVEN", "Event", tagOptionEvent, tagSortIndividualEvents)

    // Pertaining to a noteworthy attribute or fact concerning an individual, a
    // group, or an organization. A structure is usually qualified or classified
    // by a subordinate use of the TYPE tag. New in Gedcom 5.5.1.
    TagFact = newTag("FACT", "Fact", tagOptionNone, tagSortIndividualInfo)

    // Identifies a legal, common law, or other customary relationship of man
    // and woman and their children, if any, or a family created by virtue of
    // the birth of a child to its biological father and mother.
    TagFamily = newTag("FAM", "Family", tagOptionNone, tagSortIndividualInfo)

    // Identifies the family in which an individual appears as a child.
    TagFamilyChild = newTag("FAMC", "Family Child", tagOptionNone, tagSortIndividualInfo)

    // Pertaining to, or the name of, a family file. Names stored in a file that
    // are assigned to a family for doing temple ordinance work.
    TagFamilyFile = newTag("FAMF", "Family File", tagOptionNone, tagSortIndividualInfo)

    // Identifies the family in which an individual appears as a spouse.
    TagFamilySpouse = newTag("FAMS", "Family Spouse", tagOptionNone, tagSortIndividualInfo)

    // A FAX telephone number appropriate for sending data facsimiles. New in
    // Gedcom 5.5.1.
    TagFax = newTag("FAX", "Fax", tagOptionNone, tagSortIndividualInfo)

    // A religious rite, the first act of sharing in the Lord's supper as part
    // of church worship.
    TagFirstCommunion = newTag("FCOM", "First Communion", tagOptionEvent, tagSortIndividualEvents)

    // An information storage place that is ordered and arranged for
    // preservation and reference.
    TagFile = newTag("FILE", "File", tagOptionNone, tagSortIndividualInfo)

    // See PhoneticNode.
    TagPhonetic = newTag("FONE", "Phonetic", tagOptionNone, tagSortIndividualInfo)

    // See FormatNode.
    TagFormat = newTag("FORM", "Format", tagOptionNone, tagSortIndividualInfo)

    // Information about the use of GEDCOM in a transmission.
    TagGedcomInformation = newTag("GEDC", "GEDCOM Information", tagOptionNone, tagSortIndividualInfo)

    // A given or earned name used for official identification of a person. It
    // is also commonly known as the "first name".
    //
    // The NameNode provides a GivenName() function.
    TagGivenName = newTag("GIVN", "Given Name", tagOptionNone, tagSortIndividualInfo)

    // An event of awarding educational diplomas or degrees to individuals.
    TagGraduation = newTag("GRAD", "Graduation", tagOptionEvent, tagSortIndividualEvents)

    // Identifies information pertaining to an entire GEDCOM transmission.
    TagHeader = newTag("HEAD", "Header", tagOptionNone, tagSortIndividualInfo)

    // See HusbandNode.
    TagHusband = newTag("HUSB", "Husband", tagOptionNone, tagSortIndividualInfo)

    // A number assigned to identify a person within some significant external
    // system.
    TagIdentityNumber = newTag("IDNO", "Identity Number", tagOptionNone, tagSortIndividualInfo)

    // An event of entering into a new locality with the intent of residing
    // there.
    TagImmigration = newTag("IMMI", "Immigration", tagOptionEvent, tagSortIndividualEvents)

    // A person.
    TagIndividual = newTag("INDI", "Individual", tagOptionNone, tagSortIndividualInfo)

    // Defines label for given fact.
    TagLabel = newTag("LABL", "Label", tagOptionNone, tagSortIndividualInfo)

    // The name of the language used in a communication or transmission of
    // information.
    TagLanguage = newTag("LANG", "Language", tagOptionNone, tagSortIndividualInfo)

    // See LatitudeNode.
    TagLatitude = newTag("LATI", "Latitude", tagOptionNone, tagSortIndividualInfo)

    // A role of an individual acting as a person receiving a bequest or legal
    // devise.
    TagLegatee = newTag("LEGA", "Legatee", tagOptionNone, tagSortIndividualInfo)

    // See LongitudeNode.
    TagLongitude = newTag("LONG", "Longitude", tagOptionNone, tagSortIndividualInfo)

    // See MapNode.
    TagMap = newTag("MAP", "Map", tagOptionNone, tagSortIndividualInfo)

    // An event of an official public notice given that two people intend to
    // marry.
    TagMarriageBann = newTag("MARB", "Marriage Bann", tagOptionEvent, tagSortIndividualEvents)

    // An event of recording a formal agreement of marriage, including the
    // prenuptial agreement in which marriage partners reach agreement about the
    // property rights of one or both, securing property to their children.
    TagMarriageContract = newTag("MARC", "Marriage Contract", tagOptionEvent, tagSortIndividualEvents)

    // An event of obtaining a legal license to marry.
    TagMarriageLicence = newTag("MARL", "Marriage Licence", tagOptionEvent, tagSortIndividualEvents)

    // A legal, common-law, or customary event of creating a family unit of a
    // man and a woman as husband and wife.
    TagMarriage = newTag("MARR", "Marriage", tagOptionEvent, tagSortIndividualEvents)

    // An event of creating an agreement between two people contemplating
    // marriage, at which time they agree to release or modify property rights
    // that would otherwise arise from the marriage.
    TagMarriageSettlement = newTag("MARS", "Marriage Settlement", tagOptionEvent, tagSortIndividualEvents)

    // Identifies information about the media or having to do with the medium in
    // which information is stored.
    TagMedia = newTag("MEDI", "Media", tagOptionNone, tagSortIndividualInfo)

    // A word or combination of words used to help identify an individual,
    // title, or other item. More than one NAME line should be used for people
    // who were known by multiple names.
    //
    // NAME tags will be interpreted with the NameNode type.
    TagName = newTag("NAME", "Name", tagOptionNone, tagSortIndividualName)

    // The national heritage of an individual.
    TagNationality = newTag("NATI", "Nationality", tagOptionNone, tagSortIndividualInfo)

    // The event of obtaining citizenship.
    TagNaturalization = newTag("NATU", "Naturalization", tagOptionEvent, tagSortIndividualEvents)

    // The number of children that this person is known to be the parent of (all
    // marriages) when subordinate to an individual, or that belong to this
    // family when subordinate to a FAM_RECORD.
    TagChildrenCount = newTag("NCHI", "Children Count", tagOptionNone, tagSortIndividualInfo)

    // See NicknameNode.
    TagNickname = newTag("NICK", "Nickname", tagOptionNone, tagSortIndividualInfo)

    // The number of times this person has participated in a family as a spouse
    // or parent.
    TagMarriageCount = newTag("NMR", "Marriage Count", tagOptionNone, tagSortIndividualInfo)

    // See NoteNode.
    TagNote = newTag("NOTE", "Note", tagOptionNone, tagSortIndividualInfo)

    // Text which appears on a name line before the given and surname parts of a
    // name. i.e. ( Lt. Cmndr. ) Joseph /Allen/ jr. In this example Lt. Cmndr.
    // is considered as the name prefix portion.
    //
    // The NameNode provides a Prefix() function.
    TagNamePrefix = newTag("NPFX", "Name Prefix", tagOptionNone, tagSortIndividualInfo)

    // Text which appears on a name line after or behind the given and surname
    // parts of a name. i.e. Lt. Cmndr. Joseph /Allen/ ( jr. ) In this example
    // jr. is considered as the name suffix portion.
    //
    // The NameNode provides a Suffix() function.
    TagNameSuffix = newTag("NSFX", "Name Suffix", tagOptionNone, tagSortIndividualInfo)

    // Pertaining to a grouping of attributes used in describing something.
    // Usually referring to the data required to represent a multimedia object,
    // such an audio recording, a photograph of a person, or an image of a
    // document.
    TagObject = newTag("OBJE", "Object", tagOptionNone, tagSortIndividualInfo)

    // The type of work or profession of an individual.
    TagOccupation = newTag("OCCU", "Occupation", tagOptionNone, tagSortIndividualInfo)

    // Pertaining to a religious ordinance in general.
    TagOrdinance = newTag("ORDI", "Ordinance", tagOptionNone, tagSortIndividualInfo)

    // A religious event of receiving authority to act in religious matters.
    TagOrdination = newTag("ORDN", "Ordination", tagOptionEvent, tagSortIndividualEvents)

    // A number or description to identify where information can be found in a
    // referenced work.
    TagPage = newTag("PAGE", "Page", tagOptionNone, tagSortIndividualInfo)

    // Information pertaining to an individual to parent lineage chart.
    TagPedigree = newTag("PEDI", "Pedigree", tagOptionNone, tagSortIndividualInfo)

    // A unique number assigned to access a specific telephone.
    TagPhone = newTag("PHON", "Phone", tagOptionNone, tagSortIndividualInfo)

    // See PlaceNode.
    TagPlace = newTag("PLAC", "Place", tagOptionNone, tagSortIndividualInfo)

    // A code used by a postal service to identify an area to facilitate mail
    // handling.
    TagPostalCode = newTag("POST", "Postal Code", tagOptionNone, tagSortIndividualInfo)

    // An event of judicial determination of the validity of a will. May
    // indicate several related court activities over several dates.
    TagProbate = newTag("PROB", "Probate", tagOptionEvent, tagSortIndividualEvents)

    // Pertaining to possessions such as real estate or other property of
    // interest.
    TagProperty = newTag("PROP", "Property", tagOptionNone, tagSortIndividualInfo)

    // Refers to when and/or were a work was published or created.
    TagPublication = newTag("PUBL", "Publication", tagOptionNone, tagSortIndividualInfo)

    // An assessment of the certainty of the evidence to support the conclusion
    // drawn from evidence.
    TagQualityOfData = newTag("QUAY", "Quality Of Data", tagOptionNone, tagSortIndividualInfo)

    // A description or number used to identify an item for filing, storage, or
    // other reference purposes.
    TagReference = newTag("REFN", "Reference", tagOptionNone, tagSortIndividualInfo)

    // A relationship value between the indicated contexts.
    TagRelationship = newTag("RELA", "Relationship", tagOptionNone, tagSortIndividualInfo)

    // A religious denomination to which a person is affiliated or for which a
    // record applies.
    TagReligion = newTag("RELI", "Religion", tagOptionNone, tagSortIndividualInfo)

    // An institution or person that has the specified item as part of their
    // collection(s).
    TagRepository = newTag("REPO", "Repository", tagOptionNone, tagSortIndividualInfo)

    // See ResidenceNode.
    TagResidence = newTag("RESI", "Residence", tagOptionEvent, tagSortIndividualEvents)

    // A processing indicator signifying access to information has been denied
    // or otherwise restricted.
    TagRestriction = newTag("RESN", "Restriction", tagOptionNone, tagSortIndividualInfo)

    // An event of exiting an occupational relationship with an employer after a
    // qualifying time period.
    TagRetirement = newTag("RETI", "Retirement", tagOptionEvent, tagSortIndividualEvents)

    // A permanent number assigned to a record that uniquely identifies it
    // within a known file.
    TagRecordFileNumber = newTag("RFN", "Record File Number", tagOptionNone, tagSortIndividualInfo)

    // A number assigned to a record by an originating automated system that can
    // be used by a receiving system to report results pertaining to that
    // record.
    TagRecordIDNumber = newTag("RIN", "Record ID Number", tagOptionNone, tagSortIndividualInfo)

    // A name given to a role played by an individual in connection with an
    // event.
    TagRole = newTag("ROLE", "Role", tagOptionNone, tagSortIndividualInfo)

    // A romanized variation of a superior text string. New in Gedcom 5.5.1.
    TagRomanized = newTag("ROMN", "Romanized", tagOptionNone, tagSortIndividualInfo)

    // See SexNode.
    TagSex = newTag("SEX", "Sex", tagOptionNone, tagSortIndividualInfo)

    // A religious event pertaining to the sealing of a child to his or her
    // parents in an LDS temple ceremony.
    TagSealingChild = newTag("SLGC", "Sealing Child", tagOptionEvent, tagSortIndividualEvents)

    // A religious event pertaining to the sealing of a husband and wife in an
    // LDS temple ceremony.
    TagSealingSpouse = newTag("SLGS", "Sealing Spouse", tagOptionEvent, tagSortIndividualEvents)

    // The initial or original material from which information was obtained.
    TagSource = newTag("SOUR", "Source", tagOptionNone, tagSortIndividualInfo)

    // A name piece used as a non-indexing pre-part of a surname.
    TagSurnamePrefix = newTag("SPFX", "Surname Prefix", tagOptionNone, tagSortIndividualInfo)

    // A number assigned by the United States Social Security Administration.
    // Used for tax identification purposes.
    TagSocialSecurityNumber = newTag("SSN", "Social Security Number", tagOptionNone, tagSortIndividualInfo)

    // A geographical division of a larger jurisdictional area, such as a State
    // within the United States of America.
    TagState = newTag("STAE", "State", tagOptionNone, tagSortIndividualInfo)

    // An assessment of the state or condition of something.
    TagStatus = newTag("STAT", "Status", tagOptionNone, tagSortIndividualInfo)

    // An individual or organization who contributes genealogical data to a file
    // or transfers it to someone else.
    TagSubmitter = newTag("SUBM", "Submitter", tagOptionNone, tagSortIndividualInfo)

    // Pertains to a collection of data issued for processing.
    TagSubmission = newTag("SUBN", "Submission", tagOptionNone, tagSortIndividualInfo)

    // A family name passed on or used by members of a family.
    //
    // The NameNode provides a Surname() function.
    TagSurname = newTag("SURN", "Surname", tagOptionNone, tagSortIndividualInfo)

    // The name or code that represents the name a temple of the LDS Church.
    TagTemple = newTag("TEMP", "Temple", tagOptionNone, tagSortIndividualInfo)

    // The exact wording found in an original source document.
    TagText = newTag("TEXT", "Text", tagOptionNone, tagSortIndividualInfo)

    // A time value in a 24-hour clock format, including hours, minutes, and
    // optional seconds, separated by a colon (:). Fractions of seconds are
    // shown in decimal notation.
    TagTime = newTag("TIME", "Time", tagOptionNone, tagSortIndividualInfo)

    // A description of a specific writing or other work, such as the title of a
    // book when used in a source context, or a formal designation used by an
    // individual in connection with positions of royalty or other social
    // status, such as Grand Duke.
    //
    // The NameNode provides a Title() function.
    TagTitle = newTag("TITL", "Title", tagOptionNone, tagSortIndividualInfo)

    // At level 0, specifies the end of a GEDCOM transmission.
    TagTrailer = newTag("TRLR", "Trailer", tagOptionNone, tagSortIndividualInfo)

    // See TypeNode.
    TagType = newTag("TYPE", "Type", tagOptionNone, tagSortIndividualInfo)

    // Indicates which version of a product, item, or publication is being used
    // or referenced.
    TagVersion = newTag("VERS", "Version", tagOptionNone, tagSortIndividualInfo)

    // See WifeNode.
    TagWife = newTag("WIFE", "Wife", tagOptionNone, tagSortIndividualInfo)

    // World Wide Web home page. New in Gedcom 5.5.1.
    TagWWW = newTag("WWW", "WWW", tagOptionNone, tagSortIndividualInfo)

    // A legal document treated as an event, by which a person disposes of his
    // or her estate, to take effect after death. The event date is the date the
    // will was signed while the person was alive. (See also PROBate)
    TagWill = newTag("WILL", "Will", tagOptionEvent, tagSortIndividualEvents)
)

http://wiki-en.genealogy.net/GEDCOM-Tags

Definition of all standard GEDCOM-Tags

List of all field names (tags), used in GEDCOM Specification 5.5, or (with a special comment) or added/deleted in GEDCOM 5.5.1. These field names are used in a hierarchical structure to describe e.g. single persons in connection with their families. Field names may have different meaning and content depending on their position in the data structure.

GEDCOM-standard permits user defined field names (one of the major causes of "misunderstandings" of different GEDCOM-compliant programs!). They have to begin with an underscore _ .

var (

    // See FamilySearchIDNode
    UnofficialTagFamilySearchID1 = newTag("_FID", "FamilySearch ID", tagOptionNone, tagSortIndividualUnofficial)
    UnofficialTagFamilySearchID2 = newTag("_FSFTID", "FamilySearch ID", tagOptionNone, tagSortIndividualUnofficial)

    // Unofficial. Latitude degrees. This has been seen exported from
    // MacFamilyFree.
    UnofficialTagLatitudeDegrees = newTag("_LAD", "Latitude Degrees", tagOptionNone, tagSortIndividualUnofficial)

    // Unofficial. Latitude minutes. This has been seen exported from
    // MacFamilyFree.
    UnofficialTagLatitudeMinutes = newTag("_LAM", "Latitude Minutes", tagOptionNone, tagSortIndividualUnofficial)

    // Unofficial. Latitude seconds. This has been seen exported from
    // MacFamilyFree.
    UnofficialTagLatitudeSeconds = newTag("_LAS", "Latitude Seconds", tagOptionNone, tagSortIndividualUnofficial)

    // Unofficial. Longitude degrees. This has been seen exported from
    // MacFamilyFree.
    UnofficialTagLongitudeDegress = newTag("_LOD", "Longitude Degress", tagOptionNone, tagSortIndividualUnofficial)

    // Unofficial. Longitude minutes. This has been seen exported from
    // MacFamilyFree.
    UnofficialTagLongitudeMinutes = newTag("_LOM", "Longitude Minutes", tagOptionNone, tagSortIndividualUnofficial)

    // Unofficial. Longitude north? This has been seen exported from
    // MacFamilyFree.
    UnofficialTagLongitudeNorth = newTag("_LON", "Longitude North", tagOptionNone, tagSortIndividualUnofficial)

    // Unofficial. Longitude seconds. This has been seen exported from
    // MacFamilyFree.
    UnofficialTagLongitudeSeconds = newTag("_LOS", "Longitude Seconds", tagOptionNone, tagSortIndividualUnofficial)

    // Unofficial. Used to group the _LA* and _LO* tags for latitude and
    // longitude. This has been seen exported from MacFamilyFree.
    UnofficialTagCoordinates = newTag("_COR", "Coordinates", tagOptionNone, tagSortIndividualUnofficial)

    // Unofficial. The created date and/or time. This has been seen exported
    // from Ancestry.com.
    UnofficialTagCreated = newTag("_CRE", "Created", tagOptionNone, tagSortIndividualUnofficial)

    // See UniqueIDNode.
    UnofficialTagUniqueID = newTag("_UID", "Unique ID", tagOptionNone, tagSortIndividualUnofficial)
)
var Countries = []string{ /* 205 elements not displayed */

}

Countries is a list of all the known current and historical countries.

These are used to help identify countries in place names. See PlaceNode.Country().

https://www.searchify.ca/list-of-countries/

func Atoi Uses

func Atoi(s string) int

Atoi is a fault tolerant way to convert a string to an integer.

Atoi ultimately uses strconv.Atoi to do the conversion, but will clean the string by removing any surrounding spaces or processing "0" characters.

It is usually the logic behind any function in this package that expects to receive an integer from a string value.

If the string cannot be parsed to an integer then 0 is returned.

func CleanSpace Uses

func CleanSpace(s string) string

CleanSpace works similar to strings.TrimSpace except that it also replaces consecutive spaces anywhere in the string with a single space.

"  Foo   bar BAZ" -> "Foo bar BAZ"

CleanSpace is used in many places throughout the library to clean values that are known to not place any significance on their spaces. Such as individual and place names.

func DateAndPlace Uses

func DateAndPlace(nodes ...Node) (date *DateNode, place *PlaceNode)

DateAndPlace is a convenience method for fetching a date and place from a list of nodes.

If multiple dates and places exist it will choose the first respective one.

func DeepEqual Uses

func DeepEqual(left, right Node) bool

DeepEqual tests if left and right are recursively equal.

If either left or right is nil (including both) then false is always returned.

If left does not equal right (see Node.Equals) or both sides do not contain exactly the same amount of child nodes then false is returned.

The GEDCOM standard allows nodes to appear in any order. So the children are compared in this way as well. For example the following root nodes are equal:

0 INDI @P1@        |  0 INDI @P1@
1 BIRT             |  1 BIRT
2 DATE 3 SEP 1943  |  2 PLAC England
2 PLAC England     |  2 DATE 3 SEP 1943

DeepEqual heavily depends on the logic of the Equals method for each kind of node. Equals may or may not take into consideration child nodes to determine if the parent itself is equal. You should see the specific documentation for Equals on each node type.

If Equals is not implemented it will fall back to SimpleNode.Equals.

If an equal node appears multiple times on either side it will also have to appear the same number of times on the opposite side for the DeepEqual to be true.

func DeepEqualNodes Uses

func DeepEqualNodes(left, right Nodes) bool

DeepEqualNodes allows two slices of nodes to be compared.

The slices must have the same length (including zero) or the result will always be false. If both slices contain zero elements then the result is always true.

Every node in the left must DeepEqual a node on the right. The same node cannot be used twice in a comparison. The slices are allowed to have duplicate nodes (by reference or value) as long as the other side has an equal amount of duplicates.

See DeepEqual for semantics on how nodes are compared.

func DeleteNodesWithTag Uses

func DeleteNodesWithTag(node Node, tag Tag)

func GEDCOMLine Uses

func GEDCOMLine(value GEDCOMLiner, indent int) string

GEDCOMLine is the safer alternative to GEDCOMLiner.GEDCOMLine. It will handle nils gracefully, returning an empty string.

func GEDCOMString Uses

func GEDCOMString(value GEDCOMStringer, indent int) string

GEDCOMString is the safer alternative to GEDCOMStringer.GEDCOMString. It will handle nils gracefully, returning an empty string.

func HasNestedNode Uses

func HasNestedNode(node Node, lookingFor Node) bool

HasNestedNode checks if node contains lookingFor at any depth. If node and lookingFor are the same false is returned. If either node or lookingFor is nil then false is always returned.

Nodes are matched by reference, not value so nodes that represent exactly the same value will not be considered equal.

func IsNil Uses

func IsNil(node interface{}) bool

IsNil is the safe and reliable way to check if a node is nil. You should not compare Node values with an untyped nil as it will lead to unexpected results.

As a side node IsNil cannot be part of the Node interface because more specific node types (such as DateNode) use SimpleNode as an instance variable and that would cause a nil pointer panic.

func JaroWinkler Uses

func JaroWinkler(a, b string, boostThreshold float64, prefixSize int) float64

JaroWinkler distance. JaroWinkler returns a number between 0 and 1 where 1 means perfectly equal and 0 means completely different. It is commonly used on Record Linkage stuff, thus it tries to be accurate for real names and common typos. You should consider it on data such as person names and street names.

JaroWinkler is sensitive to punctuation and capitalization of strings. If you are comparing names or places you may want to use StringSimilarity instead. StringSimilarity removes punctuation, extra whitespace and normalises capitalization before performing the comparison which almost always delivers more desirable results.

JaroWinkler is a more accurate version of the Jaro algorithm. It works by boosting the score of exact matches at the beginning of the strings. By doing this, Winkler says that typos are less common to happen at the beginning. For this to happen, it introduces two more parameters: the boostThreshold and the prefixSize. These are commonly set to 0.7 and 4, respectively. However, you should use DefaultJaroWinklerBoostThreshold and DefaultJaroWinklerPrefixSize as they have been calcuated by the gedcomtune command.

The code and comment above has been copied from:

https://github.com/xrash/smetrics/blob/master/jaro-winkler.go

A big thanks to Felipe (@xrash) for the explanation and code. It you read this, I copied the code to avoid the need to have a dependency manager for this project.

func NewDateRangeWithNow Uses

func NewDateRangeWithNow() (Date, Date)

NewDateWithNow creates a two Dates that represents the the start and end of the current day. See NewDateWithTime for implementation details.

func Pointer Uses

func Pointer(node Node) string

Pointer is a safe way to fetch the Pointer() from a node. If the node is nil then an empty string will be returned.

func String Uses

func String(node Node) string

String is a safe way to fetch the String() from a node. If the node is nil then an empty string will be returned.

func StringSimilarity Uses

func StringSimilarity(a, b string, boostThreshold float64, prefixSize int) float64

StringSimilarity is a less sensitive version of a JaroWinkler string comparison. It is the ideal choice to compare strings that represent individual names, places, etc as it does not take into account capitalization, punctuation and extra spaces.

func Value Uses

func Value(node Node) string

Value is a safe way to fetch the Value() from a node. If the node is nil then an empty string will be returned.

func Years Uses

func Years(v interface{}) float64

Years is a safe way to fetch the Years() value from a value. If the value is nil or does not implement Yearer then 0.0 will be returned. Otherwise the value of Years() is returned.

type Age Uses

type Age struct {
    // Age is the duration of time from the point where the birth was
    // determined.
    //
    // The age may be an estimation, see IsEstimate. The age might also be
    // greater than the maximum living age of the individual, see IsAfterDeath.
    Age time.Duration

    // IsEstimate will be true when there was no birth event or the birth event
    // is a range (like "Between 1943 to 1947").
    IsEstimate bool

    // IsKnown will be true if the age can be determined (either as exact or an
    // estimation). The age cannot be determined if no estimated birth date is
    // found or an event does not contain a usable date.
    //
    // When IsKnown is false you should not use the value of Age.
    IsKnown bool

    // See the AgeConstraint constants for a full explanation.
    Constraint AgeConstraint
}

Age represents an age of an individual at a point in time.

An Age is often paired with another Age to allow a range of time. For example an event could be an absolute like a christening, or it could represent a range such as the start and end age during a residence that spans multiple years.

You should avoid initializing the struct directly, and instead use the most appropriate constructor.

func NewAge Uses

func NewAge(age time.Duration, isEstimate bool, constraint AgeConstraint) Age

NewAge will initialise a new known exact or estimate age age with the provided attributes.

func NewAgeWithYears Uses

func NewAgeWithYears(years float64, isEstimate bool, constraint AgeConstraint) Age

NewAgeWithYears creates an age by using the number of years.

This is not precise as a year is averaged out at 365.25 days (see Year constant) but is useful when only whole years matter.

func NewUnknownAge Uses

func NewUnknownAge() Age

NewUnknownAge returns a value that represents an age that is not known.

func (Age) IsAfter Uses

func (age Age) IsAfter(age2 Age) bool

IsAfter is true if the right age is after (greater than) the left age. If both ages are equal this will return false.

func (Age) String Uses

func (age Age) String() string

String returns an age in one of the following forms:

unknown     -- if IsKnown is false
20y         -- living age is very close to the whole year
20y 5m      -- living age with 5 months
~ 25y       -- if IsEstimated is true
~ 22y 11m   -- same as above

String will not consider the age constraint.

A special case is 0. When the age duration is zero (or less than half of one month) the estimate marker ("~") will not be shown because this would not make sense.

func (Age) Years Uses

func (age Age) Years() float64

Years returns the approximate amount of years.

The value is approximate because a year is both a variable amount of time and has to be combined with a point in time to be practical.

Years can be used when 1 month resolution is enough. However, it's not recommended to use this for calculations. Instead use the Age value.

type AgeConstraint Uses

type AgeConstraint int

AgeConstraint is used to describe if the individual was living during the calculated age.

See the AgeConstraint constants for more information.

const (
    // The constraint is not known. This is the case if none of the other
    // options can be determined to be true.
    AgeConstraintUnknown AgeConstraint = iota

    // The age represents a time before the known birth. This would be
    // represented as a negative age.
    AgeConstraintBeforeBirth

    // The age represents the number of years since the known birth of the
    // individual. Even if the age is an approximation or a wide range it can
    // still be considered as fully or partly within their lifetime.
    AgeConstraintLiving

    // The age is after the known death of the individual. Like the "before
    // birth" constraint it can be sometimes useful to know the age of the
    // individual if they were still living or subtract their death age to see
    // how many years after their death the event may have occurred.
    //
    // You can use IndividualNode.Age() to fetch the maximum living age of a now
    // deceased individual.
    AgeConstraintAfterDeath
)

func (AgeConstraint) String Uses

func (ac AgeConstraint) String() string

Strings returns a human-readable form of the constant, like "After Death".

type BaptismNode Uses

type BaptismNode struct {
    *SimpleNode
}

BaptismNode is event of baptism (not LDS), performed in infancy or later.

See also BAPL and CHR.

func NewBaptismNode Uses

func NewBaptismNode(value string, children ...Node) *BaptismNode

NewBaptismNode creates a new BAPM node.

func (*BaptismNode) Dates Uses

func (node *BaptismNode) Dates() DateNodes

Dates returns zero or more dates associated with the Baptism.

When more than one date is returned you should not assume that the order has any significance for the importance of the dates.

If the node is nil the result will also be nil.

func (*BaptismNode) Equals Uses

func (node *BaptismNode) Equals(node2 Node) bool

Equal will always return true if both nodes are not nil.

If either node is nil (including both) or if the right side is not a BaptismNode then false is always returned. Otherwise Equals will always return true.

The reason Equals always returns true is because Equals is a shallow test and an individual can only ever have one baptism event. Therefore it is safe to assume that baptism events themselves are equal, even if the children they contain are not.

This logic is especially important for CompareNodes.

type BirthNode Uses

type BirthNode struct {
    *SimpleNode
}

BirthNode is the event of entering into life.

func NewBirthNode Uses

func NewBirthNode(value string, children ...Node) *BirthNode

NewBirthNode creates a new BIRT node.

func (*BirthNode) Dates Uses

func (node *BirthNode) Dates() DateNodes

Dates returns zero or more dates associated with the Birth.

When more than one date is returned you should not assume that the order has any significance for the importance of the dates.

If the node is nil the result will also be nil.

func (*BirthNode) Equals Uses

func (node *BirthNode) Equals(node2 Node) bool

Equal will always return true if both nodes are not nil.

If either node is nil (including both) or if the right side is not a BirthNode then false is always returned. Otherwise Equals will always return true.

The reason Equals always returns true is because Equals is a shallow test and an individual can only ever have one birth event. Therefore it is safe to assume that birth events themselves are equal, even if the children they contain are not.

This logic is especially important for CompareNodes.

type BurialNode Uses

type BurialNode struct {
    *SimpleNode
}

BurialNode is the event of the proper disposing of the mortal remains of a deceased person.

func NewBurialNode Uses

func NewBurialNode(value string, children ...Node) *BurialNode

NewBurialNode creates a new BURI node.

func (*BurialNode) Dates Uses

func (node *BurialNode) Dates() DateNodes

Dates returns zero or more dates associated with the burial.

When more than one date is returned you should not assume that the order has any significance for the importance of the dates.

If the node is nil the result will also be nil.

func (*BurialNode) Equals Uses

func (node *BurialNode) Equals(node2 Node) bool

Equal will always return true if both nodes are not nil.

If either node is nil (including both) or if the right side is not a BurialNode then false is always returned. Otherwise Equals will always return true.

The reason Equals always returns true is because Equals is a shallow test and an individual can only ever have one burial event. Therefore it is safe to assume that burial events themselves are equal, even if the children they contain are not.

This logic is especially important for CompareNodes.

type ChildBornBeforeParentWarning Uses

type ChildBornBeforeParentWarning struct {
    Parent *IndividualNode
    Child  *ChildNode
}

func NewChildBornBeforeParentWarning Uses

func NewChildBornBeforeParentWarning(parent *IndividualNode, child *ChildNode) *ChildBornBeforeParentWarning

func (*ChildBornBeforeParentWarning) Name Uses

func (w *ChildBornBeforeParentWarning) Name() string

func (*ChildBornBeforeParentWarning) String Uses

func (w *ChildBornBeforeParentWarning) String() string

type ChildNode Uses

type ChildNode struct {
    *SimpleNode
    // contains filtered or unexported fields
}

ChildNode is the natural, adopted, or sealed (LDS) child of a father and a mother.

func (*ChildNode) Family Uses

func (node *ChildNode) Family() *FamilyNode

func (*ChildNode) Father Uses

func (node *ChildNode) Father() *HusbandNode

func (*ChildNode) Individual Uses

func (node *ChildNode) Individual() *IndividualNode

func (*ChildNode) Mother Uses

func (node *ChildNode) Mother() *WifeNode

func (*ChildNode) String Uses

func (node *ChildNode) String() string

type ChildNodes Uses

type ChildNodes []*ChildNode

func (ChildNodes) ByPointer Uses

func (nodes ChildNodes) ByPointer(pointer string) *ChildNode

func (ChildNodes) IndividualByPointer Uses

func (nodes ChildNodes) IndividualByPointer(pointer string) *IndividualNode

func (ChildNodes) Individuals Uses

func (nodes ChildNodes) Individuals() (individuals IndividualNodes)

func (ChildNodes) Similarity Uses

func (nodes ChildNodes) Similarity(other ChildNodes, options SimilarityOptions) float64

type Date Uses

type Date struct {
    // Day of the month. When the day is not provided (like "Feb 1990") this
    // will be 0.
    Day int

    // Month of the year. When the month is not provided (like "1999") this will
    // be 0.
    Month time.Month

    // Year number. Go only allows for date ranges of the year between 0 and
    // 9999. If this year is outside of that date you will not be able to use
    // the Time() function and you will probably run into all sort of other
    // trouble.
    Year int

    // IsEndOfRange signifies is this date is the start or end of the range
    // (provided by DateNode). This is important for Time() to create a
    // timestamp that is constrained to the lower or upper bound.
    //
    // For example if the date was "Feb 1822" the Time() function would return:
    //
    //    1 Feb 1822 00:00:00.000000000 // IsEndOfRange = false
    //   29 Feb 1822 23:59:59.999999999 // IsEndOfRange = true
    //
    IsEndOfRange bool

    // Constraint indicates if the date is the exact value specified,
    // approximate or bound to before or after its value. See the documentation
    // for DateConstraint for a full explanation.
    //
    // This value does not affect the value calculated by Time() but it may be
    // important in some cases to know the date may not be the value returned by
    // Time().
    Constraint DateConstraint

    // If the date cannot be parsed this will contain the error.
    ParseError error
}

Date is a single point in time.

A date in GEDCOM always represents a range contained between the StartDate() and EndDate(), even when it represents a single day, like "23 Jan 1921".

Before diving into the full specs below you should be aware of the known limitations:

1. Only the Gregorian calendar with the English language (for month names) is currently supported.

2. You should only expect dates that are valid and within the range of Go's supported libraries will work correctly. That is years between 0 and 9999. It is possible that dates outside of this range may be interpreted correctly but you should not rely on that remaining the same.

3. There are surly more keyword combinations used in GEDCOM files than are documented below. Interpreting these dates is not necessarily guaranteed to work, not work or retain the same behaviour between releases. If you believe there are other known cases please open an issue or pull request.

Now into the specification. There are two basic forms of a DATE value:

between date and date
date

The second case is actually equivalent to the first case the the same "date" substituted twice.

The "between" keyword can be any of (non case sensitive):

between
bet
bet.
from

The "and" keyword can be one of (non case sensitive):

-
and
to

A "date" has three basic forms:

prefix? day month year
prefix? month year
prefix? year

The "prefix" is optional and can be used to indicate if the date is approximate or not with one of the following keywords:

abt
abt.
about
c.
circa

Or, the "prefix" can be used to signify unbounded dates with one of the following keywords:

after
aft
aft.
before
bef
bef.

The "day" must be an integer between 1 and 31 and can have a single proceeding zero, like "03". The day should be valid against the month used. The behavior is unexpected when using invalid dates like "31 Feb 1999", but you will likely not receive a date at all if it's invalid.

The "month" must be one of the following strings (case in-sensitive):

apr
april
aug
august
dec
december
feb
february
jan
january
jul
july
jun
june
mar
march
may
nov
november
oct
october
sep
september

The "year" must be an integer with a value between 0 and 9999 (as to conform to the restrictions of the Go time package). It may be possible to parse dates outside of this range but they behaviour is not defined.

The "year" may be 1 to 4 digits but it always treated as the absolute year. The year 89 is treated as the year 89, not 1989, for example.

Values represented by a Date instance must be compatible with Go's time package. This only allows for date ranges of the year between 0 and 9999. So Date would not allow for BC/BCE dates.

You should be careful about directly creating dates from the defined instance variables because they may contain 0 to signify that a date component was not provided. Unless you have a very special case you should use Time() to convert to a usable date.

func NewDateWithTime Uses

func NewDateWithTime(t time.Time, isEndOfRange bool) Date

NewDateWithTime creates a new Date with the provided time.Time.

It is important to note that a Date only has a resolution of a single day and does not take into account timezone information.

The isEndOfRange must be provided to signal if the Date returned represents the start or end of the day since the minimum resolution is one day.

The returned Date will have an Exact constraint.

If t IsZero then a zero Date will be returned (see Date.IsZero).

func (Date) Equals Uses

func (date Date) Equals(date2 Date) bool

Equals compares two dates.

Unlike Is(), Equals() takes into what the date and its constraint represents, rather than just its raw value.

For example, "3 Sep 1943" == "Bef. Oct 1943" returns true because 3 Sep 1943 is before Oct 1943.

If either date (including both) is IsZero then false is always returned.

If Is() is true when comparing both dates then true is always returned.

Otherwise the comparison used is selected from the following matrix:

        ----------- Left ----------
        Exact  About  Before  After
 Exact    A      A      B       C
 About    A      A      D       D
Before    C      D      C       D
 After    B      D      D       B

A. A match if the day, month and year are all equal.

B. Match if left.Years() > right.Years().

C. Match if left.Years() < right.Years().

D. Never a match.

func (Date) Is Uses

func (date Date) Is(date2 Date) bool

Is compares two dates. Dates are only considered to be the same if the day, month, year and constraint are all the same.

The IsEndOfRange property is not used as part of the comparison because it only affects the behaviour of Time().

func (Date) IsAfter Uses

func (date Date) IsAfter(date2 Date) bool

func (Date) IsBefore Uses

func (date Date) IsBefore(date2 Date) bool

func (Date) IsExact Uses

func (date Date) IsExact() bool

IsExact will return true all parts of the date are complete and the date constraint is exact.

This is to say that is points to a specific day.

func (Date) IsZero Uses

func (date Date) IsZero() bool

IsZero returns true if the day, month and year are not provided. No other attributes are taken into consideration.

func (Date) String Uses

func (date Date) String() string

String returns the date in one of the three forms:

17 Jul 1890
Jul 1890
1890

All forms of the date may also be proceeded with one of the constraints:

Abt.
Aft.
Bef.

func (Date) Time Uses

func (date Date) Time() time.Time

Time returns the minimum or maximum (depending on IsEndOfRange) representation of the Date as a Go Time instance.

func (Date) Years Uses

func (date Date) Years() float64

Years returns the number of years of a date as a floating-point. It can be used as an approximation to get a general idea of how far apart dates are but should not be treated as an accurate representation of time.

The smallest date unit in a GEDCOM is a day. For specific dates it is calculated as the number of days that have past, divided by the number of days in that year (to correct for leap years). For example "10 Oct 2009" would return 2009.860274.

Since some date components can be missing (like the day or month) Years compensates by returning the midpoint (average) of the maximum and minimum value in days. For example the date "Mar 1945" is the equivalent to the average Years value of "1 Mar 1945" and "31 Mar 1945", returning 1945.205479.

When only a year is provided 0.5 will be added to the year. For example, "1845" returns 1845.5. This is not the exact midpoint of the year but will be close enough for general calculations. You should not rely on 0.5 being returned (as part of a check) as this may change in the future.

The value returned from Years is not effected by any other component of the date. Such as if the date is approximate ("Abt.", etc) or directional ("Bef.", "Aft.", etc). If this property is important to you will need to take it into account in an appropriate way.

type DateConstraint Uses

type DateConstraint int

DateConstraint describes if a date is constrained by a particular range. See Date for full explanation.

func DateConstraintFromString Uses

func DateConstraintFromString(word string) DateConstraint

DateConstraintFromString will return the constraint for the provided keyword based on the keywords described in the specification of DateNode.

If the word is not understood DateConstraintExact will be returned.

This function is not case sensitive so "before" and "Before" are treated the same.

func (DateConstraint) String Uses

func (constraint DateConstraint) String() string

String returns the constraint abbreviation for non-exact dates. Exact dates will return an empty string.

The chosen (default) abbreviation is the first value in the appropriate DateWords constant.

If the constraint is invalid then an empty string will be returned.

type DateNode Uses

type DateNode struct {
    *SimpleNode
    // contains filtered or unexported fields
}

DateNode represents a DATE node.

See the full specification for dates in the documentation for Date.

func NewDateNode Uses

func NewDateNode(value string, children ...Node) *DateNode

NewDateNode creates a new DATE node.

func (*DateNode) DateRange Uses

func (node *DateNode) DateRange() (dateRange DateRange)

If the node is nil both results will be zero dates.

func (*DateNode) EndDate Uses

func (node *DateNode) EndDate() Date

func (*DateNode) Equals Uses

func (node *DateNode) Equals(node2 Node) bool

func (*DateNode) IsAfter Uses

func (node *DateNode) IsAfter(node2 *DateNode) bool

func (*DateNode) IsBefore Uses

func (node *DateNode) IsBefore(node2 *DateNode) bool

func (*DateNode) IsExact Uses

func (node *DateNode) IsExact() bool

func (*DateNode) IsPhrase Uses

func (node *DateNode) IsPhrase() bool

func (*DateNode) IsValid Uses

func (node *DateNode) IsValid() bool

func (*DateNode) Similarity Uses

func (node *DateNode) Similarity(node2 *DateNode, maxYears float64) float64

func (*DateNode) StartAndEndDates Uses

func (node *DateNode) StartAndEndDates() (Date, Date)

func (*DateNode) StartDate Uses

func (node *DateNode) StartDate() Date

func (*DateNode) String Uses

func (node *DateNode) String() string

String returns the date range as defined in the specification of DateNode.

There are too many combinations to document here, but the two main formats you will receive will look like:

Bet. Feb 1956 and Mar 1956
Abt. 13 Nov 1983

func (*DateNode) Sub Uses

func (node *DateNode) Sub(node2 *DateNode) (min Duration, max Duration, errs error)

func (*DateNode) Warnings Uses

func (node *DateNode) Warnings() Warnings

func (*DateNode) Years Uses

func (node *DateNode) Years() float64

Years fulfils the Yearer interface and is a convenience for:

node.DateRange().Years()

type DateNodes Uses

type DateNodes []*DateNode

DateNodes is a slice of zero or more DateNodes. It may also be nil as other slice.

func Dates Uses

func Dates(node Node) (result DateNodes)

Dates returns the shallow DateNodes.

Dates is safe to use with nil nodes.

Dates will always return all dates, even dates that are invalid.

func (DateNodes) Maximum Uses

func (dates DateNodes) Maximum() *DateNode

Maximum returns the date node with the maximum Years value from the provided slice.

For date ranges the end value is used. For example "Between 1924 and 1934" is considered greater than "Between 1923 and 1943" because 1924 is greater than 1923. Even though the Years value (which is an average) would place them in the opposite order.

If the slice is nil or contains zero elements then nil will be returned.

func (DateNodes) Minimum Uses

func (dates DateNodes) Minimum() *DateNode

Minimum returns the date node with the minimum Years value from the provided slice.

For date ranges the start value is used. For example "Between 1923 and 1943" is considered less than "Between 1924 and 1934" because 1923 is less than 1924. Even though the Years value (which is an average) would place them in the opposite order.

If the slice is nil or contains zero elements then nil will be returned.

func (DateNodes) StripZero Uses

func (dates DateNodes) StripZero() (validDates DateNodes)

StripZero returns a new slice that only contains dates that are not zero.

A "zero date" (Date.IsZero) is a date that is missing the year, month and day. Even if there is other associated information this date is considered to be useless for most purposes.

type DateRange Uses

type DateRange struct {
    // contains filtered or unexported fields
}

A DateRange represents a period of time.

The minimum possible period is 1 day and ranges only have a resolution of a single day.

DateRanges should be considered immutable and are passed by value because of this. You should create a new DateRange to represent a new range rather than mutating an existing DateRange.

func NewDateRange Uses

func NewDateRange(start, end Date) DateRange

NewDateRange creates a new date range between two provided dates. It is expected that the start date be less than or equal to the end date.

func NewDateRangeWithString Uses

func NewDateRangeWithString(s string) (dr DateRange)

func NewZeroDateRange Uses

func NewZeroDateRange() DateRange

func (DateRange) Compare Uses

func (dr DateRange) Compare(dr2 DateRange) DateRangeComparison

func (DateRange) EndDate Uses

func (dr DateRange) EndDate() Date

End is the upper boundary of the date range.

func (DateRange) Equals Uses

func (dr DateRange) Equals(dr2 DateRange) bool

Equals compares the values of two dates taking into consideration the date constraint.

If either date is nil then false is always returned. Even if both dates are nil.

A DateNode is considered to be equal only when its StartDate() and EndDate() both equal their respective values in the other DateNode.

The comparisons of dates is quite complicated. See the documentation for Date.Equals for a full explanation.

func (DateRange) IsAfter Uses

func (dr DateRange) IsAfter(dr2 DateRange) bool

After returns true if the end date is after the other end date.

See Before for a more detailed explanation.

func (DateRange) IsBefore Uses

func (dr DateRange) IsBefore(dr2 DateRange) bool

Before returns true if the start date is before the other start date.

The idea of "before" in the context of overlapping date ranges is ambiguous. The simplest way to think treat all these situations is to only look at the start date for each range. No matter when the end dates are or how much of each other then end up overlapping.

func (DateRange) IsExact Uses

func (dr DateRange) IsExact() bool

IsExact will return true if the date range represents a single day with an exact constraint.

See Date.IsExact for more information.

func (DateRange) IsPhrase Uses

func (dr DateRange) IsPhrase() bool

IsPhrase returns true if the date value is a phrase.

A phrase is any statement offered as a date when the year is not recognizable to a date parser, but which gives information about when an event occurred. The date phrase is enclosed in matching parentheses.

IsPhrase is safe to use on a nil DateNode, and will return false.

func (DateRange) IsValid Uses

func (dr DateRange) IsValid() bool

IsValid returns true only when the node is not nil and the start and end date are non-zero.

A "zero date" (Date.IsZero) is a date that is missing the year, month and day. Even if there is other associated information this date is considered to be useless for most purposes.

It is safe and completely valid to use IsValid on a nil node.

func (DateRange) ParseError Uses

func (dr DateRange) ParseError() error

func (DateRange) Similarity Uses

func (dr DateRange) Similarity(dr2 DateRange, maxYears float64) float64

Similarity returns a value from 0.0 to 1.0 to identify how similar two dates (or date ranges) are to each other. 1.0 would mean that the dates are exactly the same, whereas 0.0 would mean that they are not similar at all.

Similarity is safe to use when either date is nil. If either side is nil then 0.5 is returned. Not because they are similar but because there is not enough information to make the distinction either way. This is important when using date comparisons in combination or part of larger calculations where missing data on both sides does not lead to very low scores unnecessarily.

The returned value is calculated on a parabola that awards higher values to dates that are proportionally closer to each other. That is, dates that are twice as close will have more than twice the score. This attempts to satisfy a usable comparison values for close specific dates as well as more relaxed values (such as those that one provide an approximate year).

Only the difference between dates is used in the calculation so it is not affected by time lines. That is to say that the difference between the years 500 and 502 would return the same similarity as the years 2000 to 2002.

The maxYears allows the error margin to be adjusted. Dates that are further apart (in any direction) than maxYears will always return 0.0.

A greater maxYears can be used when dates are less exact (such as ancient dates that could be commonly off by 10 years or more) or a smaller value when dealing with recent dates that are provided in a more exact form.

A sensible default value for maxYears is provided with DefaultMaxYearsForSimilarity. You should use this if you are unsure. There is also more explanation on the constant.

func (DateRange) StartAndEndDates Uses

func (dr DateRange) StartAndEndDates() (Date, Date)

func (DateRange) StartDate Uses

func (dr DateRange) StartDate() Date

Start is the lower boundary of the date range.

func (DateRange) Years Uses

func (dr DateRange) Years() float64

Years works in a similar way to Date.Years() but also takes into consideration the StartDate() and EndDate() values of a whole date range, like "Bet. 1943 and 1945". It does this by averaging out the Years() value of the StartDate() and EndDate() values.

If the DateNode has a single date, like "Mar 1937" then Years will return the same value as the Years on the start or end date (no average will be used.)

You can read the specific conversion rules in Date.Years() but be aware that the returned value is an approximation and should not be used in date calculations.

type DateRangeComparison Uses

type DateRangeComparison int

DateRangeComparison describe how two date ranges (each can be described with a DateNode) relate to each other.

Since we are comparing ranges of time, rather than absolute points there are several variations of results to be considered. It's easiest to explain visually where Left and Right are the date range operands respectively:

                                                    Method returns true:
Left:                        |========|
Right:
  Equal:                     |========|             IsEqual()
  Inside:                    | <====> |             IsPartiallyEqual()
  InsideStart:               |======> |             IsPartiallyEqual()
  InsideEnd:                 | <======|             IsPartiallyEqual()
  Outside:               <===+========+===>         IsPartiallyEqual()
  OutsideStart:              |========+===>         IsPartiallyEqual()
  OutsideEnd:            <===+========|             IsPartiallyEqual()
  PartiallyBefore:       <===+===>    |             IsPartiallyEqual()
  PartiallyAfter:            |     <==+===>         IsPartiallyEqual()
  Before:                <===|        |             IsNotEqual()
  After:                     |        |===>         IsNotEqual()
  EntirelyBefore:        <=> |        |             IsNotEqual()
  EntirelyAfter:             |        | <=>         IsNotEqual()

The Simplified value is the DateRangeComparisonSimplified value which is derived from DateRangeComparison.Simplified().

func (DateRangeComparison) IsEqual Uses

func (c DateRangeComparison) IsEqual() bool

IsEqual returns true only if both date ranges are exactly the same.

It's important to note that a DateRangeComparison can be in one of three simplified states: Equal, PartiallyEqual or NotEqual. So !IsEqual() is not the same as IsNotEqual().

func (DateRangeComparison) IsNotEqual Uses

func (c DateRangeComparison) IsNotEqual() bool

IsNotEqual returns true if the two date ranges do not intersect at any point.

It's important to note that a DateRangeComparison can be in one of three simplified states: Equal, PartiallyEqual or NotEqual. So !IsNotEqual() is not the same as IsEqual().

func (DateRangeComparison) IsPartiallyEqual Uses

func (c DateRangeComparison) IsPartiallyEqual() bool

IsPartiallyEqual returns true if any part of the date range touches or intersects another.

func (DateRangeComparison) String Uses

func (c DateRangeComparison) String() string

String returns the name of the constant like "DateRangeComparisonInsideStart".

type Dater Uses

type Dater interface {
    Dates() DateNodes
}

Dater is implemented by nodes that are reasonably expected to have dates associated with them, such as events.

type DeathNode Uses

type DeathNode struct {
    *SimpleNode
}

DeathNode is the event when mortal life terminates.

func NewDeathNode Uses

func NewDeathNode(value string, children ...Node) *DeathNode

NewDeathNode creates a new DEAT node.

func (*DeathNode) Dates Uses

func (node *DeathNode) Dates() DateNodes

Dates returns zero or more dates associated with the death.

When more than one date is returned you should not assume that the order has any significance for the importance of the dates.

If the node is nil the result will also be nil.

func (*DeathNode) Equals Uses

func (node *DeathNode) Equals(node2 Node) bool

Equal will always return true if both nodes are not nil.

If either node is nil (including both) or if the right side is not a DeathNode then false is always returned. Otherwise Equals will always return true.

The reason Equals always returns true is because Equals is a shallow test and an individual can only ever have one death event. Therefore it is safe to assume that death events themselves are equal, even if the children they contain are not.

This logic is especially important for CompareNodes.

type Decoder Uses

type Decoder struct {
    // contains filtered or unexported fields
}

Decoder represents a GEDCOM decoder.

func NewDecoder Uses

func NewDecoder(r io.Reader) *Decoder

Create a new decoder to parse a reader that contain GEDCOM data.

func (*Decoder) Decode Uses

func (dec *Decoder) Decode() (*Document, error)

Decode will parse the entire GEDCOM stream (until EOF is reached) and return a Document. If the GEDCOM stream is not valid then the document node will be nil and the error is returned.

A blank GEDCOM or a GEDCOM that only contains empty lines is valid and a Document will be returned with zero nodes.

type Document Uses

type Document struct {
    // HasBOM controls if the encoded stream will start with the Byte Order
    // Mark.
    //
    // This is not recommended by the UTF-8 standard and many applications will
    // have problems reading the data. However, streams that were decoded
    // containing the BOM will retain it so that the re-encoded stream is as
    // compatible and similar to the original stream as possible.
    //
    // Also see Decoder.consumeOptionalBOM().
    HasBOM bool

    // MaxLivingAge is used by Individual.IsLiving to determine if an individual
    // without a DeathNode should be considered living.
    //
    // 100 is chosen as a reasonable default. If you set it to 0 then an
    // individual will never be considered dead without a DeathNode.
    MaxLivingAge float64
    // contains filtered or unexported fields
}

Document represents a whole GEDCOM document. It is possible for a Document to contain zero Nodes, this means the GEDCOM file was empty. It may also (and usually) contain several Nodes.

You should not instantiate a Document yourself because there are sensible defaults and cache that need to be setup. Use one of the NewDocument constructors instead.

func MergeDocuments Uses

func MergeDocuments(left, right *Document, mergeFn MergeFunction) *Document

MergeDocuments creates a new document with their respective nodes merged.

The MergeFunction must not be nil, but may return nil. See MergeFunction for usage.

The left and right may be nil. This is treated as an empty document.

The result document will have a deep copy of all nodes. So it's safe to manipulate the nodes without affecting the original nodes.

Individuals will not be merged amongst each other, only appended to the final document. To merge similar individuals see MergeDocumentsAndIndividuals.

func MergeDocumentsAndIndividuals Uses

func MergeDocumentsAndIndividuals(left, right *Document, mergeFn MergeFunction, options *IndividualNodesCompareOptions) (*Document, error)

MergeDocumentsAndIndividuals merges two documents while also merging similar individuals.

The MergeFunction must not be nil, but may return nil. It will only be used for nodes that are not individuals. See MergeFunction for usage.

The options must be provided, see

func NewDocument Uses

func NewDocument() *Document

NewDocument returns an empty document.

func NewDocumentFromGEDCOMFile Uses

func NewDocumentFromGEDCOMFile(path string) (*Document, error)

NewDocumentFromGEDCOMFile returns a decoded Document from the provided file.

If the file does not exist, be read or parse then an error is returned and the document will be nil.

func NewDocumentFromString Uses

func NewDocumentFromString(gedcom string) (*Document, error)

NewDocumentFromString creates a document from a string containing GEDCOM data.

An error is returned if a line cannot be parsed.

func NewDocumentWithNodes Uses

func NewDocumentWithNodes(nodes Nodes) *Document

NewDocumentWithNodes creates a new document with the provided root nodes.

func (*Document) AddFamily Uses

func (doc *Document) AddFamily(pointer string) *FamilyNode

func (*Document) AddFamilyWithHusbandAndWife Uses

func (doc *Document) AddFamilyWithHusbandAndWife(pointer string, husband, wife *IndividualNode) *FamilyNode

func (*Document) AddIndividual Uses

func (doc *Document) AddIndividual(pointer string, children ...Node) *IndividualNode

func (*Document) AddNode Uses

func (doc *Document) AddNode(node Node)

AddNode appends a node to the document.

If the node is nil this function has no effect.

If the node already exists it will be added again. This will cause problems with duplicate references.

func (*Document) DeleteNode Uses

func (doc *Document) DeleteNode(node Node) (didDelete bool)

func (*Document) Families Uses

func (doc *Document) Families() (families FamilyNodes)

Families returns the family entities in the document.

func (*Document) GEDCOMString Uses

func (doc *Document) GEDCOMString(indent int) string

GEDCOMString will render the entire GEDCOM document.

func (*Document) Individuals Uses

func (doc *Document) Individuals() IndividualNodes

Individuals returns all of the people in the document.

func (*Document) NodeByPointer Uses

func (doc *Document) NodeByPointer(ptr string) Node

NodeByPointer returns the Node for a pointer value.

If the pointer does not exist nil is returned.

func (*Document) Nodes Uses

func (doc *Document) Nodes() Nodes

Nodes returns the root nodes for the document.

It is important that the slice returned is not manually manipulated (such as appending) because it may cause the internal cache to all out of sync. You may manipulate the nodes themselves.

func (*Document) Places Uses

func (doc *Document) Places() map[*PlaceNode]Node

TODO: needs tests

func (*Document) SetNodes Uses

func (doc *Document) SetNodes(nodes Nodes)

func (*Document) Sources Uses

func (doc *Document) Sources() []*SourceNode

TODO: Needs tests

func (*Document) String Uses

func (doc *Document) String() string

String will render the entire GEDCOM document.

It is a shorthand for the more proper GEDCOMString() function.

func (*Document) Warnings Uses

func (doc *Document) Warnings() (warnings Warnings)

type DocumentNoder Uses

type DocumentNoder interface {
    Document() *Document
}

type Duration Uses

type Duration time.Duration

A duration that only considers whole-day resolution.

func (Duration) String Uses

func (d Duration) String() string

type Encoder Uses

type Encoder struct {
    // contains filtered or unexported fields
}

Encoder represents a GEDCOM encoder.

func NewEncoder Uses

func NewEncoder(w io.Writer, document *Document) *Encoder

Create a new encoder to generate GEDCOM data.

func (*Encoder) Encode Uses

func (enc *Encoder) Encode() (err error)

Encode will write the GEDCOM document to the Writer.

type Errors Uses

type Errors []error

func NewErrors Uses

func NewErrors(errors ...error) (errs Errors)

func (Errors) Err Uses

func (e Errors) Err() error

func (Errors) Error Uses

func (e Errors) Error() string

func (Errors) Errors Uses

func (e Errors) Errors() (errors []string)

type EventNode Uses

type EventNode struct {
    *SimpleNode
}

EventNode is a noteworthy happening related to an individual, a group, or an organization.

func NewEventNode Uses

func NewEventNode(value string, children ...Node) *EventNode

EventNode creates a new EVEN node.

func (*EventNode) Dates Uses

func (node *EventNode) Dates() DateNodes

Dates returns zero or more dates associated with the event.

When more than one date is returned you should not assume that the order has any significance for the importance of the dates.

If the node is nil the result will also be nil.

func (*EventNode) Equals Uses

func (node *EventNode) Equals(node2 Node) bool

Equal tests if two events are the same.

Two events are considered equal if:

1. They both contain the same date. If either or both contain more than one date only a single date must match both sides.

2. They both do not have any dates, but all other attributes are the same.

If either node is nil (including both) or if the right side is not a EventNode then false is always returned.

func (*EventNode) Years Uses

func (node *EventNode) Years() float64

Years returns the Years value of the minimum date node in the node.

type FamilyNode Uses

type FamilyNode struct {
    // contains filtered or unexported fields
}

FamilyNode represents a family.

func (*FamilyNode) AddChild Uses

func (node *FamilyNode) AddChild(individual *IndividualNode) *ChildNode

func (*FamilyNode) Children Uses

func (node *FamilyNode) Children() ChildNodes

TODO: Needs tests

If the node is nil the result will also be nil.

func (FamilyNode) Document Uses

func (node FamilyNode) Document() *Document

func (*FamilyNode) HasChild Uses

func (node *FamilyNode) HasChild(individual *IndividualNode) bool

TODO: Needs tests

If the node is nil the result will also be nil.

func (*FamilyNode) Husband Uses

func (node *FamilyNode) Husband() (husband *HusbandNode)

If the node is nil the result will also be nil.

func (*FamilyNode) SetHusband Uses

func (node *FamilyNode) SetHusband(individual *IndividualNode) *FamilyNode

func (*FamilyNode) SetHusbandPointer Uses

func (node *FamilyNode) SetHusbandPointer(pointer string) *FamilyNode

func (*FamilyNode) SetWife Uses

func (node *FamilyNode) SetWife(individual *IndividualNode) *FamilyNode

func (*FamilyNode) SetWifePointer Uses

func (node *FamilyNode) SetWifePointer(pointer string) *FamilyNode

func (FamilyNode) ShallowCopy Uses

func (node FamilyNode) ShallowCopy() Node

func (*FamilyNode) Similarity Uses

func (node *FamilyNode) Similarity(other *FamilyNode, depth int, options SimilarityOptions) float64

Similarity calculates the similarity between two families.

The depth controls how many generations should be compared. A depth of 0 will only compare the husband/wife and not take into account any children. At the moment only a depth of 0 is supported. Any other depth will raise panic.

The options.MaxYears allows the error margin on dates to be adjusted. See DefaultMaxYearsForSimilarity for more information.

func (*FamilyNode) Warnings Uses

func (node *FamilyNode) Warnings() (warnings Warnings)

func (*FamilyNode) Wife Uses

func (node *FamilyNode) Wife() (wife *WifeNode)

If the node is nil the result will also be nil.

type FamilyNoder Uses

type FamilyNoder interface {
    Family() *FamilyNode
}

type FamilyNodes Uses

type FamilyNodes []*FamilyNode

func (FamilyNodes) ByPointer Uses

func (nodes FamilyNodes) ByPointer(pointer string) *FamilyNode

type FamilySearchIDNode Uses

type FamilySearchIDNode struct {
    *SimpleNode
}

FamilySearchIDNode is the unique identifier for the person on FamilySearch.org. A FamilySearch ID always takes the form of:

LZDP-V9V

There are several known tags that carry the FamilySearch ID:

_FID (UnofficialTagFamilySearchID1): Seen exported from MacFamilyFree.
_FSFTID (UnofficialTagFamilySearchID2): Some other applications.

func NewFamilySearchIDNode Uses

func NewFamilySearchIDNode(tag Tag, value string, children ...Node) *FamilySearchIDNode

type FilterFlags Uses

type FilterFlags struct {
    // Specific exclusions.
    NoEvents      bool
    NoResidences  bool
    NoPlaces      bool
    NoSources     bool
    NoMaps        bool
    NoChanges     bool
    NoObjects     bool
    NoLabels      bool
    NoCensuses    bool
    NoEmptyDeaths bool

    // Only vitals (name, birth, baptism, death and burial).
    OnlyVitals bool

    // Only official tags.
    OnlyOfficial bool

    // When comparing, hide lines that are equal on both sides.
    HideEqual bool

    // Condense NAME nodes to a simple string.
    NameFormat string
}

func (*FilterFlags) Filter Uses

func (ff *FilterFlags) Filter(node Node) Node

func (*FilterFlags) FilterFunctions Uses

func (ff *FilterFlags) FilterFunctions() []FilterFunction

func (*FilterFlags) SetupCLI Uses

func (ff *FilterFlags) SetupCLI()

type FilterFunction Uses

type FilterFunction func(node Node) (newNode Node, traverseChildren bool)

FilterFunction is used with the Filter function.

The node (as passed in through the parameter) will be replaced with newNode. You should return the same node argument if you do not want the node to be changed.

The traverseChildren argument decides if the traversal should continue through the children of node. If the traversal continues (traverseChildren is true) the FilterFunction will always receive the children of the node, and not the children (if any) of newNode.

If the newNode is nil then it will be removed and the children will not be traversed, regardless of the traverseChildren value.

func BlacklistTagFilter Uses

func BlacklistTagFilter(tags ...Tag) FilterFunction

BlacklistTagFilter returns any node that is not one of the provided tags.

This is the opposite of WhitelistTagFilter.

See the Filter function.

func OfficialTagFilter Uses

func OfficialTagFilter() FilterFunction

OfficialTagFilter returns any node that is official tag. See Tag.IsOfficial for more information.

See the Filter function.

func OnlyVitalsTagFilter Uses

func OnlyVitalsTagFilter() FilterFunction

OnlyVitalsTagFilter removes all tags except for vital individual information.

The vital nodes are (or multiples in the same individual of): Name, birth, baptism, death and burial. Within these only the date and place is retained.

func RemoveEmptyDeathTagFilter Uses

func RemoveEmptyDeathTagFilter() FilterFunction

RemoveEmptyDeathTagFilter removes any Death (DEAT) events that do not have any child nodes (which would otherwise be information like the date or place.

This is because some applications use the death tag as a marker without any further information which can cause problems when comparing individuals.

func SimpleNameFilter Uses

func SimpleNameFilter(format NameFormat) FilterFunction

SimpleNameFilter flattens NAME nodes with the provided format.

This is useful for comparing names when the components of the name (title, suffix, etc) are less important than the name itself.

func WhitelistTagFilter Uses

func WhitelistTagFilter(tags ...Tag) FilterFunction

WhitelistTagFilter returns any node that is one of the provided tags.

This is the opposite of BlacklistTagFilter.

See the Filter() function.

type FormatNode Uses

type FormatNode struct {
    *SimpleNode
}

FormatNode represents an assigned name given to a consistent format in which information can be conveyed.

func NewFormatNode Uses

func NewFormatNode(value string, children ...Node) *FormatNode

NewFormatNode creates a new FORM node.

type GEDCOMLiner Uses

type GEDCOMLiner interface {
    // GEDCOMLine will return a single GEDCOM line, excluding children and with
    // an optional indent-level.
    //
    // The indent will only be included if it is at least 0. If you want to use
    // GEDCOMLine to compare the string values of nodes or exclude the indent
    // you should use the NoIndent constant.
    //
    // It is not safe to invoke GEDCOMLine on a nil value. Use GEDCOMLine() for
    // a safer alternative.
    GEDCOMLine(indent int) string
}

GEDCOMLiner allows an instance to return the single-line GEDCOM value as a string. This excludes any child nodes.

type GEDCOMStringer Uses

type GEDCOMStringer interface {
    // GEDCOMString returns the multi-line GEDCOM that includes an optional
    // indent for each line.
    //
    // The indent will only be included if it is at least 0. If you want to use
    // GEDCOMString to compare the string values of nodes or exclude the indent
    // you should use the NoIndent constant.
    //
    // It is not safe to invoke GEDCOMString on a nil value. Use GEDCOMString()
    // for a safer alternative.
    GEDCOMString(indent int) string
}

GEDCOMStringer allows an instance to be rendered as multi-line GEDCOM.

GEDCOMStringer can be thought of as a superset of GEDCOMLiner, often sharing the same line. However, for some entities (such as a Document) it does not make sense to implement GEDCOMLiner as well.

type HusbandNode Uses

type HusbandNode struct {
    *SimpleNode
    // contains filtered or unexported fields
}

HusbandNode is an individual in the family role of a married man or father.

func (*HusbandNode) Family Uses

func (node *HusbandNode) Family() *FamilyNode

func (*HusbandNode) Individual Uses

func (node *HusbandNode) Individual() *IndividualNode

func (*HusbandNode) IsIndividual Uses

func (node *HusbandNode) IsIndividual(node2 *IndividualNode) bool

func (*HusbandNode) Similarity Uses

func (node *HusbandNode) Similarity(other *HusbandNode, options SimilarityOptions) float64

type IndividualComparison Uses

type IndividualComparison struct {
    // Left or Right may be nil, but never both.
    Left, Right *IndividualNode

    // Similarity will only contain a usable value if Left and Right are not
    // nil. Otherwise, Similarity may contain any unexpected value.
    Similarity *SurroundingSimilarity
    // contains filtered or unexported fields
}

IndividualComparison is the result of two compared individuals.

func NewIndividualComparison Uses

func NewIndividualComparison(Left, Right *IndividualNode, Similarity *SurroundingSimilarity) *IndividualComparison

func (IndividualComparison) String Uses

func (c IndividualComparison) String() string

String returns the comparison in a human-readable format, like one of:

John Smith <-> John H Smith (0.833333)
Jane Doe <-> (none) (?)
(none) <-> Joe Bloggs (?)

type IndividualComparisons Uses

type IndividualComparisons []*IndividualComparison

IndividualComparisons is a slice of IndividualComparison instances.

func (IndividualComparisons) String Uses

func (comparisons IndividualComparisons) String() string

String returns each comparison string on its own like, like:

John Smith <-> John H Smith (0.833333)
Jane Doe <-> (none) (?)
(none) <-> Joe Bloggs (?)

type IndividualNode Uses

type IndividualNode struct {
    // contains filtered or unexported fields
}

IndividualNode represents a person.

func (*IndividualNode) AddBirthDate Uses

func (node *IndividualNode) AddBirthDate(birthDate string) *IndividualNode

func (*IndividualNode) AddName Uses

func (node *IndividualNode) AddName(name string) *IndividualNode

func (*IndividualNode) Age Uses

func (node *IndividualNode) Age() (Age, Age)

Age returns the best estimate minimum and maximum age of the individual if they are still living or their approximate age range at the time of their death.

Age will use EstimatedBirthDate which will allow it to be more resilient if a birth date is strictly missing but this means that the value returned from Age may not always be exact. See IsEstimate and other fields returned in either Age return values.

If the birth or death date is a range, such as "Between 1945 and 1947" the minimum and maximum possible ages will be returned.

If the birth or death date is not an exact value then the ages will be estimates. See Age.IsEstimate.

If no estimated birth date can be determined then Age.IsKnown will be false.

IsLiving will be used to determine if the individual is still living which includes a maximum possible age when no death elements exist. However, in the case that the individual is not living then EstimatedDeathDate will be used to try and estimate the age at the time of death instead of simply using the maximum possible age (which is 100 by default).

func (*IndividualNode) AgeAt Uses

func (node *IndividualNode) AgeAt(event Node) (Age, Age)

AgeAt follows the same logic as Age but uses an event as the comparison instead of the current time.

If there is more than one date associated with the event or a date contains a range the minimum and maximum values will be used to return the full range.

func (*IndividualNode) AllEvents Uses

func (node *IndividualNode) AllEvents() (nodes Nodes)

AllEvents returns zero or more events of any kind for the individual.

This is not to be confused with the EventNode.

func (*IndividualNode) Baptism Uses

func (node *IndividualNode) Baptism() (*DateNode, *PlaceNode)

Baptism returns the first values for the date and place of the baptism events.

func (*IndividualNode) Baptisms Uses

func (node *IndividualNode) Baptisms() []*BaptismNode

Baptisms returns zero or more baptism events for the individual. The baptisms do not include LDS baptisms.

If the node is nil the result will also be nil.

func (*IndividualNode) Birth Uses

func (node *IndividualNode) Birth() (*DateNode, *PlaceNode)

Birth returns the first values for the date and place of the birth events.

func (*IndividualNode) Births Uses

func (node *IndividualNode) Births() (nodes []*BirthNode)

Births returns zero or more birth events for the individual.

If the node is nil the result will also be nil.

func (*IndividualNode) Burial Uses

func (node *IndividualNode) Burial() (*DateNode, *PlaceNode)

Burial returns the first values for the date and place of the burial events.

func (*IndividualNode) Burials Uses

func (node *IndividualNode) Burials() []*BurialNode

Burials returns zero or more burial events for the individual.

If the node is nil the result will also be nil.

func (*IndividualNode) Children Uses

func (node *IndividualNode) Children() ChildNodes

TODO: Needs tests

If the node is nil the result will also be nil.

func (*IndividualNode) Death Uses

func (node *IndividualNode) Death() (*DateNode, *PlaceNode)

Death returns the first values for the date and place of the death events.

func (*IndividualNode) Deaths Uses

func (node *IndividualNode) Deaths() []*DeathNode

Deaths returns zero or more death events for the individual. It is common for individuals to not have a death event if the death date is not known. If you need to check if an individual is living you should use IsLiving().

If the node is nil the result will also be nil.

func (IndividualNode) Document Uses

func (node IndividualNode) Document() *Document

func (*IndividualNode) EstimatedBirthDate Uses

func (node *IndividualNode) EstimatedBirthDate() *DateNode

EstimatedBirthDate attempts to find the exact or approximate birth date of an individual. It does this by looking at the births, baptisms and LDS baptisms. If any of them contain a date then the lowest date value is returned based on the Years() value which takes in account the full date range.

This logic is loosely based off the idea that if the birth date is not known that a baptism usually happens when the individual is quite young (and therefore close to the their birth date).

It is worth noting that since EstimatedBirthDate returns the lowest possible date that an exact birth date will be ignored if another event happens in a range before that. For example, if an individual has a birth date of "9 Feb 1983" but the Baptism was "9 Jan 1983" then the Baptism is returned. This data must be wrong in either case but EstimatedBirthDate cannot make a sensible decision in this case so it always returned the earliest date.

EstimatedBirthDate is useful when comparing individuals where the exact dates are less important that attempting to serve approximate information for comparison. You almost certainly do not want to use the EstimatedBirthDate value for anything meaningful aside from comparisons.

If the node is nil the result will also be nil.

func (*IndividualNode) EstimatedDeathDate Uses

func (node *IndividualNode) EstimatedDeathDate() *DateNode

EstimatedDeathDate attempts to find the exact or approximate death date of an individual. It does this by returning the earliest death date based on the value of Years(). If there are no death dates then it will attempt to return the minimum burial date.

This logic is loosely based off the idea that if the death date is not known that a burial usually happens a short time after the death of the individual.

It is worth noting that EstimatedDeathDate will always return a death date if one is present before falling back to a possibly more specific burial date. One example of this might be a death date that has a large range such as "1983 - 1993". The burial may be a much more specific date like "Apr 1985". This almost certainly indicates that the death date was around early 1985, however the larger death date range will still be returned.

EstimatedDeathDate is useful when comparing individuals where the exact dates are less important that attempting to serve approximate information for comparison. You almost certainly do not want to use the EstimatedDeathDate value for anything meaningful aside from comparisons.

If the node is nil the result will also be nil.

func (*IndividualNode) Families Uses

func (node *IndividualNode) Families() (families FamilyNodes)

TODO: needs tests

If the node is nil the result will also be nil.

func (*IndividualNode) FamilySearchIDs Uses

func (node *IndividualNode) FamilySearchIDs() (nodes []*FamilySearchIDNode)

func (*IndividualNode) FamilyWithSpouse Uses

func (node *IndividualNode) FamilyWithSpouse(spouse *IndividualNode) *FamilyNode

TODO: needs tests

If the node is nil the result will also be nil.

func (*IndividualNode) FamilyWithUnknownSpouse Uses

func (node *IndividualNode) FamilyWithUnknownSpouse() *FamilyNode

TODO: needs tests

If the node is nil the result will also be nil.

func (*IndividualNode) Is Uses

func (node *IndividualNode) Is(individual *IndividualNode) bool

TODO: needs tests

func (*IndividualNode) IsLiving Uses

func (node *IndividualNode) IsLiving() bool

IsLiving determines if the individual is living.

If no death node exists, but the estimated birth date is found to be older than Document.MaxLivingAge then the individual will not be considered living.

The default value for MaxLivingAge is 100 and can be modified on the document attached to this node. A MaxLivingAge of 0 means that it will only consider the individual to be not living if there is an explicit Death event.

If there is no document attached DefaultMaxLivingAge will be used.

If the node is nil the result will always be false.

func (*IndividualNode) LDSBaptisms Uses

func (node *IndividualNode) LDSBaptisms() Nodes

LDSBaptisms returns zero or more LDS baptism events for the individual. These are not to be confused with Baptisms().

If the node is nil the result will also be nil.

func (*IndividualNode) Name Uses

func (node *IndividualNode) Name() *NameNode

TODO: Needs tests

If the node is nil the result will also be nil.

func (*IndividualNode) Names Uses

func (node *IndividualNode) Names() []*NameNode

If the node is nil the result will also be nil.

func (*IndividualNode) Parents Uses

func (node *IndividualNode) Parents() FamilyNodes

Parents returns the families for which this individual is a child. There may be zero or more parents for an individual. The families returned will all reference this individual as child. However the father, mother or both may not exist.

It is also possible to have duplicate families. That is, families that have the same husband and wife combinations if these families are defined in the GEDCOM file.

If the node is nil the result will also be nil.

func (*IndividualNode) SetSex Uses

func (node *IndividualNode) SetSex(sex string) *IndividualNode

SetSex adds or replaces tge gender of an individual. You should use one of the SexMale, SexFemale or SexUnknown constants.

func (*IndividualNode) Sex Uses

func (node *IndividualNode) Sex() *SexNode

If the node is nil the result will be SexUnknown.

func (IndividualNode) ShallowCopy Uses

func (node IndividualNode) ShallowCopy() Node

func (*IndividualNode) Similarity Uses

func (node *IndividualNode) Similarity(other *IndividualNode, options SimilarityOptions) float64

Similarity calculates how similar two individuals are. The returned value will be between 0.0 and 1.0 where 1.0 means an exact match.

You should prefer SurroundingSimilarity, a more advanced checker that uses this function as part of it's ultimate analysis.

The similarity is based off three equally weighted components, the individuals name, estimated birth and estimated death date and is calculated as follows:

similarity = (nameSimilarity + birthSimilarity + deathSimilarity) / 3.0

Individual names are compared with the StringSimilarity function that does not consider the punctuation and extra spacing.

An individual may have more than one name, if this is the case then each name is checked and the highest matching combination is used.

The birth and death dates use the EstimatedBirthDate and EstimatedDeathDate functions respectively. These functions are allowed to make some estimates when critical information like the birth date does not exist so there is more data to include in the comparison.

Both dates are compared with the DateNode.Similarity function, which also returns a value of 0.0 to 1.0. To put simply the dates must existing within an error margin (for example, 10 years in either direction). Higher scores are awarded to dates that are more relatively closer to each other on a parabola. See DateNode.Similarity for a full explanation of how it deals with approximate dates and date ranges.

It is safe to use Similarity when one or both of the individuals are nil. This will always result in a 0.5. It is a 0.5 not because it is a partial match but that a positive or negative match cannot be determined. This is important when Similarity is used is more extensive similarity calculations as to not unnecessarily skew the results.

The options.MaxYears allows the error margin on dates to be adjusted. See DefaultMaxYearsForSimilarity for more information.

func (*IndividualNode) SpouseChildren Uses

func (node *IndividualNode) SpouseChildren() SpouseChildren

SpouseChildren maps the known spouses to their children. The spouse will be nil if the other parent is not known for some or all of the children. Children can appear under multiple spouses.

If the node is nil the result will also be nil.

func (*IndividualNode) Spouses Uses

func (node *IndividualNode) Spouses() (spouses IndividualNodes)

TODO: needs tests

If the node is nil the result will also be nil.

func (*IndividualNode) String Uses

func (node *IndividualNode) String() string

String returns a human-readable representation of the individual like:

(no name) (b. Aft. 1983)
Bob Smith (b. 1943)
John Chance
Jane Doe (b. 3 Apr 1923, bur. Abt. 1943)

Ideally it will use birth (b.) and death (d.) if available. However, it will fall back to the baptism (bap.) or burial (bur.) respectively.

func (*IndividualNode) SurroundingSimilarity Uses

func (node *IndividualNode) SurroundingSimilarity(other *IndividualNode, options SimilarityOptions, forceFullCalculation bool) (s *SurroundingSimilarity)

SurroundingSimilarity is a more advanced version of Similarity. SurroundingSimilarity also takes into account the immediate surrounding family. That is the parents, spouses and children have separate metrics calculated so they can be interpreted differently or together.

Checking for surrounding family is critical for calculating the similarity of individuals that would otherwise be considered the same because of similar names and dates in large family trees.

SurroundingSimilarity returns a structure of the same name, but really it calculates four discreet similarities:

1. IndividualSimilarity: This is the same as Individual.Similarity().

2. ParentsSimilarity: The similarity of the fathers and mothers of the individual. Each missing parent will be given 0.5. If both parents are missing the parent similarity will also be 0.5.

An individual can have zero or more pairs of parents, but only a single ParentsSimilarity is returned. The ParentsSimilarity is the highest value when each of the parents are compared with the other parents of the other individual.

3. SpousesSimilarity: The similarity of the spouses is compared with IndividualNodes.Similarity() which is designed to compare several individuals at once. It also handles comparing a different number of individuals on either side.

4. ChildrenSimilarity: Children are also compared with IndividualNodes.Similarity() but without respect to their parents (which in this case would be the current individual and likely one of their spouses). It is done this way as to not skew the results if any particular parent is unknown or the child is connected to a different spouse.

The options.MaxYears allows the error margin on dates to be adjusted. See DefaultMaxYearsForSimilarity for more information.

The options.MinimumSimilarity is used when comparing slices of individuals. In this case that means for the spouses and children. A higher value makes the matching more strict. See DefaultMinimumSimilarity for more information.

func (*IndividualNode) UniqueIDs Uses

func (node *IndividualNode) UniqueIDs() (nodes []*UniqueIDNode)

func (*IndividualNode) UniqueIdentifiers Uses

func (node *IndividualNode) UniqueIdentifiers() *StringSet

UniqueIdentifiers returns any strings that can be used to uniquely this individual in this document, but also between documents. For this reason the individual pointer is not included.

It's quite possible to receive an empty set, but it could also contain commonly unique identifiers such as the FamilySearch ID or UUID generated by some applications.

type IndividualNodePair Uses

type IndividualNodePair struct {
    Left, Right *IndividualNode
}

type IndividualNodePairs Uses

type IndividualNodePairs []*IndividualNodePair

func (IndividualNodePairs) Has Uses

func (pairs IndividualNodePairs) Has(findPair *IndividualNodePair) bool

type IndividualNodes Uses

type IndividualNodes []*IndividualNode

IndividualNodes is a collection of individuals.

func (IndividualNodes) ByPointer Uses

func (nodes IndividualNodes) ByPointer(pointer string) *IndividualNode

func (IndividualNodes) ByUniqueIdentifier Uses

func (nodes IndividualNodes) ByUniqueIdentifier(identifier string) *IndividualNode

ByUniqueIdentifier returns the first individual that has a UniqueIdentifier of identifier. If no individual is found the nil is returned.

func (IndividualNodes) ByUniqueIdentifiers Uses

func (nodes IndividualNodes) ByUniqueIdentifiers(identifiers *StringSet) (all IndividualNodes)

ByUniqueIdentifiers returns the any individuals that have a UniqueIdentifier of one of the provided identifiers.

func (IndividualNodes) Compare Uses

func (nodes IndividualNodes) Compare(other IndividualNodes, options *IndividualNodesCompareOptions) IndividualComparisons

Compare returns the matching individuals from two lists.

The length of the result slice will be no larger than the largest slice provided and no smaller than the smallest slice provided.

Individuals can only be matched once on their respective side so you can guarantee that all the Left's are unique and belong to the current nodes. Likewise all Right's will be unique and only belong to the other set.

See IndividualNodesCompareOptions for more options.

func (IndividualNodes) GEDCOMString Uses

func (nodes IndividualNodes) GEDCOMString(indent int) string

GEDCOMString returns the GEDCOM for all individuals. See GEDCOMStringer for more details.

func (IndividualNodes) Merge Uses

func (nodes IndividualNodes) Merge(other IndividualNodes, options *IndividualNodesCompareOptions) (IndividualNodes, error)

Merge uses the expensive but more accurate Compare algorithm to determine the best way to merge two slices of individuals.

Merge relies exclusively on the logic of Compare so there's no need to repeat those details here.

Any individuals that do not match on either side will be appended to the end.

func (IndividualNodes) Nodes Uses

func (nodes IndividualNodes) Nodes() (ns Nodes)

Nodes returns a slice containing the same individuals.

Individuals that are manipulated will affect the original individuals.

func (IndividualNodes) Similarity Uses

func (nodes IndividualNodes) Similarity(other IndividualNodes, options SimilarityOptions) float64

Similarity calculates how similar two collections of individuals are. The individuals could be children of the same parents, spouses that share the same partner or some other similar group of individuals.

Individuals that have a similarity below minimumSimilarity will not be considered a match. Making this a larger value will lead to less false-positives but also cause more true-negatives. You can use the DefaultMinimumSimilarity constant if you are unsure.

As a rule of thumb you should not trust a return value of 0.5 of less as any kind of match. 0.7 and above is getting in the range of what is likely to be considered the same.

Although there is no theoretical limit to the amount of individuals that can be compared, this function invokes a complex chain of comparisons that can be very CPU intensive. It is not a good idea to use it compare a large amount of individuals, like an entire file.

If both slices have zero elements then 1.0 is returned. However, if one slice is not empty then 0.5 is returned. 0.5 is actually the same value that would be returned in all cases if the logic were to fall through.

The algorithm works through several stages explained in more detail below but the basic principle is this:

1. Find an individual from both slices that have the highest similarity. There similarity is added to a total. These individuals are now excluded from the next pass.

2. Repeat the first step until one of the list runs out of individuals.

3. Increase the number of matched individuals to the length of the largest slice by using the score 0.5 for each individual.

4. Take the average. The total score (including the 0.5 for padding individuals) and divide it by the maximum slice size.

The easiest way to explain how the process works is by working through an example. Consider the two following slices of individuals:

[a, b, c]
[d, e]

There is 5 individuals in total, but the largest slice length is 3.

The first step is to calculate the individual similarity matrix between the inputs. This is the expensive part because it takes O(nm) time where n and m are the slice lengths respectively. The results may look like:

a.Similarity(d) = 0.234
a.Similarity(e) = 0.123
b.Similarity(d) = 0.546
b.Similarity(e) = 0.678
c.Similarity(d) = 0.235
c.Similarity(e) = 0.456

The results are sorted by their similarity score, highest first:

b.Similarity(e) = 0.678
b.Similarity(d) = 0.546
c.Similarity(e) = 0.456
c.Similarity(d) = 0.235
a.Similarity(d) = 0.234
a.Similarity(e) = 0.123

In reality the scores should be closer to 1.0 for many of the individuals, but I will use a wide range of values for this example.

The above list states that individual "b" is the most similar individual to "e". So we should consider these a match, and record the fact that "b" and "e" are matched.

Moving on to the second iteration, "b" has already been matched. Even though "d" has not we still skip this iteration. The same is true for the third iteration, since "e" has already been matched.

The forth iteration is the first time we see two new individuals, "c" and "d". For the second time we consider these two to be a match.

The process continues and can be visualised like this:

b.Similarity(e) = 0.678   b = e
b.Similarity(d) = 0.546   b already matched
c.Similarity(e) = 0.456   e already matched
c.Similarity(d) = 0.235   c = d
a.Similarity(d) = 0.234   d already matched
a.Similarity(e) = 0.123   e already matched

There should be the same amount of matches as the smallest slice size. As we can see the two matches is the same number as the smallest slice.

Finally, we pad out the remaining individuals with a score of 0.5 so that the total matches equals the longest slice. Using a middle-score (and not 0.0) is important because 0.0 would represent that individuals were a complete non-match and throw out the final score quite heavily. We must treat missing individuals as neither a perfect or non-match because we simply don't have the information to make the call either way, hence 0.5.

The returned score is now the average:

(0.678 + 0.234 + 0.5) / 3 = 0.4707

There are some known caveats to the algorithm:

When calculating the similarity of individuals where data is missing from both sides (such as both individuals having a missing birth date) then the result will be less than 1.0 even though the individuals are arguably the same.

This is designed this way on purpose as to not so eagerly match individuals with incomplete information. Otherwise these would take a higher score for matches of individuals that have a slightly different birth date.

The options.MaxYears allows the error margin on dates to be adjusted. See DefaultMaxYearsForSimilarity for more information.

func (IndividualNodes) String Uses

func (nodes IndividualNodes) String() string

type IndividualNodesCompareOptions Uses

type IndividualNodesCompareOptions struct {
    // SimilarityOptions controls the weights of the comparisons. See
    // SimilarityOptions for more information. Any matches below
    // MinimumSimilarity will not be used.
    //
    // Since this can take a long time to run with a lot of individuals there is
    // an optional notifier channel that can be listened to for progress
    // updates. Or pass nil to ignore this feature.
    SimilarityOptions SimilarityOptions

    // Notifier will be sent progress updates throughout the comparison if it is
    // not nil. If it is nil then this feature is ignored.
    //
    // You can control how precise this is with NotifierStep.
    //
    // You may close this Notifier to abort the comparison early.
    Notifier chan Progress

    // NotifierStep is the number of comparisons that must happen before the
    // Notifier be notified. The default is zero so all comparisons will cause a
    // notify. You should set this to a higher amount of reduce the frequency of
    // chatter.
    NotifierStep int64

    // Jobs controls the parallelism of the processing. The default value of 0
    // works the same as a value of 1 (no concurrency). Any number higher than 1
    // will create extra go routines to increase the CPU utilization of the
    // processing.
    //
    // It is important to note that the parallelism is still bound by
    // GOMAXPROCS.
    Jobs int
}

IndividualNodesCompareOptions provides more optional attributes for IndividualNodes.Compare.

You should use NewIndividualNodesCompareOptions to start with sensible defaults.

func NewIndividualNodesCompareOptions Uses

func NewIndividualNodesCompareOptions() *IndividualNodesCompareOptions

NewIndividualNodesCompareOptions creates sensible defaults for IndividualNodesCompareOptions. In the majority of cases you will not need to change any further options.

func (*IndividualNodesCompareOptions) ConcurrentJobs Uses

func (o *IndividualNodesCompareOptions) ConcurrentJobs() int

type LatitudeNode Uses

type LatitudeNode struct {
    *SimpleNode
}

LatitudeNode represents a value indicating a coordinate position on a line, plane, or space.

New in Gedcom 5.5.1.

func NewLatitudeNode Uses

func NewLatitudeNode(value string, children ...Node) *LatitudeNode

NewLatitudeNode creates a new LATI node.

type LongitudeNode Uses

type LongitudeNode struct {
    *SimpleNode
}

LongitudeNode represents a value indicating a coordinate position on a line, plane, or space.

New in Gedcom 5.5.1.

func NewLongitudeNode Uses

func NewLongitudeNode(value string, children ...Node) *LongitudeNode

NewLongitudeNode creates a new LONG node.

type MapNode Uses

type MapNode struct {
    *SimpleNode
}

MapNode pertains to a representation of measurements usually presented in a graphical form.

New in Gedcom 5.5.1.

func NewMapNode Uses

func NewMapNode(value string, children ...Node) *MapNode

NewMapNode creates a new MAP node.

func (*MapNode) Latitude Uses

func (node *MapNode) Latitude() *LatitudeNode

Latitude is the value specifying the latitudinal coordinate of the place name.

The latitude coordinate is the direction North or South from the equator in degrees and fraction of degrees carried out to give the desired accuracy.

For example: 18 degrees, 9 minutes, and 3.4 seconds North would be formatted as N18.150944.

Minutes and seconds are converted by dividing the minutes value by 60 and the seconds value by 3600 and adding the results together. This sum becomes the fractional part of the degree’s value.

func (*MapNode) Longitude Uses

func (node *MapNode) Longitude() *LongitudeNode

Longitude is the value specifying the longitudinal coordinate of the place name.

The longitude coordinate is degrees and fraction of degrees east or west of the zero or base meridian coordinate.

For example: 168 degrees, 9 minutes, and 3.4 seconds East would be formatted as E168.150944.

type MergeFunction Uses

type MergeFunction func(left, right Node) Node

MergeFunction will do one of two things:

1. If the nodes should be merged, it must return a new new node.

2. If the nodes should not or could not be merged, then nil is returned.

A MergeFunction can be used with MergeNodeSlices.

func IndividualBySurroundingSimilarityMergeFunction Uses

func IndividualBySurroundingSimilarityMergeFunction(minimumSimilarity float64, options SimilarityOptions) MergeFunction

IndividualBySurroundingSimilarityMergeFunction creates a MergeFunction that will merge individuals if their surrounding similarity is at least minimumSimilarity.

If either of the nodes are not IndividualNode instances then it will always return nil so they will not be merged.

The minimumSimilarity should be value between 0.0 and 1.0. The options must not be nil, you should use NewSimilarityOptions() for sensible defaults.

type NameFormat Uses

type NameFormat string

NameFormat describes how an individuals name should be formatted.

The format is a string that contains placeholders and works similar to fmt.Printf where placeholders represent different components of the name:

%% "%"
%f GivenName
%l Surname
%m SurnamePrefix
%p Prefix
%s Suffix
%t Title

Each of the letters may be in upper case to convert the name part to upper case also. Whitespace before, after and between name components will be removed:

name.Format("%l, %f")     // "Smith, Bob"
name.Format("%f %L")      // "Bob SMITH"
name.Format("%f %m (%l)") // "Bob (Smith)"
const (
    // This is the written format, also used by String().
    NameFormatWritten NameFormat = "%t %p %f %m %l %s"

    // This is the style used in GEDCOM NAME nodes. It is used in GedcomName().
    //
    // It should be noted that while the formatted name is valid GEDCOM, it
    // cannot be reverse back into its individual name parts.
    NameFormatGEDCOM NameFormat = "%t %p %f %m /%l/ %s"

    // NameFormatIndex is appropriate for showing names that are indexed by
    // their surname, such as "Smith, Bob"
    NameFormatIndex NameFormat = "%m %l, %t %p %f %s"
)

NameFormat constants can be used with NameNode.Format.

func NewNameFormatByName Uses

func NewNameFormatByName(name string) (NameFormat, bool)

NewNameFormatByName returns one of the NameFormat constants.

The name is the lowercase name of the constant without the prefix. For example, "NameFormatWritten" would have the name "written".

It will return the original name and false if the name is not known. This allows custom formats to be passed through like:

NewNameFormatByName("gedcom") // "%t %p %f %m /%l/ %s", true
NewNameFormatByName("%L %f")  // "%L %f", false

type NameNode Uses

type NameNode struct {
    *SimpleNode
}

NameNode represents all the parts that make up a single name. An individual may have more than one name, each one would be represented by a NameNode.

func NewNameNode Uses

func NewNameNode(value string, children ...Node) *NameNode

func (*NameNode) Format Uses

func (node *NameNode) Format(format NameFormat) string

Format returns a formatted name.

There are some common formats described with the NameFormat constants. See NameFormat for a full description.

func (*NameNode) GedcomName Uses

func (node *NameNode) GedcomName() (name string)

GedcomName returns the simplified GEDCOM name often used also as the value for the NAME node.

The only difference between this as String() is that the surname is encapsulated inside forward slashes like:

Sir Elliot Rupert /Chance/ Sr

Even this uses the NameFormatGEDCOM it may return a different value from Format(NameFormatGEDCOM) because any empty surnames will be removed.

func (*NameNode) GivenName Uses

func (node *NameNode) GivenName() string

GivenName is the given or earned name used for official identification of a person. It is also commonly known as the "first name".

func (*NameNode) Prefix Uses

func (node *NameNode) Prefix() string

func (*NameNode) String Uses

func (node *NameNode) String() string

String returns all name components in the format that would be written like "Grand Duke Bob Smith Esq.". It specifically uses NameFormatWritten.

func (*NameNode) Suffix Uses

func (node *NameNode) Suffix() string

func (*NameNode) Surname Uses

func (node *NameNode) Surname() string

Surname is a family name passed on or used by members of a family.

func (*NameNode) SurnamePrefix Uses

func (node *NameNode) SurnamePrefix() string

func (*NameNode) Title Uses

func (node *NameNode) Title() string

func (*NameNode) Type Uses

func (node *NameNode) Type() NameType

type NameType Uses

type NameType string

func (NameType) String Uses

func (t NameType) String() string

Is usually blank for the primary name

type NicknameNode Uses

type NicknameNode struct {
    *SimpleNode
}

NicknameNode is a descriptive or familiar that is used instead of, or in addition to, one's proper name.

func NewNicknameNode Uses

func NewNicknameNode(value string, children ...Node) *NicknameNode

NewNicknameNode creates a new NICK node.

type Node Uses

type Node interface {
    fmt.Stringer
    NodeCopier
    Noder
    GEDCOMLiner
    GEDCOMStringer

    // The node itself.
    RawSimpleNode() *SimpleNode
    Tag() Tag
    Value() string
    Pointer() string

    // Equals performs a shallow comparison between two nodes.
    //
    // The implementation is different depending on the types of nodes being
    // compared. You should see the specific documentation for the Node.
    //
    // That being said, as a general rule is fair to assume that in most cases
    // the following things take place:
    //
    // 1. The default logic, if not overridden by the node is to consider nodes
    // equal if they have the all of the same; tag, value and pointer.
    //
    // 2. If either side is nil (or both) the nodes are never considered equal.
    //
    // 3. If both nodes are different types they are not considered equal.
    //
    // 4. Despite being a shallow equality test some nodes need to check the
    // equality some children to make a determination. For example, a BirthNode
    // is always equal to another BirthNode, even if they contain different
    // children or dates. Whereas a ResidenceNode is only considered equal if
    // they both contain at least one DateNode with exactly the same value.
    //
    // The rules above play heavily into the logic of other things, such as
    // CompareNodes.
    Equals(node2 Node) bool
}

func DeepCopy Uses

func DeepCopy(node Node) Node

DeepCopy returns a new node with all recursive children also duplicated.

func EqualityMergeFunction Uses

func EqualityMergeFunction(left, right Node) Node

EqualityMergeFunction is a MergeFunction that will return a merged node if the node are considered equal (with Equals). This is probably the most generic case when doing general merges.

func Filter Uses

func Filter(root Node, fn FilterFunction) Node

Filter returns a new nest node structure by recursively filtering all children based on a callback FilterFunction.

See FilterFunction for the implementation details of fn.

There are several other functions that can be used as filters including; WhitelistTagFilter, BlacklistTagFilter and OfficialTagFilter.

Some nodes, such as an IndividualNode or FamilyNode cannot be created without being attached to a document. Filter will attach these to a new document which can be accessed through their respective Document() method.

func First Uses

func First(nodes interface{}) Node

First returns the first non-nil node of nodes. If the length of nodes is zero or a non-nil value is not found then nil is returned.

First is useful in combination with other functions like:

birth := First(individual.Births())

func Last Uses

func Last(nodes interface{}) Node

Last returns the last non-nil node of nodes. If the length of nodes is zero or a non-nil value is not found then nil is returned.

Last is useful in combination with other functions like:

death := Last(individual.Deaths())

func MergeNodes Uses

func MergeNodes(left, right Node) (Node, error)

MergeNodes returns a new node that merges children from both nodes.

If either of the nodes are nil, or they are not the same tag an error will be returned and the result node will be nil.

The node returned and all of the merged children will be created as new nodes as to not interfere with the original input.

func NewNode Uses

func NewNode(tag Tag, value, pointer string, children ...Node) Node

NewNode creates a node with no children. It is also the correct way to create a shallow copy of a node.

If the node tag is recognised as a more specific type, such as *DateNode then that will be returned. Otherwise a *SimpleNode will be used.

func NodeCondition Uses

func NodeCondition(condition bool, node1, node2 Node) Node

NodeCondition is a convenience method for inline conditionals.

type NodeCopier Uses

type NodeCopier interface {
    // ShallowCopy returns a new node with all the same properties, but no
    // children.
    //
    // You should assume that it is not safe to use ShallowCopy() on a nil
    // value.
    //
    // See DeepCopy() for copying nodes recursively.
    ShallowCopy() Node
}

type NodeDiff Uses

type NodeDiff struct {
    // Left or Right may be nil, but never both.
    //
    // Since nodes may be compared from different documents and have different
    // raw values it's important to retain the left and right nodes. Make sure
    // when displaying or traversing your data you are showing the correct side.
    //
    // The Left and Right retain their original children as well so you an still
    // perform all the same operations on the nodes inside a NodeDiff.
    Left, Right Node

    // Children represents each of the compared child nodes from both sides. See
    // CompareNodes for a full explanation.
    Children []*NodeDiff
}

NodeDiff is used to describe the difference when two nodes are compared.

It is important to understand the semantics of what a "difference" (and therefore "equality") means for GEDCOM data as this heavily factors into influencing the way the algorithms and returned values represent.

GEDCOM files are quite unbounded when it comes to events and facts. For example, it's common to have multiple birth events (BIRT tag) for the same individual. This is not necessarily a bug in the data but rather a way to describe two possible known birth dates or locations.

The order of nodes in the GEDCOM file is also insignificant. That is to say that a birth event that appears before another birth event is no more important than any other tag, including other birth events.

Child nodes belonging to two parent nodes that are considered equal (by using Equals) can be merged. For example, all of the following examples are considered to be equal because the BirthNode.Equals regards all BirthNodes as equal (see specific documentation for a complete explanation):

BIRT               |  BIRT               |  BIRT
  DATE 3 SEP 1943  |    DATE 3 SEP 1943  |    PLAC England
BIRT               |    PLAC England     |    DATE 3 SEP 1943
  PLAC England     |                     |  BIRT

However, the semantics of Equals is quite different for other types of nodes. For example ResidenceNodes are considered equal only if they have the same date, as it wouldn't make sense (or just be plain wrong) to merge children from separate Residence events.

func CompareNodes Uses

func CompareNodes(left, right Node) *NodeDiff

CompareNodes returns the recursive comparison of two root nodes. To properly understand the motivations and expected result you should first understand NodeDiff before you continue reading.

The returned NodeDiff will have root node assigned to the Left and Right, even if they are non-equal values. This is the only case where this is possible. It was decided to do it this way to allow comparing of nodes that often have a different root node value (like individuals with different pointers), and also keep the output from CompareNodes consistent.

If you need to be sure the root node are the equal after the comparison, you can use (this is also nil safe):

d.Left.Equals(d.Right)

The algorithm to perform the diff is actually very simple:

1. It creates an empty NodeDiff instance.

2. It traverses down the left creating all the respective child nodes as it goes. Before it adds a child node at any level it will always check previously created nodes at the same level for equality. If it finds a match it will redirect the traversal through this parent rather than creating a new child.

3. It traverses the right side with the same rules. The only real difference is that it will assign the node to the right side on a match/new child instead of the left.

Here are two individuals that have slightly different data:

0 INDI @P3@           |  0 INDI @P4@
1 NAME John /Smith/   |  1 NAME J. /Smith/
1 BIRT                |  1 BIRT
2 DATE 3 SEP 1943     |  2 DATE Abt. Sep 1943
1 DEAT                |  1 BIRT
2 PLAC England        |  2 DATE 3 SEP 1943
1 BIRT                |  1 DEAT
2 DATE Abt. Oct 1943  |  2 DATE Aft. 2001
                      |  2 PLAC Surry, England

In this case both of the root nodes are different (because of the different pointer values). The returned left and right will have the respective root nodes.

Here is the output, rendered with NodeDiff.String():

LR 0 INDI @P3@
L  1 NAME John /Smith/
LR 1 BIRT
L  2 DATE Abt. Oct 1943
LR 2 DATE 3 SEP 1943
 R 2 DATE Abt. Sep 1943
LR 1 DEAT
L  2 PLAC England
 R 2 DATE Aft. 2001
 R 2 PLAC Surry, England
 R 1 NAME J. /Smith/

func (*NodeDiff) IsDeepEqual Uses

func (nd *NodeDiff) IsDeepEqual() bool

IsDeepEqual returns true if the current NodeDiff and all of its children have been assigned to the left and right.

The following diff (rendered with String) shows each NodeDiff and if it would be considered DeepEqual:

LR 0 INDI @P3@           | false
LR 1 NAME John /Smith/   | true
LR 1 BIRT                | false
L  2 DATE Abt. Oct 1943  | false
LR 2 DATE 3 SEP 1943     | true
 R 2 DATE Abt. Sep 1943  | false
LR 1 DEAT                | true
LR 2 PLAC England        | true
 R 1 NAME J. /Smith/     | false

func (*NodeDiff) LeftNode Uses

func (nd *NodeDiff) LeftNode() Node

LeftNode returns the flattening Node value that favors the left side.

To favor means to return the Left value when both the Left and Right are set.

func (*NodeDiff) RightNode Uses

func (nd *NodeDiff) RightNode() Node

RightNode returns the flattening Node value that favors the right side.

To favor means to return the Left value when both the Left and Right are set.

func (*NodeDiff) Sort Uses

func (nd *NodeDiff) Sort()

Sort mutates the existing NodeDiff to order the nodes recursively.

Nodes are first sorted by their tag group. The tag group places some tags are specific points, such as the name as the top, and the burial after the death event.

For nodes in the same tag group they are then ordered by date based on the Yearer interface.

If nodes do not implement Yearer, or the values are equal it will then use the third level of ordering which is the node Value itself.

Sort uses SliceStable to make the results more predicable and also ensures that nodes remain in the same order if all three levels are the same.

func (*NodeDiff) String Uses

func (nd *NodeDiff) String() string

String returns a readable comparison of nodes, like:

LR 0 INDI @P3@
L  1 NAME John /Smith/
LR 1 BIRT
L  2 DATE Abt. Oct 1943
LR 2 DATE 3 SEP 1943
 R 2 DATE Abt. Sep 1943
LR 1 DEAT
L  2 PLAC England
 R 2 DATE Aft. 2001
 R 2 PLAC Surry, England
 R 1 NAME J. /Smith/

The L/R/LR represent which side has the node, followed by the GEDCOM indent and node line.

There is a special case if both root nodes are different. They will be displayed as two separate lines even though they both belong to the same NodeDiff:

LR 0 INDI @P3@
LR 0 INDI @P4@

You should not rely on this format to be machine readable as it may change in the future.

func (*NodeDiff) Tag Uses

func (nd *NodeDiff) Tag() Tag

type NodeSet Uses

type NodeSet map[Node]bool

NodeSet is a collection of unique nodes.

The nodes are considered unique only by their address, not by any other measure of equality.

func (NodeSet) Add Uses

func (ns NodeSet) Add(node Node)

Add a node to the set.

The nodes are considered unique only by their address, not by any other measure of equality.

Attempting to add a node that already exists will have no effect.

func (NodeSet) Has Uses

func (ns NodeSet) Has(node Node) bool

Has returns true if a node exists in the set.

type Noder Uses

type Noder interface {
    // Nodes returns any child nodes.
    Nodes() Nodes

    // AddNode will add a child to this node.
    //
    // There is no restriction on whether a node is not allow to have children
    // so you can expect that no error can occur.
    //
    // AddNode will always append the child at the end, even if there is is an
    // exact child that already exists. However, the order of node in a GEDCOM
    // file is almost always irrelevant.
    AddNode(node Node)

    // SetNodes replaces all of the child nodes.
    SetNodes(nodes Nodes)

    DeleteNode(node Node) bool
}

Noder allows an instance to have child nodes.

type Nodes Uses

type Nodes []Node

func Compound Uses

func Compound(nodes ...interface{}) Nodes

Compound is a easier way to join a collection of nodes. The input type is flexible to allow the following types:

nil
Node
Nodes

If any of the inputs are not one of the above types then a panic is raised.

Using nil as a Node or including nil as one of the elements for Nodes will be ignored, so you should not receive any nil values in the output.

func Flatten Uses

func Flatten(node Node) Nodes

Flatten returns a slice of nodes from a tree structure.

The original nodes will not be modified, but they will also not be copied. Any changes to the result nodes will directly affect the original tree structure. This also means that the nodes returned will have the references to their children as before.

Flatten makes no guarantees about the same node appearing more than once if it also appears more then once in the original structure. Be careful not to pass in structures that have circular references between nodes.

If the input is nil then the result will also be nil.

If you would like a completely new copy of the data you can use:

Flatten(DeepCopy(node))

func MergeNodeSlices Uses

func MergeNodeSlices(left, right Nodes, mergeFn MergeFunction) Nodes

MergeNodeSlices merges two slices based on the mergeFn.

The MergeFunction must not be nil, but may return nil. See MergeFunction for usage.

The left and right may contain zero elements or be nil, these mean the same thing.

MergeNodeSlices makes some guarantees about the result:

1. The result slice will contain at least the length of the greatest length of left and right. So if len(left) = 3 and len(right) = 5 then the result slice will have a minimum of 5 items. If both slices are empty or nil the minimum length will also be zero.

2. The result slice will not contain more elements than the sum of the lengths of the left and right. So if len(left) = 3 and len(right) = 5 then the largest possible slice returned is 8.

3. All of the nodes returned will be deep copies of the original nodes so it is safe to manipulate the result in any way without affecting the original input slices.

4. Any element from the left or right may only be merged once. That is to say that if a merge happens between a left and right node that the result node cannot be merged again.

5. Merges can only happen between a node on the left with a node on the right. Even if two nodes in the left could be merged they will not be. The same goes for all of the elements in the right slice.

func NodesWithTag Uses

func NodesWithTag(node Node, tag Tag) (result Nodes)

NodesWithTag returns the zero or more nodes that have a specific GEDCOM tag. If the provided node is nil then an empty slice will always be returned.

If the node is nil the result will also be nil.

func NodesWithTagPath Uses

func NodesWithTagPath(node Node, tagPath ...Tag) Nodes

NodesWithTagPath return all of the nodes that have an exact tag path. The number of nodes returned can be zero and tag must match the tag path completely and exactly.

birthPlaces := NodesWithTagPath(individual, TagBirth, TagPlace)

If the node is nil the result will also be nil.

func (Nodes) CastTo Uses

func (nodes Nodes) CastTo(t interface{}) interface{}

CastTo creates a slice of a more specific node type.

All Nodes must be the same type and the same as the provided t.

func (Nodes) FlattenAll Uses

func (nodes Nodes) FlattenAll(result Nodes)

FlattenAll works as Flatten with multiple inputs that are returned as a single slice.

If any of the nodes are nil they will be ignored.

type NoteNode Uses

type NoteNode struct {
    *SimpleNode
}

NoteNode represents additional information provided by the submitter for understanding the enclosing data.

func NewNoteNode Uses

func NewNoteNode(value string, children ...Node) *NoteNode

NewNoteNode creates a new NOTE node.

type Number Uses

type Number int

Number can be used to transform a number into another representation.

Even though a Number is an alias for int you should use the provided function Int() to get its value in case the underlying type changes in the future.

It should also be noted that Number only supports integer values and many of the conversions or representations will only work with positive values. Some functions may also have more specific ranges.

func NewNumberWithInt Uses

func NewNumberWithInt(n int) Number

NewNumberWithInt is the preferred way to create a new Number.

While it is possible to cast the value directly to a Number, using this constructor is safer if the underlying type of Number changes.

func (Number) Int Uses

func (n Number) Int() int

Int returns the true value of the number with no loss of precision.

func (Number) LowerRoman Uses

func (n Number) LowerRoman() (string, error)

LowerRoman returns the lowercase Roman numerals, like "vii".

LowerRoman works with exactly the same rules and constraints as UpperRoman.

func (Number) UpperRoman Uses

func (n Number) UpperRoman() (string, error)

UpperRoman returns uppercase Roman numerals, like "VII".

The acceptable range is between 0 and 10000. Zero is a special case that will return "N", an abbreviation for "nulla". While it is possible to represent numbers number larger than 10000 it would get very cumbersome since each thousand would need an extra "M".

If the number is outside of the acceptable range then an empty string is returned with an error.

Also see LowerRoman.

type ObjectMapper Uses

type ObjectMapper interface {
    ObjectMap() map[string]interface{}
}

ObjectMapper allows objects to be represented a map. This is important when serializing and examining objects.

type PhoneticVariationNode Uses

type PhoneticVariationNode struct {
    *SimpleNode
}

PhoneticVariationNode represents a phonetic variation of a superior text string.

New in Gedcom 5.5.1.

func NewPhoneticVariationNode Uses

func NewPhoneticVariationNode(value string, children ...Node) *PhoneticVariationNode

NewPhoneticVariationNode creates a new FONE node.

func (*PhoneticVariationNode) Type Uses

func (node *PhoneticVariationNode) Type() *TypeNode

type PlaceNode Uses

type PlaceNode struct {
    *SimpleNode
}

PlaceNode represents a jurisdictional name to identify the place or location of an event.

The original specification was derived from http://wiki-en.genealogy.net/GEDCOM/PLAC-Tag

func NewPlaceNode Uses

func NewPlaceNode(value string, children ...Node) *PlaceNode

NewPlaceNode creates a new PLAC node.

The original specification was derived from http://wiki-en.genealogy.net/GEDCOM/PLAC-Tag

func Places Uses

func Places(nodes ...Node) (result []*PlaceNode)

Places returns the shallow PlaceNodes for each of the input nodes.

Dates is safe to use with nil nodes.

func (*PlaceNode) Country Uses

func (node *PlaceNode) Country() string

Country is the forth part of the JurisdictionalName().

Country will only return a non-empty response if the JurisdictionalName is exactly in the form of "Name,County,State,Country" or the country can be identified from the list of Countries.

func (*PlaceNode) County Uses

func (node *PlaceNode) County() string

County is the second part of the JurisdictionalName().

County will only return a non-empty response if the JurisdictionalName is exactly in the form of "Name,County,State,Country".

func (*PlaceNode) Format Uses

func (node *PlaceNode) Format() *FormatNode

Format shows the jurisdictional entities that are named in a sequence from the lowest to the highest jurisdiction.

The jurisdictions are separated by commas, and any jurisdiction's name that is missing is still accounted for by a comma.

When a PLAC.FORM structure is included in the HEADER of a GEDCOM transmission, it implies that all place names follow this jurisdictional format and each jurisdiction is accounted for by a comma, whether the name is known or not.

When the PLAC.FORM is subordinate to an event, it temporarily overrides the implications made by the PLAC.FORM structure stated in the HEADER. This usage is not common and, therefore, not encouraged. It should only be used when a system has over-structured its place-names.

See JurisdictionalName() for a more reliable way to determine the Format.

func (*PlaceNode) JurisdictionalEntities Uses

func (node *PlaceNode) JurisdictionalEntities() (string, string, string, string)

JurisdictionalEntities returns the name, county, state and country.

See JurisdictionalName() for a full explanation.

func (*PlaceNode) JurisdictionalName Uses

func (node *PlaceNode) JurisdictionalName() string

JurisdictionalName determines the best name to use to identify the jurisdiction entities.

If Format() is not empty then this is the best jurisdictional name to use because it should be in the form of "Name,County,State,Country". Otherwise it will have to fallback to using the PlaceNode value.

The PlaceNode value does not have to follow any standards but it's common for it to have the same value as the Format would have had.

If the jurisdictional name is not exactly in the form of "Name,County,State,Country" (including more or less components) then it cannot be split. In this case the Name component is the entire name and the County, State and Country will be empty.

func (*PlaceNode) Map Uses

func (node *PlaceNode) Map() *MapNode

func (*PlaceNode) Name Uses

func (node *PlaceNode) Name() string

Name is the first part of the JurisdictionalName().

If the JurisdictionalName is not in the exact form of "Name,County,State,Country" then Name will return the entire jurisdictional name.

func (*PlaceNode) Notes Uses

func (node *PlaceNode) Notes() []*NoteNode

func (*PlaceNode) PhoneticVariations Uses

func (node *PlaceNode) PhoneticVariations() []*PhoneticVariationNode

PhoneticVariations of the place name are written in the same form as was the place name used in the superior PlaceNode value, but phonetically written using the method indicated by the subordinate Type.

For example if hiragana was used to provide a reading of a name written in kanji, then the Type value would indicate kana.

See PhoneticVariationTypeHangul and PhoneticVariationTypeKana.

func (*PlaceNode) RomanizedVariations Uses

func (node *PlaceNode) RomanizedVariations() []*RomanizedVariationNode

RomanizedVariations of the place name are written in the same form prescribed for the place name used in the superior PlaceNode context.

The method used to romanize the name is indicated by the Value of the subordinate Type().

For example if romaji was used to provide a reading of a place name written in kanji, then the Type subordinate to the RomanizedVariationNode would indicate "romaji".

func (*PlaceNode) State Uses

func (node *PlaceNode) State() string

State is the third part of the JurisdictionalName().

State will only return a non-empty response if the JurisdictionalName is exactly in the form of "Name,County,State,Country".

type Placer Uses

type Placer interface {
    Places() []*PlaceNode
}

type Progress Uses

type Progress struct {
    // Done is how many operations have been completed so far. If Done is zero
    // you should add the value of Add instead.
    Done int64

    // Add represents how many operations were performed since the last
    // operation. It is possible for both the Done and Add to be zero. This
    // means the progress did not change. Add may also be a negative value.
    Add int64

    // Total is the expected number of total operations. Total may change
    // throughout the processing to be larger to smaller that any previous
    // value.
    //
    // If total is zero, you should not change the existing total value.
    Total int64
}

Progress contains information about the progress of an operation.

Progress will consist of a value for Add or Done. It will also optionally contain a value for Total.

type ResidenceNode Uses

type ResidenceNode struct {
    *SimpleNode
}

ResidenceNode is the act of dwelling at an address for a period of time.

func NewResidenceNode Uses

func NewResidenceNode(value string, children ...Node) *ResidenceNode

NewResidenceNode creates a new RESI node.

func (*ResidenceNode) Dates Uses

func (node *ResidenceNode) Dates() DateNodes

Dates returns zero or more dates associated with the residence.

When more than one date is returned you should not assume that the order has any significance for the importance of the dates.

If the node is nil the result will also be nil.

func (*ResidenceNode) Equals Uses

func (node *ResidenceNode) Equals(node2 Node) bool

Equal tests if two residence events are the same.

Two residence events are considered equal if they both contain the same date. If either or both contain more than one date only a single date must match both sides.

If either node is nil (including both) or if the right side is not a ResidenceNode then false is always returned.

func (*ResidenceNode) Years Uses

func (node *ResidenceNode) Years() float64

Years returns the Years value of the minimum date node in the node.

type RomanizedVariationNode Uses

type RomanizedVariationNode struct {
    *SimpleNode
}

RomanizedVariationNode represents a romanized variation of a superior text string.

New in Gedcom 5.5.1.

func NewRomanizedVariationNode Uses

func NewRomanizedVariationNode(value string, children ...Node) *RomanizedVariationNode

NewRomanizedVariationNode creates a new ROMN node.

func (*RomanizedVariationNode) Type Uses

func (node *RomanizedVariationNode) Type() *TypeNode

type SexNode Uses

type SexNode struct {
    *SimpleNode
}

Indicates the sex of an individual--male or female.

func NewSexNode Uses

func NewSexNode(value string) *SexNode

NewSexNode returns a node that represents a known or unknown gender. You should use one of the constants; SexMale, SexFemale or SexUnknown.

func (*SexNode) IsFemale Uses

func (node *SexNode) IsFemale() bool

func (*SexNode) IsMale Uses

func (node *SexNode) IsMale() bool

func (*SexNode) IsUnknown Uses

func (node *SexNode) IsUnknown() bool

func (*SexNode) OwnershipWord Uses

func (node *SexNode) OwnershipWord() string

func (*SexNode) String Uses

func (node *SexNode) String() string

type SiblingsBornTooCloseWarning Uses

type SiblingsBornTooCloseWarning struct {
    Sibling1, Sibling2 *ChildNode
}

func NewSiblingsBornTooCloseWarning Uses

func NewSiblingsBornTooCloseWarning(sibling1, sibling2 *ChildNode) *SiblingsBornTooCloseWarning

func (*SiblingsBornTooCloseWarning) Name Uses

func (w *SiblingsBornTooCloseWarning) Name() string

func (*SiblingsBornTooCloseWarning) String Uses

func (w *SiblingsBornTooCloseWarning) String() string

type SimilarityOptions Uses

type SimilarityOptions struct {
    // MinimumSimilarity is the threshold for matching individuals as the same
    // person. This is used to compare only the individual (not surrounding
    // family) like spouses and children. See DefaultMinimumSimilarity.
    MinimumSimilarity float64

    // MinimumWeightedSimilarity is the threshold for whether two individuals
    // should be the seen as the same person when the surrounding immediate
    // family is taken into consideration. See WeightedSimilarity().
    MinimumWeightedSimilarity float64

    // MaxYears is the maximum error margin (in years) that two dates can be
    // different before they are assume to not be the same. See
    // DefaultMaxYearsForSimilarity.
    MaxYears float64

    // All four of these must sum up to 1.0.
    IndividualWeight, ParentsWeight, SpousesWeight, ChildrenWeight float64

    // NameToDateRatio describes the ratio between the weight of the individuals
    // name to their combined estimated birth and death dates. A value of 0.0
    // would not take into account the individuals name at all, whereas 1.0
    // would not take into account any dates. A sensible default is 0.5.
    NameToDateRatio float64

    // JaroBoostThreshold and JaroPrefixSize are used by the JaroWinkler
    // function. They affect the properties of names are compared. The default
    // values for each of these can be found in the constants
    // DefaultJaroWinklerBoostThreshold and DefaultJaroWinklerPrefixSize. Their
    // values have been chosen with gedcomtune.
    JaroBoostThreshold float64
    JaroPrefixSize     int

    // PreferPointerAbove controls if two individuals should be considered a
    // match by their pointer value.
    //
    // The default value is DefaultMinimumSimilarity which means that the
    // individuals will be considered a match if they share the same pointer and
    // hit the same default minimum similarity.
    //
    // A value of 1.0 would have to be a perfect match to be considered equal on
    // their pointer, this is the same as disabling the feature.
    //
    // A value of 0.0 would mean that it always trusts the pointer match, even
    // if the individuals are nothing alike.
    //
    // PreferPointerAbove makes sense when you are comparing documents that have
    // come from the same base and retained the pointers between individuals of
    // the existing data.
    PreferPointerAbove float64
}

SimilarityOptions is used by all of the functions that calculate the similarity or otherwise compare entities. This struct allows many things to be tweaked. However, not all of the values are used by all of the functions.

Use NewSimilarityOptions() to choose sensible defaults that are best for most general cases.

func NewSimilarityOptions Uses

func NewSimilarityOptions() SimilarityOptions

NewSimilarityOptions returns sensible defaults that are used around many of the similarity functions.

func (SimilarityOptions) String Uses

func (options SimilarityOptions) String() string

String renders the options as a comma-separated string.

type SimpleNode Uses

type SimpleNode struct {
    // contains filtered or unexported fields
}

SimpleNode is used as the default node type when there is no more appropriate or specific type to use.

func (*SimpleNode) AddNode Uses

func (node *SimpleNode) AddNode(n Node)

func (*SimpleNode) DeleteNode Uses

func (node *SimpleNode) DeleteNode(n Node) (didDelete bool)

func (*SimpleNode) Equals Uses

func (node *SimpleNode) Equals(node2 Node) bool

Equals compares two nodes for value equality.

1. If either or both nodes are nil then false is always returned. 2. Nodes are compared only by their root value (shallow) meaning any value for the child nodes is ignored. 3. The document the node belongs to is not taken into consideration to be able to compare nodes by value across different documents. 4. A node is considered to have the same value (and therefore be equal) is both nodes share the all of the same tag, value and pointer.

func (*SimpleNode) GEDCOMLine Uses

func (node *SimpleNode) GEDCOMLine(indent int) string

GEDCOMLine converts a node into its single line GEDCOM value. It is used several places including the actual Encoder.

GEDCOMLine, as the name would suggest, does not handle children. You can use GEDCOMString if you need the child nodes as well.

GEDCOMLine will not work with a nil value. You can use the package GEDCOMLine function to gracefully handle nils.

The indent will only be included if it is at least 0. If you want to use GEDCOMLine to compare the string values of nodes or exclude the indent you should use the NoIndent constant.

func (*SimpleNode) GEDCOMString Uses

func (node *SimpleNode) GEDCOMString(indent int) string

GEDCOMString is the recursive version of GEDCOMLine. It will render a node and all of its children (if any) as a multi-line GEDCOM string.

GEDCOMString will not work with a nil value. You can use the package GEDCOMString function to gracefully handle nils.

The indent will only be included if it is at least 0. If you want to use GEDCOMString to compare the string values of nodes or exclude the indent you should use the NoIndent constant.

func (*SimpleNode) MarshalJSON Uses

func (node *SimpleNode) MarshalJSON() ([]byte, error)

func (*SimpleNode) Nodes Uses

func (node *SimpleNode) Nodes() Nodes

If the node is nil the result will also be nil.

func (*SimpleNode) ObjectMap Uses

func (node *SimpleNode) ObjectMap() map[string]interface{}

func (*SimpleNode) Pointer Uses

func (node *SimpleNode) Pointer() string

If the node is nil the result will be an empty string.

func (*SimpleNode) RawSimpleNode Uses

func (node *SimpleNode) RawSimpleNode() *SimpleNode

func (*SimpleNode) SetNodes Uses

func (node *SimpleNode) SetNodes(nodes Nodes)

SetNodes replaces all of the child nodes.

You can use SetNodes(nil) to remove all child nodes.

func (*SimpleNode) ShallowCopy Uses

func (node *SimpleNode) ShallowCopy() Node

ShallowCopy returns a new node that has the same properties as the input node without any children.

If the input node is nil then nil is also returned.

func (*SimpleNode) String Uses

func (node *SimpleNode) String() string

If the node is nil the result be an empty string.

func (*SimpleNode) Tag Uses

func (node *SimpleNode) Tag() Tag

If the node is nil the result will be an empty tag.

func (*SimpleNode) Value Uses

func (node *SimpleNode) Value() string

If the node is nil the result will be an empty string.

type SourceNode Uses

type SourceNode struct {
    *SimpleNode
}

SourceNode represents a source.

func NewSourceNode Uses

func NewSourceNode(value, pointer string, children ...Node) *SourceNode

func (*SourceNode) Title Uses

func (node *SourceNode) Title() string

If the node is nil the result will be an empty string.

type SpouseChildren Uses

type SpouseChildren map[*IndividualNode]ChildNodes

SpouseChildren connects a single spouse to a set of children. The children may appear under multiple spouses. This is only useful when in combination with an individual (that would be the other spouse).

The spouse can be nil, indicating that the spouse it not known for the assigned children. You should not assume that you can also recover the other spouse from one of the keys in this map as the map is valid to be empty or to only contain a nil key.

type StringSet Uses

type StringSet struct {
    // contains filtered or unexported fields
}

StringSet represents a slice of strings where all elements are unique (a set).

func NewStringSet Uses

func NewStringSet(elements ...string) *StringSet

NewStringSet creates a new StringSet that is initialized with zero or more elements.

See Add() for semantics.

func (*StringSet) Add Uses

func (ss *StringSet) Add(elements ...string) *StringSet

Add will append zero more strings to the set. If any of the elements already exist in the set they will be ignored.

func (*StringSet) Has Uses

func (ss *StringSet) Has(element string) bool

Has returns true if the string exists in the set.

func (*StringSet) Intersects Uses

func (ss *StringSet) Intersects(ss2 *StringSet) bool

Intersects returns true if the two sets contain at least one value that is the same.

func (*StringSet) Iterate Uses

func (ss *StringSet) Iterate(fn func(string) bool)

Iterate will iterate all items, similar to a "for range".

The order of the elements will change between successive iterations.

The iteration will stop if the fn returns false.

func (*StringSet) Len Uses

func (ss *StringSet) Len() (len int)

Len returns the number of elements in the set.

func (*StringSet) String Uses

func (ss *StringSet) String() string

String returns all of the items sorted, in the form of:

(bar,foo)

func (*StringSet) Strings Uses

func (ss *StringSet) Strings() (elements []string)

Strings returns all the values as a slice of strings. The result is always sorted.

type SurroundingSimilarity Uses

type SurroundingSimilarity struct {
    // ParentsSimilarity is the similarity of the fathers and mothers of the
    // individual. Each missing parent will be given 0.5. If both parents are
    // missing the parent similarity will also be 0.5.
    //
    // An individual can have zero or more pairs of parents, but only a single
    // ParentsSimilarity is provided. The ParentsSimilarity is the highest value
    // when each of the parents are compared with the other parents of the other
    // individual.
    ParentsSimilarity float64

    // IndividualSimilarity is the same as Individual.Similarity().
    IndividualSimilarity float64

    // SpousesSimilarity is the similarity of the spouses is compared with
    // IndividualNodes.Similarity() which is designed to compare several
    // individuals at once. It also handles comparing a different number of
    // individuals on either side.
    SpousesSimilarity float64

    // ChildrenSimilarity also uses IndividualNodes.Similarity() but without
    // respect to their parents (which in this case would be the current
    // individual and likely one of their spouses).
    //
    // It is done this way as to not skew the results if any particular parent
    // is unknown or the child is connected to a different spouse.
    ChildrenSimilarity float64

    // Options affects the weights and other aspects of the normalised
    // similarity metrics.
    Options SimilarityOptions
}

SurroundingSimilarity describes different aspects of the similarity of an individual by its immediate relationships; parents, spouses and children.

func NewSurroundingSimilarity Uses

func NewSurroundingSimilarity(parentsSimilarity, individualSimilarity, spousesSimilarity, childrenSimilarity float64) *SurroundingSimilarity

NewSurroundingSimilarity creates a surrounding similarity using default similarity options. You can modify or replace the Options after instantiation.

func (SurroundingSimilarity) String Uses

func (s SurroundingSimilarity) String() string

String returns the WeightedSimilarity -- a number between 0.0 and 1.0.

The WeightedSimilarity is affected by Options.

func (SurroundingSimilarity) WeightedSimilarity Uses

func (s SurroundingSimilarity) WeightedSimilarity() float64

WeightedSimilarity calculates a single similarity from all of the similarity metrics with following weights:

IndividualSimilarity: 80%
ParentsSimilarity: ~6.7%
SpousesSimilarity: ~6.7%
ChildrenSimilarity: ~6.7%

type Tag Uses

type Tag struct {
    // contains filtered or unexported fields
}

Tag is the type of node. You should not initialise a Tag instance manually, but rather use TagFromString.

func FamilySearchIDNodeTags Uses

func FamilySearchIDNodeTags() []Tag

FamilySearchIDNodeTags returns all of the known GEDCOM tags that can be represented by a FamilySearchIDNode.

func TagFromString Uses

func TagFromString(tag string) Tag

TagFromString returns known tag constant like TagHeader from it's raw string representation, like "HEAD". It will also return unofficial tags as well.

If the tag is not found a Tag will still be returned (and is find to use) but it will not include extra information like if it is a type of event (IsEvent).

You can check the Valid property to test if the returned Tag is known.

func Tags Uses

func Tags() []Tag

Tags returns all of the known GEDCOM tags. This includes official and unofficial tags.

If a tag exists as a constant but is not registered here then it will not covered by tests and the conversion from a string to a tag with TagFromString will not work correctly.

func (Tag) Is Uses

func (tag Tag) Is(tag2 Tag) bool

Is test if two tags are the same. Tags are deemed to be the same solely on their Tag attribute (the GEDCOM representation). All other properties will be ignored. This makes it safe to compare real/registered tags with ones manually created or provided from TagFromString.

func (Tag) IsEvent Uses

func (tag Tag) IsEvent() bool

IsEvent return true if the tag is a type of event. Events can be attached to individuals or families and generally include a date and/or place in the child nodes.

It is important to note that tags thar are not seen as events can still have dates and place attached to them.

func (Tag) IsKnown Uses

func (tag Tag) IsKnown() bool

IsKnown returns true if the tag can provide extra information like IsEvent, IsOfficial, etc. If you are using the Tag or UnofficialTag variables provided by this will always return true.

func (Tag) IsOfficial Uses

func (tag Tag) IsOfficial() bool

IsOfficial returns true if the tag is part of the GEDCOM 5.5 standard.

func (Tag) SortValue Uses

func (tag Tag) SortValue() int

SortValue is used when sorting tags.

The lowest SortValue should appear first.

func (Tag) String Uses

func (tag Tag) String() string

String returned the descriptive name of the tag, like "Bar Mitzvah".

func (Tag) Tag Uses

func (tag Tag) Tag() string

Tag returns the raw GEDCOM name for the tag, like "MARR".

type TypeNode Uses

type TypeNode struct {
    *SimpleNode
}

TypeNode represents a further qualification to the meaning of the associated superior tag.

The value does not have any computer processing reliability. It is more in the form of a short one or two word note that should be displayed any time the associated data is displayed.

func NewTypeNode Uses

func NewTypeNode(value string, children ...Node) *TypeNode

NewTypeNode creates a new TYPE node.

type UUID Uses

type UUID string

func NewUUIDFromString Uses

func NewUUIDFromString(s string) (UUID, error)

NewUUIDFromString returns a valid UUID in one of the forms:

EE13561DDB204985BFFDEEBF82A5226C
e0d4d387-618a-4713-ab3b-5fa3500b7a75

An error is returned if there is more than 32 hexadecimal characters.

func (UUID) Equals Uses

func (uuid UUID) Equals(uuid2 UUID) bool

Equals is true only if both UUIDs represent the same value.

func (UUID) String Uses

func (uuid UUID) String() string

String returns a lowercase, hyphenated UUID in the form of:

e0d4d387-618a-4713-ab3b-5fa3500b7a75

type UniqueIDNode Uses

type UniqueIDNode struct {
    *SimpleNode
}

UniqueIDNode represents a _UID.

The _UID tag is what I call a Common GEDCOM Extension; a GEDCOM extension that's common to many different applications. The _UID tag is a legal GEDCOM extension; it starts with an underscore, like any vendor-defined extension should. However, it would be wrong to think of the _UID tag as a vendor- or product-specific tag. The _UID tag is not specific to any particular product or vendor. It is a common GEDCOM extension, supported by quite a few different products from different vendors.

Applications that support the _UID tag include:

- Daub Ages!
- Ancestral Quest (AQ)
- Family Historian (FH)
- Family Origins for Windows (FOW)
- MyHeritage Family Tree Builder (FTB)
- Family Tree Heritage
- Family Tree Legends (FTL)
- Genbox Family History
- GenoPro
- Legacy Family Tree
- ohmiGene
- Personal Ancestral File (PAF)
- Reunion
- RootsMagic (RM)

The above list was created by googling for GEDCOM files that contain the _UID tag. It probably isn't complete, but it does show that support for the _UID tag is not merely common, but also that it is supported by some of the best-known and most popular applications, such as PAF, RootsMagic and Legacy.

https://www.tamurajones.net/The_UIDTag.xhtml

func NewUniqueIDNode Uses

func NewUniqueIDNode(value string, children ...Node) *UniqueIDNode

func (*UniqueIDNode) Checksum Uses

func (node *UniqueIDNode) Checksum() string

Checksum returns the optional last 4 digits after the UUID.

This is what a UUID looks like in a PAF GEDCOM:

92FF8B766F327F48A256C3AE6DAE50D3A114

Notice that the _UID value is not divided into groups separated by hyphens, but represented as one long hexadecimal number. What is not immediately obvious because of its length is that the number shown is not a UUID. It cannot be an UUID, because an UUID is 32 hexadecimal digits long, and the _UID value is 36 hexadecimal digits long. When we hyphenate the number for readability, we find that there are four extra digits:

92FF8B76-6F32-7F48-A256-C3AE6DAE50D3-A114

The _UID value is a UUID followed by a checksum.

That little fact, essential to making sense of the _UID value, used to be undocumented. I once figured that out myself, but you don't have to do so, nor take my word for it. Nowadays, FamilySearch documents it, if you know where to look. The FamilySearch document GEDCOM Unique Identifiers states that it provides guidelines for the use of UUIDs, but it actually documents the format of the PAF _UID value; a 32-hexadigit UUID value followed by a 4-hexadigit checksum. That brief document includes some Windows C code, possibly the actual PAF source code. That code shows how to calculate the checksum.

PAF is a fork of Ancestral Quest, so it is no wonder that Ancestral Quest uses the same format. But it is not just Ancestral Quest that uses this format. This UUID format is the most popular one. Other applications that use the same UUID format for their _UID tag are Family Origins for Windows, Family Tree Heritage, Family Tree Legends, Genbox Family History, Legacy Family Tree, Reunion and RootsMagic.

https://www.tamurajones.net/The_UIDTag.xhtml

func (*UniqueIDNode) Equals Uses

func (node *UniqueIDNode) Equals(node2 Node) bool

Equals returns true if both nodes have the same UUID value. The checksum (if any) is ignored.

If either nodes are nil (or both) the result will always be false.

func (*UniqueIDNode) UUID Uses

func (node *UniqueIDNode) UUID() (UUID, error)

UUID returns the UUID component of the UniqueID.

The cross-reference identifiers are unique with a single GEDCOM file, but different GEDCOM files, are very likely to use the same identifiers for different records.

For some purposes it would be nice to have truly unique identifiers. That requires two things; some way to create globally unique identifiers, and a GEDCOM tag to carry that identifier. The Universally Unique ID (UUID) is that globally unique identifier, and _UID is the tag that carries it.

Microsoft developers known UUID as Globally Unique Identifier (GUID). What makes UUIDs so suitable is that they were developed so precisely so that everyone can generate UUIDs, without coordinating with anyone else, and still be practically sure that the generated identifier is unique.

A UUID is an 128-bit (16-byte) number, generally represented by 32 hexadecimal digits, divided into five groups, separated by hyphens, like this: 12345678-1234-1234-1234-123456789ABC.

https://www.tamurajones.net/The_UIDTag.xhtml

type UnparsableDateWarning Uses

type UnparsableDateWarning struct {
    Date *DateNode
}

func NewUnparsableDateWarning Uses

func NewUnparsableDateWarning(date *DateNode) *UnparsableDateWarning

func (*UnparsableDateWarning) Name Uses

func (w *UnparsableDateWarning) Name() string

func (*UnparsableDateWarning) String Uses

func (w *UnparsableDateWarning) String() string

type Warner Uses

type Warner interface {
    Warnings() Warnings
}

type Warning Uses

type Warning interface {
    fmt.Stringer
    Name() string
}

type Warnings Uses

type Warnings []Warning

func (Warnings) Strings Uses

func (ws Warnings) Strings() (ss []string)

type WifeNode Uses

type WifeNode struct {
    *SimpleNode
    // contains filtered or unexported fields
}

WifeNode is an individual in the role as a mother and/or married woman.

func (*WifeNode) Family Uses

func (node *WifeNode) Family() *FamilyNode

func (*WifeNode) Individual Uses

func (node *WifeNode) Individual() *IndividualNode

func (*WifeNode) IsIndividual Uses

func (node *WifeNode) IsIndividual(node2 *IndividualNode) bool

func (*WifeNode) Similarity Uses

func (node *WifeNode) Similarity(other *WifeNode, options SimilarityOptions) float64

type Yearer Uses

type Yearer interface {
    Years() float64
}

Yearer allows some kind of date node or value to return its date representation in a number of years. This is implemented in several ways, you should read the docs for each implementation for more details.

Directories

PathSynopsis
gedcom2htmlGedcom2html renders a GEDCOM file into HTML pages that can be shared and published easily.
gedcom2jsonGedcom2json converts a GEDCOM file to JSON so that it can easily processed and consumed by other applications.
gedcom2textGedcom2text converts a GEDCOM file to a human-readable text format.
gedcomdiffGedcomdiff is a tool for comparing GEDCOM files and producing a HTML report.
gedcomqGedcomq is a command line tool and query language for GEDCOM files heavily inspired by jq, in name and syntax.
gedcomtuneGedcomtune is used to calculate the ideal weights and similarities for the main gedcom package.
htmlPackage html is shared HTML rendering components that are shared by the other packages.
qPackage q is the gedcomq parser and engine.
utilPackage util contains shared functions used by several packages.

Package gedcom imports 18 packages (graph) and is imported by 8 packages. Updated 2019-02-14. Refresh now. Tools for package owners.