/* * Arguments 2.0 Beta - A Command Line Processing Library * Copyright (C) 2000, 2001 Jared Davis  * * 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 2 of the License, or (at your  * option) 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, write to the Free Software Foundation, Inc.,  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */#include "Arguments.h"#include <algorithm>std::vector<std::string> Arguments::s_spaceArgs;// // ExplodeString function// ----------------------//   Explodes a string into tokens, which it adds to a vector.//   (This function is taken from the AFA library, also by Jared Davis)//void Arguments::ExplodeString(const std::string& str, std::vector<std::string>& tokens, char delimiter) throw(std::bad_alloc){	string::size_type next, prev = 0;	do	{		next = str.find(delimiter, prev);				tokens.push_back( str.substr(prev, next - prev) );		prev = next + 1;	} while(next != string::npos);}// // findArgument// ------------//   Performs a binary search on the argument vector and returns the integer //   corresponding to the argument, if it exists.  Otherwise returns -1.//   arg is a pipe-delimited list of acceptable arguments.//int Arguments::findArgument(const string& arg) const throw(){	if (d_arguments.size() == 0)	{		return -1;	}	vector<std::string> tokens;	ExplodeString(arg, tokens, '|');	for(unsigned int i = 0;i < tokens.size();++i)	{		int low = 0;		int high = d_arguments.size() - 1;		while(low <= high)		{			unsigned int mid = (low + high) / 2;			if (tokens[i] < d_arguments[mid].first)				{				high = mid - 1;			}			else if (tokens[i] > d_arguments[mid].first) 			{				low = mid + 1;			}						else 			{				return mid;			}		}	}	return -1;}// // Arguments::setArgumentsWithSpaces// ---------------------------------//   Adds all tokens of the pipe-delimited string, args, to the//   spaces vector.  keeps the vector sorted.//void Arguments::setArgumentsWithSpaces(const string& args) throw(std::bad_alloc){	ExplodeString(args, s_spaceArgs, '|');	std::sort(s_spaceArgs.begin(), s_spaceArgs.end());}Arguments::Arguments(int argc, const char** argv) throw(std::bad_alloc){	// start at 1 to skip program's name.	for(int i = 1;i < argc;++i)   	{		// Extract this token.		string this_arg = argv[i];		// Try to find a colon or an equals sign.		string::size_type colon = this_arg.find(':');		if (colon == string::npos)		{			colon = this_arg.find('=');		}		// Add arg/val pair if we have a colon or equals sign.		if (colon != string::npos)		{			d_arguments.push_back(make_pair( 				this_arg.substr(0, colon), 				make_pair(this_arg.substr(colon + 1), true)			));			continue;		}		// If we get here, we didn't find a colon or an equals, we need to		// consult the spaces list.		if (i < (argc - 1))		{			if (std::binary_search(s_spaceArgs.begin(), s_spaceArgs.end(), this_arg))			{			  // if parameter value starts with "-" consider it as an option			  if(argv[i+1][0]=='-')			    {			      d_arguments.push_back(make_pair(							      this_arg, 							      make_pair(string(""), false)));			      continue;   // i is not incrented !!			    }			    			  else			    {			      d_arguments.push_back(make_pair(							      this_arg, 							      make_pair(argv[++i], true)							      ));			    			      continue;			    }			}		}		// If we get here, we either don't have a space, or we are at the last		// argument that we were passed, so we can't possibly have a value for 		// this argument. Throw it into the map with an empty value.		d_arguments.push_back(make_pair(			this_arg, 			make_pair(string(""), false)		));	}	// Now let's sort the argument list so it's fast to find them.	std::sort(d_arguments.begin(), d_arguments.end());}// // Arguments::size// ---------------//   Returns the number of command-line arguments that your program was passed. //   This is not the same as argc: it does not include your program's name, nor //   does it include the values passed to your command-line arguments. //unsigned int Arguments::size() const throw(){	return d_arguments.size();}// // Arguments::has// --------------//   Cycle through the tokens of argument and return true if any of them//   are found.//bool Arguments::has(const std::string& argument) const throw(std::bad_alloc){	return findArgument(argument) != -1;}/*#ifndef NDEBUG	#include <iostream>	void Arguments::debug() const	{		cout << "Arguments Debug Information-----\n" << endl;		cout << "Number of space-taking arguments: " << s_spaceArgs.size() << "\n\t";		copy(s_spaceArgs.begin(), s_spaceArgs.end(), ostream_iterator<string>(cout, "\n\t"));		cout << "Arguments Map: " << size() << " Elements. " << endl;		for(unsigned int i = 0;i < size();++i)		{			cout << "\t" << d_arguments[i].first << " = " << d_arguments[i].second.first << "   (" 				<< d_arguments[i].second.second << ")\n";		}		cout << "\n-----End of Arguments Debug Information" << endl;	}#endif*/