rke/data/bindata.go

// Code generated for package data by go-bindata DO NOT EDIT. (@generated)
// sources:
// data/data.json
package data

import (
	"bytes"
	"compress/gzip"
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
	"time"
)

func bindataRead(data []byte, name string) ([]byte, error) {
	gz, err := gzip.NewReader(bytes.NewBuffer(data))
	if err != nil {
		return nil, fmt.Errorf("Read %q: %v", name, err)
	}

	var buf bytes.Buffer
	_, err = io.Copy(&buf, gz)
	clErr := gz.Close()

	if err != nil {
		return nil, fmt.Errorf("Read %q: %v", name, err)
	}
	if clErr != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

type asset struct {
	bytes []byte
	info  os.FileInfo
}

type bindataFileInfo struct {
	name    string
	size    int64
	mode    os.FileMode
	modTime time.Time
}

// Name return file name
func (fi bindataFileInfo) Name() string {
	return fi.name
}

// Size return file size
func (fi bindataFileInfo) Size() int64 {
	return fi.size
}

// Mode return file mode
func (fi bindataFileInfo) Mode() os.FileMode {
	return fi.mode
}

// Mode return file modify time
func (fi bindataFileInfo) ModTime() time.Time {
	return fi.modTime
}

// IsDir return file whether a directory
func (fi bindataFileInfo) IsDir() bool {
	return fi.mode&os.ModeDir != 0
}

// Sys return file is sys mode
func (fi bindataFileInfo) Sys() interface{} {
	return nil
}

var _dataDataJson = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\xbd\xe9\x72\xdc\x48\x9a\x2d\xf8\xbf\x9e\xc2\x8d\x6a\xb3\xba\x5d\x23\x04\x19\x2b\x97\xb6\xfe\x41\x91\x94\x44\x4b\x89\x8c\x4b\x32\x95\x5d\x56\xec\x61\x81\x80\x33\x02\x4d\x04\x80\x04\x10\x94\x98\xaa\xbc\x36\xaf\x31\xaf\x37\x4f\x32\xe6\xee\xd8\xe1\x40\x00\x88\x85\xb1\x1c\xb6\x59\x57\x2a\xe0\xfb\xf2\x9d\xe3\x9f\xbb\x1f\xff\xf9\x17\xb2\xf7\xcb\x91\xf7\x8d\xba\x9e\x61\x5b\xb7\xd4\x7d\x31\x34\x7a\xed\xf8\x86\x6d\x79\x7b\x27\xe4\xe7\x5f\x08\xd9\x7b\x69\xb7\xda\x07\xc1\x3f\xc8\x1e\xf5\x35\x7d\xef\x84\x58\x53\xd3\x7c\xcf\x7f\x78\x9e\x3e\x52\xd5\x31\xc2\x00\x64\x4f\x35\x4d\xfb\xbb\xe2\xb8\xc6\x8b\x61\xd2\x11\x65\xa1\xf7\x7c\x77\x4a\xf7\xde\x07\xdf\x2d\xdb\x7a\x9d\xd8\x53\x4f\x51\xa7\xfe\x98\x7d\x7d\x52\x4d\x2f\xfa\xfc\x68\x58\xba\xa2\xea\xba\x4b\x3d\x56\x84\xbd\x83\x16\xff\xbf\xf0\x33\xb5\xd4\x47\x93\x2a\xaa\x3e\x31\x3c\x56\x66\xc5\x31\xa7\x23\x83\x97\x76\xef\x4a\x9d\x50\xcf\x51\x35\xfa\xc5\x78\xa2\xda\xab\x66\xd2\xf7\x5f\x8c\x89\xe1\xdf\xa8\xd6\x88\xba\xef\x83\xea\x9d\x6a\x9a\x3d\xb5\xfc\xf7\xe7\xf4\x49\x9d\x9a\xfe\xad\x6f\xbb\xea\x88\x9e\x99\xaa\xe7\x85\xbf\xdd\xd9\x26\x75\x55\x9f\x37\x89\x66\x5b\xba\xf7\xfe\xeb\xd4\x57\x7d\xc3\x1a\x9d\x86\xf9\xfe\x46\x1f\xc7\xb6\xfd\xfc\xfe\x9b\x6a\x1a\xba\xfc\xd3\x0d\xf5\xec\xa9\xab\xd1\xff\x3d\xb5\x7d\xf5\xfd\x95\xad\xd3\x1b\xea\xf9\xae\xa1\xb1\x84\xc3\xfa\x18\x96\x47\xb5\xa9\x4b\x15\xc7\x76\x7d\x5e\xdf\xf0\x0b\x6b\x58\x93\xfa\x8a\xe3\xd2\x27\xea\xba\x34\x6a\x15\xc5\x7f\x75\x28\xaf\xf0\xa5\xe5\x53\xd7\x52\xcd\xcb\xe1\xfb\x8b\x1f\xd1\x7f\x7e\xb6\x3d\xdf\x52\x27\x51\x8b\x3a\xae\xfd\x64\x98\x86\x35\xca\xb5\xb5\x4b\x7f\x9f\x52\xcf\x1f\x53\x55\xa7\xae\x42\x7f\xf8\xae\xaa\x88\x7f\x78\x3c\x5b\xe3\x07\x8b\xf2\x5f\xca\x0d\x9d\xd8\x3e\x55\x2e\x78\x00\x79\xe4\x91\x6b\x4f\x9d\x30\x72\x2a\xd6\x27\xf6\x45\x1e\x69\xea\xb1\x32\x4f\xa8\x34\xde\xaf\x1e\x75\xa3\x68\x53\xcb\x37\x26\x54\xd1\x6c\xeb\xc9\xe0\xf5\x60\x63\xc7\x76\x8d\x3f\x78\x2f\xb5\x9e\x8f\xbc\x96\x61\xef\xbf\xb4\x1f\xa9\xaf\xb6\xff\x33\x39\xdc\x32\xcd\x3b\xe8\xf5\xba\xf1\x27\x3e\x20\x14\x55\x8c\x08\xc5\xb4\xed\xe7\xa9\x93\x1d\xaf\x9e\x18\x20\xca\xa3\xaa\x3d\x53\x8b\x0f\x67\x36\x09\xa2\x54\x7c\xd3\x53\x34\xc3\x19\x53\x57\xf1\xa6\x86\x2f\x7a\xe6\xee\xcb\xed\xc3\xc5\xd9\xf9\xe7\x0b\xf6\xff\x6f\x4f\x1f\x7e\xbb\xbc\xfb\xfc\x70\x7a\x71\xfb\xd0\xee\x1c\x3d\x7c\x3a\xfb\xfa\x70\xfb\xf9\xb4\xd3\x1f\xbc\x2f\x0c\xd7\xe9\x0f\xc2\x70\xdd\xa3\x9e\x3c\xdc\xd9\xe7\xd3\xb3\xcf\xa7\x9d\x83\x87\xe1\xf5\x97\xbf\xb7\xbb\x07\xfd\x44\xb0\x9b\x4a\x99\xde\x54\xca\xf2\xa6\x30\xc3\x3d\xd6\x04\x7f\xc6\x86\xc0\xa4\x7e\xc2\x10\x14\x4e\xe2\x39\x4d\x04\xfb\x91\x5a\xbe\xa1\xf1\xce\x57\x7c\xfb\x99\x5a\xca\x77\x31\xeb\x72\x49\x25\xc7\x89\x32\xb1\x75\xca\x42\x04\x53\x34\x0c\xa4\xf1\xd1\xeb\x29\x0e\x75\x95\xdf\x6d\xd1\x81\x89\x34\x34\xcb\x50\x1e\x0d\x4b\xd1\x0d\x97\x7d\xda\xb7\x1d\x7f\x5f\xb3\x8c\xfd\x47\xc3\x4a\x06\x61\x83\x33\x0a\x43\x7d\x8d\x87\xb1\xa8\xdf\xd2\x63\xe3\xf5\x64\xbb\x1a\x55\x2c\x5b\xa7\x0a\x6b\x04\x4d\xf5\x99\x39\x63\x31\xa2\x30\x2f\xd4\xf2\x95\xdf\x1d\x2f\x65\x0c\x26\xea\x33\x55\x0c\x87\x87\xf6\x94\xa9\x6f\x98\x8a\x36\x56\x03\xbb\x97\xac\xaf\x45\xfd\xef\xb6\xfb\x1c\x98\x45\xf6\x55\xb3\x8c\x78\xf6\xa9\xba\x62\x5b\xe6\x6b\xde\xda\xb8\xd4\xb3\xcd\x17\x5e\x87\xa8\xfc\xe2\xb7\x16\xff\x2d\x9a\x0c\x2e\x55\x27\x86\x35\x62\x21\x2d\xca\x4d\x99\x62\xe8\x26\x55\xd8\xfc\xb4\xa7\x3c\xd1\xee\xc1\x04\x93\xe3\xa0\x1f\xb6\xc1\x0b\xab\x73\x27\xfa\x97\x6d\x4e\x27\x34\xe8\x9f\x68\xb8\xbc\xa8\xee\xbe\x69\x3c\xee\x07\x93\x68\x5f\x84\x0a\xb1\x2d\x33\xcb\x1c\xd7\xfe\xf1\x1a\xcf\xb3\x31\x55\x4d\x7f\xfc\x87\x92\x45\xce\x76\xe7\x90\x4f\xbb\x76\xa6\x20\x99\xd4\xce\x6c\xcb\x77\x6d\xd3\xa4\x6e\xd5\xa9\xab\xa9\x7e\x30\x86\x35\x43\x77\x73\x43\x50\xcc\xee\xa9\xe5\xab\xa3\x11\xd5\x15\xcd\xb4\xa7\xb9\x19\x2e\x0c\x39\x33\xcc\xfc\xb3\xe2\xda\xd3\x60\x70\xa4\x66\x7a\x80\xf6\x63\xdb\xf3\x1d\xd5\x1f\x2b\x8e\x6b\xbf\x18\x0c\x63\x79\x61\xd3\x61\xcd\x00\xc5\x4c\xaa\xf9\xb9\x59\xc1\x0a\x3b\xb1\x2d\xc3\xb7\x19\x54\xa9\x1a\x65\x73\xdd\xb0\x79\xb9\x7a\x07\x5e\x04\x95\xb6\xae\xd0\x17\x81\xd0\xc9\x11\xdd\x9f\x24\xc2\x14\xc2\xa9\x4f\xdd\x89\x61\xa

func dataDataJsonBytes() ([]byte, error) {
	return bindataRead(
		_dataDataJson,
		"data/data.json",
	)
}

func dataDataJson() (*asset, error) {
	bytes, err := dataDataJsonBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "data/data.json", size: 3522227, mode: os.FileMode(420), modTime: time.Unix(1557785965, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

// Asset loads and returns the asset for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func Asset(name string) ([]byte, error) {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[cannonicalName]; ok {
		a, err := f()
		if err != nil {
			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
		}
		return a.bytes, nil
	}
	return nil, fmt.Errorf("Asset %s not found", name)
}

// MustAsset is like Asset but panics when Asset would return an error.
// It simplifies safe initialization of global variables.
func MustAsset(name string) []byte {
	a, err := Asset(name)
	if err != nil {
		panic("asset: Asset(" + name + "): " + err.Error())
	}

	return a
}

// AssetInfo loads and returns the asset info for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func AssetInfo(name string) (os.FileInfo, error) {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[cannonicalName]; ok {
		a, err := f()
		if err != nil {
			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
		}
		return a.info, nil
	}
	return nil, fmt.Errorf("AssetInfo %s not found", name)
}

// AssetNames returns the names of the assets.
func AssetNames() []string {
	names := make([]string, 0, len(_bindata))
	for name := range _bindata {
		names = append(names, name)
	}
	return names
}

// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() (*asset, error){
	"data/data.json": dataDataJson,
}

// AssetDir returns the file names below a certain
// directory embedded in the file by go-bindata.
// For example if you run go-bindata on data/... and data contains the
// following hierarchy:
//     data/
//       foo.txt
//       img/
//         a.png
//         b.png
// then AssetDir("data") would return []string{"foo.txt", "img"}
// AssetDir("data/img") would return []string{"a.png", "b.png"}
// AssetDir("foo.txt") and AssetDir("notexist") would return an error
// AssetDir("") will return []string{"data"}.
func AssetDir(name string) ([]string, error) {
	node := _bintree
	if len(name) != 0 {
		cannonicalName := strings.Replace(name, "\\", "/", -1)
		pathList := strings.Split(cannonicalName, "/")
		for _, p := range pathList {
			node = node.Children[p]
			if node == nil {
				return nil, fmt.Errorf("Asset %s not found", name)
			}
		}
	}
	if node.Func != nil {
		return nil, fmt.Errorf("Asset %s not found", name)
	}
	rv := make([]string, 0, len(node.Children))
	for childName := range node.Children {
		rv = append(rv, childName)
	}
	return rv, nil
}

type bintree struct {
	Func     func() (*asset, error)
	Children map[string]*bintree
}

var _bintree = &bintree{nil, map[string]*bintree{
	"data": &bintree{nil, map[string]*bintree{
		"data.json": &bintree{dataDataJson, map[string]*bintree{}},
	}},
}}

// RestoreAsset restores an asset under the given directory
func RestoreAsset(dir, name string) error {
	data, err := Asset(name)
	if err != nil {
		return err
	}
	info, err := AssetInfo(name)
	if err != nil {
		return err
	}
	err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
	if err != nil {
		return err
	}
	err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
	if err != nil {
		return err
	}
	err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
	if err != nil {
		return err
	}
	return nil
}

// RestoreAssets restores an asset under the given directory recursively
func RestoreAssets(dir, name string) error {
	children, err := AssetDir(name)
	// File
	if err != nil {
		return RestoreAsset(dir, name)
	}
	// Dir
	for _, child := range children {
		err = RestoreAssets(dir, filepath.Join(name, child))
		if err != nil {
			return err
		}
	}
	return nil
}

func _filePath(dir, name string) string {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
}