class Appl reworked.

src/ebusctl/ebusctl.cpp

@@ -35,39 +35,34 @@
 
 using namespace libebus;
 
-Appl& A = Appl::Instance();
+Appl& A = Appl::Instance(true);
 
 void define_args()
 {
-	A.addArgs("COMMAND {ARGS...}\n\n"
-		  " local commands:\n"
+	A.setVersion("ebusctl is part of """PACKAGE_STRING"");
+
+	A.addText(" local commands:\n"
 		  "  'scan' scans the bus and identifies the participants\n\n"
 		  "  'feed' sends a dump file to a local virtual serial device\n"
 		  "        (hint: socat -d -d pty,raw,echo=0 pty,raw,echo=0)\n\n"
 		  " remote commands:\n"
-		  "   send 'help' to server", 1);
+		  "   send 'help' to server\n\n"
+		  " Options:\n");
 
-	A.addItem("p_device", Appl::Param("/dev/ttyUSB60"), "d", "device",
-		  "virtual serial device (/dev/ttyUSB60)",
-		  Appl::type_string, Appl::opt_mandatory);
+	A.addOption("device", "d", OptVal("/dev/ttyUSB60"), dt_string, ot_mandatory,
+		    "virtual serial device (/dev/ttyUSB60)");
 
-	A.addItem("p_file", Appl::Param(""), "f", "file",
-		  "dump file with raw data",
-		  Appl::type_string, Appl::opt_mandatory);
+	A.addOption("file", "f", OptVal("/tmp/ebus_dump.bin"),dt_string, ot_mandatory,
+		    "dump file name (/tmp/ebus_dump.bin)");
 
-	A.addItem("p_time", Appl::Param(10000), "t", "time",
-		  "delay between 2 bytes in 'us' (10000)\n",
-		  Appl::type_long, Appl::opt_mandatory);
+	A.addOption("time", "t", OptVal(10000), dt_long, ot_mandatory,
+		    "delay between 2 bytes in 'us' (10000)\n");
 
-	A.addItem("p_server", Appl::Param("localhost"), "s", "server",
-		  "name or ip (localhost)",
-		  Appl::type_string, Appl::opt_mandatory);
+	A.addOption("server", "s", OptVal("localhost"), dt_string, ot_mandatory,
+		    "name or ip (localhost)");
 
-	A.addItem("p_port", Appl::Param(8888), "p", "port",
-		  "port (8888)\n",
-		  Appl::type_int, Appl::opt_mandatory);
-
-	A.addVersion("ebusctl is part of """PACKAGE_STRING"");
+	A.addOption("port", "p", OptVal(8888), dt_int, ot_mandatory,
+		    "port (8888)\n");
 }
 
 
@@ -175,14 +170,14 @@ int main(int argc, char* argv[])
 	A.parseArgs(argc, argv);
 
 	if (strcasecmp(A.getArg(0).c_str(), "feed") == 0) {
-		std::string dev(A.getParam<const char*>("p_device"));
+		std::string dev(A.getOptVal<const char*>("device"));
 		Port port(dev, true);
 
 		port.open();
 		if(port.isOpen() == true) {
 			std::cout << "openPort successful." << std::endl;
 
-			std::fstream file(A.getParam<const char*>("p_file"), std::ios::in | std::ios::binary);
+			std::fstream file(A.getOptVal<const char*>("file"), std::ios::in | std::ios::binary);
 
 			if(file.is_open() == true) {
 
@@ -192,25 +187,25 @@ int main(int argc, char* argv[])
 					<< static_cast<unsigned>(byte) << std::endl;
 
 					port.send(&byte, 1);
-					usleep(A.getParam<long>("p_time"));
+					usleep(A.getOptVal<long>("time"));
 				}
 
 				file.close();
 			} else {
-				std::cout << "error opening file " << A.getParam<const char*>("p_file") << std::endl;
+				std::cout << "error opening file " << A.getOptVal<const char*>("file") << std::endl;
 			}
 
 			port.close();
 			if(port.isOpen() == false)
 				std::cout << "closePort successful." << std::endl;
 		} else {
-			std::cout << "error opening device " << A.getParam<const char*>("p_device") << std::endl;
+			std::cout << "error opening device " << A.getOptVal<const char*>("device") << std::endl;
 		}
 
 	} else {
 
 		TCPClient* client = new TCPClient();
-		TCPSocket* socket = client->connect(A.getParam<const char*>("p_server"), A.getParam<int>("p_port"));
+		TCPSocket* socket = client->connect(A.getOptVal<const char*>("server"), A.getOptVal<int>("port"));
 
 		if (socket != NULL) {
 
@@ -262,7 +257,7 @@ int main(int argc, char* argv[])
 			} else {
 				// build message
 				std::string message(A.getArg(0));
-				for (size_t i = 1; i < A.numArg(); i++) {
+				for (int i = 1; i < A.numArgs(); i++) {
 					message += " ";
 					message += A.getArg(i);
 				}
@@ -280,8 +275,8 @@ int main(int argc, char* argv[])
 
 			delete socket;
 		} else {
-			std::cout << "error connecting to " << A.getParam<const char*>("p_server")
-				  << ":" << A.getParam<int>("p_port") << std::endl;
+			std::cout << "error connecting to " << A.getOptVal<const char*>("server")
+				  << ":" << A.getOptVal<int>("port") << std::endl;
 		}
 
 		delete client;

src/ebusd/baseloop.cpp

@@ -28,8 +28,8 @@ extern Appl& A;
 BaseLoop::BaseLoop()
 {
 	// create commands DB
-	m_commands = ConfigCommands(A.getParam<const char*>("p_ebusconfdir"), CSV).getCommands();
-	L.log(bas, trace, "ebus configuration dir: %s", A.getParam<const char*>("p_ebusconfdir"));
+	m_commands = ConfigCommands(A.getOptVal<const char*>("ebusconfdir"), CSV).getCommands();
+	L.log(bas, trace, "ebus configuration dir: %s", A.getOptVal<const char*>("ebusconfdir"));
 	L.log(bas, event, "commands DB: %d ", m_commands->sizeCmdDB());
 	L.log(bas, event, "   cycle DB: %d ", m_commands->sizeCycDB());
 	L.log(bas, event, " polling DB: %d ", m_commands->sizePolDB());
@@ -39,7 +39,7 @@ BaseLoop::BaseLoop()
 	m_ebusloop->start("ebusloop");
 
 	// create network
-	m_network = new Network(A.getParam<bool>("p_localhost"), &m_msgQueue);
+	m_network = new Network(A.getOptVal<bool>("localhost"), &m_msgQueue);
 	m_network->start("network");
 }
 
@@ -147,7 +147,7 @@ std::string BaseLoop::decodeMessage(const std::string& data)
 				break;
 			}
 
-			std::string ebusCommand(A.getParam<const char*>("p_address"));
+			std::string ebusCommand(A.getOptVal<const char*>("address"));
 			ebusCommand += m_commands->getEbusCommand(index);
 			std::transform(ebusCommand.begin(), ebusCommand.end(), ebusCommand.begin(), tolower);
 
@@ -188,7 +188,7 @@ std::string BaseLoop::decodeMessage(const std::string& data)
 
 		if (index >= 0) {
 
-			std::string ebusCommand(A.getParam<const char*>("p_address"));
+			std::string ebusCommand(A.getOptVal<const char*>("address"));
 			ebusCommand += m_commands->getEbusCommand(index);
 
 			// encode data
@@ -268,7 +268,7 @@ std::string BaseLoop::decodeMessage(const std::string& data)
 		}
 
 		{
-			std::string ebusCommand(A.getParam<const char*>("p_address"));
+			std::string ebusCommand(A.getOptVal<const char*>("address"));
 			cmd[1].erase(std::remove_if(cmd[1].begin(), cmd[1].end(), isspace), cmd[1].end());
 			ebusCommand += cmd[1];
 			std::transform(ebusCommand.begin(), ebusCommand.end(), ebusCommand.begin(), tolower);
@@ -344,8 +344,8 @@ std::string BaseLoop::decodeMessage(const std::string& data)
 
 		{
 			// create commands DB
-			Commands* commands = ConfigCommands(A.getParam<const char*>("p_ebusconfdir"), CSV).getCommands();
-			L.log(bas, trace, "ebus configuration dir: %s", A.getParam<const char*>("p_ebusconfdir"));
+			Commands* commands = ConfigCommands(A.getOptVal<const char*>("ebusconfdir"), CSV).getCommands();
+			L.log(bas, trace, "ebus configuration dir: %s", A.getOptVal<const char*>("ebusconfdir"));
 			L.log(bas, event, "commands DB: %d ", m_commands->sizeCmdDB());
 			L.log(bas, event, "   cycle DB: %d ", m_commands->sizeCycDB());
 			L.log(bas, event, " polling DB: %d ", m_commands->sizePolDB());

src/ebusd/ebusd.cpp

@@ -38,93 +38,70 @@ BaseLoop* baseloop;
 
 void define_args()
 {
-	A.addArgs("", 0);
 
-	A.addItem("p_address", Appl::Param("FF"), "a", "address",
-		  "\tebus device address (FF)",
-		  Appl::type_string, Appl::opt_mandatory);
+	A.setVersion(""PACKAGE_STRING"");
 
-	A.addItem("p_device", Appl::Param("/dev/ttyUSB0"), "d", "device",
-		  "\tebus device (serial or network) (/dev/ttyUSB0)",
-		  Appl::type_string, Appl::opt_mandatory);
+	A.addText("test");
 
-	A.addItem("p_nodevicecheck", Appl::Param(false), "n", "nodevicecheck",
-		  "disable valid ebus device test\n",
-		  Appl::type_bool, Appl::opt_none);
+	A.addOption("address", "a", OptVal("FF"),  dt_string, ot_mandatory,
+		    "\tebus device address (FF)");
 
-	A.addItem("p_sendretries", Appl::Param(2), "s", "sendretries",
-		  "number retries send ebus command (2)",
-		  Appl::type_int, Appl::opt_mandatory);
+	A.addOption("device", "d", OptVal("/dev/ttyUSB0"), dt_string, ot_mandatory,
+		    "\tebus device (serial or network) (/dev/ttyUSB0)");
 
-	A.addItem("p_lockretries", Appl::Param(2), "", "lockretries",
-		  "number retries to lock ebus (2)",
-		  Appl::type_int, Appl::opt_mandatory);
+	A.addOption("nodevicecheck", "n", OptVal(false), dt_bool, ot_none,
+		    "disable valid ebus device test\n");
 
-	A.addItem("p_lockcounter", Appl::Param(5), "", "lockcounter",
-		  "number of SYN to unlock send function (5)",
-		  Appl::type_int, Appl::opt_mandatory);
+	A.addOption("sendretries", "s", OptVal(2), dt_int, ot_mandatory,
+		    "number retries send ebus command (2)");
 
-	A.addItem("p_recvtimeout", Appl::Param(15000), "", "recvtimeout",
-		  "receive timeout in 'us' (15000)",
-		  Appl::type_long, Appl::opt_mandatory);
+	A.addOption("lockretries", "", OptVal(2), dt_int, ot_mandatory,
+		    "number retries to lock ebus (2)");
 
-	A.addItem("p_acquiretime", Appl::Param(4200), "", "acquiretime",
-		  "waiting time for bus acquire in 'us' (4200)\n",
-		  Appl::type_long, Appl::opt_mandatory);
+	A.addOption("lockcounter", "", OptVal(5), dt_int, ot_mandatory,
+		    "number of SYN to unlock send function (5)");
 
-	A.addItem("p_pollinterval", Appl::Param(5), "", "pollinterval",
-		  "polling interval in 's' (5)\n",
-		  Appl::type_int, Appl::opt_mandatory);
+	A.addOption("recvtimeout", "", OptVal(15000), dt_long, ot_mandatory,
+		    "receive timeout in 'us' (15000)");
 
-	A.addItem("p_ebusconfdir", Appl::Param("/etc/ebusd"), "e", "ebusconfdir",
-		  "directory for ebus configuration (/etc/ebusd)\n",
-		  Appl::type_string, Appl::opt_mandatory);
+	A.addOption("acquiretime", "", OptVal(4200), dt_long, ot_mandatory,
+		    "waiting time for bus acquire in 'us' (4200)\n");
 
-	A.addItem("p_foreground", Appl::Param(false), "f", "foreground",
-		  "run in foreground\n",
-		  Appl::type_bool, Appl::opt_none);
+	A.addOption("pollinterval", "", OptVal(5), dt_int, ot_mandatory,
+		    "polling interval in 's' (5)\n");
 
-	A.addItem("p_port", Appl::Param(8888), "p", "port",
-		  "\tlisten port (8888)",
-		  Appl::type_int, Appl::opt_mandatory);
+	A.addOption("ebusconfdir", "e", OptVal("/etc/ebusd"), dt_string, ot_mandatory,
+		    "directory for ebus configuration (/etc/ebusd)\n");
 
-	A.addItem("p_localhost", Appl::Param(false), "", "localhost",
-		  "listen localhost only\n",
-		  Appl::type_bool, Appl::opt_none);
+	A.addOption("foreground", "f", OptVal(false), dt_bool, ot_none,
+		    "run in foreground\n");
 
-	A.addItem("p_logfile", Appl::Param("/var/log/ebusd.log"), "l", "logfile",
-		  "\tlog file name (/var/log/ebusd.log)",
-		  Appl::type_string, Appl::opt_mandatory);
+	A.addOption("port", "p", OptVal(8888), dt_int, ot_mandatory,
+		    "\tlisten port (8888)");
 
-	A.addItem("p_logareas", Appl::Param("all"), "", "logareas",
-		  "\tlog areas - bas|net|bus|cyc|all (all)",
-		  Appl::type_string, Appl::opt_mandatory);
+	A.addOption("localhost", "", OptVal(false), dt_bool, ot_none,
+		    "listen localhost only\n");
 
-	A.addItem("p_loglevel", Appl::Param("trace"), "", "loglevel",
-		  "\tlog level - error|event|trace|debug (event)",
-		  Appl::type_string, Appl::opt_mandatory);
+	A.addOption("logfile", "l", OptVal("/var/log/ebusd.log"), dt_string, ot_mandatory,
+		    "\tlog file name (/var/log/ebusd.log)");
 
-	A.addItem("p_lograwdata", Appl::Param(false), "", "lograwdata",
-		  "log raw data (bytes)\n",
-		  Appl::type_bool, Appl::opt_none);
+	A.addOption("logareas", "", OptVal("all"), dt_string, ot_mandatory,
+		    "\tlog areas - bas|net|bus|cyc|all (all)");
 
-	A.addItem("p_dump", Appl::Param(false), "D", "dump",
-		  "\tenable dump",
-		  Appl::type_bool, Appl::opt_none);
+	A.addOption("loglevel", "", OptVal("trace"), dt_string, ot_mandatory,
+		    "\tlog level - error|event|trace|debug (event)");
 
-	A.addItem("p_dumpfile", Appl::Param("/tmp/ebus_dump.bin"), "", "dumpfile",
-		  "\tdump file name (/tmp/ebus_dump.bin)",
-		  Appl::type_string, Appl::opt_mandatory);
+	A.addOption("lograwdata", "", OptVal(false), dt_bool, ot_none,
+		    "log raw data (bytes)\n");
 
-	A.addItem("p_dumpsize", Appl::Param(100), "", "dumpsize",
-		  "\tmax size for dump file in 'kB' (100)\n",
-		  Appl::type_long, Appl::opt_mandatory);
+	A.addOption("dump", "D", OptVal(false), dt_bool, ot_none,
+		    "\tenable dump");
 
-	A.addItem("p_settings", Appl::Param(false), "", "settings",
-		  "\tprint daemon settings\n",
-		  Appl::type_bool, Appl::opt_none);
+	A.addOption("dumpfile", "", OptVal("/tmp/ebus_dump.bin"), dt_string, ot_mandatory,
+		    "\tdump file name (/tmp/ebus_dump.bin)");
 
-	A.addVersion(""PACKAGE_STRING"");
+	A.addOption("dumpsize", "", OptVal(100), dt_long, ot_mandatory,
+		    "\tmax size for dump file in 'kB' (100)\n");
 }
 
 void shutdown()
@@ -177,20 +154,16 @@ int main(int argc, char* argv[])
 	// parse arguments
 	A.parseArgs(argc, argv);
 
-	// print daemon settings
-	if (A.getParam<bool>("p_settings") == true)
-		A.printSettings();
-
 	// make me daemon
-	if (A.getParam<bool>("p_foreground") == true) {
-		L += new LogConsole(calcAreas(A.getParam<const char*>("p_logareas")),
-				    calcLevel(A.getParam<const char*>("p_loglevel")),
+	if (A.getOptVal<bool>("foreground") == true) {
+		L += new LogConsole(calcAreas(A.getOptVal<const char*>("logareas")),
+				    calcLevel(A.getOptVal<const char*>("loglevel")),
 				    "logconsole");
 	} else {
 		D.run("/var/run/ebusd.pid");
-		L += new LogFile(calcAreas(A.getParam<const char*>("p_logareas")),
-				 calcLevel(A.getParam<const char*>("p_loglevel")),
-				 "logfile", A.getParam<const char*>("p_logfile"));
+		L += new LogFile(calcAreas(A.getOptVal<const char*>("logareas")),
+				 calcLevel(A.getOptVal<const char*>("loglevel")),
+				 "logfile", A.getOptVal<const char*>("logfile"));
 	}
 
 	// trap signals that we expect to receive

src/ebusd/ebusloop.cpp

@@ -27,26 +27,26 @@ extern Appl& A;
 EBusLoop::EBusLoop(Commands* commands)
 	: m_commands(commands), m_stop(false), m_lockCounter(0), m_priorRetry(false)
 {
-	m_port = new Port(A.getParam<const char*>("p_device"), A.getParam<bool>("p_nodevicecheck"));
+	m_port = new Port(A.getOptVal<const char*>("device"), A.getOptVal<bool>("nodevicecheck"));
 	m_port->open();
 
 	if (m_port->isOpen() == false)
-		L.log(bus, error, "can't open %s", A.getParam<const char*>("p_device"));
+		L.log(bus, error, "can't open %s", A.getOptVal<const char*>("device"));
 
-	m_dump = new Dump(A.getParam<const char*>("p_dumpfile"), A.getParam<long>("p_dumpsize"));
-	m_dumpState = A.getParam<bool>("p_dump");
+	m_dump = new Dump(A.getOptVal<const char*>("dumpfile"), A.getOptVal<long>("dumpsize"));
+	m_dumpState = A.getOptVal<bool>("dump");
 
-	m_logRawData = A.getParam<bool>("p_lograwdata");
+	m_logRawData = A.getOptVal<bool>("lograwdata");
 
-	m_pollInterval = A.getParam<int>("p_pollinterval");
+	m_pollInterval = A.getOptVal<int>("pollinterval");
 
-	m_recvTimeout = A.getParam<long>("p_recvtimeout");
+	m_recvTimeout = A.getOptVal<long>("recvtimeout");
 
-	m_sendRetries = A.getParam<int>("p_sendretries");
+	m_sendRetries = A.getOptVal<int>("sendretries");
 
-	m_lockRetries = A.getParam<int>("p_lockretries");
+	m_lockRetries = A.getOptVal<int>("lockretries");
 
-	m_acquireTime = A.getParam<long>("p_acquiretime");
+	m_acquireTime = A.getOptVal<long>("acquiretime");
 }
 
 EBusLoop::~EBusLoop()
@@ -134,7 +134,7 @@ void* EBusLoop::run()
 					}
 
 					lockRetries = 0;
-					m_lockCounter = A.getParam<int>("p_lockcounter");
+					m_lockCounter = A.getOptVal<int>("lockcounter");
 				}
 				else if (busResult == RESULT_ERR_BUS_LOST) {
 					L.log(bus, trace, " acquire bus failed");
@@ -154,7 +154,7 @@ void* EBusLoop::run()
 						L.log(bus, trace, " lock retry %d", lockRetries);
 					}
 
-					m_lockCounter = A.getParam<int>("p_lockcounter");
+					m_lockCounter = A.getOptVal<int>("lockcounter");
 				}
 
 			}
@@ -166,7 +166,7 @@ void* EBusLoop::run()
 			m_port->open();
 
 			if (m_port->isOpen() == false)
-				L.log(bus, error, "can't open %s", A.getParam<const char*>("p_device"));
+				L.log(bus, error, "can't open %s", A.getOptVal<const char*>("device"));
 
 		}
 
@@ -271,7 +271,7 @@ void EBusLoop::addPollCommand()
 		tmp += (*m_commands)[index][2];
 		L.log(bus, event, " polling [%4d] %s", index, tmp.c_str());
 
-		std::string ebusCommand(A.getParam<const char*>("p_address"));
+		std::string ebusCommand(A.getOptVal<const char*>("address"));
 		ebusCommand += m_commands->getEbusCommand(index);
 		std::transform(ebusCommand.begin(), ebusCommand.end(), ebusCommand.begin(), tolower);
 

src/ebusd/network.cpp

@@ -30,9 +30,9 @@ Network::Network(const bool localhost, WQueue<Message*>* msgQueue)
 	: m_msgQueue(msgQueue), m_listening(false), m_running(false)
 {
 	if (localhost == true)
-		m_tcpServer = new TCPServer(A.getParam<int>("p_port"), "127.0.0.1");
+		m_tcpServer = new TCPServer(A.getOptVal<int>("port"), "127.0.0.1");
 	else
-		m_tcpServer = new TCPServer(A.getParam<int>("p_port"), "0.0.0.0");
+		m_tcpServer = new TCPServer(A.getOptVal<int>("port"), "0.0.0.0");
 
 	if (m_tcpServer != NULL && m_tcpServer->start() == 0)
 		m_listening = true;

src/lib/utils/appl.cpp

@@ -22,46 +22,162 @@
 #include <iomanip>
 #include <cstdlib>
 
-Appl& Appl::Instance()
+Appl& Appl::Instance(const bool command)
 {
-	static Appl instance;
+	static Appl instance(command);
 	return instance;
 }
 
 Appl::~Appl()
 {
-	m_args.clear();
-	m_params.clear();
+	m_opts.clear();
+	m_optvals.clear();
 }
 
-void Appl::addArgs(const std::string argTxt, const int argNum)
+void Appl::addText(const char* text)
 {
-	m_argTxt = argTxt;
-	m_argNum = argNum;
+	opt_t opt;
+	opt.name = "__text_only__";
+	opt.shortname = "";
+	opt.datatype = dt_none;
+	opt.optiontype = ot_none;
+	opt.description = text;
+	m_opts.push_back(opt);
 }
 
-void Appl::addItem(const char* name, Param param, const char* shortname,
-	     const char* longname, const char* description,
-	     Datatype datatype, Optiontype optiontype)
+void Appl::addOption(const char* name, const char* shortname, OptVal optval,
+		     DataType datatype, OptionType optiontype, const char* description)
 {
-	if (strlen(name) != 0)
-		m_params[name] = param;
+	if (strlen(name) != 0) {
 
-	if (strlen(longname) != 0) {
-		Arg arg;
-		arg.name = name;
-		arg.shortname = shortname;
-		arg.longname = longname;
-		arg.description = description;
-		arg.datatype = datatype;
-		arg.optiontype = optiontype;
-		m_args.push_back(arg);
+		m_optvals[name] = optval;
+
+		opt_t opt;
+		opt.name = name;
+		opt.shortname = shortname;
+		opt.datatype = datatype;
+		opt.optiontype = optiontype;
+		opt.description = description;
+		m_opts.push_back(opt);
 	}
 }
 
-void Appl::addVersion(const char* version)
+void Appl::parseArgs(int argc, char* argv[])
 {
-	m_version = version;
+	std::vector<std::string> _argv(argv, argv + argc);
+	m_argv = _argv;
+
+	// walk through all arguments
+	for (int i = 1; i < argc; i++) {
+
+		// find option with long format '--'
+		if (_argv[i].rfind("--") == 0 && _argv[i].size() > 2) {
+
+			// is next item an added argument?
+			if (i+1 < argc && _argv[i+1].rfind("-", 0) == std::string::npos) {
+				if (checkOption(_argv[i].substr(2), _argv[i+1]) == false)
+					printHelp();
+			}
+			else {
+				if (checkOption(_argv[i].substr(2), "") == false)
+					printHelp();
+			}
+
+		// find option with short format '-'
+		} else if (_argv[i].rfind("-") == 0 && _argv[i].size() > 1) {
+
+			// walk through all characters
+			for (size_t j = 1; j < _argv[i].size(); j++) {
+
+				// only last charater could have an argument
+				if (i+1 < argc && _argv[i+1].rfind("-", 0) == std::string::npos
+				&& j+1 == _argv[i].size()) {
+					if (checkOption(_argv[i].substr(j,1), _argv[i+1]) == false)
+						printHelp();
+				}
+				else {
+					if (checkOption(_argv[i].substr(j,1), "") == false)
+						printHelp();
+				}
+			}
+		}
+
+	}
+
+	// check command
+	if (m_needCommand == true) {
+		for (int i = 1; i < argc; i++) {
+
+			if (_argv[i].rfind("-", 0) != std::string::npos) {
+				i++;
+				continue;
+			}
+			m_arguments.push_back(_argv[i]);
+		}
+
+		if (m_arguments.size() == 0) {
+			std::cerr << std::endl << "command needed" << std::endl;
+			printHelp();
+		}
+	}
+
+}
+
+bool Appl::checkOption(const std::string& option, const std::string& value)
+{
+	if (strcmp(option.c_str(), "settings") == 0)
+		printSettings();
+
+	if (strcmp(option.c_str(), "v") == 0 || strcmp(option.c_str(), "version") == 0)
+		printVersion();
+
+	if (strcmp(option.c_str(), "h") == 0 || strcmp(option.c_str(), "help") == 0)
+		printHelp();
+
+	for (o_it = m_opts.begin(); o_it < m_opts.end(); o_it++) {
+		if (o_it->shortname == option || o_it->name == option) {
+
+			// need this option and argument?
+			if (o_it->optiontype == ot_mandatory && value.size() == 0) {
+				std::cerr << std::endl << "option requires an argument '"
+					  << option << "'" << std::endl;
+				return false;
+			}
+
+			// add given value to option
+			if ((o_it->optiontype == ot_optional && value.size() != 0)
+			|| o_it->optiontype != ot_optional)
+				setOptVal(o_it->name, value, o_it->datatype);
+
+			return true;
+		}
+	}
+
+	std::cerr << std::endl << "unknown option '" << option << "'" << std::endl;
+	return false;
+}
+
+void Appl::setOptVal(const char* option, const std::string value, DataType datatype)
+{
+	switch (datatype) {
+	case dt_bool:
+		m_optvals[option] = true;
+		break;
+	case dt_int:
+		m_optvals[option] = strtol(value.c_str(), NULL, 10);
+		break;
+	case dt_long:
+		m_optvals[option] = strtol(value.c_str(), NULL, 10);
+		break;
+	case dt_float:
+		m_optvals[option] = static_cast<float>(strtod(value.c_str(), NULL));
+		break;
+	case dt_string:
+		m_optvals[option] = value.c_str();
+		break;
+	default:
+		break;
+	}
 }
 
 void Appl::printVersion()
@@ -75,163 +191,60 @@ void Appl::printHelp()
 	std::cerr << std::endl << "Usage:" << std::endl << "  "
 		  << m_argv[0].substr(m_argv[0].find_last_of("/\\") + 1) << " [OPTIONS...]" ;
 
-	if (m_argTxt.size() != 0)
-		std::cerr << " " << m_argTxt;
+	if (m_needCommand == true)
+		std::cerr << " COMMAND {ARGS...}" << std::endl << std::endl;
+	else
+		std::cerr << std::endl << std::endl;
 
-	std::cerr << std::endl << std::endl << "Options:" << std::endl << std::endl;
-
-	for (a_it = m_args.begin(); a_it < m_args.end(); a_it++) {
-		const char* c = (strlen(a_it->shortname) == 1) ? a_it->shortname : " ";
-		std::cerr << ((strcmp(c, " ") == 0) ? " " : "-") << c
-			  << " | --" << a_it->longname
-			  << "\t" << a_it->description
-			  << std::endl;
+	for (o_it = m_opts.begin(); o_it < m_opts.end(); o_it++) {
+		if (strcmp(o_it->name, "__text_only__") == 0)
+			continue;
+		else {
+			const char* c = (strlen(o_it->shortname) == 1) ? o_it->shortname : " ";
+			std::cerr << ((strcmp(c, " ") == 0) ? " " : "-") << c
+				  << " | --" << o_it->name
+				  << "\t" << o_it->description
+				  << std::endl;
+		}
 	}
 
-	std::cerr << "-v | --version\n-h | --help" << std::endl << std::endl;
+	std::cerr << "   | --settings\n-v | --version\n-h | --help" << std::endl << std::endl;
 	exit(EXIT_SUCCESS);
 }
 
-void Appl::parseArgs(int argc, char* argv[])
-{
-	std::vector<std::string> _argv(argv, argv + argc);
-	m_argc = argc;
-	m_argv = _argv;
-
-	for (size_t i = 1; i < m_argc; i++) {
-
-		// find option with long format '--'
-		if (m_argv[i].rfind("--") == 0 && m_argv[i].size() > 2) {
-			// is next item an added argument?
-			if (i+1 < m_argc && m_argv[i+1].rfind("-", 0) == std::string::npos) {
-				if (checkArg(m_argv[i].substr(2), m_argv[i+1]) == false)
-					printHelp();
-			} else {
-				if (checkArg(m_argv[i].substr(2), "") == false)
-					printHelp();
-			}
-
-		// find option with short format '-'
-		} else if (m_argv[i].rfind("-") == 0 && m_argv[i].size() > 1) {
-
-			// walk through all characters
-			for (size_t j = 1; j < m_argv[i].size(); j++) {
-
-				// only last charater could have an argument
-				if (i+1 < m_argc && m_argv[i+1].rfind("-", 0) == std::string::npos
-				&& j+1 == m_argv[i].size()) {
-					if (checkArg(m_argv[i].substr(j,1), m_argv[i+1]) == false)
-						printHelp();
-				} else {
-					if (checkArg(m_argv[i].substr(j,1), "") == false)
-						printHelp();
-				}
-			}
-		}
-
-	}
-
-	// check args
-	if (m_argNum > 0) {
-		if (m_argc < (m_argNum + 1))
-			printHelp();
-
-		for (size_t i = 1; i < m_argc; i++) {
-
-			if (m_argv[i].rfind("-", 0) != std::string::npos) {
-				i++;
-				continue;
-			}
-			m_argValues.push_back(m_argv[i]);
-		}
-
-		if (m_argValues.size() < m_argNum)
-			printHelp();
-	}
-}
-
 void Appl::printSettings()
 {
-	std::cerr << std::endl << "Settings:" << std::endl;
+	std::cerr << std::endl << "Settings:" << std::endl << std::endl;
 
-	for (a_it = m_args.begin(); a_it < m_args.end(); a_it++) {
-		const char* c = (strlen(a_it->shortname) == 1) ? a_it->shortname : " ";
+	for (o_it = m_opts.begin(); o_it < m_opts.end(); o_it++) {
+		if (strcmp(o_it->name, "__text_only__") == 0)
+			continue;
+
+		const char* c = (strlen(o_it->shortname) == 1) ? o_it->shortname : " ";
 		std::cerr << ((strcmp(c, " ") == 0) ? " " : "-") << c
-			  << " | --" << a_it->longname
+			  << " | --" << o_it->name
 			  << " = ";
-		if (a_it->datatype == type_bool) {
-			if (getParam<bool>(a_it->name) == true)
+		if (o_it->datatype == dt_bool) {
+			if (getOptVal<bool>(o_it->name) == true)
 				std::cerr << "yes" << std::endl;
 			else
 				std::cerr << "no" << std::endl;
 		}
-		else if (a_it->datatype == type_int) {
-			std::cerr << getParam<int>(a_it->name) << std::endl;
+		else if (o_it->datatype == dt_int) {
+			std::cerr << getOptVal<int>(o_it->name) << std::endl;
 		}
-		else if (a_it->datatype == type_long) {
-			std::cerr << getParam<long>(a_it->name) << std::endl;
+		else if (o_it->datatype == dt_long) {
+			std::cerr << getOptVal<long>(o_it->name) << std::endl;
 		}
-		else if (a_it->datatype == type_float) {
-			std::cerr << getParam<float>(a_it->name) << std::endl;
+		else if (o_it->datatype == dt_float) {
+			std::cerr << getOptVal<float>(o_it->name) << std::endl;
 		}
-		else if (a_it->datatype == type_string) {
-			std::cerr << getParam<const char*>(a_it->name) << std::endl;
+		else if (o_it->datatype == dt_string) {
+			std::cerr << getOptVal<const char*>(o_it->name) << std::endl;
 		}
 
 	}
 
 	std::cerr << std::endl;
+	exit(EXIT_SUCCESS);
 }
-
-bool Appl::checkArg(const std::string& name, const std::string& arg)
-{
-	if (strcmp(name.c_str(), "v") == 0 || strcmp(name.c_str(), "version") == 0)
-		printVersion();
-
-	if (strcmp(name.c_str(), "h") == 0 || strcmp(name.c_str(), "help") == 0)
-		printHelp();
-
-	for (a_it = m_args.begin(); a_it < m_args.end(); a_it++) {
-		if (a_it->shortname == name || a_it->longname == name) {
-			if (a_it->optiontype == opt_mandatory && arg.size() == 0) {
-				std::cerr << std::endl << "option requires an argument '"
-					  << name << "'" << std::endl;
-				return false;
-			}
-
-			if ((a_it->optiontype == opt_optional && arg.size() != 0)
-			|| a_it->optiontype != opt_optional)
-				addParam(a_it->name, arg, a_it->datatype);
-
-			return true;
-		}
-	}
-
-	std::cerr << std::endl << "unknown option '" << name << "'" << std::endl;
-	return false;
-}
-
-void Appl::addParam(const char* name, const std::string arg, Datatype datatype)
-{
-	switch (datatype) {
-	case type_bool:
-		m_params[name] = true;
-		break;
-	case type_int:
-		m_params[name] = strtol(arg.c_str(), NULL, 10);
-		break;
-	case type_long:
-		m_params[name] = strtol(arg.c_str(), NULL, 10);
-		break;
-	case type_float:
-		m_params[name] = static_cast<float>(strtod(arg.c_str(), NULL));
-		break;
-	case type_string:
-		m_params[name] = arg.c_str();
-		break;
-	default:
-		break;
-	}
-}
-
-

src/lib/utils/appl.h

@@ -25,93 +25,179 @@
 #include <map>
 #include <vector>
 
+/** the available data types. */
+enum DataType {
+	dt_none,       // default value
+	dt_bool,       //
+	dt_int,        //
+	dt_long,       //
+	dt_float,      //
+	dt_string,     //
+};
+
+/** option types. */
+enum OptionType {
+	ot_none,       // default value
+	ot_optional,   // a value is optional
+	ot_mandatory,  // a value is mandatory
+};
+
+/** structure for defining application options */
+typedef struct opt {
+	const char* name;
+	const char* shortname;
+	const char* description;
+	DataType datatype;
+	OptionType optiontype;
+} opt_t;
+
+/** union for option values */
+union OptVal {
+	bool b;
+	int i;
+	long l;
+	float f;
+	const char* c;
+
+	OptVal() { memset(this, 0, sizeof(OptVal)); }
+	OptVal(bool _b) : b(_b) {}
+	OptVal(int _i) : i(_i) {}
+	OptVal(long _l) : l(_l) {}
+	OptVal(float _f) : f(_f) {}
+	OptVal(const char* _c) : c(_c) {}
+};
+
+
+/**
+ * @brief class for all kinds of application parameters.
+ */
 class Appl
 {
 
-private:
-	struct Option;
-
 public:
-	enum Datatype { type_none, type_bool, type_int, type_long, type_float, type_string };
-	enum Optiontype { opt_none, opt_optional, opt_mandatory };
-
-	union Param {
-		bool b;
-		int i;
-		long l;
-		float f;
-		const char* c;
-
-		Param() { memset(this, 0, sizeof(Param)); }
-		Param(bool _b) : b(_b) {}
-		Param(int _i) : i(_i) {}
-		Param(long _l) : l(_l) {}
-		Param(float _f) : f(_f) {}
-		Param(const char* _c) : c(_c) {}
-	};
-
-	template <typename T>
-	T getParam(const char* name)
-	{
-		p_it = m_params.find(name);
-		return (reinterpret_cast<T&>(p_it->second));
-	}
-
-	static Appl& Instance();
+	/**
+	 * @brief create an Appl instance and return the reference.
+	 * @param command is true if an command is needed.
+	 * @return the reference to instance.
+	 */
+	static Appl& Instance(const bool command=false);
 
+	/**
+	 * @brief destructor.
+	 */
 	~Appl();
 
-	void addArgs(const std::string argTxt, const int argNum);
-	size_t numArg() const { return m_argValues.size(); }
-	std::string getArg(const int argNum) const { return m_argValues[argNum]; }
+	/**
+	 * @brief save application version string.
+	 * @param version string
+	 */
+	void setVersion(const char* version) { m_version = version; }
 
-	void addItem(const char* name, Param param, const char* shortname,
-		     const char* longname, const char* description,
-		     Datatype datatype, Optiontype optiontype);
+	/**
+	 * @brief create new entry of application option only for help page.
+	 * @param text string to print
+	 */
+	void addText(const char* text);
 
-	void addVersion(const char* version);
+	/**
+	 * @brief create new entry of application option.
+	 * @param name the long name
+	 * @param shortname optional short name
+	 * @param optval value of option
+	 * @param datatype data type of option value
+	 * @param optiontype type of given option
+	 * @param description hint text for help page
+	 */
+	void addOption(const char* name, const char* shortname, OptVal optval,
+		       DataType datatype, OptionType optiontype, const char* description);
 
+	/**
+	 * @brief returns the value of the interested option
+	 * @param the interested option
+	 * @return casted value
+	 */
+	template <typename T>
+	T getOptVal(const char* name)
+	{
+		ov_it = m_optvals.find(name);
+		return (reinterpret_cast<T&>(ov_it->second));
+	}
+
+	/**
+	 * @brief parse application arguments.
+	 * @param argc the number of options
+	 * @param argv the given options
+	 */
 	void parseArgs(int argc, char* argv[]);
-	void printSettings();
+
+	/**
+	 * @brief returns the number of saved commands and arguments
+	 * @return number of commands and arguments
+	 */
+	int numArgs() const { return m_arguments.size(); }
+
+	/**
+	 * @brief returns the string of an interested argument (0 = command)
+	 * @param num number of interested argument
+	 * @return string value
+	 */
+	std::string getArg(const int num) const { return m_arguments[num]; }
 
 private:
-	Appl() {}
+	/** private constructor - singleton pattern*/
+	Appl(const bool command) : m_needCommand(command) {}
 	Appl(const Appl&);
-	Appl& operator= (const Appl&);
+	Appl& operator=(const Appl&);
 
-	struct Arg {
-		const char* name;
-		const char* shortname;
-		const char* longname;
-		const char* description;
-		Datatype datatype;
-		Optiontype optiontype;
-	};
+	/** application options */
+	std::vector<opt_t> m_opts;
+	std::vector<opt_t>::const_iterator o_it;
 
-	size_t m_argc;
+	/** map option - value */
+	std::map<const char*, OptVal> m_optvals;
+	std::map<const char*, OptVal>::iterator ov_it;
+
+	/** given arguments */
 	std::vector<std::string> m_argv;
 
-	std::vector<Arg> m_args;
-	std::vector<Arg>::const_iterator a_it;
-
-	std::map<const char*, Param> m_params;
-	std::map<const char*, Param>::iterator p_it;
-
-	std::string m_argTxt;
-	size_t m_argNum;
-
+	/** application version string */
 	const char* m_version;
 
-	std::vector<std::string> m_argValues;
+	/** true if the application need a command */
+	bool m_needCommand;
 
-	bool checkArg(const std::string& name, const std::string& arg);
+	/** arguments (argument 0 = command) string */
+	std::vector<std::string> m_arguments;
 
-	void addParam(const char* name, Param param) { m_params[name] = param; }
+	/**
+	 * @brief checks the passed parameter if this is a valid option.
+	 * @param option to check
+	 * @param value to save if paramter is a valid option
+	 */
+	bool checkOption(const std::string& option, const std::string& value);
 
-	void addParam(const char* name, const std::string arg, Datatype datatype);
+	/**
+	 * @brief save the passed value to option.
+	 * @param option name
+	 * @param value to save
+	 * @param datatype of given option
+	 */
+	void setOptVal(const char* option, const std::string value, DataType datatype);
 
+	/**
+	 * @brief print application version.
+	 */
 	void printVersion();
+
+	/**
+	 * @brief print help page.
+	 */
 	void printHelp();
+
+	/**
+	 * @brief print used option settings.
+	 */
+	void printSettings();
 };
 
 #endif // LIBUTILS_APPL_H_