fix: refactor code for oasis service, more details please go to #223

integration/oasis/chargingstrategy/chargingstrategy.go → integration/oasis/chargingstrategy/fake_charge_strategy.go

@@ -5,30 +5,30 @@ import (
 	"github.com/golang/glog"
 )
 
-type fakeChargingStrategyCreator struct {
+type fakeChargeStrategy struct {
 	maxEnergyLevel float64
 }
 
-// NewFakeChargingStrategyCreator creates fake charging strategy
-func NewFakeChargingStrategyCreator(maxEnergyLevel float64) *fakeChargingStrategyCreator {
-	return &fakeChargingStrategyCreator{
+// NewFakeChargingStrategy creates fake charge strategy
+func NewFakeChargingStrategy(maxEnergyLevel float64) *fakeChargeStrategy {
+	return &fakeChargeStrategy{
 		maxEnergyLevel: maxEnergyLevel,
 	}
 }
 
 // @todo:
 // - Influence of returning candidate with no charge time and additional energy
-// CreateChargingStrategies returns different charging strategy
-func (f *fakeChargingStrategyCreator) CreateChargingStrategies() []State {
+// CreateChargingStates returns different charging strategy
+func (f *fakeChargeStrategy) CreateChargingStates() []State {
 	return []State{
 		State{
-			ChargingEnergy: f.maxEnergyLevel * 0.6,
+			Energy: f.maxEnergyLevel * 0.6,
 		},
 		State{
-			ChargingEnergy: f.maxEnergyLevel * 0.8,
+			Energy: f.maxEnergyLevel * 0.8,
 		},
 		State{
-			ChargingEnergy: f.maxEnergyLevel,
+			Energy: f.maxEnergyLevel,
 		},
 	}
 }
@@ -38,15 +38,15 @@ func (f *fakeChargingStrategyCreator) CreateChargingStrategies() []State {
 //                    1 hour charge to 60% of max energy
 //                    2 hour charge to 80%, means from 60% ~ 80% need 1 hour
 //                    4 hour charge to 100%, means from 80% ~ 100% need 2 hours
-func (f *fakeChargingStrategyCreator) EvaluateCost(arrivalEnergy float64, targetState State) ChargingCost {
+func (f *fakeChargeStrategy) EvaluateCost(arrivalEnergy float64, targetState State) ChargingCost {
 	sixtyPercentOfMaxEnergy := f.maxEnergyLevel * 0.6
 	eightyPercentOfMaxEnergy := f.maxEnergyLevel * 0.8
 	noNeedCharge := ChargingCost{
 		Duration: 0.0,
 	}
 
-	if arrivalEnergy > targetState.ChargingEnergy ||
-		util.FloatEquals(targetState.ChargingEnergy, 0.0) {
+	if arrivalEnergy > targetState.Energy ||
+		util.FloatEquals(targetState.Energy, 0.0) {
 		return noNeedCharge
 	}
 
@@ -58,7 +58,7 @@ func (f *fakeChargingStrategyCreator) EvaluateCost(arrivalEnergy float64, target
 		currentEnergy = sixtyPercentOfMaxEnergy
 	}
 
-	if util.FloatEquals(targetState.ChargingEnergy, sixtyPercentOfMaxEnergy) {
+	if util.FloatEquals(targetState.Energy, sixtyPercentOfMaxEnergy) {
 		return ChargingCost{
 			Duration: totalTime,
 		}
@@ -69,7 +69,7 @@ func (f *fakeChargingStrategyCreator) EvaluateCost(arrivalEnergy float64, target
 		totalTime += energyNeeded4Stage2 / (eightyPercentOfMaxEnergy - sixtyPercentOfMaxEnergy) * 3600.0
 		currentEnergy = eightyPercentOfMaxEnergy
 	}
-	if util.FloatEquals(targetState.ChargingEnergy, eightyPercentOfMaxEnergy) {
+	if util.FloatEquals(targetState.Energy, eightyPercentOfMaxEnergy) {
 		return ChargingCost{
 			Duration: totalTime,
 		}
@@ -80,7 +80,7 @@ func (f *fakeChargingStrategyCreator) EvaluateCost(arrivalEnergy float64, target
 		totalTime += energyNeeded4Stage3 / (f.maxEnergyLevel - eightyPercentOfMaxEnergy) * 7200.0
 	}
 
-	if util.FloatEquals(targetState.ChargingEnergy, f.maxEnergyLevel) {
+	if util.FloatEquals(targetState.Energy, f.maxEnergyLevel) {
 		return ChargingCost{
 			Duration: totalTime,
 		}

integration/oasis/chargingstrategy/chargingstrategy_test.go → integration/oasis/chargingstrategy/fake_charge_strategy_test.go

@@ -60,8 +60,8 @@ func TestFakeChargingStrategyCreator(t *testing.T) {
 
 	for _, c := range cases {
 		var actualResult []ChargingCost
-		strategy := NewFakeChargingStrategyCreator(c.maxEnergyLevel)
-		for _, state := range strategy.CreateChargingStrategies() {
+		strategy := NewFakeChargingStrategy(c.maxEnergyLevel)
+		for _, state := range strategy.CreateChargingStates() {
 			actualResult = append(actualResult, strategy.EvaluateCost(c.arrivalEnergyLevel, state))
 		}
 		if !reflect.DeepEqual(actualResult, c.expectResult) {

integration/oasis/chargingstrategy/null_charge_strategy.go

@@ -8,7 +8,7 @@ func NewNullChargeStrategy() *nullChargeStrategy {
 	return &nullChargeStrategy{}
 }
 
-func (f *nullChargeStrategy) CreateChargingStrategies() []State {
+func (f *nullChargeStrategy) CreateChargingStates() []State {
 	return []State{}
 }
 

integration/oasis/chargingstrategy/strategy_interface.go

@@ -0,0 +1,30 @@
+package chargingstrategy
+
+// State contains charging related information
+type State struct {
+	Energy float64
+}
+
+// ChargingCost represents the cost needed to reach certain states
+type ChargingCost struct {
+	Duration float64
+	// Later could add money usage, etc
+}
+
+// Creator creates charge states based on different charge strategy
+type Creator interface {
+	// CreateChargingStates creates charge States which could be used by other algorithm
+	CreateChargingStates() []State
+}
+
+// Evaluator calculate cost from given status(energy, etc) to target State
+type Evaluator interface {
+	// EvaluateCost accepts current status and target status and returns cost needed
+	EvaluateCost(arrivalEnergy float64, targetState State) ChargingCost
+}
+
+// Strategy defines interface related with creation and evaluation
+type Strategy interface {
+	Creator
+	Evaluator
+}

integration/oasis/has_enough_energy_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/Telenav/osrm-backend/integration/pkg/api/osrm/route"
+	"github.com/Telenav/osrm-backend/integration/util"
 )
 
 func TestHasEnoughEnergyPositive1(t *testing.T) {
@@ -20,7 +21,7 @@ func TestHasEnoughEnergyPositive1(t *testing.T) {
 	}
 
 	expect := 10000.0
-	if !floatEquals(remainRange, expect) {
+	if !util.FloatEquals(remainRange, expect) {
 		t.Errorf("Incorrect remaining range calculated, expect %s while actual value is %s", strconv.FormatFloat(expect, 'f', -1, 64), strconv.FormatFloat(remainRange, 'f', -1, 64))
 	}
 
@@ -39,16 +40,7 @@ func TestHasEnoughEnergyPositive2(t *testing.T) {
 	}
 
 	expect := 0.0
-	if !floatEquals(remainRange, expect) {
+	if !util.FloatEquals(remainRange, expect) {
 		t.Errorf("Incorrect remaining range calculated, expect %s while actual value is %s", strconv.FormatFloat(expect, 'f', -1, 64), strconv.FormatFloat(remainRange, 'f', -1, 64))
 	}
 }
-
-var epsilon float64 = 0.00000001
-
-func floatEquals(a, b float64) bool {
-	if (a-b) < epsilon && (b-a) < epsilon {
-		return true
-	}
-	return false
-}

integration/oasis/haversine/distance_test.go

@@ -1,21 +1,16 @@
 package haversine
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/Telenav/osrm-backend/integration/util"
+)
 
 func TestGreatCircleDistance(t *testing.T) {
 	// expect value got from http://www.onlineconversion.com/map_greatcircle_distance.htm
 	expect := 111595.4865288326
 	actual := GreatCircleDistance(32.333, 122.323, 31.333, 122.423)
-	if !floatEquals(expect, actual) {
+	if !util.FloatEquals(expect, actual) {
 		t.Errorf("Expected GreatCircleDistance returns %v, got %v", expect, actual)
 	}
 }
-
-var epsilon float64 = 0.00000001
-
-func floatEquals(a, b float64) bool {
-	if (a-b) < epsilon && (b-a) < epsilon {
-		return true
-	}
-	return false
-}

integration/oasis/reachable_by_multiple_charge.go

@@ -17,7 +17,7 @@ func pickChargeStationsWithEarlistArrival(oasisReq *oasis.Request, routeResp *ro
 	// for _, locations := range chargeLocations {
 	// 	c := stationfinder.CalculateWeightBetweenNeighbors(locations, oc, sc)
 	// 	sol := stationgraph.NewStationGraph(c, oasisReq.CurrRange, oasisReq.MaxRange,
-	// 		chargingstrategy.NewFakeChargingStrategyCreator(oasisReq.MaxRange)).GenerateChargeSolutions()
+	// 		chargingstrategy.NewFakeChargingStrategy(oasisReq.MaxRange)).GenerateChargeSolutions()
 	// }
 }
 

integration/oasis/stationfinder/stations_iterator_alg_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/Telenav/osrm-backend/integration/oasis/searchconnector"
 	"github.com/Telenav/osrm-backend/integration/pkg/api/osrm/table"
 	"github.com/Telenav/osrm-backend/integration/pkg/api/search/nearbychargestation"
+	"github.com/Telenav/osrm-backend/integration/util"
 )
 
 var mockDict1 map[string]bool = map[string]bool{
@@ -239,10 +240,10 @@ func TestCalculateWeightBetweenNeighbors(t *testing.T) {
 
 		if r.URL.EscapedPath() == "/entity/v4/search/json" {
 			req, _ := nearbychargestation.ParseRequestURL(r.URL)
-			if floatEquals(req.Location.Lat, 2.2) && floatEquals(req.Location.Lon, 2.2) {
+			if util.FloatEquals(req.Location.Lat, 2.2) && util.FloatEquals(req.Location.Lon, 2.2) {
 				var searchResponseBytes4Location1, _ = json.Marshal(nearbychargestation.MockSearchResponse1)
 				w.Write(searchResponseBytes4Location1)
-			} else if floatEquals(req.Location.Lat, 3.3) && floatEquals(req.Location.Lon, 3.3) {
+			} else if util.FloatEquals(req.Location.Lat, 3.3) && util.FloatEquals(req.Location.Lon, 3.3) {
 				var searchResponseBytes4Location2, _ = json.Marshal(nearbychargestation.MockSearchResponse3)
 				w.Write(searchResponseBytes4Location2)
 			}
@@ -530,12 +531,3 @@ func TestCalculateWeightBetweenNeighbors(t *testing.T) {
 		}
 	}
 }
-
-var epsilon float64 = 0.00000001
-
-func floatEquals(a, b float64) bool {
-	if (a-b) < epsilon && (b-a) < epsilon {
-		return true
-	}
-	return false
-}

integration/oasis/stationgraph/graph.go

@@ -9,7 +9,7 @@ type graph struct {
 	nodes       []*node
 	startNodeID nodeID
 	endNodeID   nodeID
-	strategy    chargingstrategy.ChargingStrategyCreator
+	strategy    chargingstrategy.Strategy
 }
 
 func (g *graph) dijkstra() []nodeID {