cloudfoundry-community/bosh-cloudstack-cpi

package charset

import (
    "encoding/json"
    "fmt"
    "os"
    "sync"
)

var (
    readLocalCharsetsOnce sync.Once
    localCharsets         = make(map[string]*localCharset)
)

type localCharset struct {
    Charset
    arg string
    *class
}

// A class of character sets.
// Each class can be instantiated with an argument specified in the config file.
// Many character sets can use a single class.
type class struct {
    from, to func(arg string) (Translator, error)
}

// The set of classes, indexed by class name.
var classes = make(map[string]*class)

func registerClass(charset string, from, to func(arg string) (Translator, error)) {
    classes[charset] = &class{from, to}
}

type localFactory struct{}

func (f localFactory) TranslatorFrom(name string) (Translator, error) {
    f.init()
    name = NormalizedName(name)
    cs := localCharsets[name]
    if cs == nil {
        return nil, fmt.Errorf("character set %q not found", name)
    }
    if cs.from == nil {
        return nil, fmt.Errorf("cannot translate from %q", name)
    }
    return cs.from(cs.arg)
}

func (f localFactory) TranslatorTo(name string) (Translator, error) {
    f.init()
    name = NormalizedName(name)
    cs := localCharsets[name]
    if cs == nil {
        return nil, fmt.Errorf("character set %q not found", name)
    }
    if cs.to == nil {
        return nil, fmt.Errorf("cannot translate to %q", name)
    }
    return cs.to(cs.arg)
}

func (f localFactory) Names() []string {
    f.init()
    var names []string
    for name, cs := range localCharsets {
        // add names only for non-aliases.
        if localCharsets[cs.Name] == cs {
            names = append(names, name)
        }
    }
    return names
}

func (f localFactory) Info(name string) *Charset {
    f.init()
    lcs := localCharsets[NormalizedName(name)]
    if lcs == nil {
        return nil
    }
    // copy the charset info so that callers can't mess with it.
    cs := lcs.Charset
    return &cs
}

func (f localFactory) init() {
    readLocalCharsetsOnce.Do(readLocalCharsets)
}

// charsetEntry is the data structure for one entry in the JSON config file.
// If Alias is non-empty, it should be the canonical name of another
// character set; otherwise Class should be the name
// of an entry in classes, and Arg is the argument for
// instantiating it.
type charsetEntry struct {
    Aliases []string
    Desc    string
    Class   string
    Arg     string
}

// readCharsets reads the JSON config file.
// It's done once only, when first needed.
func readLocalCharsets() {
    csdata, err := readFile("charsets.json")
    if err != nil {
        fmt.Fprintf(os.Stderr, "charset: cannot open \"charsets.json\": %v\n", err)
        return
    }

    var entries map[string]charsetEntry
    err = json.Unmarshal(csdata, &entries)
    if err != nil {
        fmt.Fprintf(os.Stderr, "charset: cannot decode config file: %v\n", err)
    }
    for name, e := range entries {
        class := classes[e.Class]
        if class == nil {
            continue
        }
        name = NormalizedName(name)
        for i, a := range e.Aliases {
            e.Aliases[i] = NormalizedName(a)
        }
        cs := &localCharset{
            Charset: Charset{
                Name:    name,
                Aliases: e.Aliases,
                Desc:    e.Desc,
                NoFrom:  class.from == nil,
                NoTo:    class.to == nil,
            },
            arg:   e.Arg,
            class: class,
        }
        localCharsets[cs.Name] = cs
        for _, a := range cs.Aliases {
            localCharsets[a] = cs
        }
    }
}

// A general cache store that local character set translators
// can use for persistent storage of data.
var (
    cacheMutex sync.Mutex
    cacheStore = make(map[interface{}]interface{})
)

func cache(key interface{}, f func() (interface{}, error)) (interface{}, error) {
    cacheMutex.Lock()
    defer cacheMutex.Unlock()
    if x := cacheStore[key]; x != nil {
        return x, nil
    }
    x, err := f()
    if err != nil {
        return nil, err
    }
    cacheStore[key] = x
    return x, err
}