Stefan/evcc-io
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Revert "chore: make decorate dependency-aware (#15434)"
Some checks failed
Release / call-build-workflow (push) Has been cancelled
Details
Release / Publish Docker :release (push) Has been cancelled
Details
Release / Github & APT (push) Has been cancelled
Details
Release / Demo (push) Has been cancelled
Details
Release / Hassio Addon (push) Has been cancelled
Details

Browse source 
This reverts commit 15a3deef0a.
This commit is contained in:
andig 2024-08-20 20:51:59 +02:00
parent d9dd50155f
commit d8aab205b1
30 changed files with 7149 additions and 5049 deletions
Download patch file Download diff file Expand all files Collapse all files

11
charger/abl_decorators.go
View file

@ -22,6 +22,17 @@ func decorateABLeMH(base *ABLeMH, meter func() (float64, error), phaseCurrents f
},
}
case meter == nil && phaseCurrents != nil:
return &struct {
*ABLeMH
api.PhaseCurrents
}{
ABLeMH: base,
PhaseCurrents: &decorateABLeMHPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && phaseCurrents != nil:
return &struct {
*ABLeMH

11
charger/alfen_decorators.go
View file

@ -22,6 +22,17 @@ func decorateAlfen(base *Alfen, phaseSwitcher func(int) error, phaseGetter func(
},
}
case phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Alfen
api.PhaseGetter
}{
Alfen: base,
PhaseGetter: &decorateAlfenPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case phaseGetter != nil && phaseSwitcher != nil:
return &struct {
*Alfen

500
charger/bender_decorators.go
View file

@ -22,6 +22,17 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery == nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*BenderCC
api.PhaseCurrents
}{
BenderCC: base,
PhaseCurrents: &decorateBenderCCPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case battery == nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*BenderCC
@ -37,6 +48,17 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery == nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*BenderCC
api.PhaseVoltages
}{
BenderCC: base,
PhaseVoltages: &decorateBenderCCPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*BenderCC
@ -52,6 +74,21 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery == nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*BenderCC
api.PhaseCurrents
api.PhaseVoltages
}{
BenderCC: base,
PhaseCurrents: &decorateBenderCCPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateBenderCCPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*BenderCC
@ -71,6 +108,17 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery == nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*BenderCC
api.MeterEnergy
}{
BenderCC: base,
MeterEnergy: &decorateBenderCCMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case battery == nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*BenderCC
@ -86,6 +134,21 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery == nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*BenderCC
api.MeterEnergy
api.PhaseCurrents
}{
BenderCC: base,
MeterEnergy: &decorateBenderCCMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateBenderCCPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case battery == nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*BenderCC
@ -105,6 +168,21 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery == nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*BenderCC
api.MeterEnergy
api.PhaseVoltages
}{
BenderCC: base,
MeterEnergy: &decorateBenderCCMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decorateBenderCCPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*BenderCC
@ -124,6 +202,25 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery == nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*BenderCC
api.MeterEnergy
api.PhaseCurrents
api.PhaseVoltages
}{
BenderCC: base,
MeterEnergy: &decorateBenderCCMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateBenderCCPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateBenderCCPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*BenderCC
@ -173,6 +270,21 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery != nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*BenderCC
api.Battery
api.PhaseCurrents
}{
BenderCC: base,
Battery: &decorateBenderCCBatteryImpl{
battery: battery,
},
PhaseCurrents: &decorateBenderCCPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case battery != nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*BenderCC
@ -192,6 +304,21 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery != nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*BenderCC
api.Battery
api.PhaseVoltages
}{
BenderCC: base,
Battery: &decorateBenderCCBatteryImpl{
battery: battery,
},
PhaseVoltages: &decorateBenderCCPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*BenderCC
@ -211,6 +338,25 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery != nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*BenderCC
api.Battery
api.PhaseCurrents
api.PhaseVoltages
}{
BenderCC: base,
Battery: &decorateBenderCCBatteryImpl{
battery: battery,
},
PhaseCurrents: &decorateBenderCCPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateBenderCCPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*BenderCC
@ -234,6 +380,21 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery != nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*BenderCC
api.Battery
api.MeterEnergy
}{
BenderCC: base,
Battery: &decorateBenderCCBatteryImpl{
battery: battery,
},
MeterEnergy: &decorateBenderCCMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case battery != nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*BenderCC
@ -253,6 +414,25 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery != nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*BenderCC
api.Battery
api.MeterEnergy
api.PhaseCurrents
}{
BenderCC: base,
Battery: &decorateBenderCCBatteryImpl{
battery: battery,
},
MeterEnergy: &decorateBenderCCMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateBenderCCPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case battery != nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*BenderCC
@ -276,6 +456,25 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery != nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*BenderCC
api.Battery
api.MeterEnergy
api.PhaseVoltages
}{
BenderCC: base,
Battery: &decorateBenderCCBatteryImpl{
battery: battery,
},
MeterEnergy: &decorateBenderCCMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decorateBenderCCPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*BenderCC
@ -299,6 +498,29 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery != nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*BenderCC
api.Battery
api.MeterEnergy
api.PhaseCurrents
api.PhaseVoltages
}{
BenderCC: base,
Battery: &decorateBenderCCBatteryImpl{
battery: battery,
},
MeterEnergy: &decorateBenderCCMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateBenderCCPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateBenderCCPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*BenderCC
@ -352,6 +574,21 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery == nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*BenderCC
api.Identifier
api.PhaseCurrents
}{
BenderCC: base,
Identifier: &decorateBenderCCIdentifierImpl{
identifier: identifier,
},
PhaseCurrents: &decorateBenderCCPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case battery == nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*BenderCC
@ -371,6 +608,21 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery == nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*BenderCC
api.Identifier
api.PhaseVoltages
}{
BenderCC: base,
Identifier: &decorateBenderCCIdentifierImpl{
identifier: identifier,
},
PhaseVoltages: &decorateBenderCCPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*BenderCC
@ -390,6 +642,25 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery == nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*BenderCC
api.Identifier
api.PhaseCurrents
api.PhaseVoltages
}{
BenderCC: base,
Identifier: &decorateBenderCCIdentifierImpl{
identifier: identifier,
},
PhaseCurrents: &decorateBenderCCPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateBenderCCPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*BenderCC
@ -413,6 +684,21 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery == nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*BenderCC
api.Identifier
api.MeterEnergy
}{
BenderCC: base,
Identifier: &decorateBenderCCIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateBenderCCMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case battery == nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*BenderCC
@ -432,6 +718,25 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery == nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*BenderCC
api.Identifier
api.MeterEnergy
api.PhaseCurrents
}{
BenderCC: base,
Identifier: &decorateBenderCCIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateBenderCCMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateBenderCCPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case battery == nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*BenderCC
@ -455,6 +760,25 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery == nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*BenderCC
api.Identifier
api.MeterEnergy
api.PhaseVoltages
}{
BenderCC: base,
Identifier: &decorateBenderCCIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateBenderCCMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decorateBenderCCPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*BenderCC
@ -478,6 +802,29 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery == nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*BenderCC
api.Identifier
api.MeterEnergy
api.PhaseCurrents
api.PhaseVoltages
}{
BenderCC: base,
Identifier: &decorateBenderCCIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateBenderCCMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateBenderCCPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateBenderCCPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*BenderCC
@ -539,6 +886,25 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery != nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*BenderCC
api.Battery
api.Identifier
api.PhaseCurrents
}{
BenderCC: base,
Battery: &decorateBenderCCBatteryImpl{
battery: battery,
},
Identifier: &decorateBenderCCIdentifierImpl{
identifier: identifier,
},
PhaseCurrents: &decorateBenderCCPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case battery != nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*BenderCC
@ -562,6 +928,25 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery != nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*BenderCC
api.Battery
api.Identifier
api.PhaseVoltages
}{
BenderCC: base,
Battery: &decorateBenderCCBatteryImpl{
battery: battery,
},
Identifier: &decorateBenderCCIdentifierImpl{
identifier: identifier,
},
PhaseVoltages: &decorateBenderCCPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*BenderCC
@ -585,6 +970,29 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery != nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*BenderCC
api.Battery
api.Identifier
api.PhaseCurrents
api.PhaseVoltages
}{
BenderCC: base,
Battery: &decorateBenderCCBatteryImpl{
battery: battery,
},
Identifier: &decorateBenderCCIdentifierImpl{
identifier: identifier,
},
PhaseCurrents: &decorateBenderCCPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateBenderCCPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*BenderCC
@ -612,6 +1020,25 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery != nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*BenderCC
api.Battery
api.Identifier
api.MeterEnergy
}{
BenderCC: base,
Battery: &decorateBenderCCBatteryImpl{
battery: battery,
},
Identifier: &decorateBenderCCIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateBenderCCMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case battery != nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*BenderCC
@ -635,6 +1062,29 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery != nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*BenderCC
api.Battery
api.Identifier
api.MeterEnergy
api.PhaseCurrents
}{
BenderCC: base,
Battery: &decorateBenderCCBatteryImpl{
battery: battery,
},
Identifier: &decorateBenderCCIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateBenderCCMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateBenderCCPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case battery != nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*BenderCC
@ -662,6 +1112,29 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery != nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*BenderCC
api.Battery
api.Identifier
api.MeterEnergy
api.PhaseVoltages
}{
BenderCC: base,
Battery: &decorateBenderCCBatteryImpl{
battery: battery,
},
Identifier: &decorateBenderCCIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateBenderCCMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decorateBenderCCPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*BenderCC
@ -689,6 +1162,33 @@ func decorateBenderCC(base *BenderCC, meter func() (float64, error), phaseCurren
},
}
case battery != nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*BenderCC
api.Battery
api.Identifier
api.MeterEnergy
api.PhaseCurrents
api.PhaseVoltages
}{
BenderCC: base,
Battery: &decorateBenderCCBatteryImpl{
battery: battery,
},
Identifier: &decorateBenderCCIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateBenderCCMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateBenderCCPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateBenderCCPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*BenderCC

86
charger/cfos_decorators.go
View file

@ -22,6 +22,17 @@ func decorateCfos(base *CfosPowerBrain, meter func() (float64, error), meterEner
},
}
case meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher == nil:
return &struct {
*CfosPowerBrain
api.MeterEnergy
}{
CfosPowerBrain: base,
MeterEnergy: &decorateCfosMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher == nil:
return &struct {
*CfosPowerBrain
@ -37,6 +48,17 @@ func decorateCfos(base *CfosPowerBrain, meter func() (float64, error), meterEner
},
}
case meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher == nil:
return &struct {
*CfosPowerBrain
api.PhaseCurrents
}{
CfosPowerBrain: base,
PhaseCurrents: &decorateCfosPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher == nil:
return &struct {
*CfosPowerBrain
@ -52,6 +74,21 @@ func decorateCfos(base *CfosPowerBrain, meter func() (float64, error), meterEner
},
}
case meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher == nil:
return &struct {
*CfosPowerBrain
api.MeterEnergy
api.PhaseCurrents
}{
CfosPowerBrain: base,
MeterEnergy: &decorateCfosMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateCfosPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher == nil:
return &struct {
*CfosPowerBrain
@ -97,6 +134,21 @@ func decorateCfos(base *CfosPowerBrain, meter func() (float64, error), meterEner
},
}
case meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher != nil:
return &struct {
*CfosPowerBrain
api.MeterEnergy
api.PhaseSwitcher
}{
CfosPowerBrain: base,
MeterEnergy: &decorateCfosMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseSwitcher: &decorateCfosPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher != nil:
return &struct {
*CfosPowerBrain
@ -116,6 +168,21 @@ func decorateCfos(base *CfosPowerBrain, meter func() (float64, error), meterEner
},
}
case meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher != nil:
return &struct {
*CfosPowerBrain
api.PhaseCurrents
api.PhaseSwitcher
}{
CfosPowerBrain: base,
PhaseCurrents: &decorateCfosPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateCfosPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher != nil:
return &struct {
*CfosPowerBrain
@ -135,6 +202,25 @@ func decorateCfos(base *CfosPowerBrain, meter func() (float64, error), meterEner
},
}
case meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher != nil:
return &struct {
*CfosPowerBrain
api.MeterEnergy
api.PhaseCurrents
api.PhaseSwitcher
}{
CfosPowerBrain: base,
MeterEnergy: &decorateCfosMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateCfosPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateCfosPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher != nil:
return &struct {
*CfosPowerBrain

12
charger/charger.go
View file

@ -23,7 +23,7 @@ func init() {
registry.Add(api.Custom, NewConfigurableFromConfig)
}
//go:generate go run ../cmd/tools/decorate.go -f decorateCustom -b *Charger -r api.Charger -t "api.ChargerEx,MaxCurrentMillis,func(float64) error" -t "api.Identifier,Identify,func() (string, error)" -t "api.PhaseSwitcher,Phases1p3p,func(int) error" -t "api.Resurrector,WakeUp,func() error" -t "api.Battery,Soc,func() (float64, error)" -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)" -t "api.PhaseVoltages,Voltages,func() (float64, float64, float64, error)"
//go:generate go run ../cmd/tools/decorate.go -f decorateCustom -b *Charger -r api.Charger -t "api.ChargerEx,MaxCurrentMillis,func(float64) error" -t "api.Identifier,Identify,func() (string, error)" -t "api.PhaseSwitcher,Phases1p3p,func(int) error" -t "api.Resurrector,WakeUp,func() error" -t "api.Battery,Soc,func() (float64, error)" -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)"
// NewConfigurableFromConfig creates a new configurable charger
func NewConfigurableFromConfig(other map[string]interface{}) (api.Charger, error) {
@ -40,7 +40,8 @@ func NewConfigurableFromConfig(other map[string]interface{}) (api.Charger, error
Power *provider.Config
Energy *provider.Config
Currents, Voltages, Powers []provider.Config
// phase values, currently not supported (https://github.com/evcc-io/evcc/pull/14546)
// Currents, Voltages, Powers []provider.Config
}
if err := util.DecodeOther(other, &cc); err != nil {
@ -136,12 +137,7 @@ func NewConfigurableFromConfig(other map[string]interface{}) (api.Charger, error
return nil, err
}
currentsG, voltagesG, _, err := meter.BuildPhaseMeasurements(cc.Currents, cc.Voltages, nil)
if err != nil {
return nil, err
}
return decorateCustom(c, maxcurrentmillis, identify, phases1p3p, wakeup, soc, powerG, energyG, currentsG, voltagesG), nil
return decorateCustom(c, maxcurrentmillis, identify, phases1p3p, wakeup, soc, powerG, energyG), nil
}
// NewConfigurable creates a new charger

5230
charger/charger_decorators.go
View file

File diff suppressed because it is too large Load diff

26
charger/eebus_decorators.go
View file

@ -22,6 +22,17 @@ func decorateEEBus(base *EEBus, meter func() (float64, error), phaseCurrents fun
},
}
case chargeRater == nil && meter == nil && phaseCurrents != nil:
return &struct {
*EEBus
api.PhaseCurrents
}{
EEBus: base,
PhaseCurrents: &decorateEEBusPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargeRater == nil && meter != nil && phaseCurrents != nil:
return &struct {
*EEBus
@ -63,6 +74,21 @@ func decorateEEBus(base *EEBus, meter func() (float64, error), phaseCurrents fun
},
}
case chargeRater != nil && meter == nil && phaseCurrents != nil:
return &struct {
*EEBus
api.ChargeRater
api.PhaseCurrents
}{
EEBus: base,
ChargeRater: &decorateEEBusChargeRaterImpl{
chargeRater: chargeRater,
},
PhaseCurrents: &decorateEEBusPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargeRater != nil && meter != nil && phaseCurrents != nil:
return &struct {
*EEBus

26
charger/em2go_decorators.go
View file

@ -48,6 +48,32 @@ func decorateEm2Go(base *Em2Go, chargerEx func(float64) error, phaseSwitcher fun
},
}
case chargerEx == nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Em2Go
api.PhaseGetter
}{
Em2Go: base,
PhaseGetter: &decorateEm2GoPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case chargerEx != nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Em2Go
api.ChargerEx
api.PhaseGetter
}{
Em2Go: base,
ChargerEx: &decorateEm2GoChargerExImpl{
chargerEx: chargerEx,
},
PhaseGetter: &decorateEm2GoPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case chargerEx == nil && phaseGetter != nil && phaseSwitcher != nil:
return &struct {
*Em2Go

500
charger/evsewifi_decorators.go
View file

@ -22,6 +22,17 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
api.MeterEnergy
}{
EVSEWifi: base,
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
@ -37,6 +48,17 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
api.PhaseCurrents
}{
EVSEWifi: base,
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
@ -52,6 +74,21 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
api.MeterEnergy
api.PhaseCurrents
}{
EVSEWifi: base,
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
@ -71,6 +108,17 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
api.PhaseVoltages
}{
EVSEWifi: base,
PhaseVoltages: &decorateEVSEPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
@ -86,6 +134,21 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
api.MeterEnergy
api.PhaseVoltages
}{
EVSEWifi: base,
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decorateEVSEPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
@ -105,6 +168,21 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
api.PhaseCurrents
api.PhaseVoltages
}{
EVSEWifi: base,
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateEVSEPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
@ -124,6 +202,25 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
api.MeterEnergy
api.PhaseCurrents
api.PhaseVoltages
}{
EVSEWifi: base,
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateEVSEPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
@ -173,6 +270,21 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.MeterEnergy
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
chargerEx: chargerEx,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
@ -192,6 +304,21 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.PhaseCurrents
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
chargerEx: chargerEx,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
@ -211,6 +338,25 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.MeterEnergy
api.PhaseCurrents
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
chargerEx: chargerEx,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
@ -234,6 +380,21 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.PhaseVoltages
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
chargerEx: chargerEx,
},
PhaseVoltages: &decorateEVSEPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
@ -253,6 +414,25 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.MeterEnergy
api.PhaseVoltages
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
chargerEx: chargerEx,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decorateEVSEPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
@ -276,6 +456,25 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.PhaseCurrents
api.PhaseVoltages
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
chargerEx: chargerEx,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateEVSEPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
@ -299,6 +498,29 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.MeterEnergy
api.PhaseCurrents
api.PhaseVoltages
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
chargerEx: chargerEx,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateEVSEPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
@ -352,6 +574,21 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
api.Identifier
api.MeterEnergy
}{
EVSEWifi: base,
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
@ -371,6 +608,21 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
api.Identifier
api.PhaseCurrents
}{
EVSEWifi: base,
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
@ -390,6 +642,25 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
api.Identifier
api.MeterEnergy
api.PhaseCurrents
}{
EVSEWifi: base,
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
@ -413,6 +684,21 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
api.Identifier
api.PhaseVoltages
}{
EVSEWifi: base,
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
PhaseVoltages: &decorateEVSEPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
@ -432,6 +718,25 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
api.Identifier
api.MeterEnergy
api.PhaseVoltages
}{
EVSEWifi: base,
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decorateEVSEPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
@ -455,6 +760,25 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
api.Identifier
api.PhaseCurrents
api.PhaseVoltages
}{
EVSEWifi: base,
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateEVSEPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
@ -478,6 +802,29 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
api.Identifier
api.MeterEnergy
api.PhaseCurrents
api.PhaseVoltages
}{
EVSEWifi: base,
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateEVSEPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
@ -539,6 +886,25 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.Identifier
api.MeterEnergy
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
chargerEx: chargerEx,
},
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
@ -562,6 +928,25 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.Identifier
api.PhaseCurrents
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
chargerEx: chargerEx,
},
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
@ -585,6 +970,29 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.Identifier
api.MeterEnergy
api.PhaseCurrents
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
chargerEx: chargerEx,
},
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*EVSEWifi
@ -612,6 +1020,25 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.Identifier
api.PhaseVoltages
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
chargerEx: chargerEx,
},
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
PhaseVoltages: &decorateEVSEPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
@ -635,6 +1062,29 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.Identifier
api.MeterEnergy
api.PhaseVoltages
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
chargerEx: chargerEx,
},
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decorateEVSEPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
@ -662,6 +1112,29 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.Identifier
api.PhaseCurrents
api.PhaseVoltages
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
chargerEx: chargerEx,
},
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateEVSEPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
@ -689,6 +1162,33 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.Identifier
api.MeterEnergy
api.PhaseCurrents
api.PhaseVoltages
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
chargerEx: chargerEx,
},
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateEVSEPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*EVSEWifi

37
charger/hardybarth-salia_decorators.go
View file

@ -22,6 +22,17 @@ func decorateSalia(base *Salia, meter func() (float64, error), meterEnergy func(
},
}
case meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Salia
api.MeterEnergy
}{
Salia: base,
MeterEnergy: &decorateSaliaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Salia
@ -37,6 +48,17 @@ func decorateSalia(base *Salia, meter func() (float64, error), meterEnergy func(
},
}
case meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Salia
api.PhaseCurrents
}{
Salia: base,
PhaseCurrents: &decorateSaliaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Salia
@ -52,6 +74,21 @@ func decorateSalia(base *Salia, meter func() (float64, error), meterEnergy func(
},
}
case meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Salia
api.MeterEnergy
api.PhaseCurrents
}{
Salia: base,
MeterEnergy: &decorateSaliaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateSaliaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Salia

37
charger/innogy_decorators.go
View file

@ -10,6 +10,43 @@ func decorateInnogy(base *Innogy, meterEnergy func() (float64, error), phaseVolt
switch {
case meterEnergy == nil && phaseVoltages == nil:
return base
case meterEnergy != nil && phaseVoltages == nil:
return &struct {
*Innogy
api.MeterEnergy
}{
Innogy: base,
MeterEnergy: &decorateInnogyMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case meterEnergy == nil && phaseVoltages != nil:
return &struct {
*Innogy
api.PhaseVoltages
}{
Innogy: base,
PhaseVoltages: &decorateInnogyPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case meterEnergy != nil && phaseVoltages != nil:
return &struct {
*Innogy
api.MeterEnergy
api.PhaseVoltages
}{
Innogy: base,
MeterEnergy: &decorateInnogyMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decorateInnogyPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
}
return nil

634
charger/keba-modbus_decorators.go
View file

@ -22,6 +22,17 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseGetter == nil && phaseSwitcher == nil:
return &struct {
*Keba
api.MeterEnergy
}{
Keba: base,
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseGetter == nil && phaseSwitcher == nil:
return &struct {
*Keba
@ -37,6 +48,17 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseGetter == nil && phaseSwitcher == nil:
return &struct {
*Keba
api.PhaseCurrents
}{
Keba: base,
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseGetter == nil && phaseSwitcher == nil:
return &struct {
*Keba
@ -52,6 +74,21 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseGetter == nil && phaseSwitcher == nil:
return &struct {
*Keba
api.MeterEnergy
api.PhaseCurrents
}{
Keba: base,
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseGetter == nil && phaseSwitcher == nil:
return &struct {
*Keba
@ -97,6 +134,21 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseGetter == nil && phaseSwitcher == nil:
return &struct {
*Keba
api.Identifier
api.MeterEnergy
}{
Keba: base,
Identifier: &decorateKebaIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseGetter == nil && phaseSwitcher == nil:
return &struct {
*Keba
@ -116,6 +168,21 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseGetter == nil && phaseSwitcher == nil:
return &struct {
*Keba
api.Identifier
api.PhaseCurrents
}{
Keba: base,
Identifier: &decorateKebaIdentifierImpl{
identifier: identifier,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseGetter == nil && phaseSwitcher == nil:
return &struct {
*Keba
@ -135,6 +202,25 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseGetter == nil && phaseSwitcher == nil:
return &struct {
*Keba
api.Identifier
api.MeterEnergy
api.PhaseCurrents
}{
Keba: base,
Identifier: &decorateKebaIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseGetter == nil && phaseSwitcher == nil:
return &struct {
*Keba
@ -184,6 +270,21 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseGetter == nil && phaseSwitcher != nil:
return &struct {
*Keba
api.MeterEnergy
api.PhaseSwitcher
}{
Keba: base,
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseSwitcher: &decorateKebaPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseGetter == nil && phaseSwitcher != nil:
return &struct {
*Keba
@ -203,6 +304,21 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseGetter == nil && phaseSwitcher != nil:
return &struct {
*Keba
api.PhaseCurrents
api.PhaseSwitcher
}{
Keba: base,
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateKebaPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseGetter == nil && phaseSwitcher != nil:
return &struct {
*Keba
@ -222,6 +338,25 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseGetter == nil && phaseSwitcher != nil:
return &struct {
*Keba
api.MeterEnergy
api.PhaseCurrents
api.PhaseSwitcher
}{
Keba: base,
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateKebaPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseGetter == nil && phaseSwitcher != nil:
return &struct {
*Keba
@ -279,6 +414,25 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseGetter == nil && phaseSwitcher != nil:
return &struct {
*Keba
api.Identifier
api.MeterEnergy
api.PhaseSwitcher
}{
Keba: base,
Identifier: &decorateKebaIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseSwitcher: &decorateKebaPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseGetter == nil && phaseSwitcher != nil:
return &struct {
*Keba
@ -302,6 +456,25 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseGetter == nil && phaseSwitcher != nil:
return &struct {
*Keba
api.Identifier
api.PhaseCurrents
api.PhaseSwitcher
}{
Keba: base,
Identifier: &decorateKebaIdentifierImpl{
identifier: identifier,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateKebaPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseGetter == nil && phaseSwitcher != nil:
return &struct {
*Keba
@ -325,6 +498,29 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseGetter == nil && phaseSwitcher != nil:
return &struct {
*Keba
api.Identifier
api.MeterEnergy
api.PhaseCurrents
api.PhaseSwitcher
}{
Keba: base,
Identifier: &decorateKebaIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateKebaPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseGetter == nil && phaseSwitcher != nil:
return &struct {
*Keba
@ -352,6 +548,310 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Keba
api.PhaseGetter
}{
Keba: base,
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Keba
api.Meter
api.PhaseGetter
}{
Keba: base,
Meter: &decorateKebaMeterImpl{
meter: meter,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Keba
api.MeterEnergy
api.PhaseGetter
}{
Keba: base,
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Keba
api.Meter
api.MeterEnergy
api.PhaseGetter
}{
Keba: base,
Meter: &decorateKebaMeterImpl{
meter: meter,
},
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Keba
api.PhaseCurrents
api.PhaseGetter
}{
Keba: base,
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Keba
api.Meter
api.PhaseCurrents
api.PhaseGetter
}{
Keba: base,
Meter: &decorateKebaMeterImpl{
meter: meter,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Keba
api.MeterEnergy
api.PhaseCurrents
api.PhaseGetter
}{
Keba: base,
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Keba
api.Meter
api.MeterEnergy
api.PhaseCurrents
api.PhaseGetter
}{
Keba: base,
Meter: &decorateKebaMeterImpl{
meter: meter,
},
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Keba
api.Identifier
api.PhaseGetter
}{
Keba: base,
Identifier: &decorateKebaIdentifierImpl{
identifier: identifier,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Keba
api.Identifier
api.Meter
api.PhaseGetter
}{
Keba: base,
Identifier: &decorateKebaIdentifierImpl{
identifier: identifier,
},
Meter: &decorateKebaMeterImpl{
meter: meter,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Keba
api.Identifier
api.MeterEnergy
api.PhaseGetter
}{
Keba: base,
Identifier: &decorateKebaIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Keba
api.Identifier
api.Meter
api.MeterEnergy
api.PhaseGetter
}{
Keba: base,
Identifier: &decorateKebaIdentifierImpl{
identifier: identifier,
},
Meter: &decorateKebaMeterImpl{
meter: meter,
},
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Keba
api.Identifier
api.PhaseCurrents
api.PhaseGetter
}{
Keba: base,
Identifier: &decorateKebaIdentifierImpl{
identifier: identifier,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Keba
api.Identifier
api.Meter
api.PhaseCurrents
api.PhaseGetter
}{
Keba: base,
Identifier: &decorateKebaIdentifierImpl{
identifier: identifier,
},
Meter: &decorateKebaMeterImpl{
meter: meter,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Keba
api.Identifier
api.MeterEnergy
api.PhaseCurrents
api.PhaseGetter
}{
Keba: base,
Identifier: &decorateKebaIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*Keba
api.Identifier
api.Meter
api.MeterEnergy
api.PhaseCurrents
api.PhaseGetter
}{
Keba: base,
Identifier: &decorateKebaIdentifierImpl{
identifier: identifier,
},
Meter: &decorateKebaMeterImpl{
meter: meter,
},
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseGetter != nil && phaseSwitcher != nil:
return &struct {
*Keba
@ -386,6 +886,25 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseGetter != nil && phaseSwitcher != nil:
return &struct {
*Keba
api.MeterEnergy
api.PhaseGetter
api.PhaseSwitcher
}{
Keba: base,
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
PhaseSwitcher: &decorateKebaPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseGetter != nil && phaseSwitcher != nil:
return &struct {
*Keba
@ -409,6 +928,25 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseGetter != nil && phaseSwitcher != nil:
return &struct {
*Keba
api.PhaseCurrents
api.PhaseGetter
api.PhaseSwitcher
}{
Keba: base,
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
PhaseSwitcher: &decorateKebaPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseGetter != nil && phaseSwitcher != nil:
return &struct {
*Keba
@ -432,6 +970,29 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseGetter != nil && phaseSwitcher != nil:
return &struct {
*Keba
api.MeterEnergy
api.PhaseCurrents
api.PhaseGetter
api.PhaseSwitcher
}{
Keba: base,
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
PhaseSwitcher: &decorateKebaPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseGetter != nil && phaseSwitcher != nil:
return &struct {
*Keba
@ -501,6 +1062,29 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseGetter != nil && phaseSwitcher != nil:
return &struct {
*Keba
api.Identifier
api.MeterEnergy
api.PhaseGetter
api.PhaseSwitcher
}{
Keba: base,
Identifier: &decorateKebaIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
PhaseSwitcher: &decorateKebaPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseGetter != nil && phaseSwitcher != nil:
return &struct {
*Keba
@ -528,6 +1112,29 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseGetter != nil && phaseSwitcher != nil:
return &struct {
*Keba
api.Identifier
api.PhaseCurrents
api.PhaseGetter
api.PhaseSwitcher
}{
Keba: base,
Identifier: &decorateKebaIdentifierImpl{
identifier: identifier,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
PhaseSwitcher: &decorateKebaPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseGetter != nil && phaseSwitcher != nil:
return &struct {
*Keba
@ -555,6 +1162,33 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseGetter != nil && phaseSwitcher != nil:
return &struct {
*Keba
api.Identifier
api.MeterEnergy
api.PhaseCurrents
api.PhaseGetter
api.PhaseSwitcher
}{
Keba: base,
Identifier: &decorateKebaIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseGetter: &decorateKebaPhaseGetterImpl{
phaseGetter: phaseGetter,
},
PhaseSwitcher: &decorateKebaPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseGetter != nil && phaseSwitcher != nil:
return &struct {
*Keba

37
charger/keba-udp_decorators.go
View file

@ -22,6 +22,17 @@ func decorateKebaUdp(base *KebaUdp, meter func() (float64, error), meterEnergy f
},
}
case meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*KebaUdp
api.MeterEnergy
}{
KebaUdp: base,
MeterEnergy: &decorateKebaUdpMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*KebaUdp
@ -37,6 +48,17 @@ func decorateKebaUdp(base *KebaUdp, meter func() (float64, error), meterEnergy f
},
}
case meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*KebaUdp
api.PhaseCurrents
}{
KebaUdp: base,
PhaseCurrents: &decorateKebaUdpPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*KebaUdp
@ -52,6 +74,21 @@ func decorateKebaUdp(base *KebaUdp, meter func() (float64, error), meterEnergy f
},
}
case meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*KebaUdp
api.MeterEnergy
api.PhaseCurrents
}{
KebaUdp: base,
MeterEnergy: &decorateKebaUdpMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateKebaUdpPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*KebaUdp

26
charger/kse_decorators.go
View file

@ -22,6 +22,17 @@ func decorateKSE(base *KSE, phaseSwitcher func(int) error, phaseGetter func() (i
},
}
case identifier == nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*KSE
api.PhaseGetter
}{
KSE: base,
PhaseGetter: &decorateKSEPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier == nil && phaseGetter != nil && phaseSwitcher != nil:
return &struct {
*KSE
@ -63,6 +74,21 @@ func decorateKSE(base *KSE, phaseSwitcher func(int) error, phaseGetter func() (i
},
}
case identifier != nil && phaseGetter != nil && phaseSwitcher == nil:
return &struct {
*KSE
api.Identifier
api.PhaseGetter
}{
KSE: base,
Identifier: &decorateKSEIdentifierImpl{
identifier: identifier,
},
PhaseGetter: &decorateKSEPhaseGetterImpl{
phaseGetter: phaseGetter,
},
}
case identifier != nil && phaseGetter != nil && phaseSwitcher != nil:
return &struct {
*KSE

500
charger/ocpp_decorators.go
View file

@ -22,6 +22,17 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher == nil && phaseVoltages == nil:
return &struct {
*OCPP
api.MeterEnergy
}{
OCPP: base,
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case battery == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher == nil && phaseVoltages == nil:
return &struct {
*OCPP
@ -37,6 +48,17 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher == nil && phaseVoltages == nil:
return &struct {
*OCPP
api.PhaseCurrents
}{
OCPP: base,
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case battery == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher == nil && phaseVoltages == nil:
return &struct {
*OCPP
@ -52,6 +74,21 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher == nil && phaseVoltages == nil:
return &struct {
*OCPP
api.MeterEnergy
api.PhaseCurrents
}{
OCPP: base,
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case battery == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher == nil && phaseVoltages == nil:
return &struct {
*OCPP
@ -71,6 +108,17 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery == nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseSwitcher == nil && phaseVoltages != nil:
return &struct {
*OCPP
api.PhaseVoltages
}{
OCPP: base,
PhaseVoltages: &decorateOCPPPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseSwitcher == nil && phaseVoltages != nil:
return &struct {
*OCPP
@ -86,6 +134,21 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher == nil && phaseVoltages != nil:
return &struct {
*OCPP
api.MeterEnergy
api.PhaseVoltages
}{
OCPP: base,
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decorateOCPPPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher == nil && phaseVoltages != nil:
return &struct {
*OCPP
@ -105,6 +168,21 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher == nil && phaseVoltages != nil:
return &struct {
*OCPP
api.PhaseCurrents
api.PhaseVoltages
}{
OCPP: base,
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateOCPPPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher == nil && phaseVoltages != nil:
return &struct {
*OCPP
@ -124,6 +202,25 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher == nil && phaseVoltages != nil:
return &struct {
*OCPP
api.MeterEnergy
api.PhaseCurrents
api.PhaseVoltages
}{
OCPP: base,
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateOCPPPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher == nil && phaseVoltages != nil:
return &struct {
*OCPP
@ -173,6 +270,21 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher != nil && phaseVoltages == nil:
return &struct {
*OCPP
api.MeterEnergy
api.PhaseSwitcher
}{
OCPP: base,
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case battery == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher != nil && phaseVoltages == nil:
return &struct {
*OCPP
@ -192,6 +304,21 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher != nil && phaseVoltages == nil:
return &struct {
*OCPP
api.PhaseCurrents
api.PhaseSwitcher
}{
OCPP: base,
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case battery == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher != nil && phaseVoltages == nil:
return &struct {
*OCPP
@ -211,6 +338,25 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher != nil && phaseVoltages == nil:
return &struct {
*OCPP
api.MeterEnergy
api.PhaseCurrents
api.PhaseSwitcher
}{
OCPP: base,
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case battery == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher != nil && phaseVoltages == nil:
return &struct {
*OCPP
@ -234,6 +380,21 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery == nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseSwitcher != nil && phaseVoltages != nil:
return &struct {
*OCPP
api.PhaseSwitcher
api.PhaseVoltages
}{
OCPP: base,
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
PhaseVoltages: &decorateOCPPPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseSwitcher != nil && phaseVoltages != nil:
return &struct {
*OCPP
@ -253,6 +414,25 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher != nil && phaseVoltages != nil:
return &struct {
*OCPP
api.MeterEnergy
api.PhaseSwitcher
api.PhaseVoltages
}{
OCPP: base,
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
PhaseVoltages: &decorateOCPPPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher != nil && phaseVoltages != nil:
return &struct {
*OCPP
@ -276,6 +456,25 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher != nil && phaseVoltages != nil:
return &struct {
*OCPP
api.PhaseCurrents
api.PhaseSwitcher
api.PhaseVoltages
}{
OCPP: base,
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
PhaseVoltages: &decorateOCPPPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher != nil && phaseVoltages != nil:
return &struct {
*OCPP
@ -299,6 +498,29 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher != nil && phaseVoltages != nil:
return &struct {
*OCPP
api.MeterEnergy
api.PhaseCurrents
api.PhaseSwitcher
api.PhaseVoltages
}{
OCPP: base,
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
PhaseVoltages: &decorateOCPPPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher != nil && phaseVoltages != nil:
return &struct {
*OCPP
@ -352,6 +574,21 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher == nil && phaseVoltages == nil:
return &struct {
*OCPP
api.Battery
api.MeterEnergy
}{
OCPP: base,
Battery: &decorateOCPPBatteryImpl{
battery: battery,
},
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case battery != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher == nil && phaseVoltages == nil:
return &struct {
*OCPP
@ -371,6 +608,21 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher == nil && phaseVoltages == nil:
return &struct {
*OCPP
api.Battery
api.PhaseCurrents
}{
OCPP: base,
Battery: &decorateOCPPBatteryImpl{
battery: battery,
},
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case battery != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher == nil && phaseVoltages == nil:
return &struct {
*OCPP
@ -390,6 +642,25 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher == nil && phaseVoltages == nil:
return &struct {
*OCPP
api.Battery
api.MeterEnergy
api.PhaseCurrents
}{
OCPP: base,
Battery: &decorateOCPPBatteryImpl{
battery: battery,
},
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case battery != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher == nil && phaseVoltages == nil:
return &struct {
*OCPP
@ -413,6 +684,21 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery != nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseSwitcher == nil && phaseVoltages != nil:
return &struct {
*OCPP
api.Battery
api.PhaseVoltages
}{
OCPP: base,
Battery: &decorateOCPPBatteryImpl{
battery: battery,
},
PhaseVoltages: &decorateOCPPPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseSwitcher == nil && phaseVoltages != nil:
return &struct {
*OCPP
@ -432,6 +718,25 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher == nil && phaseVoltages != nil:
return &struct {
*OCPP
api.Battery
api.MeterEnergy
api.PhaseVoltages
}{
OCPP: base,
Battery: &decorateOCPPBatteryImpl{
battery: battery,
},
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decorateOCPPPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher == nil && phaseVoltages != nil:
return &struct {
*OCPP
@ -455,6 +760,25 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher == nil && phaseVoltages != nil:
return &struct {
*OCPP
api.Battery
api.PhaseCurrents
api.PhaseVoltages
}{
OCPP: base,
Battery: &decorateOCPPBatteryImpl{
battery: battery,
},
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateOCPPPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher == nil && phaseVoltages != nil:
return &struct {
*OCPP
@ -478,6 +802,29 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher == nil && phaseVoltages != nil:
return &struct {
*OCPP
api.Battery
api.MeterEnergy
api.PhaseCurrents
api.PhaseVoltages
}{
OCPP: base,
Battery: &decorateOCPPBatteryImpl{
battery: battery,
},
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateOCPPPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher == nil && phaseVoltages != nil:
return &struct {
*OCPP
@ -539,6 +886,25 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher != nil && phaseVoltages == nil:
return &struct {
*OCPP
api.Battery
api.MeterEnergy
api.PhaseSwitcher
}{
OCPP: base,
Battery: &decorateOCPPBatteryImpl{
battery: battery,
},
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case battery != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher != nil && phaseVoltages == nil:
return &struct {
*OCPP
@ -562,6 +928,25 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher != nil && phaseVoltages == nil:
return &struct {
*OCPP
api.Battery
api.PhaseCurrents
api.PhaseSwitcher
}{
OCPP: base,
Battery: &decorateOCPPBatteryImpl{
battery: battery,
},
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case battery != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher != nil && phaseVoltages == nil:
return &struct {
*OCPP
@ -585,6 +970,29 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher != nil && phaseVoltages == nil:
return &struct {
*OCPP
api.Battery
api.MeterEnergy
api.PhaseCurrents
api.PhaseSwitcher
}{
OCPP: base,
Battery: &decorateOCPPBatteryImpl{
battery: battery,
},
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case battery != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher != nil && phaseVoltages == nil:
return &struct {
*OCPP
@ -612,6 +1020,25 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery != nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseSwitcher != nil && phaseVoltages != nil:
return &struct {
*OCPP
api.Battery
api.PhaseSwitcher
api.PhaseVoltages
}{
OCPP: base,
Battery: &decorateOCPPBatteryImpl{
battery: battery,
},
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
PhaseVoltages: &decorateOCPPPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseSwitcher != nil && phaseVoltages != nil:
return &struct {
*OCPP
@ -635,6 +1062,29 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher != nil && phaseVoltages != nil:
return &struct {
*OCPP
api.Battery
api.MeterEnergy
api.PhaseSwitcher
api.PhaseVoltages
}{
OCPP: base,
Battery: &decorateOCPPBatteryImpl{
battery: battery,
},
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
PhaseVoltages: &decorateOCPPPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher != nil && phaseVoltages != nil:
return &struct {
*OCPP
@ -662,6 +1112,29 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher != nil && phaseVoltages != nil:
return &struct {
*OCPP
api.Battery
api.PhaseCurrents
api.PhaseSwitcher
api.PhaseVoltages
}{
OCPP: base,
Battery: &decorateOCPPBatteryImpl{
battery: battery,
},
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
PhaseVoltages: &decorateOCPPPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher != nil && phaseVoltages != nil:
return &struct {
*OCPP
@ -689,6 +1162,33 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case battery != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher != nil && phaseVoltages != nil:
return &struct {
*OCPP
api.Battery
api.MeterEnergy
api.PhaseCurrents
api.PhaseSwitcher
api.PhaseVoltages
}{
OCPP: base,
Battery: &decorateOCPPBatteryImpl{
battery: battery,
},
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
PhaseVoltages: &decorateOCPPPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher != nil && phaseVoltages != nil:
return &struct {
*OCPP

37
charger/pcelectric_decorators.go
View file

@ -22,6 +22,17 @@ func decoratePCE(base *PCElectric, meter func() (float64, error), meterEnergy fu
},
}
case meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*PCElectric
api.MeterEnergy
}{
PCElectric: base,
MeterEnergy: &decoratePCEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*PCElectric
@ -37,6 +48,17 @@ func decoratePCE(base *PCElectric, meter func() (float64, error), meterEnergy fu
},
}
case meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*PCElectric
api.PhaseCurrents
}{
PCElectric: base,
PhaseCurrents: &decoratePCEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*PCElectric
@ -52,6 +74,21 @@ func decoratePCE(base *PCElectric, meter func() (float64, error), meterEnergy fu
},
}
case meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*PCElectric
api.MeterEnergy
api.PhaseCurrents
}{
PCElectric: base,
MeterEnergy: &decoratePCEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePCEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*PCElectric

97
charger/phoenix-charx_decorators.go
View file

@ -22,6 +22,17 @@ func decoratePhoenixCharx(base *PhoenixCharx, meter func() (float64, error), met
},
}
case meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*PhoenixCharx
api.MeterEnergy
}{
PhoenixCharx: base,
MeterEnergy: &decoratePhoenixCharxMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*PhoenixCharx
@ -37,6 +48,17 @@ func decoratePhoenixCharx(base *PhoenixCharx, meter func() (float64, error), met
},
}
case meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixCharx
api.PhaseCurrents
}{
PhoenixCharx: base,
PhaseCurrents: &decoratePhoenixCharxPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixCharx
@ -52,6 +74,21 @@ func decoratePhoenixCharx(base *PhoenixCharx, meter func() (float64, error), met
},
}
case meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixCharx
api.MeterEnergy
api.PhaseCurrents
}{
PhoenixCharx: base,
MeterEnergy: &decoratePhoenixCharxMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePhoenixCharxPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixCharx
@ -71,6 +108,17 @@ func decoratePhoenixCharx(base *PhoenixCharx, meter func() (float64, error), met
},
}
case meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixCharx
api.PhaseVoltages
}{
PhoenixCharx: base,
PhaseVoltages: &decoratePhoenixCharxPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixCharx
@ -86,6 +134,21 @@ func decoratePhoenixCharx(base *PhoenixCharx, meter func() (float64, error), met
},
}
case meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixCharx
api.MeterEnergy
api.PhaseVoltages
}{
PhoenixCharx: base,
MeterEnergy: &decoratePhoenixCharxMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decoratePhoenixCharxPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixCharx
@ -105,6 +168,21 @@ func decoratePhoenixCharx(base *PhoenixCharx, meter func() (float64, error), met
},
}
case meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixCharx
api.PhaseCurrents
api.PhaseVoltages
}{
PhoenixCharx: base,
PhaseCurrents: &decoratePhoenixCharxPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decoratePhoenixCharxPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixCharx
@ -124,6 +202,25 @@ func decoratePhoenixCharx(base *PhoenixCharx, meter func() (float64, error), met
},
}
case meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixCharx
api.MeterEnergy
api.PhaseCurrents
api.PhaseVoltages
}{
PhoenixCharx: base,
MeterEnergy: &decoratePhoenixCharxMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePhoenixCharxPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decoratePhoenixCharxPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixCharx

97
charger/phoenix-em-eth_decorators.go
View file

@ -22,6 +22,17 @@ func decoratePhoenixEMEth(base *PhoenixEMEth, meter func() (float64, error), met
},
}
case meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*PhoenixEMEth
api.MeterEnergy
}{
PhoenixEMEth: base,
MeterEnergy: &decoratePhoenixEMEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*PhoenixEMEth
@ -37,6 +48,17 @@ func decoratePhoenixEMEth(base *PhoenixEMEth, meter func() (float64, error), met
},
}
case meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEMEth
api.PhaseCurrents
}{
PhoenixEMEth: base,
PhaseCurrents: &decoratePhoenixEMEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEMEth
@ -52,6 +74,21 @@ func decoratePhoenixEMEth(base *PhoenixEMEth, meter func() (float64, error), met
},
}
case meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEMEth
api.MeterEnergy
api.PhaseCurrents
}{
PhoenixEMEth: base,
MeterEnergy: &decoratePhoenixEMEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePhoenixEMEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEMEth
@ -71,6 +108,17 @@ func decoratePhoenixEMEth(base *PhoenixEMEth, meter func() (float64, error), met
},
}
case meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEMEth
api.PhaseVoltages
}{
PhoenixEMEth: base,
PhaseVoltages: &decoratePhoenixEMEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEMEth
@ -86,6 +134,21 @@ func decoratePhoenixEMEth(base *PhoenixEMEth, meter func() (float64, error), met
},
}
case meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEMEth
api.MeterEnergy
api.PhaseVoltages
}{
PhoenixEMEth: base,
MeterEnergy: &decoratePhoenixEMEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decoratePhoenixEMEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEMEth
@ -105,6 +168,21 @@ func decoratePhoenixEMEth(base *PhoenixEMEth, meter func() (float64, error), met
},
}
case meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEMEth
api.PhaseCurrents
api.PhaseVoltages
}{
PhoenixEMEth: base,
PhaseCurrents: &decoratePhoenixEMEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decoratePhoenixEMEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEMEth
@ -124,6 +202,25 @@ func decoratePhoenixEMEth(base *PhoenixEMEth, meter func() (float64, error), met
},
}
case meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEMEth
api.MeterEnergy
api.PhaseCurrents
api.PhaseVoltages
}{
PhoenixEMEth: base,
MeterEnergy: &decoratePhoenixEMEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePhoenixEMEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decoratePhoenixEMEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEMEth

500
charger/phoenix-ev-eth_decorators.go
View file

@ -22,6 +22,17 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
api.MeterEnergy
}{
PhoenixEVEth: base,
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
@ -37,6 +48,17 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
api.PhaseCurrents
}{
PhoenixEVEth: base,
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
@ -52,6 +74,21 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
api.MeterEnergy
api.PhaseCurrents
}{
PhoenixEVEth: base,
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
@ -71,6 +108,17 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
api.PhaseVoltages
}{
PhoenixEVEth: base,
PhaseVoltages: &decoratePhoenixEVEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
@ -86,6 +134,21 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
api.MeterEnergy
api.PhaseVoltages
}{
PhoenixEVEth: base,
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decoratePhoenixEVEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
@ -105,6 +168,21 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
api.PhaseCurrents
api.PhaseVoltages
}{
PhoenixEVEth: base,
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decoratePhoenixEVEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
@ -124,6 +202,25 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
api.MeterEnergy
api.PhaseCurrents
api.PhaseVoltages
}{
PhoenixEVEth: base,
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decoratePhoenixEVEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
@ -173,6 +270,21 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
api.ChargerEx
api.MeterEnergy
}{
PhoenixEVEth: base,
ChargerEx: &decoratePhoenixEVEthChargerExImpl{
chargerEx: chargerEx,
},
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
@ -192,6 +304,21 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
api.ChargerEx
api.PhaseCurrents
}{
PhoenixEVEth: base,
ChargerEx: &decoratePhoenixEVEthChargerExImpl{
chargerEx: chargerEx,
},
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
@ -211,6 +338,25 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
api.ChargerEx
api.MeterEnergy
api.PhaseCurrents
}{
PhoenixEVEth: base,
ChargerEx: &decoratePhoenixEVEthChargerExImpl{
chargerEx: chargerEx,
},
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
@ -234,6 +380,21 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
api.ChargerEx
api.PhaseVoltages
}{
PhoenixEVEth: base,
ChargerEx: &decoratePhoenixEVEthChargerExImpl{
chargerEx: chargerEx,
},
PhaseVoltages: &decoratePhoenixEVEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
@ -253,6 +414,25 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
api.ChargerEx
api.MeterEnergy
api.PhaseVoltages
}{
PhoenixEVEth: base,
ChargerEx: &decoratePhoenixEVEthChargerExImpl{
chargerEx: chargerEx,
},
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decoratePhoenixEVEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
@ -276,6 +456,25 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
api.ChargerEx
api.PhaseCurrents
api.PhaseVoltages
}{
PhoenixEVEth: base,
ChargerEx: &decoratePhoenixEVEthChargerExImpl{
chargerEx: chargerEx,
},
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decoratePhoenixEVEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
@ -299,6 +498,29 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
api.ChargerEx
api.MeterEnergy
api.PhaseCurrents
api.PhaseVoltages
}{
PhoenixEVEth: base,
ChargerEx: &decoratePhoenixEVEthChargerExImpl{
chargerEx: chargerEx,
},
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decoratePhoenixEVEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
@ -352,6 +574,21 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
api.Identifier
api.MeterEnergy
}{
PhoenixEVEth: base,
Identifier: &decoratePhoenixEVEthIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
@ -371,6 +608,21 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
api.Identifier
api.PhaseCurrents
}{
PhoenixEVEth: base,
Identifier: &decoratePhoenixEVEthIdentifierImpl{
identifier: identifier,
},
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
@ -390,6 +642,25 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
api.Identifier
api.MeterEnergy
api.PhaseCurrents
}{
PhoenixEVEth: base,
Identifier: &decoratePhoenixEVEthIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
@ -413,6 +684,21 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
api.Identifier
api.PhaseVoltages
}{
PhoenixEVEth: base,
Identifier: &decoratePhoenixEVEthIdentifierImpl{
identifier: identifier,
},
PhaseVoltages: &decoratePhoenixEVEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
@ -432,6 +718,25 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
api.Identifier
api.MeterEnergy
api.PhaseVoltages
}{
PhoenixEVEth: base,
Identifier: &decoratePhoenixEVEthIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decoratePhoenixEVEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
@ -455,6 +760,25 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
api.Identifier
api.PhaseCurrents
api.PhaseVoltages
}{
PhoenixEVEth: base,
Identifier: &decoratePhoenixEVEthIdentifierImpl{
identifier: identifier,
},
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decoratePhoenixEVEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
@ -478,6 +802,29 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
api.Identifier
api.MeterEnergy
api.PhaseCurrents
api.PhaseVoltages
}{
PhoenixEVEth: base,
Identifier: &decoratePhoenixEVEthIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decoratePhoenixEVEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
@ -539,6 +886,25 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
api.ChargerEx
api.Identifier
api.MeterEnergy
}{
PhoenixEVEth: base,
ChargerEx: &decoratePhoenixEVEthChargerExImpl{
chargerEx: chargerEx,
},
Identifier: &decoratePhoenixEVEthIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
@ -562,6 +928,25 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
api.ChargerEx
api.Identifier
api.PhaseCurrents
}{
PhoenixEVEth: base,
ChargerEx: &decoratePhoenixEVEthChargerExImpl{
chargerEx: chargerEx,
},
Identifier: &decoratePhoenixEVEthIdentifierImpl{
identifier: identifier,
},
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
@ -585,6 +970,29 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
api.ChargerEx
api.Identifier
api.MeterEnergy
api.PhaseCurrents
}{
PhoenixEVEth: base,
ChargerEx: &decoratePhoenixEVEthChargerExImpl{
chargerEx: chargerEx,
},
Identifier: &decoratePhoenixEVEthIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*PhoenixEVEth
@ -612,6 +1020,25 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
api.ChargerEx
api.Identifier
api.PhaseVoltages
}{
PhoenixEVEth: base,
ChargerEx: &decoratePhoenixEVEthChargerExImpl{
chargerEx: chargerEx,
},
Identifier: &decoratePhoenixEVEthIdentifierImpl{
identifier: identifier,
},
PhaseVoltages: &decoratePhoenixEVEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
@ -635,6 +1062,29 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
api.ChargerEx
api.Identifier
api.MeterEnergy
api.PhaseVoltages
}{
PhoenixEVEth: base,
ChargerEx: &decoratePhoenixEVEthChargerExImpl{
chargerEx: chargerEx,
},
Identifier: &decoratePhoenixEVEthIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decoratePhoenixEVEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
@ -662,6 +1112,29 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
api.ChargerEx
api.Identifier
api.PhaseCurrents
api.PhaseVoltages
}{
PhoenixEVEth: base,
ChargerEx: &decoratePhoenixEVEthChargerExImpl{
chargerEx: chargerEx,
},
Identifier: &decoratePhoenixEVEthIdentifierImpl{
identifier: identifier,
},
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decoratePhoenixEVEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
@ -689,6 +1162,33 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth
api.ChargerEx
api.Identifier
api.MeterEnergy
api.PhaseCurrents
api.PhaseVoltages
}{
PhoenixEVEth: base,
ChargerEx: &decoratePhoenixEVEthChargerExImpl{
chargerEx: chargerEx,
},
Identifier: &decoratePhoenixEVEthIdentifierImpl{
identifier: identifier,
},
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decoratePhoenixEVEthPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*PhoenixEVEth

37
charger/tasmota_decorators.go
View file

@ -10,6 +10,43 @@ func decorateTasmota(base *Tasmota, phaseVoltages func() (float64, float64, floa
switch {
case phaseCurrents == nil && phaseVoltages == nil:
return base
case phaseCurrents == nil && phaseVoltages != nil:
return &struct {
*Tasmota
api.PhaseVoltages
}{
Tasmota: base,
PhaseVoltages: &decorateTasmotaPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case phaseCurrents != nil && phaseVoltages == nil:
return &struct {
*Tasmota
api.PhaseCurrents
}{
Tasmota: base,
PhaseCurrents: &decorateTasmotaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case phaseCurrents != nil && phaseVoltages != nil:
return &struct {
*Tasmota
api.PhaseCurrents
api.PhaseVoltages
}{
Tasmota: base,
PhaseCurrents: &decorateTasmotaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateTasmotaPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
}
return nil

86
charger/wallbe_decorators.go
View file

@ -22,6 +22,17 @@ func decorateWallbe(base *Wallbe, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Wallbe
api.MeterEnergy
}{
Wallbe: base,
MeterEnergy: &decorateWallbeMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case chargerEx == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Wallbe
@ -37,6 +48,17 @@ func decorateWallbe(base *Wallbe, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Wallbe
api.PhaseCurrents
}{
Wallbe: base,
PhaseCurrents: &decorateWallbePhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Wallbe
@ -52,6 +74,21 @@ func decorateWallbe(base *Wallbe, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Wallbe
api.MeterEnergy
api.PhaseCurrents
}{
Wallbe: base,
MeterEnergy: &decorateWallbeMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateWallbePhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Wallbe
@ -97,6 +134,21 @@ func decorateWallbe(base *Wallbe, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Wallbe
api.ChargerEx
api.MeterEnergy
}{
Wallbe: base,
ChargerEx: &decorateWallbeChargerExImpl{
chargerEx: chargerEx,
},
MeterEnergy: &decorateWallbeMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case chargerEx != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Wallbe
@ -116,6 +168,21 @@ func decorateWallbe(base *Wallbe, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Wallbe
api.ChargerEx
api.PhaseCurrents
}{
Wallbe: base,
ChargerEx: &decorateWallbeChargerExImpl{
chargerEx: chargerEx,
},
PhaseCurrents: &decorateWallbePhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Wallbe
@ -135,6 +202,25 @@ func decorateWallbe(base *Wallbe, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Wallbe
api.ChargerEx
api.MeterEnergy
api.PhaseCurrents
}{
Wallbe: base,
ChargerEx: &decorateWallbeChargerExImpl{
chargerEx: chargerEx,
},
MeterEnergy: &decorateWallbeMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateWallbePhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Wallbe

1506
charger/warp2_decorators.go
View file

File diff suppressed because it is too large Load diff

43
cmd/tools/decorate.go
View file

@ -29,23 +29,6 @@ type typeStruct struct {
Params []string
}
var dependents = map[string][]string{
"api.Meter": {"api.MeterEnergy", "api.PhaseCurrents", "api.PhaseVoltages", "api.PhasePowers"},
"api.PhaseCurrents": {"api.PhasePowers"}, // phase powers are only used to determine currents sign
"api.PhaseSwitcher": {"api.PhaseGetter"},
"api.Battery": {"api.BatteryCapacity", "api.BatteryController"},
}
// hasIntersection returns if the slices intersect
func hasIntersection[T comparable](a, b []T) bool {
for _, el := range a {
if slices.Contains(b, el) {
return true
}
}
return false
}
func generate(out io.Writer, packageName, functionName, baseType string, dynamicTypes ...dynamicType) error {
types := make(map[string]typeStruct, len(dynamicTypes))
combos := make([]string, 0)
@ -69,25 +52,28 @@ func generate(out io.Writer, packageName, functionName, baseType string, dynamic
for _, dt := range dynamicTypes {
parts := strings.SplitN(dt.typ, ".", 2)
lastPart := parts[len(parts)-1]
openingBrace := strings.Index(dt.signature, "(")
closingBrace := strings.Index(dt.signature, ")")
paramsStr := dt.signature[openingBrace+1 : closingBrace]
paramsStr = strings.TrimSpace(paramsStr)
var params []string
if paramsStr = strings.TrimSpace(paramsStr); len(paramsStr) > 0 {
if len(paramsStr) > 0 {
params = strings.Split(paramsStr, ",")
}
returnValuesStr := dt.signature[closingBrace+1:]
types[dt.typ] = typeStruct{
Type: dt.typ,
ShortType: lastPart,
VarName: strings.ToLower(lastPart[:1]) + lastPart[1:],
ShortType: parts[1],
VarName: strings.ToLower(parts[1][:1]) + parts[1][1:],
Signature: dt.signature,
Function: dt.function,
Params: params,
ReturnTypes: dt.signature[closingBrace+1:],
ReturnTypes: returnValuesStr,
}
combos = append(combos, dt.typ)
@ -103,17 +89,6 @@ func generate(out io.Writer, packageName, functionName, baseType string, dynamic
shortBase = baseTypeParts[1]
}
validCombos := make([][]string, 0)
COMBO:
for _, c := range combinations.All(combos) {
for master, details := range dependents {
if returnType != master && !slices.Contains(c, master) && hasIntersection(c, details) {
continue COMBO
}
}
validCombos = append(validCombos, c)
}
vars := struct {
API string
Package, Function string
@ -129,7 +104,7 @@ COMBO:
ShortBase: shortBase,
ReturnType: returnType,
Types: types,
Combinations: validCombos,
Combinations: combinations.All(combos),
}
return tmpl.Execute(out, vars)

37
meter/e3dc_decorators.go
View file

@ -11,6 +11,17 @@ func decorateE3dc(base *E3dc, batteryCapacity func() float64, battery func() (fl
case battery == nil && batteryCapacity == nil && batteryController == nil:
return base
case battery == nil && batteryCapacity != nil && batteryController == nil:
return &struct {
*E3dc
api.BatteryCapacity
}{
E3dc: base,
BatteryCapacity: &decorateE3dcBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
}
case battery != nil && batteryCapacity == nil && batteryController == nil:
return &struct {
*E3dc
@ -37,6 +48,32 @@ func decorateE3dc(base *E3dc, batteryCapacity func() float64, battery func() (fl
},
}
case battery == nil && batteryCapacity == nil && batteryController != nil:
return &struct {
*E3dc
api.BatteryController
}{
E3dc: base,
BatteryController: &decorateE3dcBatteryControllerImpl{
batteryController: batteryController,
},
}
case battery == nil && batteryCapacity != nil && batteryController != nil:
return &struct {
*E3dc
api.BatteryCapacity
api.BatteryController
}{
E3dc: base,
BatteryCapacity: &decorateE3dcBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
BatteryController: &decorateE3dcBatteryControllerImpl{
batteryController: batteryController,
},
}
case battery != nil && batteryCapacity == nil && batteryController != nil:
return &struct {
*E3dc

26
meter/lgess_decorators.go
View file

@ -48,6 +48,32 @@ func decorateLgEss(base *LgEss, meterEnergy func() (float64, error), battery fun
},
}
case battery == nil && batteryCapacity != nil && meterEnergy == nil:
return &struct {
*LgEss
api.BatteryCapacity
}{
LgEss: base,
BatteryCapacity: &decorateLgEssBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
}
case battery == nil && batteryCapacity != nil && meterEnergy != nil:
return &struct {
*LgEss
api.BatteryCapacity
api.MeterEnergy
}{
LgEss: base,
BatteryCapacity: &decorateLgEssBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
MeterEnergy: &decorateLgEssMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case battery != nil && batteryCapacity != nil && meterEnergy == nil:
return &struct {
*LgEss

532
meter/mbmd_decorators.go
View file

@ -108,6 +108,32 @@ func decorateModbusMbmd(base api.Meter, meterEnergy func() (float64, error), pha
},
}
case battery == nil && batteryCapacity == nil && meterEnergy == nil && phaseCurrents == nil && phasePowers != nil && phaseVoltages == nil:
return &struct {
api.Meter
api.PhasePowers
}{
Meter: base,
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
}
case battery == nil && batteryCapacity == nil && meterEnergy != nil && phaseCurrents == nil && phasePowers != nil && phaseVoltages == nil:
return &struct {
api.Meter
api.MeterEnergy
api.PhasePowers
}{
Meter: base,
MeterEnergy: &decorateModbusMbmdMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
}
case battery == nil && batteryCapacity == nil && meterEnergy == nil && phaseCurrents != nil && phasePowers != nil && phaseVoltages == nil:
return &struct {
api.Meter
@ -142,6 +168,40 @@ func decorateModbusMbmd(base api.Meter, meterEnergy func() (float64, error), pha
},
}
case battery == nil && batteryCapacity == nil && meterEnergy == nil && phaseCurrents == nil && phasePowers != nil && phaseVoltages != nil:
return &struct {
api.Meter
api.PhasePowers
api.PhaseVoltages
}{
Meter: base,
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
PhaseVoltages: &decorateModbusMbmdPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && batteryCapacity == nil && meterEnergy != nil && phaseCurrents == nil && phasePowers != nil && phaseVoltages != nil:
return &struct {
api.Meter
api.MeterEnergy
api.PhasePowers
api.PhaseVoltages
}{
Meter: base,
MeterEnergy: &decorateModbusMbmdMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
PhaseVoltages: &decorateModbusMbmdPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && batteryCapacity == nil && meterEnergy == nil && phaseCurrents != nil && phasePowers != nil && phaseVoltages != nil:
return &struct {
api.Meter
@ -320,6 +380,40 @@ func decorateModbusMbmd(base api.Meter, meterEnergy func() (float64, error), pha
},
}
case battery != nil && batteryCapacity == nil && meterEnergy == nil && phaseCurrents == nil && phasePowers != nil && phaseVoltages == nil:
return &struct {
api.Meter
api.Battery
api.PhasePowers
}{
Meter: base,
Battery: &decorateModbusMbmdBatteryImpl{
battery: battery,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
}
case battery != nil && batteryCapacity == nil && meterEnergy != nil && phaseCurrents == nil && phasePowers != nil && phaseVoltages == nil:
return &struct {
api.Meter
api.Battery
api.MeterEnergy
api.PhasePowers
}{
Meter: base,
Battery: &decorateModbusMbmdBatteryImpl{
battery: battery,
},
MeterEnergy: &decorateModbusMbmdMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
}
case battery != nil && batteryCapacity == nil && meterEnergy == nil && phaseCurrents != nil && phasePowers != nil && phaseVoltages == nil:
return &struct {
api.Meter
@ -362,6 +456,48 @@ func decorateModbusMbmd(base api.Meter, meterEnergy func() (float64, error), pha
},
}
case battery != nil && batteryCapacity == nil && meterEnergy == nil && phaseCurrents == nil && phasePowers != nil && phaseVoltages != nil:
return &struct {
api.Meter
api.Battery
api.PhasePowers
api.PhaseVoltages
}{
Meter: base,
Battery: &decorateModbusMbmdBatteryImpl{
battery: battery,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
PhaseVoltages: &decorateModbusMbmdPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && batteryCapacity == nil && meterEnergy != nil && phaseCurrents == nil && phasePowers != nil && phaseVoltages != nil:
return &struct {
api.Meter
api.Battery
api.MeterEnergy
api.PhasePowers
api.PhaseVoltages
}{
Meter: base,
Battery: &decorateModbusMbmdBatteryImpl{
battery: battery,
},
MeterEnergy: &decorateModbusMbmdMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
PhaseVoltages: &decorateModbusMbmdPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && batteryCapacity == nil && meterEnergy == nil && phaseCurrents != nil && phasePowers != nil && phaseVoltages != nil:
return &struct {
api.Meter
@ -412,6 +548,310 @@ func decorateModbusMbmd(base api.Meter, meterEnergy func() (float64, error), pha
},
}
case battery == nil && batteryCapacity != nil && meterEnergy == nil && phaseCurrents == nil && phasePowers == nil && phaseVoltages == nil:
return &struct {
api.Meter
api.BatteryCapacity
}{
Meter: base,
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
}
case battery == nil && batteryCapacity != nil && meterEnergy != nil && phaseCurrents == nil && phasePowers == nil && phaseVoltages == nil:
return &struct {
api.Meter
api.BatteryCapacity
api.MeterEnergy
}{
Meter: base,
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
MeterEnergy: &decorateModbusMbmdMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case battery == nil && batteryCapacity != nil && meterEnergy == nil && phaseCurrents != nil && phasePowers == nil && phaseVoltages == nil:
return &struct {
api.Meter
api.BatteryCapacity
api.PhaseCurrents
}{
Meter: base,
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
PhaseCurrents: &decorateModbusMbmdPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case battery == nil && batteryCapacity != nil && meterEnergy != nil && phaseCurrents != nil && phasePowers == nil && phaseVoltages == nil:
return &struct {
api.Meter
api.BatteryCapacity
api.MeterEnergy
api.PhaseCurrents
}{
Meter: base,
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
MeterEnergy: &decorateModbusMbmdMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateModbusMbmdPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case battery == nil && batteryCapacity != nil && meterEnergy == nil && phaseCurrents == nil && phasePowers == nil && phaseVoltages != nil:
return &struct {
api.Meter
api.BatteryCapacity
api.PhaseVoltages
}{
Meter: base,
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
PhaseVoltages: &decorateModbusMbmdPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && batteryCapacity != nil && meterEnergy != nil && phaseCurrents == nil && phasePowers == nil && phaseVoltages != nil:
return &struct {
api.Meter
api.BatteryCapacity
api.MeterEnergy
api.PhaseVoltages
}{
Meter: base,
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
MeterEnergy: &decorateModbusMbmdMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseVoltages: &decorateModbusMbmdPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && batteryCapacity != nil && meterEnergy == nil && phaseCurrents != nil && phasePowers == nil && phaseVoltages != nil:
return &struct {
api.Meter
api.BatteryCapacity
api.PhaseCurrents
api.PhaseVoltages
}{
Meter: base,
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
PhaseCurrents: &decorateModbusMbmdPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateModbusMbmdPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && batteryCapacity != nil && meterEnergy != nil && phaseCurrents != nil && phasePowers == nil && phaseVoltages != nil:
return &struct {
api.Meter
api.BatteryCapacity
api.MeterEnergy
api.PhaseCurrents
api.PhaseVoltages
}{
Meter: base,
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
MeterEnergy: &decorateModbusMbmdMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateModbusMbmdPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseVoltages: &decorateModbusMbmdPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && batteryCapacity != nil && meterEnergy == nil && phaseCurrents == nil && phasePowers != nil && phaseVoltages == nil:
return &struct {
api.Meter
api.BatteryCapacity
api.PhasePowers
}{
Meter: base,
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
}
case battery == nil && batteryCapacity != nil && meterEnergy != nil && phaseCurrents == nil && phasePowers != nil && phaseVoltages == nil:
return &struct {
api.Meter
api.BatteryCapacity
api.MeterEnergy
api.PhasePowers
}{
Meter: base,
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
MeterEnergy: &decorateModbusMbmdMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
}
case battery == nil && batteryCapacity != nil && meterEnergy == nil && phaseCurrents != nil && phasePowers != nil && phaseVoltages == nil:
return &struct {
api.Meter
api.BatteryCapacity
api.PhaseCurrents
api.PhasePowers
}{
Meter: base,
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
PhaseCurrents: &decorateModbusMbmdPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
}
case battery == nil && batteryCapacity != nil && meterEnergy != nil && phaseCurrents != nil && phasePowers != nil && phaseVoltages == nil:
return &struct {
api.Meter
api.BatteryCapacity
api.MeterEnergy
api.PhaseCurrents
api.PhasePowers
}{
Meter: base,
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
MeterEnergy: &decorateModbusMbmdMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateModbusMbmdPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
}
case battery == nil && batteryCapacity != nil && meterEnergy == nil && phaseCurrents == nil && phasePowers != nil && phaseVoltages != nil:
return &struct {
api.Meter
api.BatteryCapacity
api.PhasePowers
api.PhaseVoltages
}{
Meter: base,
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
PhaseVoltages: &decorateModbusMbmdPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && batteryCapacity != nil && meterEnergy != nil && phaseCurrents == nil && phasePowers != nil && phaseVoltages != nil:
return &struct {
api.Meter
api.BatteryCapacity
api.MeterEnergy
api.PhasePowers
api.PhaseVoltages
}{
Meter: base,
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
MeterEnergy: &decorateModbusMbmdMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
PhaseVoltages: &decorateModbusMbmdPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && batteryCapacity != nil && meterEnergy == nil && phaseCurrents != nil && phasePowers != nil && phaseVoltages != nil:
return &struct {
api.Meter
api.BatteryCapacity
api.PhaseCurrents
api.PhasePowers
api.PhaseVoltages
}{
Meter: base,
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
PhaseCurrents: &decorateModbusMbmdPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
PhaseVoltages: &decorateModbusMbmdPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery == nil && batteryCapacity != nil && meterEnergy != nil && phaseCurrents != nil && phasePowers != nil && phaseVoltages != nil:
return &struct {
api.Meter
api.BatteryCapacity
api.MeterEnergy
api.PhaseCurrents
api.PhasePowers
api.PhaseVoltages
}{
Meter: base,
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
MeterEnergy: &decorateModbusMbmdMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateModbusMbmdPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
PhaseVoltages: &decorateModbusMbmdPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && batteryCapacity != nil && meterEnergy == nil && phaseCurrents == nil && phasePowers == nil && phaseVoltages == nil:
return &struct {
api.Meter
@ -580,6 +1020,48 @@ func decorateModbusMbmd(base api.Meter, meterEnergy func() (float64, error), pha
},
}
case battery != nil && batteryCapacity != nil && meterEnergy == nil && phaseCurrents == nil && phasePowers != nil && phaseVoltages == nil:
return &struct {
api.Meter
api.Battery
api.BatteryCapacity
api.PhasePowers
}{
Meter: base,
Battery: &decorateModbusMbmdBatteryImpl{
battery: battery,
},
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
}
case battery != nil && batteryCapacity != nil && meterEnergy != nil && phaseCurrents == nil && phasePowers != nil && phaseVoltages == nil:
return &struct {
api.Meter
api.Battery
api.BatteryCapacity
api.MeterEnergy
api.PhasePowers
}{
Meter: base,
Battery: &decorateModbusMbmdBatteryImpl{
battery: battery,
},
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
MeterEnergy: &decorateModbusMbmdMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
}
case battery != nil && batteryCapacity != nil && meterEnergy == nil && phaseCurrents != nil && phasePowers != nil && phaseVoltages == nil:
return &struct {
api.Meter
@ -630,6 +1112,56 @@ func decorateModbusMbmd(base api.Meter, meterEnergy func() (float64, error), pha
},
}
case battery != nil && batteryCapacity != nil && meterEnergy == nil && phaseCurrents == nil && phasePowers != nil && phaseVoltages != nil:
return &struct {
api.Meter
api.Battery
api.BatteryCapacity
api.PhasePowers
api.PhaseVoltages
}{
Meter: base,
Battery: &decorateModbusMbmdBatteryImpl{
battery: battery,
},
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
PhaseVoltages: &decorateModbusMbmdPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && batteryCapacity != nil && meterEnergy != nil && phaseCurrents == nil && phasePowers != nil && phaseVoltages != nil:
return &struct {
api.Meter
api.Battery
api.BatteryCapacity
api.MeterEnergy
api.PhasePowers
api.PhaseVoltages
}{
Meter: base,
Battery: &decorateModbusMbmdBatteryImpl{
battery: battery,
},
BatteryCapacity: &decorateModbusMbmdBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
MeterEnergy: &decorateModbusMbmdMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhasePowers: &decorateModbusMbmdPhasePowersImpl{
phasePowers: phasePowers,
},
PhaseVoltages: &decorateModbusMbmdPhaseVoltagesImpl{
phaseVoltages: phaseVoltages,
},
}
case battery != nil && batteryCapacity != nil && meterEnergy == nil && phaseCurrents != nil && phasePowers != nil && phaseVoltages != nil:
return &struct {
api.Meter

1404
meter/meter_decorators.go
View file

File diff suppressed because it is too large Load diff

86
meter/powerwall_decorators.go
View file

@ -48,6 +48,32 @@ func decoratePowerWall(base *PowerWall, meterEnergy func() (float64, error), bat
},
}
case battery == nil && batteryCapacity != nil && batteryController == nil && meterEnergy == nil:
return &struct {
*PowerWall
api.BatteryCapacity
}{
PowerWall: base,
BatteryCapacity: &decoratePowerWallBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
}
case battery == nil && batteryCapacity != nil && batteryController == nil && meterEnergy != nil:
return &struct {
*PowerWall
api.BatteryCapacity
api.MeterEnergy
}{
PowerWall: base,
BatteryCapacity: &decoratePowerWallBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
MeterEnergy: &decoratePowerWallMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case battery != nil && batteryCapacity != nil && batteryController == nil && meterEnergy == nil:
return &struct {
*PowerWall
@ -82,6 +108,32 @@ func decoratePowerWall(base *PowerWall, meterEnergy func() (float64, error), bat
},
}
case battery == nil && batteryCapacity == nil && batteryController != nil && meterEnergy == nil:
return &struct {
*PowerWall
api.BatteryController
}{
PowerWall: base,
BatteryController: &decoratePowerWallBatteryControllerImpl{
batteryController: batteryController,
},
}
case battery == nil && batteryCapacity == nil && batteryController != nil && meterEnergy != nil:
return &struct {
*PowerWall
api.BatteryController
api.MeterEnergy
}{
PowerWall: base,
BatteryController: &decoratePowerWallBatteryControllerImpl{
batteryController: batteryController,
},
MeterEnergy: &decoratePowerWallMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case battery != nil && batteryCapacity == nil && batteryController != nil && meterEnergy == nil:
return &struct {
*PowerWall
@ -116,6 +168,40 @@ func decoratePowerWall(base *PowerWall, meterEnergy func() (float64, error), bat
},
}
case battery == nil && batteryCapacity != nil && batteryController != nil && meterEnergy == nil:
return &struct {
*PowerWall
api.BatteryCapacity
api.BatteryController
}{
PowerWall: base,
BatteryCapacity: &decoratePowerWallBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
BatteryController: &decoratePowerWallBatteryControllerImpl{
batteryController: batteryController,
},
}
case battery == nil && batteryCapacity != nil && batteryController != nil && meterEnergy != nil:
return &struct {
*PowerWall
api.BatteryCapacity
api.BatteryController
api.MeterEnergy
}{
PowerWall: base,
BatteryCapacity: &decoratePowerWallBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
BatteryController: &decoratePowerWallBatteryControllerImpl{
batteryController: batteryController,
},
MeterEnergy: &decoratePowerWallMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case battery != nil && batteryCapacity != nil && batteryController != nil && meterEnergy == nil:
return &struct {
*PowerWall

26
meter/rct_decorators.go
View file

@ -48,6 +48,32 @@ func decorateRCT(base *RCT, meterEnergy func() (float64, error), battery func()
},
}
case battery == nil && batteryCapacity != nil && meterEnergy == nil:
return &struct {
*RCT
api.BatteryCapacity
}{
RCT: base,
BatteryCapacity: &decorateRCTBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
}
case battery == nil && batteryCapacity != nil && meterEnergy != nil:
return &struct {
*RCT
api.BatteryCapacity
api.MeterEnergy
}{
RCT: base,
BatteryCapacity: &decorateRCTBatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
MeterEnergy: &decorateRCTMeterEnergyImpl{
meterEnergy: meterEnergy,
},
}
case battery != nil && batteryCapacity != nil && meterEnergy == nil:
return &struct {
*RCT

11
meter/sma_decorators.go
View file

@ -22,6 +22,17 @@ func decorateSMA(base *SMA, battery func() (float64, error), batteryCapacity fun
},
}
case battery == nil && batteryCapacity != nil:
return &struct {
*SMA
api.BatteryCapacity
}{
SMA: base,
BatteryCapacity: &decorateSMABatteryCapacityImpl{
batteryCapacity: batteryCapacity,
},
}
case battery != nil && batteryCapacity != nil:
return &struct {
*SMA