--- /dev/null
+/*
+ * 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
+*/
git://source.jalview.org / jabaws.git / blobdiff