evcc-io/meter/meter_decorators.go

package meter

// Code generated by github.com/evcc-io/evcc/cmd/tools/decorate.go. DO NOT EDIT.

import (
	"reflect"

	"github.com/evcc-io/evcc/api"
)

func decorateMeter(base api.Meter, meterEnergy func() (float64, error), phaseCurrents func() (float64, float64, float64, error), phaseVoltages func() (float64, float64, float64, error), phasePowers func() (float64, float64, float64, error), maxACPowerGetter func() float64) api.Meter {
	caps := make(map[reflect.Type]any)

	if meterEnergy != nil {
		caps[reflect.TypeFor[api.MeterEnergy]()] = &decorateMeterMeterEnergyImpl{meterEnergy: meterEnergy}
	}

	if phaseCurrents != nil {
		caps[reflect.TypeFor[api.PhaseCurrents]()] = &decorateMeterPhaseCurrentsImpl{phaseCurrents: phaseCurrents}
	}

	if phaseVoltages != nil {
		caps[reflect.TypeFor[api.PhaseVoltages]()] = &decorateMeterPhaseVoltagesImpl{phaseVoltages: phaseVoltages}
	}

	if phasePowers != nil {
		caps[reflect.TypeFor[api.PhasePowers]()] = &decorateMeterPhasePowersImpl{phasePowers: phasePowers}
	}

	if maxACPowerGetter != nil {
		caps[reflect.TypeFor[api.MaxACPowerGetter]()] = &decorateMeterMaxACPowerGetterImpl{maxACPowerGetter: maxACPowerGetter}
	}

	if len(caps) == 0 {
		return base
	}

	return &decorateMeterCapable{Meter: base, caps: caps}
}

type decorateMeterCapable struct {
	api.Meter
	caps map[reflect.Type]any
}

func (d *decorateMeterCapable) Capability(typ reflect.Type) (any, bool) {
	c, ok := d.caps[typ]
	if !ok && reflect.TypeOf(d).Implements(typ) {
		return d, true
	}
	return c, ok
}

type decorateMeterMaxACPowerGetterImpl struct {
	maxACPowerGetter func() float64
}

func (impl *decorateMeterMaxACPowerGetterImpl) MaxACPower() float64 {
	return impl.maxACPowerGetter()
}

type decorateMeterMeterEnergyImpl struct {
	meterEnergy func() (float64, error)
}

func (impl *decorateMeterMeterEnergyImpl) TotalEnergy() (float64, error) {
	return impl.meterEnergy()
}

type decorateMeterPhaseCurrentsImpl struct {
	phaseCurrents func() (float64, float64, float64, error)
}

func (impl *decorateMeterPhaseCurrentsImpl) Currents() (float64, float64, float64, error) {
	return impl.phaseCurrents()
}

type decorateMeterPhasePowersImpl struct {
	phasePowers func() (float64, float64, float64, error)
}

func (impl *decorateMeterPhasePowersImpl) Powers() (float64, float64, float64, error) {
	return impl.phasePowers()
}

type decorateMeterPhaseVoltagesImpl struct {
	phaseVoltages func() (float64, float64, float64, error)
}

func (impl *decorateMeterPhaseVoltagesImpl) Voltages() (float64, float64, float64, error) {
	return impl.phaseVoltages()
}

func decorateMeterBattery(base api.Meter, meterEnergy func() (float64, error), battery func() (float64, error), batteryCapacity func() float64, batterySocLimiter func() (float64, float64), batteryPowerLimiter func() (float64, float64), batteryController func(api.BatteryMode) error) api.Meter {
	caps := make(map[reflect.Type]any)

	if meterEnergy != nil {
		caps[reflect.TypeFor[api.MeterEnergy]()] = &decorateMeterBatteryMeterEnergyImpl{meterEnergy: meterEnergy}
	}

	if battery != nil {
		caps[reflect.TypeFor[api.Battery]()] = &decorateMeterBatteryBatteryImpl{battery: battery}
	}

	if batteryCapacity != nil {
		caps[reflect.TypeFor[api.BatteryCapacity]()] = &decorateMeterBatteryBatteryCapacityImpl{batteryCapacity: batteryCapacity}
	}

	if batterySocLimiter != nil {
		caps[reflect.TypeFor[api.BatterySocLimiter]()] = &decorateMeterBatteryBatterySocLimiterImpl{batterySocLimiter: batterySocLimiter}
	}

	if batteryPowerLimiter != nil {
		caps[reflect.TypeFor[api.BatteryPowerLimiter]()] = &decorateMeterBatteryBatteryPowerLimiterImpl{batteryPowerLimiter: batteryPowerLimiter}
	}

	if batteryController != nil {
		caps[reflect.TypeFor[api.BatteryController]()] = &decorateMeterBatteryBatteryControllerImpl{batteryController: batteryController}
	}

	if len(caps) == 0 {
		return base
	}

	return &decorateMeterBatteryCapable{Meter: base, caps: caps}
}

type decorateMeterBatteryCapable struct {
	api.Meter
	caps map[reflect.Type]any
}

func (d *decorateMeterBatteryCapable) Capability(typ reflect.Type) (any, bool) {
	c, ok := d.caps[typ]
	if !ok && reflect.TypeOf(d).Implements(typ) {
		return d, true
	}
	return c, ok
}

type decorateMeterBatteryBatteryImpl struct {
	battery func() (float64, error)
}

func (impl *decorateMeterBatteryBatteryImpl) Soc() (float64, error) {
	return impl.battery()
}

type decorateMeterBatteryBatteryCapacityImpl struct {
	batteryCapacity func() float64
}

func (impl *decorateMeterBatteryBatteryCapacityImpl) Capacity() float64 {
	return impl.batteryCapacity()
}

type decorateMeterBatteryBatteryControllerImpl struct {
	batteryController func(api.BatteryMode) error
}

func (impl *decorateMeterBatteryBatteryControllerImpl) SetBatteryMode(p0 api.BatteryMode) error {
	return impl.batteryController(p0)
}

type decorateMeterBatteryBatteryPowerLimiterImpl struct {
	batteryPowerLimiter func() (float64, float64)
}

func (impl *decorateMeterBatteryBatteryPowerLimiterImpl) GetPowerLimits() (float64, float64) {
	return impl.batteryPowerLimiter()
}

type decorateMeterBatteryBatterySocLimiterImpl struct {
	batterySocLimiter func() (float64, float64)
}

func (impl *decorateMeterBatteryBatterySocLimiterImpl) GetSocLimits() (float64, float64) {
	return impl.batterySocLimiter()
}

type decorateMeterBatteryMeterEnergyImpl struct {
	meterEnergy func() (float64, error)
}

func (impl *decorateMeterBatteryMeterEnergyImpl) TotalEnergy() (float64, error) {
	return impl.meterEnergy()
}