| // This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication |
| // license. Its contents can be found at: |
| // http://creativecommons.org/publicdomain/zero/1.0/ |
| |
| package bindata |
| |
| import ( |
| "fmt" |
| "io" |
| "sort" |
| "strings" |
| ) |
| |
| type assetTree struct { |
| Asset Asset |
| Children map[string]*assetTree |
| } |
| |
| func newAssetTree() *assetTree { |
| tree := &assetTree{} |
| tree.Children = make(map[string]*assetTree) |
| return tree |
| } |
| |
| func (node *assetTree) child(name string) *assetTree { |
| rv, ok := node.Children[name] |
| if !ok { |
| rv = newAssetTree() |
| node.Children[name] = rv |
| } |
| return rv |
| } |
| |
| func (root *assetTree) Add(route []string, asset Asset) { |
| for _, name := range route { |
| root = root.child(name) |
| } |
| root.Asset = asset |
| } |
| |
| func ident(w io.Writer, n int) { |
| for i := 0; i < n; i++ { |
| w.Write([]byte{'\t'}) |
| } |
| } |
| |
| func (root *assetTree) funcOrNil() string { |
| if root.Asset.Func == "" { |
| return "nil" |
| } else { |
| return root.Asset.Func |
| } |
| } |
| |
| func (root *assetTree) writeGoMap(w io.Writer, nident int) { |
| fmt.Fprintf(w, "&bintree{%s, map[string]*bintree{", root.funcOrNil()) |
| |
| if len(root.Children) > 0 { |
| io.WriteString(w, "\n") |
| |
| // Sort to make output stable between invocations |
| filenames := make([]string, len(root.Children)) |
| i := 0 |
| for filename, _ := range root.Children { |
| filenames[i] = filename |
| i++ |
| } |
| sort.Strings(filenames) |
| |
| for _, p := range filenames { |
| ident(w, nident+1) |
| fmt.Fprintf(w, `"%s": `, p) |
| root.Children[p].writeGoMap(w, nident+1) |
| } |
| ident(w, nident) |
| } |
| |
| io.WriteString(w, "}}") |
| if nident > 0 { |
| io.WriteString(w, ",") |
| } |
| io.WriteString(w, "\n") |
| } |
| |
| func (root *assetTree) WriteAsGoMap(w io.Writer) error { |
| _, err := fmt.Fprint(w, `type bintree struct { |
| Func func() (*asset, error) |
| Children map[string]*bintree |
| } |
| var _bintree = `) |
| root.writeGoMap(w, 0) |
| return err |
| } |
| |
| func writeTOCTree(w io.Writer, toc []Asset) error { |
| _, err := fmt.Fprintf(w, `// 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 |
| } |
| |
| `) |
| if err != nil { |
| return err |
| } |
| tree := newAssetTree() |
| for i := range toc { |
| pathList := strings.Split(toc[i].Name, "/") |
| tree.Add(pathList, toc[i]) |
| } |
| return tree.WriteAsGoMap(w) |
| } |
| |
| // writeTOC writes the table of contents file. |
| func writeTOC(w io.Writer, toc []Asset) error { |
| err := writeTOCHeader(w) |
| if err != nil { |
| return err |
| } |
| |
| for i := range toc { |
| err = writeTOCAsset(w, &toc[i]) |
| if err != nil { |
| return err |
| } |
| } |
| |
| return writeTOCFooter(w) |
| } |
| |
| // writeTOCHeader writes the table of contents file header. |
| func writeTOCHeader(w io.Writer) error { |
| _, err := fmt.Fprintf(w, `// 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){ |
| `) |
| return err |
| } |
| |
| // writeTOCAsset write a TOC entry for the given asset. |
| func writeTOCAsset(w io.Writer, asset *Asset) error { |
| _, err := fmt.Fprintf(w, "\t%q: %s,\n", asset.Name, asset.Func) |
| return err |
| } |
| |
| // writeTOCFooter writes the table of contents file footer. |
| func writeTOCFooter(w io.Writer) error { |
| _, err := fmt.Fprintf(w, `} |
| |
| `) |
| return err |
| } |