options.go

// Copyright (c) Harri Rautila, 2012

// This file is part of github.com/hrautila/linalg package. 
// It is free software, distributed under the terms of GNU Lesser General Public 
// License Version 3, or any later version. See the COPYING tile included in this archive.

package linalg

import (
    "math"
    "math/cmplx"
    "strings"
)

// Interface for named options.
type Option interface {
    // Name of option.
    Name() string
    // Integer value of option.
    Int() int
    // Float value of option or NaN.
    Float() float64
    // Float value of option or NaN.
    Complex() complex128
    // Bool value of option.
    Bool() bool
    // Option value as string.
    String() string
    // Test if other option is of equal
    Equal(Option) bool
}

// Find named option from a list of options. Returns nil of not found.
func GetOption(name string, opts ...Option) Option {
    for _, o := range opts {
        if strings.EqualFold(o.Name(), name) {
            return o
        }
    }
    return nil
}

// Get integer option value. If option not present returns defval.
func GetIntOpt(name string, defval int, opts ...Option) (val int) {
    val = defval
    for _, o := range opts {
        if strings.EqualFold(o.Name(), name) {
            switch o.(type) {
            case *IOpt:
                val = o.Int()
                return
            }
        }
    }
    return
}

// Get float option value. If option not present returns defval.
func GetFloatOpt(name string, defval float64, opts ...Option) (val float64) {
    val = defval
    for _, o := range opts {
        if strings.EqualFold(o.Name(), name) {
            switch o.(type) {
            case *FOpt:
                val = o.Float()
                return
            }
        }
    }
    return
}

// Get boolean option value. If option not present returns defval.
func GetBoolOpt(name string, defval bool, opts ...Option) (val bool) {
    val = defval
    for _, o := range opts {
        if strings.EqualFold(o.Name(), name) {
            switch o.(type) {
            case *BOpt:
                val = o.Bool()
            case *SOpt:
                v := o.String()
                val = v[0] == 't' || v[0] == 'T' || v[0] == 'y' || v[0] == 'Y'
            }
            return
        }
    }
    return
}

// Get string option value. If option not present returns defval.
func GetStringOpt(name string, defval string, opts ...Option) (val string) {
    val = defval
    for _, o := range opts {
        if strings.EqualFold(o.Name(), name) {
            switch o.(type) {
            case *SOpt:
                val = o.String()
                return
            }
        }
    }
    return
}

// Get string option value. If option not present returns defval.
func GetComplexOpt(name string, defval complex128, opts ...Option) (val complex128) {
    val = defval
    for _, o := range opts {
        if strings.EqualFold(o.Name(), name) {
            switch o.(type) {
            case *COpt:
                val = o.Complex()
                return
            }
        }
    }
    return
}

func Equal(a, b Option) bool {
    return a.Equal(b)
}

// Integer valued option.
type IOpt struct {
    OptName string
    Val     int
}

// Return integer valued option.
func IntOpt(name string, val int) *IOpt {
    return &IOpt{name, val}

}

func (O *IOpt) Name() string {
    return O.OptName
}

func (O *IOpt) Int() int {
    return O.Val
}

// Return NaN.
func (O *IOpt) Float() float64 {
    return math.NaN()
}

// Return NaN.
func (O *IOpt) Complex() complex128 {
    return cmplx.NaN()
}

// Return false.
func (O *IOpt) Bool() bool {
    return false
}

func (O *IOpt) String() string {
    return string(O.Val)
}

func (O *IOpt) Equal(other Option) bool {
    switch other.(type) {
    case *IOpt:
        if !strings.EqualFold(O.OptName, other.Name()) {
            return false
        }
        return O.Val == other.Int()
    }
    return false
}

// Float valued option.
type FOpt struct {
    OptName string
    Val     float64
}

// Return integer valued option.
func FloatOpt(name string, val float64) *FOpt {
    return &FOpt{name, val}

}

func (O *FOpt) Name() string {
    return O.OptName
}

// Return zero.
func (O *FOpt) Int() int {
    return 0
}

func (O *FOpt) Float() float64 {
    return O.Val
}

// Return NaN.
func (O *FOpt) Complex() complex128 {
    return cmplx.NaN()
}

// Return false.
func (O *FOpt) Bool() bool {
    return false
}

func (O *FOpt) String() string {
    return "" //string(O.val)
}

func (O *FOpt) Equal(other Option) bool {
    switch other.(type) {
    case *FOpt:
        if !strings.EqualFold(O.OptName, other.Name()) {
            return false
        }
        return O.Val == other.Float()
    }
    return false
}

// String valued option.
type SOpt struct {
    OptName string
    Val     string
}

// Return string valued option.
func StringOpt(name string, val string) *SOpt {
    return &SOpt{name, val}

}
func (O *SOpt) Name() string {
    return O.OptName
}

// Return zero.
func (O *SOpt) Int() int {
    return 0
}

func (O *SOpt) Float() float64 {
    return math.NaN()
}

// Return NaN.
func (O *SOpt) Complex() complex128 {
    return cmplx.NaN()
}

// Return false.
func (O *SOpt) Bool() bool {
    return false
}

func (O *SOpt) String() string {
    return O.Val
}

func (O *SOpt) Equal(other Option) bool {
    switch other.(type) {
    case *SOpt:
        if !strings.EqualFold(O.OptName, other.Name()) {
            return false
        }
        return O.Val == other.String()
    }
    return false
}

// Boolean valued option.
type BOpt struct {
    OptName string
    Val     bool
}

// Return bool valued option.
func BoolOpt(name string, val bool) *BOpt {
    return &BOpt{name, val}
}

func (O *BOpt) Name() string {
    return O.OptName
}

func (O *BOpt) Int() int {
    return 0
}

func (O *BOpt) Float() float64 {
    return math.NaN()
}

func (O *BOpt) Complex() complex128 {
    return cmplx.NaN()
}

func (O *BOpt) Bool() bool {
    return O.Val
}

func (O *BOpt) String() string {
    return "" //string(O.val)
}

func (O *BOpt) Equal(other Option) bool {
    switch other.(type) {
    case *BOpt:
        if !strings.EqualFold(O.OptName, other.Name()) {
            return false
        }
        return O.Val == other.Bool()
    }
    return false
}

// Return complex valued option.
func ComplexOpt(name string, val complex128) *COpt {
    return &COpt{name, val}
}

// Complex valued option.
type COpt struct {
    OptName string
    Val     complex128
}

func (O *COpt) Name() string {
    return O.OptName
}

// Return zero.
func (O *COpt) Int() int {
    return 0
}

// Return NaN.
func (O *COpt) Float() float64 {
    return math.NaN()
}

// Return NaN.
func (O *COpt) Complex() complex128 {
    return O.Val
}

func (O *COpt) Bool() bool {
    return false
}

func (O *COpt) String() string {
    return "" //string(O.val)
}

func (O *COpt) Equal(other Option) bool {
    switch other.(type) {
    case *COpt:
        if !strings.EqualFold(O.OptName, other.Name()) {
            return false
        }
        return O.Val == other.Complex()
    }
    return false
}

// Local Variables:
// tab-width: 4
// End: