woe/src/woe/world/entity.go

package world
import "strings"
import "os"
import "sort"
import "encoding/xml"
import "github.com/beoran/woe/sitef"




// Anything inside the WOE World can be identified by a unique short string 
// description, the Label
type Labeled interface {
    Label() string // Returns a unique label of the thing.
}

type Typed interface {
    Type() string // Returns a string description of the type of the thing. 
}


// An entity is anything that can exist in a World
type Entity struct {
    ID                  string      `xml:"id,attr"`
    Name                string      `xml:"name,attr"`
    Short               string      `xml:"short,attr"`
    Long                string
    Aliases           []string    
    // Privilege level needed to use/interact with/enter/... this Entity
    Privilege           Privilege
}


func (me * Entity) InitKind(kind string, name string, 
    privilege Privilege) (* Entity) {
    if me == nil {
        return me
    }
    me.ID       = kind + "_" + strings.ToLower(name) 
    me.Name     = name
    me.Short    = name
    me.Long     = name
    me.Privilege= privilege
    return me
}

// Devious polymorphism for Entities...
type Entitylike interface {
    AsEntity() * Entity
}

// A little trick to need less setters and getters
func (me * Entity) AsEntity() (*Entity) {
    return me
}

func (me Entity) Label() string {
    return string(me.ID)
}


type EntitySlice []Entitylike
type EntityMap map[string]Entitylike

type EntityLookup struct {
    slice EntitySlice
    table EntityMap  
}


// By is the type of a "less" function that defines the ordering of its Planet arguments.
type EntityLikeBy func(p1, p2 Entitylike) bool

// planetSorter joins a By function and a slice of Planets to be sorted.
type EntityLikeSorter struct {
    Entities EntitySlice
    By       EntityLikeBy
}


func (me EntitySlice) By(compare func (p1, p2 Entitylike) bool) *EntityLikeSorter {
    return &EntityLikeSorter { me,  EntityLikeBy(compare) };
}

// Len is part of sort.Interface.
func (s * EntityLikeSorter) Len() int {
    return len(s.Entities)
}

// Swap is part of sort.Interface.
func (s *EntityLikeSorter) Swap(i, j int) {
    s.Entities[i], s.Entities[j] = s.Entities[j], s.Entities[i]
}

// Less is part of sort.Interface. It is implemented by calling the "by" closure in the sorter.
func (s *EntityLikeSorter) Less(i, j int) bool {
    return s.By(s.Entities[i], s.Entities[j])
}

func (me * EntityLikeSorter) Sort() {
    sort.Sort(me)
} 

// Sort is a method on the function type, By, that sorts the argument slice according to the function.
func (by EntityLikeBy) Sort(entities EntitySlice) {
    ps := &EntityLikeSorter{
        Entities: entities,
        By:      by, // The Sort method's receiver is the function (closure) that defines the sort order.
    }
    sort.Sort(ps)
}


func (me EntityLookup) Get(index int) Entitylike {
    return me.slice[index]
}

func (me EntityLookup) Len() int {
    return len(me.table)
}

func (me * EntityLookup) Add(ent Entitylike) int {
    me.slice = append(me.slice, ent)
    me.slice.By(func (e1, e2 Entitylike) bool {
            return (e1.AsEntity().Label() < e2.AsEntity().Label()) 
        }).Sort()
    res := len(me.slice) - 1 
    if me.table == nil {
        me.table = make(EntityMap)
    }
    me.table[ent.AsEntity().Label()] = ent
    return res 
}

func (me EntityLookup) Lookup(id string) (Entitylike) {
    res, ok := me.table[id]
    if !ok {
        return nil
    }
    return res    
}

func (me EntityLookup) Remove(ent Entitylike) bool {
    key := ent.AsEntity().Label()
    delete(me.table, key)
    return true
}

type EntityLookupEachFunc func (id string, ent Entitylike, args...interface{}) Entitylike

func (me EntityLookup) Each(lambda EntityLookupEachFunc, args...interface{}) Entitylike {
    for k, v := range (me.table) {
        res := lambda(k, v, args...) 
        if res != nil {
            return res
        }
    } 
    return nil
}


type EntityList interface {
    Get(int) Entitylike
    Len() int
    Add(Entitylike) int
    Lookup(string) (Entitylike)
    Remove(Entitylike) bool
}

// Interface 
type Savable interface {
    Labeled
    Typed
}

type Loadable interface {    
    Typed
}

func SaveSavable(dirname string, savable Savable) (err error) {
    path := SavePathFor(dirname, savable.Type(), savable.Label())
    
    file, err := os.Create(path)
    if err != nil {
        return err
    }
    enc := xml.NewEncoder(file)
    enc.Indent(" ", "  ")
    return enc.Encode(savable)
}

func LoadLoadable(dirname string, nameid string, result Loadable) (Loadable) {
    path := SavePathFor(dirname, result.Type(), nameid)
    
    file, err := os.Open(path)
    if err != nil {
        return nil
    }
    dec := xml.NewDecoder(file)    
    err = dec.Decode(result)
    if err != nil { return nil }
    return result
}

// A list of Identifier items mapped to their ID's 
type LabeledLister interface {
    Get(string)     Labeled
    Put(Labeled)
    Size()          int
    Index(int)      Labeled
    PutIndex(int)
}

type LabeledList struct {
    byList        []Labeled
    byLabel       map[string] Labeled
}

func NewLabeledList() * LabeledList {
    byname := make(map[string] Labeled)
    return &LabeledList{nil, byname}
}

func (me * LabeledList) Get(id string) Labeled {
    val, ok := me.byLabel[id]
    if !ok { return nil }
    return val
}

func (me * LabeledList) Index(index int) Labeled {
    if index < 0 { return nil } 
    if index > len(me.byList) { return nil }
    val := me.byList[index]
    return val
}


// Save an entity to a sitef record.
func (me * Entity) SaveSitef(rec sitef.Record) (err error) {
    rec["id"]    = string(me.ID)
    rec["name"]  = me.Name
    rec["short"] = me.Short
    rec["long"]  = me.Long
    return nil
}

// Load an entity from a sitef record.
func (me * Entity) LoadSitef(rec sitef.Record) (err error) {
    me.ID       = rec["id"]   
    me.Name     = rec["name"]
    me.Short    = rec["short"]
    me.Long     = rec["long"]
    return nil
}