Mercurial > qtargs

changeset 3:fad9b512bb46

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Updated copyright information and brought code base into standards.
author John Schneiderman <JohnMS@CodeGNU.com>
date Sat, 14 Jun 2014 15:04:44 +0000
parents 2e08e35922c9
children 7ef0a8f6b376
files INSTALL doc/ChangeLog qtargs.pro src/UNIT_TESTS/qargsut.hpp src/qargs.cpp src/qargs.h
diffstat 6 files changed, 134 insertions(+), 130 deletions(-) [+]
line wrap: on
line diff
--- a/INSTALL	Sat Jun 14 14:42:07 2014 +0000
+++ b/INSTALL	Sat Jun 14 15:04:44 2014 +0000
@@ -1,4 +1,4 @@
-********************************************************************************
+********************************************************************************
 ***  This file is part of QtArgs.                                            ***
 ***                                                                          ***
 ***  Copyright (C) 2011, 2012, 2014                                          ***
@@ -34,6 +34,4 @@
 
 Known Issues
 ============
-1) The library build in Windows contains the version in the name.
-2) Compiling the library in Windows using the MinGW compiler will not generate
-    a PDB file. So, an error when installing is expected.
+None known.
--- a/doc/ChangeLog	Sat Jun 14 14:42:07 2014 +0000
+++ b/doc/ChangeLog	Sat Jun 14 15:04:44 2014 +0000
@@ -18,8 +18,14 @@
 ***  License along with this program. If not, see                            ***
 ***  <http://www.gnu.org/licenses/>.                                         ***
 ********************************************************************************
-2014-05-20 John Schneiderman <JohnMS_AT_member_DOT_fsf_DOT_org> 1.3.0b0
+2014-06-14 CodeGNU Solutions <Licensing _AT_ CodeGNU _DOT_ com> 1.3.0
  - Upgraded to build using Qt 5.
+ - Support Windows long options as it's normally done, i.e. /long-option value.
+ - Support for case insensative options.
+ - Support to narrow boolean options to only a specific type.
+ - Prevented the addition of more options once they are set.
+ - Support for arguments with multiple values: e.g. -i 2 3 5
+ - Support for non-const argument linst in main.
 2011-05-27 John Schneiderman <JohnMS_AT_member_DOT_fsf_DOT_org> 1.2.1
  - Fixed issue with unit test failing because tabs were converted to spaces.
  - Fixed warnings when using QCoreApplication prior to creation.
--- a/qtargs.pro	Sat Jun 14 14:42:07 2014 +0000
+++ b/qtargs.pro	Sat Jun 14 15:04:44 2014 +0000
@@ -24,16 +24,16 @@
 
 isEmpty(PREFIX) {
     win32 {
-	   PREFIX = $$quote(C:\\QtSDK\\QtArgs\\)
+        PREFIX = $$quote(C:\\QtArgs\\)
     } else {
-	   PREFIX = /usr
+        PREFIX = /usr
     }
 }
 isEmpty(DOC_PATH) {
     win32 {
-	   DOC_PATH = $${PREFIX}/doc
+        DOC_PATH = $${PREFIX}/doc
     } else {
-	   DOC_PATH = $${PREFIX}/share/doc/QtArgs
+        DOC_PATH = $${PREFIX}/share/doc/QtArgs
     }
 }
 docs.files += \
--- a/src/UNIT_TESTS/qargsut.hpp	Sat Jun 14 14:42:07 2014 +0000
+++ b/src/UNIT_TESTS/qargsut.hpp	Sat Jun 14 15:04:44 2014 +0000
@@ -124,26 +124,26 @@
 	{
 		QArgs args(ARGC, argv);
 
-		QVERIFY(args.mArguments.count() == ARGC);
-		QVERIFY(args.mArguments[0] == arg0);
-		QVERIFY(args.mArguments[1] == arg1);
-		QVERIFY(args.mArguments[2] == arg2);
-		QVERIFY(args.mArguments[3] == arg3);
-		QVERIFY(args.mArguments[4] == arg4);
-		QVERIFY(args.mArguments[5] == arg5);
-		QVERIFY(args.mArguments[6] == arg6);
-		QVERIFY(args.mArguments[7] == arg7);
+		QVERIFY(args.arguments_.count() == ARGC);
+		QVERIFY(args.arguments_[0] == arg0);
+		QVERIFY(args.arguments_[1] == arg1);
+		QVERIFY(args.arguments_[2] == arg2);
+		QVERIFY(args.arguments_[3] == arg3);
+		QVERIFY(args.arguments_[4] == arg4);
+		QVERIFY(args.arguments_[5] == arg5);
+		QVERIFY(args.arguments_[6] == arg6);
+		QVERIFY(args.arguments_[7] == arg7);
 
 		// Verify help is established
-		QVERIFY(args.mSupported.value(QArgs::SHORT_HELP).shortName ==
+		QVERIFY(args.supported_.value(QArgs::SHORT_HELP).shortName ==
 			   QArgs::SHORT_HELP);
-		QVERIFY(args.mSupported.value(QArgs::SHORT_HELP).longName == "help");
-		QVERIFY(args.mSupported.value(
+		QVERIFY(args.supported_.value(QArgs::SHORT_HELP).longName == "help");
+		QVERIFY(args.supported_.value(
 				   QArgs::SHORT_HELP).description.isEmpty());
-		QVERIFY(args.mSupported.value(QArgs::SHORT_HELP).needsValue == false);
-		QVERIFY(args.mSupported.value(QArgs::SHORT_HELP).required == false);
-		QVERIFY(args.mIsCaseSensative == true);
-		QVERIFY(args.mIsLocked == false);
+		QVERIFY(args.supported_.value(QArgs::SHORT_HELP).needsValue == false);
+		QVERIFY(args.supported_.value(QArgs::SHORT_HELP).required == false);
+		QVERIFY(args.isCaseSensative_ == true);
+		QVERIFY(args.isLocked_ == false);
 	}
 
 	/// Test adding argument support
@@ -156,24 +156,24 @@
 		args.addSupported('d', "double", "Real number test", true);
 		args.addSupported('f', "flag", "Flag test");
 
-		QVERIFY(args.mSupported.value('i').shortName == 'i');
-		QVERIFY(args.mSupported.value('i').longName == "integer");
-		QVERIFY(args.mSupported.value('i').description ==
+		QVERIFY(args.supported_.value('i').shortName == 'i');
+		QVERIFY(args.supported_.value('i').longName == "integer");
+		QVERIFY(args.supported_.value('i').description ==
 			   "Whole number test");
-		QVERIFY(args.mSupported.value('i').needsValue == true);
-		QVERIFY(args.mSupported.value('i').required == true);
-		QVERIFY(args.mSupported.value('d').shortName == 'd');
-		QVERIFY(args.mSupported.value('d').longName == "double");
-		QVERIFY(args.mSupported.value('d').description ==
+		QVERIFY(args.supported_.value('i').needsValue == true);
+		QVERIFY(args.supported_.value('i').required == true);
+		QVERIFY(args.supported_.value('d').shortName == 'd');
+		QVERIFY(args.supported_.value('d').longName == "double");
+		QVERIFY(args.supported_.value('d').description ==
 			   "Real number test");
-		QVERIFY(args.mSupported.value('d').needsValue == true);
-		QVERIFY(args.mSupported.value('d').required == false);
-		QVERIFY(args.mSupported.value('f').shortName == 'f');
-		QVERIFY(args.mSupported.value('f').longName == "flag");
-		QVERIFY(args.mSupported.value('f').description ==
+		QVERIFY(args.supported_.value('d').needsValue == true);
+		QVERIFY(args.supported_.value('d').required == false);
+		QVERIFY(args.supported_.value('f').shortName == 'f');
+		QVERIFY(args.supported_.value('f').longName == "flag");
+		QVERIFY(args.supported_.value('f').description ==
 			   "Flag test");
-		QVERIFY(args.mSupported.value('f').needsValue == false);
-		QVERIFY(args.mSupported.value('f').required == false);
+		QVERIFY(args.supported_.value('f').needsValue == false);
+		QVERIFY(args.supported_.value('f').required == false);
 
 		// Test exception cases
 		try
@@ -311,10 +311,10 @@
 		{
 			QArgs args(ARGC, argv);
 
-			QVERIFY2(false == args.mIsLocked, "Arguments list not "
+			QVERIFY2(false == args.isLocked_, "Arguments list not "
 				    "locked test.");
 			args.lock();
-			QVERIFY2(true == args.mIsLocked, "Arguments list locked test.");
+			QVERIFY2(true == args.isLocked_, "Arguments list locked test.");
 			args.addSupported('a', "longA", "Test argument adding after lock.");
 			QVERIFY2(false, "Test argument adding after lock failed.");
 		}
@@ -521,7 +521,7 @@
 		QList< QVariant > arguments(about.takeAt(0));
 		QVERIFY(arguments.at(0).toString() == QString(
 				   "QtArgs version 1.3.0\n"
-				   "Copyright (C) 2011 - 2014 John Schneiderman\n"
+				   "Copyright (C) 2011 - 2014 CodeGNU Solutions\n"
 				   "QtArgs comes with ABSOLUTELY NO WARRANTY.\nThis is "
 				   "free software, and you are welcome to redistribute it\n"
 				   "under certain conditions; see the LICENSE file for details,\n"
--- a/src/qargs.cpp	Sat Jun 14 14:42:07 2014 +0000
+++ b/src/qargs.cpp	Sat Jun 14 15:04:44 2014 +0000
@@ -146,17 +146,17 @@
 
 QArgs::QArgs(int argc, const char* argv[], Sensitivity caseing):
     QObject(NULL),
-    mArguments(),
-    mSupported(),
-    mIsCaseSensative(CASE_SENSATIVE == caseing),
-    mIsLocked(false),
-    mAreArgumentsVerified(false)
+    arguments_(),
+    supported_(),
+    isCaseSensative_(CASE_SENSATIVE == caseing),
+    isLocked_(false),
+    areArgumentsVerified_(false)
 {
     qDebug() << "QArgs::QArgs(argc, const char*[], Sensitivity)" << argc
 		   << *argv << caseing;
 
     for (int index(0); index < argc; ++index)
-	   this->mArguments.append(QString(argv[index]).trimmed());
+	   this->arguments_.append(QString(argv[index]).trimmed());
 
     Properties help;
     help.shortName = SHORT_HELP;
@@ -164,22 +164,22 @@
     help.description = QString();
     help.needsValue = false;
     help.required = false;
-    this->mSupported.insert(help.shortName, help);
+    this->supported_.insert(help.shortName, help);
 }
 
 QArgs::QArgs(int argc, char* argv[], Sensitivity caseing):
     QObject(NULL),
-    mArguments(),
-    mSupported(),
-    mIsCaseSensative(CASE_SENSATIVE == caseing),
-    mIsLocked(false),
-    mAreArgumentsVerified(false)
+    arguments_(),
+    supported_(),
+    isCaseSensative_(CASE_SENSATIVE == caseing),
+    isLocked_(false),
+    areArgumentsVerified_(false)
 {
     qDebug() << "QArgs::QArgs(argc, char*[], Sensitivity)" << argc << *argv
 			 << caseing;
 
     for (int index(0); index < argc; ++index)
-	   this->mArguments.append(QString(argv[index]).trimmed());
+	   this->arguments_.append(QString(argv[index]).trimmed());
 
     Properties help;
     help.shortName = SHORT_HELP;
@@ -187,12 +187,12 @@
     help.description = QString();
     help.needsValue = false;
     help.required = false;
-    this->mSupported.insert(help.shortName, help);
+    this->supported_.insert(help.shortName, help);
 }
 
 const QStringList& QArgs::arguments() const
 {
-    return this->mArguments;
+    return this->arguments_;
 }
 
 const QChar& QArgs::marker() const
@@ -206,7 +206,7 @@
 			 ARGUMENT_MARKER));
     qint32 count(0);
 
-    foreach (QString argument, this->mArguments)
+    foreach (QString argument, this->arguments_)
 	   if (argument.startsWith(ARGUMENT_MARKER)
 			 || argument.startsWith(LONG_MARKER))
 		  ++count;
@@ -223,7 +223,7 @@
     else if (shortName.isNull() || shortName.isSpace())
 	   throw logic_error(tr("Option for the short name cannot be "
 			 "null or empty.").toStdString());
-    else if (this->mSupported.contains(shortName))
+    else if (this->supported_.contains(shortName))
 	   throw logic_error(tr("The short name '%1' was already in the "
 			 "supported options list.").arg(shortName).toStdString());
 
@@ -235,7 +235,7 @@
 			  longName.trimmed().count() < MINIMUM_LONG_OPTION))
 	   throw logic_error(tr("Option for the long name cannot be "
 			 "null, a single character, or empty.").toStdString());
-    foreach (Properties supported, this->mSupported)
+    foreach (Properties supported, this->supported_)
 	   if (supported.longName == longName.trimmed())
 		  throw logic_error(tr("The long name '%1' was already in the "
 						   "supported options list under the '%2' "
@@ -246,7 +246,7 @@
 									).arg(shortName).toStdString());
 
     // Check to see if futher options are allowed.
-    if (this->mIsLocked)
+    if (this->isLocked_)
 	   throw logic_error(tr("Cannot add futher arguments as the supported "
 					    "option list is locked.").toStdString());
 
@@ -257,7 +257,7 @@
     support.description = description.trimmed();
     support.needsValue = takesValue;
     support.required = required;
-    this->mSupported.insert(shortName, support);
+    this->supported_.insert(shortName, support);
 
     // Guarantee Required Arguments
     if (required && (! hasArgument(shortName)))
@@ -276,7 +276,7 @@
 
 void QArgs::lock()
 {
-    this->mIsLocked = true;
+    this->isLocked_ = true;
 }
 
 bool QArgs::hasHelp() const
@@ -296,7 +296,7 @@
 
     helpMessage = "usage: " % QFileInfo(fileName).fileName() %
 		  " [options]\nOptions:\n";
-    foreach (Properties property, this->mSupported)
+    foreach (Properties property, this->supported_)
 	   if (property.description.isNull())
 		  continue;
 	   else
@@ -314,7 +314,7 @@
     QString legalText("QtArgs version ");
 
     legalText = legalText % LIBRARY_VERSION % "\nCopyright (C) " %
-		  COPYRIGHT_YEARS % " John Schneiderman\nQtArgs comes with "
+		  COPYRIGHT_YEARS % " CodeGNU Solutions\nQtArgs comes with "
 		  "ABSOLUTELY NO WARRANTY.\nThis is free software, and you are " %
 		  "welcome to redistribute it\nunder certain conditions; see the "
 		  "LICENSE file for details,\nor the Free Software "
@@ -335,11 +335,11 @@
     QString valueTest;
 
     verifySupport();
-    if ((-1 != shortIndex) && ((shortIndex + 1) < this->mArguments.size()))
-	   valueTest = this->mArguments.at(shortIndex + 1).toLower();
+    if ((-1 != shortIndex) && ((shortIndex + 1) < this->arguments_.size()))
+	   valueTest = this->arguments_.at(shortIndex + 1).toLower();
     else if (-1 != longIndex)
 #ifdef Q_OS_WIN32
-	   valueTest = this->mArguments.at(longIndex + 1).toLower();
+	   valueTest = this->arguments_.at(longIndex + 1).toLower();
 #else
 	   valueTest = this->mArguments.at(longIndex).split(
 			 ARGUMENT_LONG_ASSIGNMENT)[1].toLower();
@@ -380,11 +380,11 @@
     bool converted(false);
 
     verifySupport();
-    if ((-1 != shortIndex) && ((shortIndex + 1) < this->mArguments.size()))
-	   value = this->mArguments.at(shortIndex + 1).toDouble(&converted);
+    if ((-1 != shortIndex) && ((shortIndex + 1) < this->arguments_.size()))
+	   value = this->arguments_.at(shortIndex + 1).toDouble(&converted);
     else if (-1 != longIndex)
 #ifdef Q_OS_WIN32
-	   value = this->mArguments.at(longIndex + 1).toDouble(&converted);
+	   value = this->arguments_.at(longIndex + 1).toDouble(&converted);
 #else
 	   value = this->mArguments.at(longIndex).split(
 			 ARGUMENT_LONG_ASSIGNMENT)[1].toDouble(&converted);
@@ -406,11 +406,11 @@
     bool converted(false);
 
     verifySupport();
-    if ((-1 != shortIndex) && ((shortIndex + 1) < this->mArguments.size()))
-	   value = this->mArguments.at(shortIndex + 1).toShort(&converted);
+    if ((-1 != shortIndex) && ((shortIndex + 1) < this->arguments_.size()))
+	   value = this->arguments_.at(shortIndex + 1).toShort(&converted);
     else if (-1 != longIndex)
 #ifdef Q_OS_WIN32
-	   value = this->mArguments.at(longIndex + 1).toShort(&converted);
+	   value = this->arguments_.at(longIndex + 1).toShort(&converted);
 #else
 	   value = this->mArguments.at(longIndex).split(
 			 ARGUMENT_LONG_ASSIGNMENT)[1].toShort(&converted);
@@ -432,11 +432,11 @@
     bool converted(false);
 
     verifySupport();
-    if ((-1 != shortIndex) && ((shortIndex + 1) < this->mArguments.size()))
-	   value = this->mArguments.at(shortIndex + 1).toShort(&converted);
+    if ((-1 != shortIndex) && ((shortIndex + 1) < this->arguments_.size()))
+	   value = this->arguments_.at(shortIndex + 1).toShort(&converted);
     else if (-1 != longIndex)
 #ifdef Q_OS_WIN32
-	   value = this->mArguments.at(longIndex + 1).toShort(&converted);
+	   value = this->arguments_.at(longIndex + 1).toShort(&converted);
 #else
 	   value = this->mArguments.at(longIndex).split(
 			 ARGUMENT_LONG_ASSIGNMENT)[1].toShort(&converted);
@@ -458,11 +458,11 @@
     bool converted(false);
 
     verifySupport();
-    if ((-1 != shortIndex) && ((shortIndex + 1) < this->mArguments.size()))
-	   value = this->mArguments.at(shortIndex + 1).toInt(&converted);
+    if ((-1 != shortIndex) && ((shortIndex + 1) < this->arguments_.size()))
+	   value = this->arguments_.at(shortIndex + 1).toInt(&converted);
     else if (-1 != longIndex)
 #ifdef Q_OS_WIN32
-	   value = this->mArguments.at(longIndex + 1).toInt(&converted);
+	   value = this->arguments_.at(longIndex + 1).toInt(&converted);
 #else
 	   value = this->mArguments.at(longIndex).split(
 			 ARGUMENT_LONG_ASSIGNMENT)[1].toInt(&converted);
@@ -484,11 +484,11 @@
     bool converted(false);
 
     verifySupport();
-    if ((-1 != shortIndex) && ((shortIndex + 1) < this->mArguments.size()))
-	   value = this->mArguments.at(shortIndex + 1).toLongLong(&converted);
+    if ((-1 != shortIndex) && ((shortIndex + 1) < this->arguments_.size()))
+	   value = this->arguments_.at(shortIndex + 1).toLongLong(&converted);
     else if (-1 != longIndex)
 #ifdef Q_OS_WIN32
-	   value = this->mArguments.at(longIndex + 1).toLongLong(&converted);
+	   value = this->arguments_.at(longIndex + 1).toLongLong(&converted);
 #else
 	   value = this->mArguments.at(longIndex).split(
 			 ARGUMENT_LONG_ASSIGNMENT)[1].toLongLong(&converted);
@@ -510,11 +510,11 @@
     bool converted(false);
 
     verifySupport();
-    if ((-1 != shortIndex) && ((shortIndex + 1) < this->mArguments.size()))
-	   value = this->mArguments.at(shortIndex + 1).toUShort(&converted);
+    if ((-1 != shortIndex) && ((shortIndex + 1) < this->arguments_.size()))
+	   value = this->arguments_.at(shortIndex + 1).toUShort(&converted);
     else if (-1 != longIndex)
 #ifdef Q_OS_WIN32
-	   value = this->mArguments.at(longIndex + 1).toUShort(&converted);
+	   value = this->arguments_.at(longIndex + 1).toUShort(&converted);
 #else
 	   value = this->mArguments.at(longIndex).split(
 			 ARGUMENT_LONG_ASSIGNMENT)[1].toUShort(&converted);
@@ -536,11 +536,11 @@
     bool converted(false);
 
     verifySupport();
-    if ((-1 != shortIndex) && ((shortIndex + 1) < this->mArguments.size()))
-	   value = this->mArguments.at(shortIndex + 1).toUShort(&converted);
+    if ((-1 != shortIndex) && ((shortIndex + 1) < this->arguments_.size()))
+	   value = this->arguments_.at(shortIndex + 1).toUShort(&converted);
     else if (-1 != longIndex)
 #ifdef Q_OS_WIN32
-	   value = this->mArguments.at(longIndex + 1).toUShort(&converted);
+	   value = this->arguments_.at(longIndex + 1).toUShort(&converted);
 #else
 	   value = this->mArguments.at(longIndex).split(
 			 ARGUMENT_LONG_ASSIGNMENT)[1].toUShort(&converted);
@@ -562,11 +562,11 @@
     bool converted(false);
 
     verifySupport();
-    if ((-1 != shortIndex) && ((shortIndex + 1) < this->mArguments.size()))
-	   value = this->mArguments.at(shortIndex + 1).toUInt(&converted);
+    if ((-1 != shortIndex) && ((shortIndex + 1) < this->arguments_.size()))
+	   value = this->arguments_.at(shortIndex + 1).toUInt(&converted);
     else if (-1 != longIndex)
 #ifdef Q_OS_WIN32
-	   value = this->mArguments.at(longIndex + 1).toUInt(&converted);
+	   value = this->arguments_.at(longIndex + 1).toUInt(&converted);
 #else
 	   value = this->mArguments.at(longIndex).split(
 			 ARGUMENT_LONG_ASSIGNMENT)[1].toUInt(&converted);
@@ -588,11 +588,11 @@
     bool converted(false);
 
     verifySupport();
-    if ((-1 != shortIndex) && ((shortIndex + 1) < this->mArguments.size()))
-	   value = this->mArguments.at(shortIndex + 1).toULongLong(&converted);
+    if ((-1 != shortIndex) && ((shortIndex + 1) < this->arguments_.size()))
+	   value = this->arguments_.at(shortIndex + 1).toULongLong(&converted);
     else if (-1 != longIndex)
 #ifdef Q_OS_WIN32
-	   value = this->mArguments.at(longIndex + 1).toULongLong(&converted);
+	   value = this->arguments_.at(longIndex + 1).toULongLong(&converted);
 #else
 	   value = this->mArguments.at(longIndex).split(
 			 ARGUMENT_LONG_ASSIGNMENT)[1].toULongLong(&converted);
@@ -615,11 +615,11 @@
     int longIndex(longNameIndex(shortName));
 
     verifySupport();
-    if ((-1 != shortIndex) && ((shortIndex + 1) < this->mArguments.size()))
-	   valueHolder = this->mArguments.at(shortIndex + 1);
+    if ((-1 != shortIndex) && ((shortIndex + 1) < this->arguments_.size()))
+	   valueHolder = this->arguments_.at(shortIndex + 1);
     else if (-1 != longIndex)
 #ifdef Q_OS_WIN32
-	   valueHolder = this->mArguments.at(longIndex + 1);
+	   valueHolder = this->arguments_.at(longIndex + 1);
 #else
 	   valueHolder = this->mArguments.at(longIndex).split(
 			 ARGUMENT_LONG_ASSIGNMENT)[1];
@@ -643,11 +643,11 @@
     int longIndex(longNameIndex(shortName));
 
     verifySupport();
-    if ((-1 != shortIndex) && ((shortIndex + 1) < this->mArguments.size()))
-	   value = this->mArguments.at(shortIndex + 1);
+    if ((-1 != shortIndex) && ((shortIndex + 1) < this->arguments_.size()))
+	   value = this->arguments_.at(shortIndex + 1);
     else if (-1 != longIndex)
 #ifdef Q_OS_WIN32
-	   value = this->mArguments.at(longIndex + 1);
+	   value = this->arguments_.at(longIndex + 1);
 #else
 	   value = this->mArguments.at(longIndex).split(
 			 ARGUMENT_LONG_ASSIGNMENT)[1];
@@ -667,14 +667,14 @@
     const short LONG_NAME_SIZE(3);
     QChar shortName;
 
-    if (! this->mAreArgumentsVerified)
+    if (! this->areArgumentsVerified_)
     {
 	   // Only the help option is supported & user is trying to get a value.
-	   if (1 == this->mSupported.count())
+	   if (1 == this->supported_.count())
 		  throw logic_error(tr("No arguments listed as "
 						   "being supported!").toStdString());
 
-	   foreach (QString argument, this->mArguments)
+	   foreach (QString argument, this->arguments_)
 	   {
 		  if ((SHORT_NAME_SIZE == argument.count()) &&
 				(argument[0] == ARGUMENT_MARKER) &&
@@ -687,7 +687,7 @@
 			 argument = argument.remove(0, 2);
 			 argument = argument.split(ARGUMENT_LONG_ASSIGNMENT)[0];
 			 shortName = '\0';
-			 foreach (Properties property, this->mSupported)
+			 foreach (Properties property, this->supported_)
 				if (property.longName == argument)
 				{
 				    shortName = property.shortName;
@@ -698,18 +698,18 @@
 			 continue;
 
 		  bool supported;
-		  if (this->mIsCaseSensative)
-			 supported = this->mSupported.contains(shortName);
+		  if (this->isCaseSensative_)
+			 supported = this->supported_.contains(shortName);
 		  else
-			 supported = (this->mSupported.contains(shortName.toUpper())
-					    || this->mSupported.contains(
+			 supported = (this->supported_.contains(shortName.toUpper())
+					    || this->supported_.contains(
 						   shortName.toLower()));
 
 		  if (! supported)
 			 throw runtime_error(tr("Unrecognized Option '%1'").arg(
 								argument).toStdString());
 	   }
-	   this->mAreArgumentsVerified = true;
+	   this->areArgumentsVerified_ = true;
     }
 }
 
@@ -717,13 +717,13 @@
 {
     QRegExp indexTest(QString("%1%2").arg(ARGUMENT_MARKER).arg(
 					 QRegExp::escape(name)),
-				  this->mIsCaseSensative ?
+				  this->isCaseSensative_ ?
 					 Qt::CaseSensitive : Qt::CaseInsensitive);
-    int index(this->mArguments.indexOf(indexTest));
+    int index(this->arguments_.indexOf(indexTest));
 
 #ifdef Q_OS_WIN32
     if (SHORT_HELP == name)
-	   index = this->mArguments.indexOf(QString("%1%2").arg(
+	   index = this->arguments_.indexOf(QString("%1%2").arg(
 			 ARGUMENT_MARKER).arg(SHORT_HELP));
 #endif
     return index;
@@ -735,13 +735,13 @@
 
 #ifdef Q_OS_WIN32
     // Windows long options form is: /long-index-name value
-    index = this->mArguments.indexOf(
+    index = this->arguments_.indexOf(
 			 QRegExp(QString("%1%2").arg(ARGUMENT_MARKER).arg(
-					   this->mSupported.value(name).longName)));
+					   this->supported_.value(name).longName)));
 
     if (SHORT_HELP == name)
-	   index = this->mArguments.indexOf(QRegExp(QString("%1%2").arg(
-			 ARGUMENT_MARKER).arg(mSupported.value(name).longName)));
+	   index = this->arguments_.indexOf(QRegExp(QString("%1%2").arg(
+			 ARGUMENT_MARKER).arg(supported_.value(name).longName)));
 #else
     // Unices long options form is: --long-index-name=value
     index = (this->mArguments.indexOf(
@@ -752,8 +752,8 @@
 #endif
 
     if (-1 == index) // Test for flag long name argument
-	   index = this->mArguments.indexOf(QRegExp(QString("%1%2%3").arg(
+	   index = this->arguments_.indexOf(QRegExp(QString("%1%2%3").arg(
 			 ARGUMENT_MARKER).arg(ARGUMENT_MARKER).arg(
-			 this->mSupported.value(name).longName)));
+			 this->supported_.value(name).longName)));
     return index;
 }
--- a/src/qargs.h	Sat Jun 14 14:42:07 2014 +0000
+++ b/src/qargs.h	Sat Jun 14 15:04:44 2014 +0000
@@ -692,16 +692,16 @@
     typedef QMap< QChar, Properties > PropertyArguments;
 
     /// Holder for all the options supplied by the user from the command-line.
-    QStringList mArguments;
+    QStringList arguments_;
     /// Holder for all the arguments and their properties that are supported
     ///  by an application.
-    PropertyArguments mSupported;
+    PropertyArguments supported_;
     /// Flag which when true indicates that short names are case sensative.
-    bool mIsCaseSensative;
+    bool isCaseSensative_;
     /// Flag which when true indicates no further options are allowed.
-    bool mIsLocked;
+    bool isLocked_;
     /// Flag which when true indicates the arguments were already verified.
-    mutable bool mAreArgumentsVerified;
+    mutable bool areArgumentsVerified_;
 
 
     /// The marker used on the command-line to identify an option. The marker
@@ -801,15 +801,15 @@
     Expected testValue;
     do
     {
-	   if (convertToValueType(this->mArguments.at(index), testValue))
+	   if (convertToValueType(this->arguments_.at(index), testValue))
 		  values.append(testValue);
 	   else
-		  qWarning() << "Failed to convert " << this->mArguments.at(index)
-				   << "into expected value type.";
+		  qWarning() << "Failed to convert '" << this->arguments_.at(index)
+				   << "' into expected value type.";
 	  ++index;
     }
-    while ((index < this->mArguments.size())
-		 && (ARGUMENT_MARKER != this->mArguments.at(index).at(0)));
+    while ((index < this->arguments_.size())
+		 && (ARGUMENT_MARKER != this->arguments_.at(index).at(0)));
 
     if (values.isEmpty())
 	   values.append(defaultValue);