project hyperion-remote created;

getoptPlusPlus dependency added;
small changes to getOptPlusPlus;

dependencies/build/getoptPlusPlus/test.cc

@@ -0,0 +1,196 @@
+ /* (C) 2011 Viktor Lofgren
+  *
+  *  This program is free software: you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License as published by
+  * the Free Software Foundation, either version 3 of the License, or
+  * any later version.
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+  */
+
+
+
+#include "getoptpp.h"
+#include <cstdlib>
+#include <cctype>
+#include <iostream>
+#include <algorithm>
+
+using namespace std;
+using namespace vlofgren;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+/*
+ *
+ * This is one way of adding new parameter types,
+ * inheriting existing types and adding new validation.
+ *
+ * In this case, StringParameter (which is a typedef of PODParameter<string> gets
+ * a new validator that only accepts strings with only letters.
+ *
+ */
+
+
+class AlphabeticParameter : public StringParameter {
+public:
+	AlphabeticParameter(char shortName, const char* longName, const char* description) :
+		StringParameter(shortName, longName, description) {}
+	virtual ~AlphabeticParameter() {}
+
+	void receiveSwitch() throw(Parameter::ParameterRejected) {
+		throw Parameter::ParameterRejected();
+	}
+
+
+	/* isalpha may be a macro */
+	static bool isNotAlpha(char c) { return !isalpha(c); }
+
+	virtual string validate(const string& arg) throw(Parameter::ParameterRejected) {
+		int nonalpha = count_if(arg.begin(), arg.end(), isNotAlpha);
+
+
+		if(nonalpha) throw Parameter::ParameterRejected("I only want numbers");
+		else return arg;
+	}
+
+};
+
+/*
+ *
+ * The other way is to specialize the PODParameter class
+ *
+ */
+
+enum RockPaperScissor { ROCK, PAPER, SCISSOR } ;
+
+namespace vlofgren {
+	// needs to live in the vlofgren namespace for whatever reason
+	template<> enum RockPaperScissor
+	PODParameter<enum RockPaperScissor>::validate(const string &s) throw(Parameter::ParameterRejected)
+	{
+		if(s == "rock")
+			return ROCK;
+		else if(s == "paper")
+			return PAPER;
+		else if(s == "scissor")
+			return SCISSOR;
+		else {
+			throw ParameterRejected("Invalid argument");
+		}
+
+	}
+}
+typedef PODParameter<enum RockPaperScissor> RockPaperScissorParameter;
+
+
+/*
+ *
+ *  Dummy program
+ *
+ */
+
+
+int main(int argc, const char* argv[]) {
+
+	// Create a parser
+
+	OptionsParser optp("An example program (that also runs some tests)");
+	ParameterSet& ps = optp.getParameters();
+
+	/* An alternative option is to simply extend the options parser and set all this up
+	 * in the constructor.
+	 */
+
+	ps.add<SwitchParameter>('f', "foo", "Enable the foo system (no argument)");
+	ps.add<StringParameter>('b', "bar", "Enable the bar system (string argument)");
+	ps.add<PODParameter<double> >('z', "baz", "Enable the baz system (floating point argument");
+
+	PODParameter<int>& i = ps.add<PODParameter<int> >('i', "foobar", "Enable the foobar system (integer argument");
+	i.setDefault(15);
+
+	ps.add<AlphabeticParameter>('a', "alpha", "Custom parameter that requires a string of letters");
+	ps.add<RockPaperScissorParameter>('r', "rps", "Takes the values rock, paper or scissor");
+	ps.add<SwitchParameter>('h', "help", "Display help screen");
+
+
+	// Register the parameters with the parser
+
+	try {
+		// Parse argv
+		optp.parse(argc, argv);
+
+		// Test for the help flag
+		if(ps['h'].isSet()) {
+			optp.usage();
+			return EXIT_SUCCESS;
+		}
+
+		// Print out what values the parameters were given
+
+		cout << "The following parameters were set:" << endl;
+
+		cout << "foo: " << (ps['f'].isSet() ? "true" : "false") << endl;
+		cout << "bar: \"" << ps['b'].get<string>() << "\""<< endl;
+		cout << "baz: ";
+
+		if(ps['z'].isSet()) {
+			cout << ps['z'].get<double>() << endl;
+		} else {
+			cout << "not set" << endl;
+		}
+
+		/* You can also save the return value from ParserSet::add() if
+		 * you feel the operator[].get<T>() stuff is a bit much */
+		cout << "foobar: ";
+		if(i.isSet()) {
+			cout << i.get<int>() << endl;
+		} else {
+			cout << "not set" << endl;
+		}
+		cout << "alpha: ";
+		if(ps["alpha"].isSet()) {
+			cout << ps["alpha"].get<string>() << endl;
+		} else {
+			cout << "not set" << endl;
+		}
+
+		cout << "rps: ";
+		if(ps["rps"].isSet()) {
+			cout << ps["rps"].get<enum RockPaperScissor>() << endl;
+		} else {
+			cout << "not set" << endl;
+		}
+
+	} catch(Parameter::ParameterRejected &p){
+		// This will happen if the user has fed some malformed parameter to the program
+		cerr << p.what() << endl;
+		optp.usage();
+		return EXIT_FAILURE;
+	} catch(runtime_error &e) {
+		// This will happen if you try to access a parameter that hasn't been set
+		cerr << e.what() << endl;
+
+		return EXIT_FAILURE;
+	}
+
+
+	// List what non-parameter options were given (typically files)
+	cout << "The following file arguments were given:" << endl;
+
+	vector<string> files = optp.getFiles();
+	for(vector<string>::iterator i = files.begin(); i != files.end(); i++) {
+		cout << "\t" << *i << endl;
+	}
+
+
+	return EXIT_SUCCESS;
+}
+
+#endif