ArgumentParser.h

/*
 *  ArgumentParser.h
 *  Cubism
 *
 *	This argument parser assumes that all arguments are optional ie, each of the argument names is preceded by a '-'
 *		all arguments are however NOT optional to avoid a mess with default values and returned values when not found!
 *
 *	More converter could be required:
 *		add as needed
 *			TypeName as{TypeName}() in Value
 *
 *  Created by Christian Conti on 6/7/10.
 *  Copyright 2010 ETH Zurich. All rights reserved.
 *
 */

#pragma once
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <map>
#include <vector>
#include <string>
#include <iostream>
#include <sstream>


using namespace std;

class Value
{
private:
	string content;

public:

	Value() : content("") {}

	Value(string content_) : content(content_) { /*printf("%s\n",content.c_str());*/ }

	double asDouble(double def=0)
	{
		if (content == "")
        {
            ostringstream sbuf;
            sbuf << def;
            content = sbuf.str();
        }
		return (double) atof(content.c_str());
	}

	int asInt(int def=0)
	{
		if (content == "")
        {
            ostringstream sbuf;
            sbuf << def;
            content = sbuf.str();
        }
		return atoi(content.c_str());
	}

	bool asBool(bool def=false)
	{
		if (content == "")
        {
            if (def) content = "true";
            else     content = "false";
        }
		if (content == "0") return false;
		if (content == "false") return false;

		return true;
	}

	string asString(string def="")
	{
		if (content == "") content = def;

		return content;
	}
};

class ArgumentParser
{
private:

	map<string,Value> mapArguments;

	const int iArgC;
	const char** vArgV;
	bool bStrictMode, bVerbose;

public:

	Value& operator()(const string arg)
	{
		if (bStrictMode)
		{
			map<string,Value>::const_iterator it = mapArguments.find(arg);

			if (it == mapArguments.end())
			{
				printf("Runtime option NOT SPECIFIED! ABORTING! name: %s\n",arg.data());
				abort();
			}
		}

		if (bVerbose) printf("%s is %s\n", arg.data(), mapArguments[arg].asString().data());
		return mapArguments[arg];
	}

	bool check(const string arg) const
	{
		return mapArguments.find(arg) != mapArguments.end();
	}

	ArgumentParser(const int argc, const char ** argv) : mapArguments(), iArgC(argc), vArgV(argv), bStrictMode(false), bVerbose(true)
	{
		for (int i=1; i<argc; i++)
			if (argv[i][0] == '-')
			{
				string values = "";
				int itemCount = 0;

				for (int j=i+1; j<argc; j++)
					if (argv[j][0] == '-')
						break;
					else
					{
						if (strcmp(values.c_str(), ""))
							values += ' ';

						values += argv[j];
						itemCount++;
					}

				if (itemCount == 0)
					values = "true";

				mapArguments[argv[i]] = Value(values);
				i += itemCount;
			}

		mute();
		//printf("found %ld arguments of %d\n",mapArguments.size(),argc);
	}

	int getargc() const { return iArgC; }

	const char** getargv() const { return vArgV; }

	void set_strict_mode()
	{
		bStrictMode = true;
	}

	void unset_strict_mode()
	{
		bStrictMode = false;
	}

	void mute()
	{
		bVerbose = false;
	}

	void loud()
	{
		bVerbose = true;
	}

	void save_options(string path=".")
	{
		string options;
		for(map<string,Value>::iterator it=mapArguments.begin(); it!=mapArguments.end(); it++)
		{
			options+= it->first + " " + it->second.asString() + " ";
		}
		string filepath = (path + "/" + string("argumentparser.log"));
		FILE * f = fopen(filepath.data(), "a");
		if (f == NULL)
		{
			printf("impossible to write %s.\n", filepath.data());
			return;
		}
		fprintf(f, "%s\n", options.data());
		fclose(f);
	}

	void print_options()
	{
        std::cout << "RUNTIME ARGUMENTS:" << std::endl;
		for(map<string,Value>::iterator it=mapArguments.begin(); it!=mapArguments.end(); it++)
		{
            std::cout.width(50);
            std::cout.fill('.');
            std::cout << std::left << it->first;
            std::cout << ": " << it->second.asString() << std::endl;
		}
    }
};