Possibility to pass class method reference

[command.git] / include / argument.h

diff --git a/include/argument.h b/include/argument.h
index 3ac1d71a8c034172263bff28f3235a36280720a0..2cd3c300f970a8d2e205de7685a6f10fd9ad241d 100644 (file)
--- a/include/argument.h
+++ b/include/argument.h
@@ -2,7 +2,9 @@
 #define __COMMAND_ARGUMENT_H
 
 #include <string>
+#include <sstream>
 #include <iostream>
+#include <functional>
 
 #include "parameter.h"
 #include "callable.h"
@@ -10,33 +12,82 @@
 namespace command {
     /**
      * Class responsible for handling commandline arguments.
-     * Arguments are required,x non-named parameters of program.
+     * Arguments are non-named parameters of program.
      *
      * Example:
-     *  ./myprog ARGUMENT
+     *  - ./myprog ARGUMENT
+     *  - ./myprog /path/to/file
+     *  - ./myprog "some argument"
      */
-    template<typename ArgumentType>
-    class Argument : public Parameter, public Callable<ArgumentType> {
+    template<typename ParameterType>
+    class Argument : public Parameter, public Callable<ParameterType> {
+    protected:
+        ParameterType value;
     public:
         typedef class Argument Type;
+
         /**
          * Default constructor.
          *
          * @param description Description of current Argument
          * @param function Function used to handle current Argument.
          */
-        Argument(const std::string & description, void (*function)(ArgumentType))
-            : Parameter(description), Callable<ArgumentType>(function) {
+        Argument(const std::string & description, void (*function)(ParameterType))
+            : Parameter(description), Callable<ParameterType>(function) {
+        }
+
+        Argument(const std::string & description, std::function<void(ParameterType)> function)
+            : Parameter(description), Callable<ParameterType>(function) {
         }
+
+        /**
+         *
+         */
         virtual ~Argument() { }
 
+        /**
+         * \inheritdoc
+         */
         virtual void handle() {
-            this->call(std::string("A"));
+            this->call(value);
+            this->used = true;
         }
 
-        virtual bool understand(const std::string &) {
+        /**
+         * 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 ParameterType 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 ParameterType,
+         *  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) {
+            std::stringstream ss;
+
+            ss << std::fixed << argv;
+            ss >> value;
+
+            if (!ss.fail()) {
+                return true;
+            }
+
             return false;
         }
+
+        /**
+         * \inheritdoc
+         */
+        virtual unsigned int valuePosition(const std::string & ) {
+            return 0;
+        }
     };
 }