Make (Compressed)PixelFormat work with Configuration.

And thus also Arguments.

doc/changelog.dox

@@ -40,6 +40,10 @@ See also:
 
 @subsection changelog-latest-changes Changes and improvements
 
+-   The @ref PixelFormat and @ref CompressedPixelFormat enums can now be saved
+    and retrieved from @ref Corrade::Utility::Configuration /
+    @ref Corrade::Utility::Arguments
+
 @subsubsection changelog-latest-changes-trade Trade library
 
 -   For better usability, the @ref magnum-imageconverter "magnum-imageconverter"

src/Magnum/PixelFormat.cpp

@@ -25,6 +25,7 @@
 
 #include "PixelFormat.h"
 
+#include <string>
 #include <Corrade/Containers/ArrayView.h>
 #include <Corrade/Utility/Assert.h>
 #include <Corrade/Utility/Debug.h>
@@ -205,3 +206,39 @@ Debug& operator<<(Debug& debug, const CompressedPixelFormat value) {
 #endif
 
 }
+
+namespace Corrade { namespace Utility {
+
+std::string ConfigurationValue<Magnum::PixelFormat>::toString(Magnum::PixelFormat value, ConfigurationValueFlags) {
+    if(Magnum::UnsignedInt(value) - 1 < Containers::arraySize(Magnum::PixelFormatNames))
+        return Magnum::PixelFormatNames[Magnum::UnsignedInt(value) - 1];
+
+    return {};
+}
+
+Magnum::PixelFormat ConfigurationValue<Magnum::PixelFormat>::fromString(const std::string& stringValue, ConfigurationValueFlags) {
+    /** @todo This is extremely slow with >100 values. Do a binary search on a
+        sorted index list instead (extracted into a common utility) */
+    for(std::size_t i = 0; i != Containers::arraySize(Magnum::PixelFormatNames); ++i)
+        if(stringValue == Magnum::PixelFormatNames[i]) return Magnum::PixelFormat(i + 1);
+
+    return {};
+}
+
+std::string ConfigurationValue<Magnum::CompressedPixelFormat>::toString(Magnum::CompressedPixelFormat value, ConfigurationValueFlags) {
+    if(Magnum::UnsignedInt(value) - 1 < Containers::arraySize(Magnum::CompressedPixelFormatNames))
+        return Magnum::CompressedPixelFormatNames[Magnum::UnsignedInt(value) - 1];
+
+    return {};
+}
+
+Magnum::CompressedPixelFormat ConfigurationValue<Magnum::CompressedPixelFormat>::fromString(const std::string& stringValue, ConfigurationValueFlags) {
+    /** @todo This is extremely slow with >100 values. Do a binary search on a
+        sorted index list instead (extracted into a common utility) */
+    for(std::size_t i = 0; i != Containers::arraySize(Magnum::CompressedPixelFormatNames); ++i)
+        if(stringValue == Magnum::CompressedPixelFormatNames[i]) return Magnum::CompressedPixelFormat(i + 1);
+
+    return {};
+}
+
+}}

src/Magnum/PixelFormat.h

@@ -30,6 +30,7 @@
  */
 
 #include <Corrade/Utility/Assert.h>
+#include <Corrade/Utility/StlForwardString.h>
 
 #include "Magnum/Magnum.h"
 #include "Magnum/visibility.h"
@@ -2197,4 +2198,46 @@ template<class T = UnsignedInt> constexpr T compressedPixelFormatUnwrap(Compress
 
 }
 
+namespace Corrade { namespace Utility {
+
+/** @configurationvalue{Magnum::PixelFormat} */
+template<> struct MAGNUM_EXPORT ConfigurationValue<Magnum::PixelFormat> {
+    ConfigurationValue() = delete;
+
+    /**
+     * @brief Writes enum value as string
+     *
+     * If the value is invalid, returns empty string.
+     */
+    static std::string toString(Magnum::PixelFormat value, ConfigurationValueFlags);
+
+    /**
+     * @brief Reads enum value as string
+     *
+     * If the value is invalid, returns a zero (invalid) format.
+     */
+    static Magnum::PixelFormat fromString(const std::string& stringValue, ConfigurationValueFlags);
+};
+
+/** @configurationvalue{Magnum::CompressedPixelFormat} */
+template<> struct MAGNUM_EXPORT ConfigurationValue<Magnum::CompressedPixelFormat> {
+    ConfigurationValue() = delete;
+
+    /**
+     * @brief Write enum value as string
+     *
+     * If the value is invalid, returns empty string.
+     */
+    static std::string toString(Magnum::CompressedPixelFormat value, ConfigurationValueFlags);
+
+    /**
+     * @brief Read enum value as string
+     *
+     * If the value is invalid, returns a zero (invalid) format.
+     */
+    static Magnum::CompressedPixelFormat fromString(const std::string& stringValue, ConfigurationValueFlags);
+};
+
+}}
+
 #endif

src/Magnum/Test/PixelFormatTest.cpp

@@ -27,6 +27,7 @@
 #include <Corrade/TestSuite/Tester.h>
 #include <Corrade/TestSuite/Compare/Numeric.h>
 #include <Corrade/Utility/DebugStl.h>
+#include <Corrade/Utility/Configuration.h>
 
 #include "Magnum/PixelFormat.h"
 #include "Magnum/Math/Vector3.h"
@@ -64,6 +65,9 @@ struct PixelFormatTest: TestSuite::Tester {
 
     void compressedDebug();
     void compressedDebugImplementationSpecific();
+
+    void configuration();
+    void compresedConfiguration();
 };
 
 PixelFormatTest::PixelFormatTest() {
@@ -94,7 +98,10 @@ PixelFormatTest::PixelFormatTest() {
               &PixelFormatTest::debugImplementationSpecific,
 
               &PixelFormatTest::compressedDebug,
-              &PixelFormatTest::compressedDebugImplementationSpecific});
+              &PixelFormatTest::compressedDebugImplementationSpecific,
+
+              &PixelFormatTest::configuration,
+              &PixelFormatTest::compresedConfiguration});
 }
 
 void PixelFormatTest::mapping() {
@@ -351,6 +358,38 @@ void PixelFormatTest::compressedDebugImplementationSpecific() {
     CORRADE_COMPARE(out.str(), "CompressedPixelFormat::ImplementationSpecific(0xdead)\n");
 }
 
+void PixelFormatTest::configuration() {
+    Utility::Configuration c;
+
+    c.setValue("format", PixelFormat::RGB8Srgb);
+    CORRADE_COMPARE(c.value("format"), "RGB8Srgb");
+    CORRADE_COMPARE(c.value<PixelFormat>("format"), PixelFormat::RGB8Srgb);
+
+    c.setValue("zero", PixelFormat(0));
+    CORRADE_COMPARE(c.value("zero"), "");
+    CORRADE_COMPARE(c.value<PixelFormat>("zero"), PixelFormat{});
+
+    c.setValue("invalid", PixelFormat(0xdead));
+    CORRADE_COMPARE(c.value("invalid"), "");
+    CORRADE_COMPARE(c.value<PixelFormat>("invalid"), PixelFormat{});
+}
+
+void PixelFormatTest::compresedConfiguration() {
+    Utility::Configuration c;
+
+    c.setValue("format", CompressedPixelFormat::Astc3x3x3RGBASrgb);
+    CORRADE_COMPARE(c.value("format"), "Astc3x3x3RGBASrgb");
+    CORRADE_COMPARE(c.value<CompressedPixelFormat>("format"), CompressedPixelFormat::Astc3x3x3RGBASrgb);
+
+    c.setValue("zero", CompressedPixelFormat(0));
+    CORRADE_COMPARE(c.value("zero"), "");
+    CORRADE_COMPARE(c.value<CompressedPixelFormat>("zero"), CompressedPixelFormat{});
+
+    c.setValue("invalid", CompressedPixelFormat(0xdead));
+    CORRADE_COMPARE(c.value("invalid"), "");
+    CORRADE_COMPARE(c.value<CompressedPixelFormat>("invalid"), CompressedPixelFormat{});
+}
+
 }}}
 
 CORRADE_TEST_MAIN(Magnum::Test::PixelFormatTest)