Fix GitHub Issue #1: Implement conflicting options

- The user can now set two or more options as conflicting

Author: juzzlin

README.md

@@ -247,6 +247,38 @@ Options:
 
 ```
 
+## General: Setting two or more options as conflicting
+
+Sometimes we want to prevent the user from giving a certain set of arguments.
+
+Consider this example code:
+
+```
+    ...
+
+    juzzlin::Argengine ae(argc, argv);
+    ae.addOption(
+      { "foo" }, [] {
+          std::cout << "Foo enabled!" << std::endl;
+      });
+
+    ae.addOption(
+      { "bar" }, [] {
+          std::cout << "Bar enabled!" << std::endl;
+      });
+
+    // Set "foo" and "bar" as conflicting options.
+    ae.addConflictingOptions({ "foo", "bar" });
+    ...
+```
+
+Now, if we give both `foo` and `bar` to the application, we'll get an error like this:
+
+
+```
+Argengine: Conflicting options: 'bar', 'foo'. These options cannot coexist.
+```
+
 ## General: Error handling
 
 For error handling there are two options: exceptions or error value.

src/argengine.cpp

@@ -64,6 +64,11 @@ class Argengine::Impl
         return od;
     }
 
+    void addConflictingOptions(ConflictingOptionSet conflictingOptionSet)
+    {
+        m_conflictingOptionSets.push_back(conflictingOptionSet);
+    }
+
     ArgumentVector arguments() const
     {
         return m_args;
@@ -327,10 +332,34 @@ class Argengine::Impl
         return tokens;
     }
 
+    void checkConflictingOptions(const ArgumentVector & tokens)
+    {
+        OptionDefinitionVector optionDefinitions;
+        for (size_t i = 1; i < tokens.size(); i++) {
+            if (const auto arg = tokens.at(i); const auto definition = getOptionDefinition(arg)) {
+                optionDefinitions.push_back(definition);
+            }
+        }
+        for (auto && conflictingOptionSet : m_conflictingOptionSets) {
+            ConflictingOptionSet conflictingOptionSetForError;
+            for (auto && conflictingOption : conflictingOptionSet) {
+                for (auto && optionDefinition : optionDefinitions) {
+                    if (optionDefinition->matches({ conflictingOption })) {
+                        conflictingOptionSetForError.insert(conflictingOption);
+                    }
+                }
+            }
+            if (conflictingOptionSetForError.size() > 1) {
+                throwConflictingOptionsError(conflictingOptionSetForError);
+            }
+        }
+    }
+
     void processArgs(bool dryRun)
     {
         const auto tokens = tokenize(m_args);
-        ArgumentVector positionalArguments;
+
+        checkConflictingOptions(tokens);
 
         // Process help first as it's a special case
         for (size_t i = 1; i < tokens.size(); i++) {
@@ -343,6 +372,7 @@ class Argengine::Impl
         }
 
         // Other arguments
+        ArgumentVector positionalArguments;
         for (size_t i = 1; i < tokens.size(); i++) {
             if (const auto arg = tokens.at(i); const auto definition = getOptionDefinition(arg)) {
                 if (!definition->isHelp) {
@@ -385,6 +415,18 @@ class Argengine::Impl
         return currentIndex;
     }
 
+    [[noreturn]] void throwConflictingOptionsError(const ConflictingOptionSet & conflictingOptionSet) const
+    {
+        std::string optionsString;
+        for (auto && option : conflictingOptionSet) {
+            if (!optionsString.empty() && optionsString.back() == '\'') {
+                optionsString += ", ";
+            }
+            optionsString += "'" + option + "'";
+        }
+        throw std::runtime_error(name() + ": Conflicting options: " + optionsString + ". These options cannot coexist.");
+    }
+
     [[noreturn]] void throwOptionExistingError(const OptionDefinition & existing) const
     {
         throw std::runtime_error(name() + ": Option '" + existing.getVariantsString() + "' already defined!");
@@ -411,7 +453,10 @@ class Argengine::Impl
 
     HelpSorting m_helpSorting = HelpSorting::None;
 
-    std::vector<OptionDefinitionPtr> m_optionDefinitions;
+    using OptionDefinitionVector = std::vector<OptionDefinitionPtr>;
+    OptionDefinitionVector m_optionDefinitions;
+
+    std::vector<ConflictingOptionSet> m_conflictingOptionSets;
 
     MultiStringCallback m_positionalArgumentCallback = nullptr;
 
@@ -445,6 +490,11 @@ void Argengine::addHelp(OptionVariants optionVariants, ValuelessCallback callbac
     m_impl->addOption(optionVariants, callback, false, SHOW_THIS_HELP_TEXT)->isHelp = true;
 }
 
+void Argengine::addConflictingOptions(ConflictingOptionSet conflictingOptionSet)
+{
+    m_impl->addConflictingOptions(conflictingOptionSet);
+}
+
 Argengine::ArgumentVector Argengine::arguments() const
 {
     return m_impl->arguments();

src/argengine.hpp

@@ -74,6 +74,11 @@ class Argengine
     //! \param callback Callback to be called when the help option has been given. Signature: `void()`.
     void addHelp(OptionVariants optionVariants, ValuelessCallback callback);
 
+    //! Adds a options that cannot coexist.
+    //! \param conflictingOptions A set of possible options that cannot coexist, e.g.: {"--bar", "--foo"}
+    using ConflictingOptionSet = std::set<std::string>;
+    void addConflictingOptions(ConflictingOptionSet conflictingOptionSet);
+
     //! \return All given arguments.
     ArgumentVector arguments() const;
 

src/examples/CMakeLists.txt

@@ -1,2 +1,2 @@
 add_subdirectory(ex1)
-
+add_subdirectory(ex2)

src/examples/ex2/CMakeLists.txt

@@ -0,0 +1,10 @@
+set(ARGENGINE_DIR ${CMAKE_SOURCE_DIR}/src)
+include_directories(${ARGENGINE} ${CMAKE_CURRENT_SOURCE_DIR})
+
+set(NAME ex2)
+set(SRC ${NAME}.cpp)
+
+set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR})
+add_executable(${NAME} ${SRC})
+target_link_libraries(${NAME} ${LIBRARY_NAME})
+

src/examples/ex2/ex2.cpp

@@ -0,0 +1,69 @@
+// MIT License
+//
+// Copyright (c) 2023 Jussi Lind <jussi.lind@iki.fi>
+//
+// https://github.com/juzzlin/Argengine
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "argengine.hpp"
+
+#include <cstdlib>
+#include <iostream>
+
+using juzzlin::Argengine;
+
+//
+// Ex2: Demonstrate conflicting options.
+//
+
+int main(int argc, char ** argv)
+{
+    // Instantiate Argengine and give it the raw argument data.
+    Argengine ae(argc, argv);
+
+    // Add a minimal dummy option "foo".
+    ae.addOption(
+      { "foo" }, [] {
+          std::cout << "Foo enabled!" << std::endl;
+      });
+
+    // Add a minimal dummy option "bar".
+    ae.addOption(
+      { "bar" }, [] {
+          std::cout << "Bar enabled!" << std::endl;
+      });
+
+    // Set "foo" and "bar" as conflicting options.
+    ae.addConflictingOptions({ "foo", "bar" });
+
+    // Parse the arguments and store possible error to variable error.
+    Argengine::Error error;
+    ae.parse(error);
+
+    // Check error and print the possible error message.
+    if (error.code != Argengine::Error::Code::Ok) {
+        std::cerr << error.message << std::endl
+                  << std::endl;
+        ae.printHelp(); // Print the auto-generated help.
+        return EXIT_FAILURE;
+    }
+
+    return EXIT_SUCCESS;
+}

src/tests/CMakeLists.txt

@@ -1,3 +1,4 @@
+add_subdirectory(conflicting_arguments_test)
 add_subdirectory(help_test)
 add_subdirectory(positional_argument_test)
 add_subdirectory(single_value_test)

src/tests/conflicting_arguments_test/CMakeLists.txt

@@ -0,0 +1,10 @@
+set(ARGENGINE_DIR ${CMAKE_SOURCE_DIR}/src)
+include_directories(${ARGENGINE} ${CMAKE_CURRENT_SOURCE_DIR})
+
+set(NAME conflicting_arguments_test)
+set(SRC ${NAME}.cpp)
+
+set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/tests)
+add_executable(${NAME} ${SRC})
+add_test(${NAME} ${CMAKE_BINARY_DIR}/tests/${NAME})
+target_link_libraries(${NAME} ${LIBRARY_NAME})

src/tests/conflicting_arguments_test/conflicting_arguments_test.cpp

@@ -0,0 +1,113 @@
+// MIT License
+//
+// Copyright (c) 2023 Jussi Lind <jussi.lind@iki.fi>
+//
+// https://github.com/juzzlin/Argengine
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "../../argengine.hpp"
+
+// Don't compile asserts away
+#ifdef NDEBUG
+    #undef NDEBUG
+#endif
+
+#include <cassert>
+#include <cstdlib>
+#include <iostream>
+
+using juzzlin::Argengine;
+
+const auto name = "Argengine";
+
+void testConflictingArguments_ConflictingArgumentsGiven_ShouldFail()
+{
+    Argengine ae({ "test", "foo", "bar" });
+    bool fooCalled {};
+    ae.addOption({ "foo" }, [&] {
+        fooCalled = true;
+    });
+    bool barCalled {};
+    ae.addOption({ "bar" }, [&] {
+        barCalled = true;
+    });
+    ae.addConflictingOptions({ "foo", "bar" });
+    std::string error;
+    try {
+        ae.parse();
+    } catch (std::runtime_error & e) {
+        error = e.what();
+    }
+    assert(!fooCalled);
+    assert(!barCalled);
+    assert(error == std::string(name) + ": Conflicting options: 'bar', 'foo'. These options cannot coexist.");
+}
+
+void testConflictingArguments_ConflictingArgumentsSetButNotEnoughGiven_ShouldSucceed()
+{
+    Argengine ae({ "test", "foo" });
+    bool fooCalled {};
+    ae.addOption({ "foo" }, [&] {
+        fooCalled = true;
+    });
+    ae.addConflictingOptions({ "foo", "bar" });
+    std::string error;
+    try {
+        ae.parse();
+    } catch (std::runtime_error & e) {
+        error = e.what();
+    }
+    assert(fooCalled);
+    assert(error.empty());
+}
+
+void testConflictingArguments_ConflictingArgumentsGiven_ShouldNotReferToVariants()
+{
+    Argengine ae({ "test", "foo", "bar" });
+    bool fooCalled {};
+    ae.addOption({ "foo", "-f" }, [&] {
+        fooCalled = true;
+    });
+    bool barCalled {};
+    ae.addOption({ "-b", "bar" }, [&] {
+        barCalled = true;
+    });
+    ae.addConflictingOptions({ "foo", "bar" });
+    std::string error;
+    try {
+        ae.parse();
+    } catch (std::runtime_error & e) {
+        error = e.what();
+    }
+    assert(!fooCalled);
+    assert(!barCalled);
+    assert(error == std::string(name) + ": Conflicting options: 'bar', 'foo'. These options cannot coexist.");
+}
+
+int main(int, char **)
+{
+    testConflictingArguments_ConflictingArgumentsGiven_ShouldFail();
+
+    testConflictingArguments_ConflictingArgumentsSetButNotEnoughGiven_ShouldSucceed();
+
+    testConflictingArguments_ConflictingArgumentsGiven_ShouldNotReferToVariants();
+
+    return EXIT_SUCCESS;
+}