get rid of Track interface - use Track (as public struct) directly

storage/message/message.go

@@ -7,23 +7,23 @@ import (
 )
 
 type message struct {
-	tracking.Track
+	*tracking.Track
 }
 
-func Message(tr tracking.Track) *message {
+func Message(tr *tracking.Track) *message {
 	return &message{tr}
 }
 
-func MakeMessage(c *tracking.Container, h ...string) tracking.Track {
+func MakeMessage(c *tracking.Container, h ...string) *tracking.Track {
 	h = append(h, "") // make sure at least domain is there
 	if h[0] == "" {
 		h[0] = "scopes"
 	}
-	return Message(tracking.MakeTrack(c, h...))
+	return tracking.MakeTrack(c, h...)
 }
 
 func (msg *message) Domain() string {
-	return msg.Head()["domain"]
+	return msg.Head["domain"]
 }
 
 // message container

storage/tracking/tracking.go

@@ -13,80 +13,37 @@ import (
 	sql "git.sr.ht/~cco/go-scopes/storage"
 )
 
-type ItemFactory func(*Container, ...string) Track
+type ItemFactory func(*Container, ...string) *Track
-
-type Track interface {
-	TrackId() lib.Ident
-	Head() lib.StrMap
-	Data() lib.Map
-	TimeStamp() *time.Time
-	SetTrackId(lib.Ident)
-	SetTimeStamp(*time.Time)
-	Update(lib.StrSlice, lib.Map, *time.Time)
-}
-
-type BaseTrack = track
 
 // basic track implementation
 
-type track struct {
+type Track struct {
-	trackId   lib.Ident
+	TrackId   lib.Ident
-	head      lib.StrMap
+	Head      lib.StrMap
-	timeStamp *time.Time
+	TimeStamp *time.Time
-	data      lib.Map
+	Data      lib.Map
-	container *Container
+	Container *Container
 }
 
-func MakeTrack(cont *Container, h ...string) Track {
+func MakeTrack(cont *Container, h ...string) *Track {
-	head := lib.StrMap{}
+	tr := Track{
-	for i, k := range cont.HeadFields {
+		Head:      lib.StrMap{},
-		if i >= len(h) {
+		Data:      lib.Map{},
-			break
+		Container: cont,
 	}
-		head[k] = h[i]
+	tr.SetHead(h...)
-	}
+	return &tr
-	return &track{head: head}
 }
 
-func (tr *track) TrackId() lib.Ident {
+func (tr *Track) SetHead(h ...string) {
-	return tr.trackId
+	for i, k := range tr.Container.HeadFields {
-}
-
-func (tr *track) Head() lib.StrMap {
-	return tr.head
-}
-
-func (tr *track) Data() lib.Map {
-	return tr.data
-}
-
-func (tr *track) TimeStamp() *time.Time {
-	return tr.timeStamp
-}
-
-func (tr *track) SetTrackId(id lib.Ident) {
-	tr.trackId = id
-}
-
-func (tr *track) SetTimeStamp(ts *time.Time) {
-	tr.timeStamp = ts
-}
-
-func (tr *track) Update(h lib.StrSlice, d lib.Map, ts *time.Time) {
-	for i, k := range tr.container.HeadFields {
 		if i >= len(h) {
 			break
 		}
 		if h[i] != "" {
-			tr.head[k] = h[i]
+			tr.Head[k] = h[i]
 		}
 	}
-	if d != nil {
-		tr.data = d
-	}
-	if ts != nil {
-		tr.timeStamp = ts
-	}
 }
 
 // basic container implementation
@@ -107,7 +64,7 @@ func Tracks(db *sql.Storage) *Container {
 	return &Container{container_definition, db}
 }
 
-func (cont *Container) Get(id lib.Ident) Track {
+func (cont *Container) Get(id lib.Ident) *Track {
 	db := cont.Storage
 	qu := lib.Map{
 		"schema":    db.Schema,
@@ -122,7 +79,7 @@ func (cont *Container) Get(id lib.Ident) Track {
 	return tr
 }
 
-func (cont *Container) Query(headValues lib.StrSlice) Track {
+func (cont *Container) Query(headValues lib.StrSlice) *Track {
 	db := cont.Storage
 	data := lib.Map{
 		"schema":    db.Schema,
@@ -138,27 +95,26 @@ func (cont *Container) Query(headValues lib.StrSlice) Track {
 	return tr
 }
 
-func (cont *Container) NewTrack(h []string, data lib.Map) Track {
+func (cont *Container) NewTrack(h []string, data lib.Map) *Track {
 	tr := cont.ItemFactory(cont, h...)
 	//tr.SetData(data)
 	cont.Insert(tr)
 	return tr
 }
 
-func (cont *Container) Save(t Track) lib.Ident {
+func (cont *Container) Save(t *Track) lib.Ident {
 	return 0
 }
 
-func (cont *Container) Insert(tr Track) lib.Ident {
+func (cont *Container) Insert(tr *Track) lib.Ident {
 	var columns []string
 	var values []any
-	head := tr.Head()
 	for _, k := range cont.HeadFields {
 		columns = append(columns, k)
-		values = append(values, head[k])
+		values = append(values, tr.Head[k])
 	}
 	columns = append(columns, "Data")
-	b, _ := json.Marshal(tr.Data())
+	b, _ := json.Marshal(tr.Data)
 	values = append(values, b)
 	db := cont.Storage
 	data := lib.Map{
@@ -180,8 +136,8 @@ func (cont *Container) Insert(tr Track) lib.Ident {
 	}
 	if err := db.Query(proc, sql, values...); err == nil {
 		//tr.Update(&TrackTemplate{TrackId: trid, TimeStamp: ts})
-		tr.SetTrackId(trid)
+		tr.TrackId = trid
-		tr.SetTimeStamp(ts)
+		tr.TimeStamp = ts
 		return trid
 	}
 	return 0

tests/storage_test.go

@@ -69,8 +69,8 @@ func TrackingTest(t *testing.T, cfg *sql.Cfg, db *sql.Storage) {
 	cont := tracking.Tracks(db)
 	cont.CreateTable()
 	track := cont.NewTrack(lib.StrSlice{"t01", "john"}, nil)
-	t.AssertEqual(track.TrackId(), lib.Ident(1))
+	t.AssertEqual(track.TrackId, lib.Ident(1))
-	t.AssertEqual(track.TimeStamp().Year(), time.Now().Year())
+	t.AssertEqual(track.TimeStamp.Year(), time.Now().Year())
 	//fmt.Printf("%+v\n", track.TimeStamp())
 	tr2 := cont.Get(1)
 	//tr2 := cont.Query(lib.StrSlice{"", "john"})
@@ -83,7 +83,7 @@ func MessageTest(t *testing.T, cfg *sql.Cfg, db *sql.Storage) {
 	cont := message.Messages(db)
 	cont.CreateTable()
 	msg := message.New(cont, "", "data")
-	t.AssertEqual(msg.TrackId(), lib.Ident(1))
+	t.AssertEqual(msg.TrackId, lib.Ident(1))
 	t.AssertEqual(msg.Domain(), "scopes")
 }