lsm

type AccessFriendly ¶

type AccessFriendly interface {
	M() map[string]string        // get my content as map[key]value-string
	S() []string                 // get my keys as sorted slice
	Range() []interface{}        // get my values as slice, sorted by name
	LSM() map[string]interface{} // get my complete content as is
}

AccessFriendly - interface exposed for go doc only

I love to be responsive - not only for templates :-)

	Get my content as
     - sorted slice of strings: S
     - sorted slice of my kind: Range
     - string map of strings: M
     - string map of my kind: LSM

type Friendly ¶

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

Friendly - interface exposed for go doc only

I love to contain strings, named strings, named things, things which can name themselves.

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

type LazyStringerMap ¶

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

LazyStringerMap is the type provided by this package lsm.

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

Create me with New, and Assign or Lookup, and Delete or Init as You please :-)

I love to be responsive :-)

Get my content as sorted slice: S or as map: M (or even as is: LSM)

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. ;-)

I love to be concurrency-safe :-)

Thus: I always protect myself - Alas: You may not copy myself after first use!

func New() *LazyStringerMap

func (d *LazyStringerMap) Assign(key string, val interface{}) *LazyStringerMap

func (d *LazyStringerMap) Clone() *LazyStringerMap

func (d *LazyStringerMap) Delete(key string) *LazyStringerMap

func (d *LazyStringerMap) Fetch(key string) (interface{}, bool)

func (d *LazyStringerMap) Init() *LazyStringerMap

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

func (d *LazyStringerMap) Len() int

func (d *LazyStringerMap) Lookup(key string) string

func (d *LazyStringerMap) M() map[string]string

{{ .M.key }}

func (d *LazyStringerMap) Range() []interface{}

{{ range .Range }}...{{end}}

func (d *LazyStringerMap) S() []string

{{ range .S }}...{{end}}

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() *LazyStringerMap                              // (re)start afresh: no names, no content
	Assign(key string, val interface{}) *LazyStringerMap // assign a string "val" to name "key"
	Delete(key string) *LazyStringerMap                  // forget name "key" (and related content, if any)

	// Following may also be used in templates:
	Fetch(key string) (interface{}, bool) // obtain content named "key", iff any
	Lookup(key string) string             // obtain content named "key" - as (eventually empty) string

	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 any name (as key) to any value,
and Fetch a value by it's name,
Lookup a value as string by it's name (as key),
Delete a key, if You don't need it any more
as You please :-)