elliotchance/gedcom

package gedcom

import (
    "reflect"
    "strconv"
    "strings"
)

func valueToPointer(val string) string {
    valLen := len(val)
    firstCharIsAt := val[0] == '@'
    lastCharIsAt := val[valLen-1] == '@'
    if valLen > 2 && firstCharIsAt && lastCharIsAt {
        return val[1 : valLen-1]
    }

    return ""
}

// 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 Atoi(s string) int {
    // Trim off leading zeros and surrounding spaces as they affect how the
    // integer may be parsed.
    s = strings.TrimLeft(s, "0")
    s = strings.TrimSpace(s)

    i, _ := strconv.Atoi(s)

    return i
}

// 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 CleanSpace(s string) string {
    // Replace twice if there is an odd number of spaces in a row.
    s = strings.Replace(s, "  ", " ", -1)
    s = strings.Replace(s, "  ", " ", -1)

    // Trim whatever spaces are left on either side.
    s = strings.TrimSpace(s)

    return s
}

// 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 First(nodes interface{}) Node {
    n := Compound(nodes)
    if len(n) == 0 {
        return nil
    }

    return n[0]
}

// 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 Last(nodes interface{}) Node {
    n := Compound(nodes)
    for i := len(n) - 1; i >= 0; i-- {
        if n[i] != nil {
            return n[i]
        }
    }

    return nil
}

// 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 Value(node Node) string {
    if IsNil(node) {
        return ""
    }

    return node.Value()
}

// 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 Compound(nodes ...interface{}) Nodes {
    result := Nodes{}

    for _, n := range nodes {
        v := reflect.ValueOf(n)

        switch v.Kind() {
        case reflect.Invalid:
            // Ignore

        case reflect.Slice:
            for i := 0; i < v.Len(); i++ {
                if j := v.Index(i).Interface(); j != nil {
                    result = append(result, j.(Node))
                }
            }

        default:
            result = append(result, v.Interface().(Node))
        }
    }

    return result
}

// NodeCondition is a convenience method for inline conditionals.
func NodeCondition(condition bool, node1, node2 Node) Node {
    if condition {
        return node1
    }

    return node2
}

// 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 Pointer(node Node) string {
    if IsNil(node) {
        return ""
    }

    return node.Pointer()
}

// 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 String(node Node) string {
    if IsNil(node) {
        return ""
    }

    return node.String()
}

func maxInt64(values ...int64) (r int64) {
    valuesLen := len(values)

    if valuesLen == 0 {
        return
    }

    r = values[0]
    for i := 1; i < valuesLen; i++ {
        if values[i] > r {
            r = values[i]
        }
    }

    return
}

func maxInt(values ...int) (r int) {
    valuesLen := len(values)

    if valuesLen == 0 {
        return
    }

    r = values[0]
    for i := 1; i < valuesLen; i++ {
        if values[i] > r {
            r = values[i]
        }
    }

    return
}

// 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 DateAndPlace(nodes ...Node) (date *DateNode, place *PlaceNode) {
    for _, node := range nodes {
        dates := Dates(node.(Node))
        places := Places(node.(Node))

        if date == nil && len(dates) > 0 {
            date = dates[0]
        }

        if place == nil && len(places) > 0 {
            place = places[0]
        }
    }

    return
}