base_tpl.go

// Code generated by go-bindata.
// sources:
// __tp-micro__gen__.lock
// .gitignore
// README.md
// api/handler.go
// api/router.go
// args/const.go
// args/type.go
// args/var.go
// rerrs/rerrs.go
// sdk/rpc.go
// sdk/rpc_test.go
// DO NOT EDIT!

package tpl

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

	"github.com/xiaoenai/tp-micro/cmd/micro/info"
)

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
}

func (fi bindataFileInfo) Name() string {
	return fi.name
}
func (fi bindataFileInfo) Size() int64 {
	return fi.size
}
func (fi bindataFileInfo) Mode() os.FileMode {
	return fi.mode
}
func (fi bindataFileInfo) ModTime() time.Time {
	return fi.modTime
}
func (fi bindataFileInfo) IsDir() bool {
	return false
}
func (fi bindataFileInfo) Sys() interface{} {
	return nil
}

var _Gitignore = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x4c\x8e\x4d\x8a\xc3\x30\x0c\x85\xf7\x3a\x8a\x60\x04\x33\x30\xa5\x77\x29\xc5\x38\x8e\xe2\x26\x4d\x22\xd5\x3f\x69\x9a\x45\xcf\x5e\x5c\xa7\xd0\xcd\xb3\xdf\x87\xf8\x24\x24\x01\x24\x0b\x48\x51\xc0\x48\x33\x80\x49\x1c\x13\x20\x9d\xfe\x0f\xc7\xe5\x76\x86\xfd\x25\xc9\x85\x3a\x2f\xbf\xe4\xa5\xfe\xfe\xc8\x81\x71\x5e\x4c\xcb\x5d\x9e\x3f\xc5\x4b\x7a\x28\xc7\x32\xf5\xee\xbc\xaa\x84\x44\x58\xcd\x93\xed\xe7\x2a\xe0\x95\x6b\x3e\x01\x69\x5f\xaa\x41\x3a\x40\x0a\x36\x00\xd2\xd6\x2b\x20\xf9\xad\xf0\xd8\x02\x52\x33\x95\x74\x9d\x2f\x44\xd3\x0a\x48\xa3\x78\xc0\x59\x2e\x59\xf7\x03\x97\xe8\xa4\x2d\xe2\x98\x9b\xb1\x9f\xf8\x47\x83\x0c\xec\xd2\x17\xb9\x4b\xb8\x46\xb5\x8e\x5f\x01\x00\x00\xff\xff\x2c\x12\x76\x42\xfd\x00\x00\x00")

func GitignoreBytes() ([]byte, error) {
	return bindataRead(
		_Gitignore,
		".gitignore",
	)
}

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

	info := bindataFileInfo{name: ".gitignore", size: 253, mode: os.FileMode(420), modTime: time.Unix(1529569308, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _readmeMd = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x24\xcc\x31\xcb\xc2\x40\x0c\x80\xe1\xfd\x7e\x45\xe0\x5b\x3e\x07\x9b\xdd\xad\x88\x8b\x50\x15\x71\x13\xb1\xd7\x34\xb4\x11\xd2\x94\xbb\x14\x94\xd2\xff\x2e\xd4\xf5\x79\xe1\xfd\x83\x79\xbe\x5c\xcf\xc7\xe7\xa9\xac\x0e\xcb\x12\xc2\xad\x97\x0c\x92\x21\xc2\x98\xec\xc5\xe4\x40\x89\xa3\x73\x0b\xcd\x07\x6a\x15\x4a\x06\x1d\x0f\x35\x90\xa9\xc6\xa1\x2d\x42\xb8\x97\x8d\x4d\x0e\xd5\xda\xf6\x3f\x7e\xfc\xf7\xee\x63\xde\x21\x76\xe2\xfd\xd4\x14\x64\x8a\x6f\x89\xc6\x43\x14\xf4\x71\xbb\x9e\xd0\x13\x33\x6a\xcc\xce\x09\x49\x5b\x5c\x75\x13\xbe\x01\x00\x00\xff\xff\x33\x0c\x98\x1f\x96\x00\x00\x00")

func readmeMdBytes() ([]byte, error) {
	return bindataRead(
		_readmeMd,
		"README.md",
	)
}

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

	info := bindataFileInfo{name: "README.md", size: 150, mode: os.FileMode(420), modTime: time.Unix(1529568750, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var ___tpMicro__gen__Lock = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x1c\xca\xc1\x0d\x82\x21\x0c\x06\xd0\xbb\x53\x7c\x32\x00\x03\x78\xf7\xaa\x17\x06\xc0\x60\x0b\x4d\xa0\x4d\x28\x2a\x6e\x6f\xfc\xaf\x2f\xef\x76\x4f\xd7\xcb\x09\xa9\x89\x23\x0f\x29\xd3\x50\x49\x33\x8a\x8d\xf1\xd0\x27\x4c\xfb\x17\xc5\xde\x34\x1d\x2c\x9d\x1c\x1f\x59\x0d\xab\x11\x42\xac\xa4\xb1\x5a\x80\xbf\x98\x65\x43\xf8\xf0\x7f\x03\x6d\xf1\xe5\xe7\x5f\x00\x00\x00\xff\xff\x83\x15\xc3\x44\x5f\x00\x00\x00")

func __tpMicro__gen__LockBytes() ([]byte, error) {
	return bindataRead(
		___tpMicro__gen__Lock,
		"__tp-micro__gen__.lock",
	)
}

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

	info := bindataFileInfo{name: "__tp-micro__gen__.lock", size: 95, mode: os.FileMode(420), modTime: time.Unix(1529569232, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _apiHandlerGo = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x2a\x48\x4c\xce\x4e\x4c\x4f\x55\x48\x2c\xc8\xe4\x02\x04\x00\x00\xff\xff\x0c\x0c\x0a\x62\x0c\x00\x00\x00")

func apiHandlerGoBytes() ([]byte, error) {
	return bindataRead(
		_apiHandlerGo,
		"api/handler.go",
	)
}

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

	info := bindataFileInfo{name: "api/handler.go", size: 12, mode: os.FileMode(420), modTime: time.Unix(1529564906, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _apiRouterGo = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x4c\x8b\x41\x0e\x02\x21\x0c\x45\xd7\xf6\x14\xcd\xac\x66\x5c\x0c\x89\x47\xf1\x06\x88\x15\x88\x40\x9b\x52\x16\xc6\x78\x77\x83\xba\x70\xf9\xdf\x7f\x4f\x7c\xb8\xfb\x48\xe8\x25\x03\xe4\x2a\xac\x86\x2b\x1c\x4c\x70\x89\xd9\xd2\xb8\xec\x81\xab\x4b\xd4\xf4\x51\x88\x4e\xa1\x39\xa3\x42\x53\x5b\x60\x03\x70\x0e\xc3\xe8\xc6\xf5\xcc\xc3\x08\x95\x62\xee\x46\xda\x7f\x14\x93\x6f\xd7\x32\xb7\x31\xea\x54\x74\x87\xdb\x68\xe1\xbf\x5a\xbf\x07\x1e\x4d\xf6\x0f\xd0\x0d\x9f\xf0\x82\x77\x00\x00\x00\xff\xff\xd3\xb5\x7a\x55\x9b\x00\x00\x00")

func apiRouterGoBytes() ([]byte, error) {
	return bindataRead(
		_apiRouterGo,
		"api/router.go",
	)
}

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

	info := bindataFileInfo{name: "api/router.go", size: 155, mode: os.FileMode(420), modTime: time.Unix(1529564906, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _argsConstGo = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x2a\x48\x4c\xce\x4e\x4c\x4f\x55\x48\x2c\x4a\x2f\xe6\xe2\x4a\xce\xcf\x2b\x2e\x51\xd0\xd0\xe4\x02\x04\x00\x00\xff\xff\xf5\x9a\x10\x2f\x17\x00\x00\x00")

func argsConstGoBytes() ([]byte, error) {
	return bindataRead(
		_argsConstGo,
		"args/const.go",
	)
}

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

	info := bindataFileInfo{name: "args/const.go", size: 23, mode: os.FileMode(420), modTime: time.Unix(1529564906, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _argsTypeGo = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x2a\x48\x4c\xce\x4e\x4c\x4f\x55\x48\x2c\x4a\x2f\xe6\xe2\x2a\xa9\x2c\x48\x55\xd0\xd0\xe4\x02\x04\x00\x00\xff\xff\x61\x1b\x80\x25\x16\x00\x00\x00")

func argsTypeGoBytes() ([]byte, error) {
	return bindataRead(
		_argsTypeGo,
		"args/type.go",
	)
}

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

	info := bindataFileInfo{name: "args/type.go", size: 22, mode: os.FileMode(420), modTime: time.Unix(1529564906, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _argsVarGo = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x2a\x48\x4c\xce\x4e\x4c\x4f\x55\x48\x2c\x4a\x2f\xe6\xe2\x2a\x4b\x2c\x52\xd0\xd0\xe4\x02\x04\x00\x00\xff\xff\xa5\xca\xdc\xfb\x15\x00\x00\x00")

func argsVarGoBytes() ([]byte, error) {
	return bindataRead(
		_argsVarGo,
		"args/var.go",
	)
}

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

	info := bindataFileInfo{name: "args/var.go", size: 21, mode: os.FileMode(420), modTime: time.Unix(1529564906, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _rerrsRerrsGo = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x6c\xca\xb1\xce\x82\x30\x10\x00\xe0\x99\x7b\x8a\x4b\x27\x48\x08\x2d\xff\xfe\x4f\x4e\x2e\xc6\xf0\x06\x27\x5e\xa0\x11\xda\x7a\x3d\x30\xbe\xbd\xc1\xa0\x93\xf3\xf7\x25\xea\x6f\x34\x30\x0a\x8b\x64\x00\x3f\xa7\x28\x8a\x25\x14\x9a\xd0\x0c\x5e\xc7\xe5\xd2\xf4\x71\xb6\x23\x07\x79\x4e\xcc\x7f\x7d\xb0\xca\x13\x6f\xcd\x40\x05\xb0\x92\x6c\xdd\x5a\xec\x58\xe4\x18\x56\x9a\xfc\xf5\x4c\x42\x33\x2b\x0b\xb2\x48\x14\x28\x7e\xda\x3f\x6a\x6a\x4e\xfc\xe8\xde\xa9\x6c\x9d\x73\xae\xad\xd1\xec\x11\xbf\xd3\xd4\x68\x0e\x31\x28\xf9\x90\xd1\xef\x2a\x7c\x5f\x38\x2b\xa6\xcf\xca\xa6\x82\x0a\x5e\x01\x00\x00\xff\xff\x8b\x81\xb9\xe7\xd1\x00\x00\x00")

func rerrsRerrsGoBytes() ([]byte, error) {
	return bindataRead(
		_rerrsRerrsGo,
		"rerrs/rerrs.go",
	)
}

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

	info := bindataFileInfo{name: "rerrs/rerrs.go", size: 209, mode: os.FileMode(420), modTime: time.Unix(1529564906, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _sdkRpcGo = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x2a\x48\x4c\xce\x4e\x4c\x4f\x55\x28\x4e\xc9\xe6\x02\x04\x00\x00\xff\xff\x36\xfa\x03\xb1\x0c\x00\x00\x00")

func sdkRpcGoBytes() ([]byte, error) {
	return bindataRead(
		_sdkRpcGo,
		"sdk/rpc.go",
	)
}

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

	info := bindataFileInfo{name: "sdk/rpc.go", size: 12, mode: os.FileMode(420), modTime: time.Unix(1529564906, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _sdkRpc_testGo = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x2a\x48\x4c\xce\x4e\x4c\x4f\x55\x28\x4e\xc9\xe6\x02\x04\x00\x00\xff\xff\x36\xfa\x03\xb1\x0c\x00\x00\x00")

func sdkRpc_testGoBytes() ([]byte, error) {
	return bindataRead(
		_sdkRpc_testGo,
		"sdk/rpc_test.go",
	)
}

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

	info := bindataFileInfo{name: "sdk/rpc_test.go", size: 12, mode: os.FileMode(420), modTime: time.Unix(1529564906, 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){
	".gitignore":             Gitignore,
	"README.md":              readmeMd,
	"__tp-micro__gen__.lock": __tpMicro__gen__Lock,
	"api/handler.go":         apiHandlerGo,
	"api/router.go":          apiRouterGo,
	"args/const.go":          argsConstGo,
	"args/type.go":           argsTypeGo,
	"args/var.go":            argsVarGo,
	"rerrs/rerrs.go":         rerrsRerrsGo,
	"sdk/rpc.go":             sdkRpcGo,
	"sdk/rpc_test.go":        sdkRpc_testGo,
}

// 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{
	".gitignore":             &bintree{Gitignore, map[string]*bintree{}},
	"README.md":              &bintree{readmeMd, map[string]*bintree{}},
	"__tp-micro__gen__.lock": &bintree{__tpMicro__gen__Lock, map[string]*bintree{}},
	"api": &bintree{nil, map[string]*bintree{
		"handler.go": &bintree{apiHandlerGo, map[string]*bintree{}},
		"router.go":  &bintree{apiRouterGo, map[string]*bintree{}},
	}},
	"args": &bintree{nil, map[string]*bintree{
		"const.go": &bintree{argsConstGo, map[string]*bintree{}},
		"type.go":  &bintree{argsTypeGo, map[string]*bintree{}},
		"var.go":   &bintree{argsVarGo, map[string]*bintree{}},
	}},
	"rerrs": &bintree{nil, map[string]*bintree{
		"rerrs.go": &bintree{rerrsRerrsGo, map[string]*bintree{}},
	}},
	"sdk": &bintree{nil, map[string]*bintree{
		"rpc.go":      &bintree{sdkRpcGo, map[string]*bintree{}},
		"rpc_test.go": &bintree{sdkRpc_testGo, 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
	}
	data = bytes.Replace(data, projNameTpl, projNameBytes, -1)
	data = bytes.Replace(data, projPathTpl, projPathBytes, -1)
	if strings.HasSuffix(name, ".go") {
		data, _ = format.Source(data)
	}
	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
	}
	fmt.Printf("generate %s\n", string(projPathBytes)+"/"+_filePath(dir, name))
	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 {
		if name == "__tp-micro__gen__.lock" {
			return nil
		}
		return RestoreAsset(dir, name)
	}
	// Dir
	for _, child := range children {
		if child == "logic" {
			continue
		}
		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, "/")...)...)
}

var (
	projNameBytes []byte
	projPathBytes []byte
	projNameTpl   = []byte("{{PROJ_NAME}}")
	projPathTpl   = []byte("{{PROJ_PATH}}")
)

// Create creates base files.
func Create() {
	projNameBytes = []byte(info.ProjName())
	projPathBytes = []byte(info.ProjPath())
	RestoreAssets("./", "")
}