1 #include <mbgl/style/conversion/light.hpp>
2 #include <mbgl/style/conversion/position.hpp>
3 #include <mbgl/style/conversion/property_value.hpp>
4 #include <mbgl/style/conversion/transition_options.hpp>
5 
6 namespace mbgl {
7 namespace style {
8 namespace conversion {
9 
operator ()(const Convertible & value,Error & error) const10 optional<Light> Converter<Light>::operator()(const Convertible& value, Error& error) const {
11     if (!isObject(value)) {
12         error = { "light must be an object" };
13         return {};
14     }
15 
16     Light light;
17 
18     const auto anchor = objectMember(value, "anchor");
19     if (anchor) {
20         optional<PropertyValue<LightAnchorType>> convertedAnchor =
21             convert<PropertyValue<LightAnchorType>>(*anchor, error, false);
22 
23         if (convertedAnchor) {
24             light.setAnchor(*convertedAnchor);
25         } else {
26             return {};
27         }
28     }
29 
30     const auto anchorTransition = objectMember(value, "anchor-transition");
31     if (anchorTransition) {
32         optional<TransitionOptions> transition =
33             convert<TransitionOptions>(*anchorTransition, error);
34         if (transition) {
35             light.setAnchorTransition(*transition);
36         } else {
37             return {};
38         }
39     }
40 
41     const auto color = objectMember(value, "color");
42     if (color) {
43         optional<PropertyValue<Color>> convertedColor =
44             convert<PropertyValue<Color>>(*color, error, false);
45 
46         if (convertedColor) {
47             light.setColor(*convertedColor);
48         } else {
49             return {};
50         }
51     }
52 
53     const auto colorTransition = objectMember(value, "color-transition");
54     if (colorTransition) {
55         optional<TransitionOptions> transition =
56             convert<TransitionOptions>(*colorTransition, error);
57         if (transition) {
58             light.setColorTransition(*transition);
59         } else {
60             return {};
61         }
62     }
63 
64     const auto position = objectMember(value, "position");
65     if (position) {
66         optional<PropertyValue<Position>> convertedPosition =
67             convert<PropertyValue<Position>>(*position, error, false);
68 
69         if (convertedPosition) {
70             light.setPosition(*convertedPosition);
71         } else {
72             return {};
73         }
74     }
75 
76     const auto positionTransition = objectMember(value, "position-transition");
77     if (positionTransition) {
78         optional<TransitionOptions> transition =
79             convert<TransitionOptions>(*positionTransition, error);
80         if (transition) {
81             light.setPositionTransition(*transition);
82         } else {
83             return {};
84         }
85     }
86 
87     const auto intensity = objectMember(value, "intensity");
88     if (intensity) {
89         optional<PropertyValue<float>> convertedIntensity =
90             convert<PropertyValue<float>>(*intensity, error, false);
91 
92         if (convertedIntensity) {
93             light.setIntensity(*convertedIntensity);
94         } else {
95             return {};
96         }
97     }
98 
99     const auto intensityTransition = objectMember(value, "intensity-transition");
100     if (intensityTransition) {
101         optional<TransitionOptions> transition =
102             convert<TransitionOptions>(*intensityTransition, error);
103         if (transition) {
104             light.setIntensityTransition(*transition);
105         } else {
106             return {};
107         }
108     }
109 
110     return { std::move(light) };
111 }
112 
113 } // namespace conversion
114 } // namespace style
115 } // namespace mbgl
116