add remove driver function

models/bus.go

@@ -0,0 +1,56 @@
+package models
+
+import "slices"
+
+// bus model
+type Bus struct {
+	Name    string `json:"name"`
+	Address []uint `json:"address,omitempty"` // address of bus
+	Topic   *Topic `json:"topic,omitempty"`   // address of bus
+}
+
+func (b *Bus) AddAddress(address ...uint) {
+	for _, a := range address {
+		if slices.Contains(b.Address, a) {
+			continue
+		}
+		b.Address = append(b.Address, a)
+		slices.Sort(b.Address)
+	}
+}
+
+func (b *Bus) AddSubscription(sub ...string) {
+	if b.Topic == nil {
+		b.Topic = &Topic{}
+	}
+	b.Topic.AddSubscription(sub...)
+}
+
+func (b *Bus) AddPublish(pub ...string) {
+	if b.Topic == nil {
+		b.Topic = &Topic{}
+	}
+	b.Topic.AddPublish(pub...)
+}
+
+func (b *Bus) RemoveAddress(address ...uint) {
+	if len(b.Address) == 1 {
+		b.Address = []uint{}
+		return
+	}
+	for _, toDelete := range address {
+		for i, a := range b.Address {
+			if a == toDelete {
+				b.Address = slices.Delete(b.Address, i, i+1)
+			}
+		}
+	}
+}
+
+func (b *Bus) RemoveSubscription(sub ...string) {
+	b.Topic.RemoveSubscription(sub...)
+}
+
+func (b *Bus) RemovePublish(pub ...string) {
+	b.Topic.RemovePublish(pub...)
+}

models/driver.go

@@ -0,0 +1,80 @@
+package models
+
+import "slices"
+
+// driver model
+type Driver struct {
+	Type  string `json:"type"`            // driver type name of driver in collection
+	Buses []*Bus `json:"buses,omitempty"` // name of driver bus
+}
+
+func (d *Driver) AddNewBus(name string) *Bus {
+	for _, b := range d.Buses {
+		if b.Name == name {
+			return b
+		}
+	}
+	b := &Bus{Name: name}
+	d.Buses = append(d.Buses, b)
+	return b
+}
+
+func (d *Driver) AddBuses(buses []*Bus) {
+next:
+	for _, newBus := range buses {
+		for _, currentBus := range d.Buses {
+			if currentBus.Name != newBus.Name {
+				continue
+			}
+			currentBus.AddAddress(newBus.Address...)
+			if newBus.Topic == nil {
+				continue next
+			}
+			currentBus.AddSubscription(newBus.Topic.Subscribe...)
+			currentBus.AddPublish(newBus.Topic.Publish...)
+			continue next
+		}
+		d.Buses = append(d.Buses, newBus)
+	}
+}
+
+func (d *Driver) RemoveBus(bus *Bus) {
+	for _, currentBus := range d.Buses {
+		if currentBus.Name != bus.Name {
+			continue
+		}
+
+		currentBus.RemoveAddress(bus.Address...)
+		if bus.Topic != nil {
+			currentBus.RemoveSubscription(bus.Topic.Subscribe...)
+			currentBus.RemovePublish(bus.Topic.Publish...)
+			if len(currentBus.Address) == 0 {
+				var remove bool = true
+				if currentBus.Topic != nil {
+					remove = len(currentBus.Topic.Subscribe) == 0 && len(currentBus.Topic.Publish) == 0
+				}
+				if remove {
+					if len(d.Buses) == 1 {
+						d.Buses = []*Bus{}
+						return
+					}
+					for i, b := range d.Buses {
+						if bus.Name == b.Name {
+							d.Buses = slices.Delete(d.Buses, i, i+1)
+						}
+					}
+				}
+			}
+			break
+		}
+	}
+}
+
+func (d *Driver) GetBus(name string) *Bus {
+	for _, b := range d.Buses {
+		if b.Name == name {
+			return b
+		}
+	}
+	return nil
+}

models/drivers.go

@@ -3,23 +3,19 @@ package models
 // collection of drivers ordered in map
 type Drivers map[string]*Driver
 
-// driver model
+func (d *Drivers) AddNewDriver(typ string) *Driver {
-type Driver struct {
+	if drv, ok := (*d)[typ]; ok {
-	Type    string `json:"type,omitempty"` // driver type name of driver in collection
+		return drv
-	Bus     string `json:"bus"`            // name of driver bus
+	}
-	Address uint   `json:"address"`        // address of bus
+	(*d)[typ] = &Driver{Type: typ}
+	return (*d)[typ]
 }
 
-// returns a new collection of drivers
+func (d *Drivers) AddDriver(drv *Driver) {
-func NewDrivers() Drivers {
+	if driver, ok := (*d)[drv.Type]; ok {
-	return make(Drivers)
+		driver.AddBuses(drv.Buses)
-}
+		(*d)[drv.Type] = driver
-
+		return
-// Add new driver to driver collection
-// typ is the name of the driver in driver collection
-func (d *Drivers) AddDriver(typ, bus string, address uint) {
-	(*d)[typ] = &Driver{
-		Bus:     bus,
-		Address: address,
 	}
+	(*d)[drv.Type] = drv
 }

models/get.go

@@ -7,10 +7,10 @@ type Get struct {
 	Uuid     uuid.UUID `json:"uuid"`               //  universally unique identifier
 	Path     string    `json:"path"`               // dbm path
 	Query    *Query    `json:"query,omitempty"`    // query paramater
-	Drivers  *Drivers  `json:"driver,omitempty"`   // assigned drivers
+	Drivers  *Drivers  `json:"drivers,omitempty"`  // assigned drivers
 	Type     Type      `json:"type,omitempty"`     // dbm datatype
 	Value    any       `json:"value,omitempty"`    // dbm value
-	HasChild bool      `json:"hasChild,omitempty"` // inidicates path has child/ren
+	HasChild bool      `json:"hasChild,omitempty"` // inidicates path has children
 	Rights   Rights    `json:"rights,omitempty"`   // dbm read /write rights
 }
 

models/response.go

@@ -49,7 +49,7 @@ func (r *Response) AddUnsubscription(sub Subscription) {
 }
 
 // Add new data publish to response
-func (r *Response) AddUPublish(pub Publish) {
+func (r *Response) AddPublish(pub Publish) {
 	r.Publish = append(r.Publish, pub)
 }
 

models/set.go

@@ -12,6 +12,7 @@ type Set struct {
 	Value    any       `json:"value,omitempty"`    // dbm value
 	Rights   Rights    `json:"rights,omitempty"`   // dbm read /write rights
 	Create   bool      `json:"create,omitempty"`   // dbm create new datapoint
+	HasChild bool      `json:"hasChild,omitempty"` // inidicates path has children
 	Updated  bool      `json:"-"`
 }
 
@@ -36,10 +37,31 @@ func (s *Set) New(path string, typ Type, value any, rights Rights) {
 }
 
 // sets new driver typ with bus and address
-func (s *Set) NewDriver(typ, bus string, address uint) {
+func (s *Set) NewDriverAddress(typ, bus string, address uint) {
-	s.Driver = &Driver{
+	if s.Drivers == nil {
-		Type:    typ,
+		s.Drivers = &Drivers{}
-		Bus:     bus,
-		Address: address,
 	}
+	drv := s.Drivers.AddNewDriver(typ)
+	b := drv.AddNewBus(bus)
+	b.AddAddress(address)
+}
+
+// sets new driver typ with bus and subscription
+func (s *Set) NewDriverSubscribe(typ, bus string, sub string) {
+	if s.Drivers == nil {
+		s.Drivers = &Drivers{}
+	}
+	drv := s.Drivers.AddNewDriver(typ)
+	b := drv.AddNewBus(bus)
+	b.AddSubscription(sub)
+}
+
+// sets new driver typ with bus and publish
+func (s *Set) NewDriverPublish(typ, bus string, pub string) {
+	if s.Drivers == nil {
+		s.Drivers = &Drivers{}
+	}
+	drv := s.Drivers.AddNewDriver(typ)
+	b := drv.AddNewBus(bus)
+	b.AddPublish(pub)
 }

models/subscription.go

@@ -8,7 +8,8 @@ type Subscription struct {
 	Path     string    `json:"path,omitempty"`     // dbm path
 	Depth    uint      `json:"depth,omitempty"`    // depth of subscriptions from found path or uuid
 	Value    any       `json:"value,omitempty"`    // current value
-	HasChild bool      `json:"hasChild,omitempty"` // inidicates path has child/ren
+	Rights   Rights    `json:"rights,omitempty"`   // read /write rights
+	HasChild bool      `json:"hasChild,omitempty"` // inidicates path has children
 	Drivers  *Drivers  `json:"drivers,omitempty"`  // assigned drivers
 	Driver   string    `json:"driver,omitempty"`   // driver type to assign this subscription
 	OnCreate bool      `json:"onCreate,omitempty"` // notify at datapoint creation

models/topic.go

@@ -0,0 +1,57 @@
+package models
+
+import "slices"
+
+// topic model
+type Topic struct {
+	Publish   []string `json:"publish,omitempty"`
+	Subscribe []string `json:"subscribe,omitempty"`
+}
+
+func (t *Topic) AddSubscription(subs ...string) {
+	for _, sub := range subs {
+		if slices.Contains(t.Subscribe, sub) {
+			continue
+		}
+		t.Subscribe = append(t.Subscribe, sub)
+		slices.Sort(t.Subscribe)
+	}
+}
+
+func (t *Topic) AddPublish(pubs ...string) {
+	for _, pub := range pubs {
+		if slices.Contains(t.Publish, pub) {
+			continue
+		}
+		t.Subscribe = append(t.Publish, pub)
+		slices.Sort(t.Publish)
+	}
+}
+
+func (t *Topic) RemoveSubscription(subs ...string) {
+	if len(t.Subscribe) == 1 {
+		t.Subscribe = []string{}
+		return
+	}
+	for _, toDelete := range subs {
+		for i, a := range t.Subscribe {
+			if a == toDelete {
+				t.Subscribe = slices.Delete(t.Subscribe, i, i+1)
+			}
+		}
+	}
+}
+
+func (t *Topic) RemovePublish(pubs ...string) {
+	if len(t.Publish) == 1 {
+		t.Publish = []string{}
+		return
+	}
+	for _, toDelete := range pubs {
+		for i, a := range t.Publish {
+			if a == toDelete {
+				t.Publish = slices.Delete(t.Publish, i, i+1)
+			}
+		}
+	}
+}

models/type.go

@@ -20,7 +20,7 @@ const (
 	LOU  Type = "LOU" // UINT64
 	F32  Type = "F32" // FLOAT32
 	F64  Type = "F64" // FLOAT64
-	STR  Type = "STRING" // STRING
+	STR  Type = "STR" // STRING
 )
 
 // dbm datatype model

utils/convert.go

@@ -36,8 +36,8 @@ func Float32From(v any) float32 {
 	case uint64:
 		return float32(val)
 	case string:
-		if i, err := strconv.Atoi(val); err == nil {
+		if f64, err := strconv.ParseFloat(val, 32); err == nil {
-			return float32(i)
+			return float32(f64)
 		}
 		return 0
 	default:
@@ -76,8 +76,8 @@ func Float64From(v any) float64 {
 	case uint64:
 		return float64(val)
 	case string:
-		if i, err := strconv.Atoi(val); err == nil {
+		if f64, err := strconv.ParseFloat(val, 32); err == nil {
-			return float64(i)
+			return f64
 		}
 		return 0
 	default:
@@ -433,7 +433,14 @@ func BoolFrom(v any) bool {
 	case float64:
 		return val >= 1
 	case string:
-		return strings.ToLower(val) == "false" || v == "0"
+		if strings.ToLower(val) == "true" {
+			return true
+		} else if strings.ToLower(val) == "false" {
+			return false
+		} else if i, err := strconv.Atoi(val); err == nil {
+			return i > 0
+		}
+		return false
 	default:
 		return false
 	}