return empty optional when color could not be parsed

Author: ivovandongen

Makefile

@@ -1,4 +1,4 @@
-CXXFLAGS = -std=c++11 -Wall -Wextra -Wpedantic -Wno-unused-parameter
+CXXFLAGS = -std=c++14 -Wall -Wextra -Wpedantic -Wno-unused-parameter
 
 build: test
 

csscolorparser.cpp

@@ -179,7 +179,7 @@ std::vector<std::string> split(const std::string& s, char delim) {
     return elems;
 }
 
-Color parse(const std::string& css_str) {
+optional<Color> parse(const std::string& css_str) {
     std::string str = css_str;
 
     // Remove all whitespace, not compliant, but should just be more accepting.
@@ -191,7 +191,7 @@ Color parse(const std::string& css_str) {
 
     for (size_t i = 0; i < namedColorCount; i++) {
         if (str == namedColors[i].name) {
-            return namedColors[i].color;
+            return { namedColors[i].color };
         }
     }
 
@@ -202,24 +202,24 @@ Color parse(const std::string& css_str) {
             if (!(iv >= 0 && iv <= 0xfff)) {
                 return {};
             } else {
-                return {
+                return {{
                     static_cast<uint8_t>(((iv & 0xf00) >> 4) | ((iv & 0xf00) >> 8)),
                     static_cast<uint8_t>((iv & 0xf0) | ((iv & 0xf0) >> 4)),
                     static_cast<uint8_t>((iv & 0xf) | ((iv & 0xf) << 4)),
                     1
-                };
+                }};
             }
         } else if (str.length() == 7) {
             int64_t iv = parseInt(str.substr(1), 16);  // TODO(deanm): Stricter parsing.
             if (!(iv >= 0 && iv <= 0xffffff)) {
                 return {};  // Covers NaN.
             } else {
-                return {
+                return {{
                     static_cast<uint8_t>((iv & 0xff0000) >> 16),
                     static_cast<uint8_t>((iv & 0xff00) >> 8),
                     static_cast<uint8_t>(iv & 0xff),
                     1
-                };
+                }};
             }
         }
 
@@ -245,12 +245,12 @@ Color parse(const std::string& css_str) {
                 }
             }
 
-            return {
+            return {{
                 parse_css_int(params[0]),
                 parse_css_int(params[1]),
                 parse_css_int(params[2]),
                 alpha
-            };
+            }};
 
         } else if (fname == "hsla" || fname == "hsl") {
             if (fname == "hsla") {
@@ -276,12 +276,12 @@ Color parse(const std::string& css_str) {
             float m2 = l <= 0.5f ? l * (s + 1.0f) : l + s - l * s;
             float m1 = l * 2.0f - m2;
 
-            return {
+            return {{
                 clamp_css_byte(css_hue_to_rgb(m1, m2, h + 1.0f / 3.0f) * 255.0f),
                 clamp_css_byte(css_hue_to_rgb(m1, m2, h) * 255.0f),
                 clamp_css_byte(css_hue_to_rgb(m1, m2, h - 1.0f / 3.0f) * 255.0f),
                 alpha
-            };
+            }};
         }
     }
 

csscolorparser.hpp

@@ -27,9 +27,13 @@
 
 #include <string>
 #include <cmath>
+#include <experimental/optional>
 
 namespace CSSColorParser {
 
+template <class T>
+using optional = std::experimental::optional<T>;
+
 struct Color {
     inline Color() {
     }
@@ -41,14 +45,14 @@ struct Color {
 };
 
 inline bool operator==(const Color& lhs, const Color& rhs) {
-    return lhs.r == rhs.r && lhs.g == rhs.g && lhs.b == rhs.b && ::fabs(lhs.a - lhs.b) < 0.0001f;
+    return lhs.r == rhs.r && lhs.g == rhs.g && lhs.b == rhs.b && ::fabs(lhs.a - rhs.a) < 0.0001f;
 }
 
 inline bool operator!=(const Color& lhs, const Color& rhs) {
     return !(lhs == rhs);
 }
 
-Color parse(const std::string& css_str);
+optional<Color> parse(const std::string& css_str);
 
 } // namespace CSSColorParser
 

test.cpp

@@ -4,30 +4,34 @@
 
 using namespace CSSColorParser;
 
-std::ostream& operator<<(std::ostream& os, const Color& color) {
-    return os << "rgba(" << int(color.r) << ", " << int(color.g) << ", " << int(color.b) << ", "
-              << color.a << ")";
+std::ostream& operator<<(std::ostream& os, const optional<Color>& color) {
+    if (color) {
+        return os << "rgba(" << int(color->r) << ", " << int(color->g) << ", " << int(color->b)
+                  << ", " << color->a << ")";
+    } else {
+        return os << "<no color>";
+    }
 }
 
 static bool errored = false;
 
-void ASSERT_EQUAL(const Color& expected, const std::string& input) {
+void ASSERT_EQUAL(const optional<Color>& expected, const std::string& input) {
     const auto actual = parse(input);
     if (expected != actual) {
         errored = true;
         std::cerr << "\033[1mERROR!: expected " << expected << " != parsed " << actual
                   << " when parsing \"" << input << "\"\033[0m" << std::endl;
     } else {
-        std::cerr << "Passed: " << actual << std::endl;
+        std::cerr << "Passed: " << actual << " expected when parsing \"" << input << "\"" << std::endl;
     }
 }
 
-void ASSERT_EQUAL(const Color& expected, const Color& actual) {
+void ASSERT_EQUAL(const optional<Color>& expected, const optional<Color>& actual) {
     if (expected != actual) {
         errored = true;
         std::cerr << "\033[1mERROR!: expected " << expected << " != actual " << actual << "\"\033[0m" << std::endl;
     } else {
-        std::cerr << "Passed: " << actual << std::endl;
+        std::cerr << "Passed: " << actual << " expected" << std::endl;
     }
 }
 
@@ -37,15 +41,15 @@ int main() {
         ASSERT_EQUAL(Color{ 255, 255, 255, 1 }, "#fff");
         ASSERT_EQUAL(Color{ 255, 0, 17, 1 }, "#ff0011");
         ASSERT_EQUAL(Color{ 106, 90, 205, 1 }, "slateblue");
-        ASSERT_EQUAL(Color{ 0, 0, 0, 1 }, "blah");
-        ASSERT_EQUAL(Color{ 0, 0, 0, 1 }, "ffffff");
+        ASSERT_EQUAL({}, "blah");
+        ASSERT_EQUAL({}, "ffffff");
         ASSERT_EQUAL(Color{ 226, 233, 233, 0.5 }, "hsla(900, 15%, 90%, 0.5)");
-        ASSERT_EQUAL(Color{ 0, 0, 0, 1 }, "hsla(900, 15%, 90%)");
+        ASSERT_EQUAL({}, "hsla(900, 15%, 90%)");
         ASSERT_EQUAL(Color{ 226, 233, 233, 1 }, "hsl(900, 15%, 90%)");
         ASSERT_EQUAL(Color{ 226, 233, 233, 1 }, "hsl(900, 0.15, 90%)"); // NOTE: not spec compliamt.
 
         // Out of range:
-        ASSERT_EQUAL(Color{ 0, 0, 0, 1 }, "xxx");
+        ASSERT_EQUAL({}, "xxx");
         ASSERT_EQUAL(Color{ 255, 128, 12, 1 }, " rgba (255, 128, 12, 2)");
         ASSERT_EQUAL(Color{ 255, 128, 12, 1 }, " rgba (400, 128, 12, 2)");
         ASSERT_EQUAL(Color{ 255, 128, 12, 1 }, Color{ 255, 128, 12, 3 });