Added mechanism to understand passed Option without value.

[command.git] / include / argument.h

diff --git a/include/argument.h b/include/argument.h
index 6a292b4f6b63135945f8d8a9619b427c4b5de450..53dea343344e8b3b1bf42ab301551135eb9d33c0 100644 (file)
--- a/include/argument.h
+++ b/include/argument.h
@@ -2,46 +2,85 @@
 #define __COMMAND_ARGUMENT_H
 
 #include <string>
+#include <sstream>
+#include <iostream>
 
-#include <command/descriptive.h>
+#include "parameter.h"
+#include "callable.h"
 
 namespace command {
     /**
      * Class responsible for handling commandline arguments.
-     * Arguments are required non-named parameters for program.
+     * Arguments are required, non-named parameters of program.
+     * Accepts
      *
      * Example:
      *  ./myprog ARGUMENT
+     *  ./myprog /path/to/file
+     *  ./myprog "some argument"
      */
     template<typename ArgumentType>
-    class Argument : public Descriptive {
-    public:
-        typedef void (*)(ArgumentType) FunctionType;
-
+    class Argument : public Parameter, public Callable<ArgumentType> {
     protected:
-        /**
-         * Function handling user Arguments
-         */
-        FunctionType function;
+        /** Variable indicating if current Argument was already used or not */
+        bool used = false;
 
+        ArgumentType argument;
     public:
+        typedef class Argument Type;
+
         /**
          * Default constructor.
          *
          * @param description Description of current Argument
          * @param function Function used to handle current Argument.
          */
-        Argument(std::string description, FunctionType function)
-            : Descriptive(description), function(function) {
+        Argument(const std::string & description, void (*function)(ArgumentType))
+            : Parameter(description), Callable<ArgumentType>(function) {
         }
 
         /**
-         * Executes command binded with argument
          *
-         * @param value Value passed to program argument
          */
-        void run(ArgumentType value) {
-            this->function(value);
+        virtual ~Argument() { }
+
+        /**
+         *
+         */
+        virtual void handle() {
+            this->call(argument);
+        }
+
+        /**
+         * Method used for checking if Argument understands user value.
+         * If so current Argument is flagged as used and no more checks against
+         * it will be done in future.
+         *
+         * \attention If conversion from passed value to ArgumentType is
+         * impossible, it is ignored. It means that it is not understanded by
+         * Argument.
+         *
+         * @param argv command line value against which test will be made.
+         *
+         * @return If passed argv is succesfully converted to ArgumentType,
+         *  returns true and Argument is set as used one. If there was an error
+         *  during conversion, method returns false and can be used to check
+         *  against next value.
+         */
+        virtual bool understand(const std::string & argv) {
+            if (!used) {
+                std::stringstream ss;
+
+                ss << argv;
+                ss >> argument;
+
+                if (!ss.fail()) {
+                    used = true;
+                    return true;
+                }
+            }
+
+            return false;
         }
     };
 }