das

package
v0.0.0-...-4b9bf86 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 22, 2020 License: MIT Imports: 2 Imported by: 0

Documentation

Overview

Package das provides a Dictionary by Anything for Strings

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Das 

type Das struct {
	// contains filtered or unexported fields
}

Das - a Dictionary by Anything for Strings

I love to be easy - thus: I give You a simple API! 

Create me with 'New', and then
'Assign' and/or 'Append' and/or 'Add',
'Fetch' and/or 'Lookup', and
'Delete' or 'Init' - as You please :-)

I love to be responsive :-) 

Get my 'KeyS', or 'Lookup' my (sorted!) content as slice,
or as map with sorted! strings: 'Das' - Dictionary by any for strings

I love to be lazy - do not like to do things over and over again. 

Thus: only when You ask the question, then, on Your demand, so to say
do I prepare the answer for such certain question about my content. ;-)

I love to be concurrency-safe :-) 

Thus: I always protect myself!
Alas: You may not copy myself after frist use!
Example 
package main

import (
	"bytes"
	"text/template"

	"github.com/GoLangsam/container/ccsafe/das"
)

var keyBuff = bytes.NewBufferString("Test")
var keyTmpl = template.New("Test")
var keyStrg = "Test"
var keyInt8 = 4711
var keyBool = true

var newData = []string{"Foo", "Bar", "Buh", "Faa", "Bir"}
var addData = []string{"Fuu", "Bor", "Bah", "Fee", "Ber"}

func main() *das.Das {
	var das *das.Das // test also lazyInit

	das = das.Assign(keyBuff, newData...)
	das = das.Assign(keyTmpl, newData...)
	das = das.Assign(keyStrg, newData...)
	das = das.Assign(keyInt8, newData...)
	das = das.Assign(keyBool, newData...)

	das = das.Append(keyBuff, addData...)
	das = das.Append(keyTmpl, addData...)
	das = das.Append(keyStrg, addData...)
	das = das.Append(keyInt8, addData...)
	das = das.Append(keyBool, addData...)

	return das
}

Output:

func New 

func New() *Das

New - my creator - for good orders sake ;-)

Note: no need to call me - I use lazyInit to care for myself :-)

Hint: just plug me into Your "type favourite structure{}" :-)

func (*Das) Append 

func (d *Das) Append(key interface{}, vals ...string) *Das

Append - You want me to append "val"-strings? to my "key" content

Example 
package main

import (
	"bytes"
	"text/template"

	"github.com/GoLangsam/container/ccsafe/das"
)

var keyBuff = bytes.NewBufferString("Test")
var keyTmpl = template.New("Test")
var keyStrg = "Test"
var keyInt8 = 4711
var keyBool = true

var newData = []string{"Foo", "Bar", "Buh", "Faa", "Bir"}
var addData = []string{"Fuu", "Bor", "Bah", "Fee", "Ber"}

func ExampleDas() *das.Das {
	var das *das.Das

	das = das.Assign(keyBuff, newData...)
	das = das.Assign(keyTmpl, newData...)
	das = das.Assign(keyStrg, newData...)
	das = das.Assign(keyInt8, newData...)
	das = das.Assign(keyBool, newData...)

	das = das.Append(keyBuff, addData...)
	das = das.Append(keyTmpl, addData...)
	das = das.Append(keyStrg, addData...)
	das = das.Append(keyInt8, addData...)
	das = das.Append(keyBool, addData...)

	return das
}

func main() {
	das := ExampleDas() // a populated *Das

	das = das.Append(keyBuff, addData...)
	das = das.Append(keyTmpl, addData...)
	das = das.Append(keyStrg, addData...)
	das = das.Append(keyInt8, addData...)
	das = das.Append(keyBool, addData...)
}

Output:

func (*Das) Assign 

func (d *Das) Assign(key interface{}, vals ...string) *Das

Assign - You want to reset my "key" content "val"-strings?

Example 
package main

import (
	"bytes"
	"text/template"

	"github.com/GoLangsam/container/ccsafe/das"
)

var keyBuff = bytes.NewBufferString("Test")
var keyTmpl = template.New("Test")
var keyStrg = "Test"
var keyInt8 = 4711
var keyBool = true

var newData = []string{"Foo", "Bar", "Buh", "Faa", "Bir"}
var addData = []string{"Fuu", "Bor", "Bah", "Fee", "Ber"}

func ExampleDas() *das.Das {
	var das *das.Das

	das = das.Assign(keyBuff, newData...)
	das = das.Assign(keyTmpl, newData...)
	das = das.Assign(keyStrg, newData...)
	das = das.Assign(keyInt8, newData...)
	das = das.Assign(keyBool, newData...)

	das = das.Append(keyBuff, addData...)
	das = das.Append(keyTmpl, addData...)
	das = das.Append(keyStrg, addData...)
	das = das.Append(keyInt8, addData...)
	das = das.Append(keyBool, addData...)

	return das
}

func main() {
	das := ExampleDas() // a populated *Das

	das = das.Assign(keyBuff, newData...)
	das = das.Assign(keyTmpl, newData...)
	das = das.Assign(keyStrg, newData...)
	das = das.Assign(keyInt8, newData...)
	das = das.Assign(keyBool, newData...)
}

Output:

func (*Das) Das 

func (d *Das) Das() map[interface{}][]string

Das returns my complete content

Example 
package main

import (
	"bytes"
	"fmt"
	"text/template"

	"github.com/GoLangsam/container/ccsafe/das"
)

var keyBuff = bytes.NewBufferString("Test")
var keyTmpl = template.New("Test")
var keyStrg = "Test"
var keyInt8 = 4711
var keyBool = true

var newData = []string{"Foo", "Bar", "Buh", "Faa", "Bir"}
var addData = []string{"Fuu", "Bor", "Bah", "Fee", "Ber"}

func ExampleDas() *das.Das {
	var das *das.Das

	das = das.Assign(keyBuff, newData...)
	das = das.Assign(keyTmpl, newData...)
	das = das.Assign(keyStrg, newData...)
	das = das.Assign(keyInt8, newData...)
	das = das.Assign(keyBool, newData...)

	das = das.Append(keyBuff, addData...)
	das = das.Append(keyTmpl, addData...)
	das = das.Append(keyStrg, addData...)
	das = das.Append(keyInt8, addData...)
	das = das.Append(keyBool, addData...)

	return das
}

func main() {
	das := ExampleDas() // a populated *Das

	for key, val := range das.Das() {
		fmt.Printf("%v:\t\t\n", key)
		for v := range val {
			fmt.Printf("\t%v\t\n", v)
		}
	}
}

Output:

func (*Das) Delete 

func (d *Das) Delete(key interface{}) *Das

Delete - You want me to forget abou "key" (and it's related content)?

Example 
package main

import (
	"bytes"
	"fmt"
	"text/template"

	"github.com/GoLangsam/container/ccsafe/das"
)

var keyBuff = bytes.NewBufferString("Test")
var keyTmpl = template.New("Test")
var keyStrg = "Test"
var keyInt8 = 4711
var keyBool = true

var newData = []string{"Foo", "Bar", "Buh", "Faa", "Bir"}
var addData = []string{"Fuu", "Bor", "Bah", "Fee", "Ber"}

func ExampleDas() *das.Das {
	var das *das.Das

	das = das.Assign(keyBuff, newData...)
	das = das.Assign(keyTmpl, newData...)
	das = das.Assign(keyStrg, newData...)
	das = das.Assign(keyInt8, newData...)
	das = das.Assign(keyBool, newData...)

	das = das.Append(keyBuff, addData...)
	das = das.Append(keyTmpl, addData...)
	das = das.Append(keyStrg, addData...)
	das = das.Append(keyInt8, addData...)
	das = das.Append(keyBool, addData...)

	return das
}

func main() {
	das := ExampleDas() // a populated *Das

	fmt.Println("Len == 5 ?", das.Len())

	das = das.Delete(keyBuff)
	das = das.Delete(keyTmpl)
	das = das.Delete(keyStrg)
	das = das.Delete(keyInt8)
	das = das.Delete(keyBool)

	fmt.Println("Len == 0 ?", das.Len())
}

Output:

func (*Das) Fetch 

func (d *Das) Fetch(key interface{}) ([]string, bool)

Fetch - You want my content of "key"

Example 
package main

import (
	"bytes"
	"fmt"
	"text/template"

	"github.com/GoLangsam/container/ccsafe/das"
)

var keyBuff = bytes.NewBufferString("Test")
var keyTmpl = template.New("Test")
var keyStrg = "Test"
var keyInt8 = 4711
var keyBool = true

var newData = []string{"Foo", "Bar", "Buh", "Faa", "Bir"}
var addData = []string{"Fuu", "Bor", "Bah", "Fee", "Ber"}

func ExampleDas() *das.Das {
	var das *das.Das

	das = das.Assign(keyBuff, newData...)
	das = das.Assign(keyTmpl, newData...)
	das = das.Assign(keyStrg, newData...)
	das = das.Assign(keyInt8, newData...)
	das = das.Assign(keyBool, newData...)

	das = das.Append(keyBuff, addData...)
	das = das.Append(keyTmpl, addData...)
	das = das.Append(keyStrg, addData...)
	das = das.Append(keyInt8, addData...)
	das = das.Append(keyBool, addData...)

	return das
}

func main() {
	das := ExampleDas() // a populated *Das

	key := keyBool
	fmt.Printf("%v:\t\t\n", key)
	if vS, ok := das.Fetch(key); ok {
		for i := range vS {
			fmt.Printf("\t%v\t\n", vS[i])
		}
	}
}

Output:

func (*Das) Init 

func (d *Das) Init() *Das

Init - Want my content reborn empty?

Example 
package main

import (
	"bytes"
	"fmt"
	"text/template"

	"github.com/GoLangsam/container/ccsafe/das"
)

var keyBuff = bytes.NewBufferString("Test")
var keyTmpl = template.New("Test")
var keyStrg = "Test"
var keyInt8 = 4711
var keyBool = true

var newData = []string{"Foo", "Bar", "Buh", "Faa", "Bir"}
var addData = []string{"Fuu", "Bor", "Bah", "Fee", "Ber"}

func ExampleDas() *das.Das {
	var das *das.Das

	das = das.Assign(keyBuff, newData...)
	das = das.Assign(keyTmpl, newData...)
	das = das.Assign(keyStrg, newData...)
	das = das.Assign(keyInt8, newData...)
	das = das.Assign(keyBool, newData...)

	das = das.Append(keyBuff, addData...)
	das = das.Append(keyTmpl, addData...)
	das = das.Append(keyStrg, addData...)
	das = das.Append(keyInt8, addData...)
	das = das.Append(keyBool, addData...)

	return das
}

func main() {
	das := ExampleDas() // a populated *Das
	fmt.Println("Len == 5 ?", das.Len())

	das = das.Init()
	fmt.Println("Len == 0 ?", das.Len())

	das = ExampleDas() // a populated *Das - again
	fmt.Println("Len == 5 ?", das.Len())
}

Output:

func (*Das) KeyS 

func (d *Das) KeyS() []interface{}

KeyS returns the my keys as unsorted slice Thus: {{ range .Range }}...{{end}} walks my (sorted) values

Example 
package main

import (
	"bytes"
	"fmt"
	"text/template"

	"github.com/GoLangsam/container/ccsafe/das"
)

var keyBuff = bytes.NewBufferString("Test")
var keyTmpl = template.New("Test")
var keyStrg = "Test"
var keyInt8 = 4711
var keyBool = true

var newData = []string{"Foo", "Bar", "Buh", "Faa", "Bir"}
var addData = []string{"Fuu", "Bor", "Bah", "Fee", "Ber"}

func ExampleDas() *das.Das {
	var das *das.Das

	das = das.Assign(keyBuff, newData...)
	das = das.Assign(keyTmpl, newData...)
	das = das.Assign(keyStrg, newData...)
	das = das.Assign(keyInt8, newData...)
	das = das.Assign(keyBool, newData...)

	das = das.Append(keyBuff, addData...)
	das = das.Append(keyTmpl, addData...)
	das = das.Append(keyStrg, addData...)
	das = das.Append(keyInt8, addData...)
	das = das.Append(keyBool, addData...)

	return das
}

func main() {
	das := ExampleDas() // a populated *Das

	var res []interface{}
	res = das.KeyS()
	fmt.Println("Len == 3 ???", len(res))
	fmt.Println("Is result sorted?", res)

}

Output:

func (*Das) Len 

func (d *Das) Len() int

Len - How many keys do I contain right now?

Example 
package main

import (
	"bytes"
	"fmt"
	"text/template"

	"github.com/GoLangsam/container/ccsafe/das"
)

var keyBuff = bytes.NewBufferString("Test")
var keyTmpl = template.New("Test")
var keyStrg = "Test"
var keyInt8 = 4711
var keyBool = true

var newData = []string{"Foo", "Bar", "Buh", "Faa", "Bir"}
var addData = []string{"Fuu", "Bor", "Bah", "Fee", "Ber"}

func ExampleDas() *das.Das {
	var das *das.Das

	das = das.Assign(keyBuff, newData...)
	das = das.Assign(keyTmpl, newData...)
	das = das.Assign(keyStrg, newData...)
	das = das.Assign(keyInt8, newData...)
	das = das.Assign(keyBool, newData...)

	das = das.Append(keyBuff, addData...)
	das = das.Append(keyTmpl, addData...)
	das = das.Append(keyStrg, addData...)
	das = das.Append(keyInt8, addData...)
	das = das.Append(keyBool, addData...)

	return das
}

func main() {
	das := ExampleDas() // a populated *Das

	fmt.Println("Len == 5 ?", das.Len())
}

Output:

func (*Das) Lookup 

func (d *Das) Lookup(key interface{}) []string

Lookup - You want my content of "key" - as (eventually empty) string-slice

Example 
package main

import (
	"bytes"
	"fmt"
	"text/template"

	"github.com/GoLangsam/container/ccsafe/das"
)

var keyBuff = bytes.NewBufferString("Test")
var keyTmpl = template.New("Test")
var keyStrg = "Test"
var keyInt8 = 4711
var keyBool = true

var newData = []string{"Foo", "Bar", "Buh", "Faa", "Bir"}
var addData = []string{"Fuu", "Bor", "Bah", "Fee", "Ber"}

func ExampleDas() *das.Das {
	var das *das.Das

	das = das.Assign(keyBuff, newData...)
	das = das.Assign(keyTmpl, newData...)
	das = das.Assign(keyStrg, newData...)
	das = das.Assign(keyInt8, newData...)
	das = das.Assign(keyBool, newData...)

	das = das.Append(keyBuff, addData...)
	das = das.Append(keyTmpl, addData...)
	das = das.Append(keyStrg, addData...)
	das = das.Append(keyInt8, addData...)
	das = das.Append(keyBool, addData...)

	return das
}

func main() {
	das := ExampleDas() // a populated *Das

	var res []string
	res = das.Lookup(keyBuff)
	res = das.Lookup(keyTmpl)
	res = das.Lookup(keyStrg)
	res = das.Lookup(keyInt8)
	res = das.Lookup(keyBool)

	fmt.Println("Len == 5 ?", len(res))
}

Output:

type Friendly 

type Friendly interface {
	UserFriendly        // use.go
	PerformanceFriendly // lazy.go
}

Friendly - interface exposed for go doc only

I love to contain strings, identified by 'anything'. 

And I love to give them back to You, when You need 'em.
And also as slice or map - as You need 'em.
And also sorted, or reversed, all for Your convenience.

type PerformanceFriendly 

type PerformanceFriendly interface {
	// contains filtered or unexported methods
}

PerformanceFriendly - interface exposed for go doc only

I love to be fast :-) 

Thus: I memoize answers about my content, and about when to forget my memos

I love to be lazy - do not like to do things over and over again. 

Thus: only when You ask the question, then, on Your demand, so to say
do I prepare the answer for such certain question about my content. ;-)

type UserFriendly 

type UserFriendly interface {
	// Following may be chained:
	Init() *Das                                  // (re)start afresh: no names, no content
	Assign(key interface{}, vals ...string) *Das // assign strings "vals" to name "key" (replacing prev. content!)
	Append(key interface{}, vals ...string) *Das // append strings "vals" to name "key" (respecting prev. content!)
	Delete(key interface{}) *Das                 // forget name "key" (and related content, if any)
	// Following may also be used in templates
	Fetch(key interface{}) ([]string, bool) // obtain content named "key"
	Lookup(key interface{}) []string        // obtain content named "key" - as (eventually empty) string
	//
	KeyS() []interface{}           // return my keys as slice (in random order)
	Das() map[interface{}][]string // return Content with sorted duplicatefree stringslices
	//
	Len() int // How many things do I contain right now?
}

UserFriendly - interface exposed for go doc only

I love to be easy - thus: I give You a simple API! 

Create me with New, if You like - Note: No need, I'm friendly :-)
and Init me to use me afresh,
Assign anything (as key) to any slice of strings,
and Fetch a value by it's key,
Lookup a value (or nil) by it's key,
Delete a key, if You don't need it any more
as You please :-)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.