예제 #1
0
void
Ex3SuifPass::initialize()
{
    PipelinablePass::initialize();

    OptionList *l;

    // Create grammar for parsing the command line.  This must occur
    // after the parent class's initialize routine has been executed.
    _command_line->set_description("cookbook example #3");

    // Collect optional flags.
    OptionSelection *flags = new OptionSelection(false);

    // -reserve_reg
    l = new OptionList;
    l->add(new OptionLiteral("-reserve_reg"));
    l->add(new OptionString("reg", &reserved_reg_name));
    l->set_description("specifies name of register to reserve");
    flags->add(l);

    // Accept tagged options in any order.
    _command_line->add(new OptionLoop(flags));

    // zero or more file names
    file_names = new OptionString("file name");
    OptionLoop *files =
	new OptionLoop(file_names,
		       "names of optional input and/or output files");
    _command_line->add(files);
}
JavaAssertions::OptionList*
JavaAssertions::match_package(const char* classname) {
  // Search the package list for any items that apply to classname.  Each
  // sub-package in classname is checked, from most-specific to least, until one
  // is found.
  if (_packages == 0) return 0;

  // Find the length of the "most-specific" package in classname.  If classname
  // does not include a package, length will be 0 which will match items for the
  // default package (from options "-ea:..."  or "-da:...").
  size_t len = strlen(classname);
  for (/* empty */; len > 0 && classname[len] != '/'; --len) /* empty */;

  do {
    assert(len == 0 || classname[len] == '/', "not a package name");
    for (OptionList* p = _packages; p != 0; p = p->next()) {
      if (strncmp(p->name(), classname, len) == 0 && p->name()[len] == '\0') {
        return p;
      }
    }

    // Find the length of the next package, taking care to avoid decrementing
    // past 0 (len is unsigned).
    while (len > 0 && classname[--len] != '/') /* empty */;
  } while (len > 0);

  return 0;
}
예제 #3
0
int real_main(int argc, char* argv[])
{
   OptionList options;

   options.parse(argc, argv, "f:L:l:c:t:s");

   if(options.args.size() == 0)
   {
      usage("testngppst-runner");
   }

   //showOptions(options);
   
   StringList listeners;
   getListeners(listeners, options);   

   StringList searchingPathsOfListeners;
   getSearchingPathsOfListeners(searchingPathsOfListeners, options);   

   StringList fixtures;
	getSpecifiedFixtures(fixtures, options);

   bool usesSandbox = useSandbox(options);
   
   unsigned int maxConcurrent = 0;
   if(usesSandbox)
   {
      maxConcurrent = getMaxConcurrent(options);
   }
   
   std::string tagsFilterOption = getSingleOption("t", options, "*");
                                                 
   return TestRunner().runTests(useSandbox(options), maxConcurrent, options.args, listeners
                         , searchingPathsOfListeners, fixtures, tagsFilterOption);
}
예제 #4
0
// Sets an option
void Installer::setOption(const std::string& name,
                          const std::string& value)
{
    BOOST_ASSERT(name.empty() == false);
    BOOST_ASSERT(value.empty() == false);

    // before set any new config file option
    // reread config file
    m_factory->getConfig()->load();

    // look for the option
    OptionList options = m_factory->getConfig()->getOptions();
    OptionList::iterator i = std::find_if(
        options.begin(), options.end(),
        boost::bind(
            std::equal_to<std::string>(),
            name,
            boost::bind(&IOption::getName, _1)));
    if (i == options.end())
    {
        throw Exception(__FILE__, __LINE__,
                        "Cannot find option with name: " + name);
    }

    (*i)->setValue(value);

    // save result
    m_factory->getConfig()->save();

}
예제 #5
0
MeterRandom::MeterRandom(std::list<Option> options)
		: Protocol("random")
{
	OptionList optlist;

	_min = 0;
	_max = 40;
	_last = (_max + _min) / 2; /* start in the middle */

	try {
		_min = optlist.lookup_double(options, "min");
	} catch( vz::OptionNotFoundException &e ) {
		_min = 0;
	} catch( vz::VZException &e ) {
		print(log_error, "Min value has to be a floating point number (e.g. '40.0')", name().c_str());
		throw;
	}

	try {
		_max = optlist.lookup_double(options, "max");
	} catch( vz::OptionNotFoundException &e ) {
		_max = 0;
	} catch( vz::VZException &e ) {
		print(log_error, "Max value has to be a floating point number (e.g. '40.0')", name().c_str());
		throw;
	}
}
예제 #6
0
void
M2aSuifPass::initialize()
{
    OptionList *l;
    OptionLiteral *f;

    PipelinablePass::initialize();

    // Create parse tree for parsing the command line.  This must occur
    // after the parent class's initialize routine has been executed.
    _command_line->set_description(
	"translate Machine-SUIF file to assembly language");

    // Collect optional flags.
    OptionSelection *flags = new OptionSelection(false);

    // -debug level
    l = new OptionList;
    l->add(new OptionLiteral("-debug"));
    l->add(new OptionInt("level", &debuglvl));
    l->set_description("set verbosity level for debugging messages");
    flags->add(l);

    // -all_notes -- print all instruction notes
    f = new OptionLiteral("-all_notes", &m2a.print_all_notes, true);
    f->set_description("force all instruction notes to appear in output");
    flags->add(f);
    
    // -noprint note -- do not print this note
    l = new OptionList;
    l->add(new OptionLiteral("-noprint"));
    nonprinting_notes_option = new OptionString("annotation key");
    l->add(nonprinting_notes_option);
    l->set_description("suppress annotations with given key");
    flags->add(l);

    // -G max -- max byte size of datum in $gp area
    l = new OptionList;
    l->add(new OptionLiteral("-G"));
    l->add(new OptionInt("max", &m2a.Gnum));
    l->set_description("set max byte size of a datum in the $gp area");
    flags->add(l);

    // -stabs -- print with stabs information
    f = new OptionLiteral("-stabs", &m2a.want_stabs, true);
    f->set_description("add stabs debugging information to output");
    flags->add(f);

    // accept flags in any order
    _command_line->add(new OptionLoop(flags));

    // zero or more file names
    file_names_option = new OptionString("file name");
    OptionLoop *files =
	new OptionLoop(file_names_option,
		       "names of optional input and/or output files");
    _command_line->add(files);
}
inline JavaAssertions::OptionList*
JavaAssertions::match_class(const char* classname) {
  for (OptionList* p = _classes; p != 0; p = p->next()) {
    if (strcmp(p->name(), classname) == 0) {
      return p;
    }
  }
  return 0;
}
void SolveFeedbackVariablesPass3::initialize()
{
  PipelinablePass::initialize() ;
  _command_line->set_description("Solves feedback variables") ;
  OptionInt* optionIsSystolic = new OptionInt("IsSystolic", &isSystolic) ;
  OptionList* feedbackArguments = new OptionList() ;
  feedbackArguments->add(optionIsSystolic) ;
  _command_line->add(feedbackArguments) ;
}
예제 #9
0
void ExportPass::initialize()
{
  PipelinablePass::initialize() ;
  _command_line->set_description("Add either a system or a module to the repository from the current suif file") ;
  OptionString* directory = new OptionString("Local Dir", &localDirectory) ;
  OptionList* args = new OptionList() ;
  args->add(directory) ;
  _command_line->add(args) ;
}
예제 #10
0
vz::api::Volkszaehler::Volkszaehler(
	Channel::Ptr ch,
	std::list<Option> pOptions
	)
	: ApiIF(ch)
	, _last_timestamp(0)
{
	OptionList optlist;
	char url[255], agent[255];
	unsigned short curlTimeout = 30; // 30 seconds

/* parse options */
	try {
		_middleware = optlist.lookup_string(pOptions, "middleware");
	} catch (vz::OptionNotFoundException &e) {
		throw;
	} catch (vz::VZException &e) {
		throw;
	}

	try {
		curlTimeout = optlist.lookup_int(pOptions, "timeout");
	} catch (vz::OptionNotFoundException &e) {
	// use default value instead
		curlTimeout = 30; // 30 seconds
	} catch (vz::VZException &e) {
		throw;
	}

/* prepare header, uuid & url */
	sprintf(agent, "User-Agent: %s/%s (%s)", PACKAGE, VERSION, curl_version());     /* build user agent */
	sprintf(url, "%s/data/%s.json", middleware().c_str(), channel()->uuid());                        /* build url */

	_api.headers = NULL;
	_api.headers = curl_slist_append(_api.headers, "Content-type: application/json");
	_api.headers = curl_slist_append(_api.headers, "Accept: application/json");
	_api.headers = curl_slist_append(_api.headers, agent);

	_api.curl = curl_easy_init();
	if (!_api.curl) {
		throw vz::VZException("CURL: cannot create handle.");
	}

	curl_easy_setopt(_api.curl, CURLOPT_URL, url);
	curl_easy_setopt(_api.curl, CURLOPT_HTTPHEADER, _api.headers);
	curl_easy_setopt(_api.curl, CURLOPT_VERBOSE, options.verbosity());
	curl_easy_setopt(_api.curl, CURLOPT_DEBUGFUNCTION, curl_custom_debug_callback);
	curl_easy_setopt(_api.curl, CURLOPT_DEBUGDATA, channel().get());

	// signal-handling in libcurl is NOT thread-safe. so force to deactivated them!
	curl_easy_setopt(_api.curl, CURLOPT_NOSIGNAL, 1);

	// set timeout to 5 sec. required if next router has an ip-change.
	curl_easy_setopt(_api.curl, CURLOPT_TIMEOUT, curlTimeout);
}
QVariant TableModelVariablesOptions::data(const QModelIndex &index, int role) const
{
	if (_boundTo == NULL)
		return QVariant();

	if (index.column() == 0)
	{
		if (role == Qt::DisplayRole)
		{
			OptionField *option = static_cast<OptionField *>(_boundTo->at(index.row())->get(0));
			string value = option->value()[0];
			return QString::fromUtf8(value.c_str(), value.length());
		}
		else
		{
			return QVariant();
		}
	}
	else
	{
		if (role != Qt::DisplayRole && role != Qt::EditRole)
			return QVariant();

		Option* option = _boundTo->at(index.row())->get(index.column());
		OptionList *list = dynamic_cast<OptionList *>(option);
		if (list == NULL)
			return QVariant("WTF");

		string selected = list->value();
		QString qsSelected = QString::fromUtf8(selected.c_str(), selected.length());

		if (role == Qt::DisplayRole)
			return qsSelected;

		vector<string> items = list->options();
		QStringList qsItems;

		for (int i = 0; i < items.size(); i++)
		{
			string item = items.at(i);
			QString qs = QString::fromUtf8(item.c_str(), item.size());
			qsItems.append(qs);
		}

		QVariant qvSelected = QVariant(qsSelected);
		QVariant qvItems = QVariant(qsItems);

		QList<QVariant> qvValue;
		qvValue.append(qvSelected);
		qvValue.append(qvItems);

		return qvValue;
	}

}
예제 #12
0
파일: MeterS0.cpp 프로젝트: andig/vzlogger
MeterS0::HWIF_UART::HWIF_UART(const std::list<Option> &options) :
	_fd(-1)
{
	OptionList optlist;

	try {
		_device = optlist.lookup_string(options, "device");
	} catch (vz::VZException &e) {
		print(log_error, "Missing device or invalid type", "");
		throw;
	}
}
예제 #13
0
void MarkRedundantPass::initialize()
{
  PipelinablePass::initialize() ;
  _command_line->set_description("Marks labels as redundant") ;
  OptionString* optionRedundantLabel = new OptionString("Redundant Label",
							&redundantLabel) ;
  OptionInt* doubleOption = new OptionInt("DoubleOrTriple", &doubleOrTriple) ;
  OptionList* arguments = new OptionList() ;
  arguments->add(optionRedundantLabel) ;
  arguments->add(doubleOption) ;
  _command_line->add(arguments) ;
}
예제 #14
0
	//------------------------------------------------------------------------
	void OptimiseTool::doInvoke(const OptionList& toolOptions,
		const Ogre::StringVector& inFileNames, const Ogre::StringVector& outFileNamesArg)
	{
		// Name count has to match, else we have no way to figure out how to apply output
		// names to input files.
		if (!(outFileNamesArg.empty() || inFileNames.size() == outFileNamesArg.size()))
		{
			fail("number of output files must match number of input files.");
		}

		mPosTolerance = mNormTolerance = mUVTolerance = 1e-06f;
		mKeepIdentityTracks = OptionsUtil::isOptionSet(toolOptions, "keep-identity-tracks");
		for (OptionList::const_iterator it = toolOptions.begin(); it != toolOptions.end(); ++it)
		{
			if (it->first == "tolerance")
			{
				mPosTolerance = mNormTolerance = mUVTolerance = static_cast<float>(any_cast<Real>(it->second));
			}
			else if (it->first == "pos_tolerance")
			{
				mPosTolerance = static_cast<float>(any_cast<Real>(it->second));
			}
			else if (it->first == "norm_tolerance")
			{
				mNormTolerance = static_cast<float>(any_cast<Real>(it->second));
			}
			else if (it->first == "uv_tolerance")
			{
				mUVTolerance = static_cast<float>(any_cast<Real>(it->second));
			}
		}


		StringVector outFileNames = outFileNamesArg.empty() ? inFileNames : outFileNamesArg;

		// Process the meshes
		for (size_t i = 0, end = inFileNames.size(); i < end; ++i)
		{
			if (StringUtil::endsWith(inFileNames[i], ".mesh", true))
			{
				processMeshFile(inFileNames[i], outFileNames[i]);
			}
			else if (StringUtil::endsWith(inFileNames[i], ".skeleton", true))
			{
				processSkeletonFile(inFileNames[i], outFileNames[i]);
			}
			else
			{
				warn("unrecognised name ending for file " + inFileNames[i]);
				warn("file skipped.");
			}
		}
	}
예제 #15
0
void RemoveModulePass::initialize()
{
    PipelinablePass::initialize() ;
    _command_line->set_description("Remove a module from the repository") ;
    OptionString* name = new OptionString("Module Name", &moduleName) ;
    OptionString* directory = new OptionString("Local Directory",
            &localDirectory) ;
    OptionList* args = new OptionList() ;
    args->add(name) ;
    args->add(directory) ;
    _command_line->add(args) ;
}
예제 #16
0
Playlist Generator::generate(OptionList optionList)
{
  //Recupération d'une pool de morceaux
  TrackPool pool = db.select(optionList,optionList.getSize()*POOL_SIZE_FACTOR);
  selectionFeedback.notifyAll(pool.size(), pool);
  Playlist playlist;
  if(pool.size() == 0)
    return playlist;
  //On lance la génération
  generationLoop(&playlist, pool, optionList.getSize());
  return playlist;
}
예제 #17
0
MeterSML::MeterSML(std::list<Option> options) 
		: Protocol("sml")
		, _host("")
		, _device("")
		, BUFFER_LEN(SML_BUFFER_LEN)
{
	OptionList optlist;

	/* connection */
	try {
		_host = optlist.lookup_string(options, "host");
	} catch ( vz::OptionNotFoundException &e ) {
		try {
			_device = optlist.lookup_string(options, "device");
		} catch ( vz::VZException &e ){
			print(log_error, "Missing device or host", name().c_str());
			throw ;
		}
	} catch( vz::VZException &e ) {
		print(log_error, "Missing device or host", name().c_str());
		throw;
	}

	/* baudrate */
	int baudrate = 9600; /* default to avoid compiler warning */
	try {
		baudrate = optlist.lookup_int(options, "baudrate");
		/* find constant for termios structure */
		switch (baudrate) {
				case 1200: _baudrate = B1200; break;
				case 1800: _baudrate = B1800; break;
				case 2400: _baudrate = B2400; break;
				case 4800: _baudrate = B4800; break;
				case 9600: _baudrate = B9600; break;
				case 19200: _baudrate = B19200; break;
				case 38400: _baudrate = B38400; break;
				case 57600: _baudrate = B57600; break;
				case 115200: _baudrate = B115200; break;
				case 230400: _baudrate = B230400; break;
				default:
					print(log_error, "Invalid baudrate: %i", name().c_str(), baudrate);
					throw vz::VZException("Invalid baudrate");
		}
	} catch( vz::OptionNotFoundException &e ) {
		/* using default value if not specified */
		_baudrate = 9600;
	} catch( vz::VZException &e ) {
		print(log_error, "Failed to parse the baudrate", name().c_str());
		throw;
	}
}
예제 #18
0
Playlist Generator::regenerate(OptionList optionList, Playlist playlist)
{
  //Recupération d'une pool de morceaux
  TrackPool pool = db.select(optionList,optionList.getSize()*POOL_SIZE_FACTOR);
  selectionFeedback.notifyAll(pool.size(), pool);
  if(pool.size() == 0)
    return playlist;
  //On remplit la pool avec les morceaux de la playlist précédente
  for(auto it = playlist.begin(); it != playlist.end(); ++it)
    pool.insert(*it);
  Playlist newPlaylist;
  //On lance la génération
  generationLoop(&newPlaylist, pool, optionList.getSize());
  return newPlaylist;
}
예제 #19
0
  virtual void initialize() {
    Pass::initialize();

    _def_flag_argument = new OptionLiteral("-D", &def, true);
    _def_opts_argument = new OptionMultiString("definition", &_d_opts);
    _def_list_argument = new OptionList();
    _def_list_argument->add(_def_flag_argument);
    _def_list_argument->add(_def_opts_argument);
    _def_loop_argument = new OptionLoop(_def_list_argument, true);

    _def_selector = new OptionSelection(true);
    _def_selector->add(_def_loop_argument);
    _command_line->add(_def_selector);

    _incl_flag_argument = new OptionLiteral("-I", &incl, true);
    _incl_opts_argument = new OptionMultiString("include", &_i_opts);
    _incl_list_argument = new OptionList();
    _incl_list_argument->add(_incl_flag_argument);
    _incl_list_argument->add(_incl_opts_argument);
    _incl_loop_argument = new OptionLoop(_incl_list_argument, true);

    _incl_selector = new OptionSelection(true);
    _incl_selector->add(_incl_loop_argument);
    _command_line->add(_incl_selector);
    
    _debug_argument = new OptionLiteral("-d", &debug_it, true);
    _debug_selector = new OptionSelection(true);
    _debug_selector-> add( _debug_argument );
    _command_line-> add(_debug_selector);

#ifndef MSVC
    _macro_file_name = get_default_file_name("suif/suif2b/basesuif/s2c/c_text.mac");
#else
    _macro_file_name = get_default_file_name("suif\\suif2b\\basesuif\\s2c\\c_text.mac");
#endif

    _output_file_name_argument = new OptionString( "output-file" );
    _command_line-> add( _output_file_name_argument );
    _macro_file_name_argument = new OptionString( "macro-file",&_macro_file_name );
    _option_selector = new OptionSelection(true);
    _option_selector-> add( _macro_file_name_argument );
    _command_line-> add(_option_selector);
    
    _command_line-> set_description("Outputs C form of a SUIF tree." );
    // SuifEnv *s = get_suif_env();

  }
예제 #20
0
파일: main.cpp 프로젝트: t0suj4/minetest
static void print_allowed_options(const OptionList &allowed_options)
{
	for (OptionList::const_iterator i = allowed_options.begin();
			i != allowed_options.end(); ++i) {
		std::ostringstream os1(std::ios::binary);
		os1 << "  --" << i->first;
		if (i->second.type != VALUETYPE_FLAG)
			os1 << _(" <value>");

		dstream << padStringRight(os1.str(), 24);

		if (i->second.help != NULL)
			dstream << i->second.help;

		dstream << std::endl;
	}
}
bool JavaAssertions::enabled(const char* classname, bool systemClass) {
  assert(classname != 0, "must have a classname");

  // This will be slow if the number of assertion options on the command line is
  // large--it traverses two lists, one of them multiple times.  Could use a
  // single n-ary tree instead of lists if someone ever notices.

  // First check options that apply to classes.  If we find a match we're done.
  OptionList* p;
  if (p = match_class(classname)) {
    trace(classname, "class", p->name(), p->enabled());
    return p->enabled();
  }

  // Now check packages, from most specific to least.
  if (p = match_package(classname)) {
    trace(classname, "package", p->name(), p->enabled());
    return p->enabled();
  }

  // No match.  Return the default status.
  bool result = systemClass ? systemClassDefault() : userClassDefault();
  trace(classname, systemClass ? "system" : "user", "default", result);
  return result;
}
예제 #22
0
void set_option_to_list( const std::string & name,
                         const typename OPTION_TYPE::value_type & value,
                         OptionList & options )
{
  if( !options.check(name) )
    options.add_option< OPTION_TYPE >(name, value);
  else
    options[name].change_value( value );
}
bool TableModelVariablesOptions::setData(const QModelIndex &index, const QVariant &value, int role)
{
	if (_boundTo == NULL)
		return false;

	Options *options = _boundTo->at(index.row());
	Option *option = options->get(index.column());
	OptionList *list = dynamic_cast<OptionList *>(option);

	QString qsValue = value.toString();
	QByteArray bytes = qsValue.toUtf8();

	list->setValue(string(bytes.constData(), bytes.length()));

	emit dataChanged(index, index);

	return true;
}
예제 #24
0
파일: MeterS0.cpp 프로젝트: andig/vzlogger
MeterS0::HWIF_GPIO::HWIF_GPIO(int gpiopin, const std::list<Option> &options) :
	_fd(-1), _gpiopin(gpiopin), _configureGPIO(true)
{
	OptionList optlist;

	if (_gpiopin <0) throw vz::VZException("invalid (<0) gpio(pin) set");

	try {
		_configureGPIO = optlist.lookup_bool(options, "configureGPIO");
	} catch (vz::VZException &e) {
		print(log_info, "Missing bool configureGPIO using default true", "S0");
		_configureGPIO = true;
	}

	_device.append("/sys/class/gpio/gpio");
	_device.append(std::to_string(_gpiopin));
	_device.append("/value");

}
QVariant TableModelVariablesOptions::data(const QModelIndex &index, int role) const
{
	if (_boundTo == NULL)
		return QVariant();

	if (index.column() == 0)
	{
		if (role == Qt::DisplayRole)
		{	
			OptionTerms *option = static_cast<OptionTerms *>(_rows.at(index.row())->get(0));
			return Term(option->value().front()).asQString();
		}
		else
		{
			return QVariant();
		}
	}
	else
	{
		if (role != Qt::DisplayRole && role != Qt::EditRole)
			return QVariant();

		Option* option = _rows.at(index.row())->get(index.column());
		OptionList *list = dynamic_cast<OptionList *>(option);
		if (list == NULL)
			return QVariant("WTF");

		QString selected = tq(list->value());

		if (role == Qt::DisplayRole)
			return selected;

		QStringList items = tql(list->options());

		QList<QVariant> value;
		value.append(selected);
		value.append(items);

		return value;
	}

}
예제 #26
0
MeterExec::MeterExec(std::list<Option> options)
		: Protocol("exec")
{
	OptionList optlist;

	try {
		_command = optlist.lookup_string(options, "command");
	} catch (vz::VZException &e) {
		print(log_error, "Missing command or invalid type", "");
		throw;
	}

	try {
		_format = optlist.lookup_string(options, "format");
	} catch (vz::OptionNotFoundException &e) {
		_format = NULL; /* use default format */
	} catch (vz::VZException &e) {
		print(log_error, "Failed to parse format", "");
		throw;
	}
}
예제 #27
0
// Available colours - if you change these update the tests :-)
ParameterTable
BrushStyle::newDefaultColorTable(const std::string& nameOfDefaultTable)
{
  typedef std::vector<std::string> OptionList;
  ParameterTable t;
  OptionList listOfColours;
  listOfColours.push_back("black");
  listOfColours.push_back("white");
  listOfColours.push_back("red");
  listOfColours.push_back("blue");
  listOfColours.push_back("green");
  listOfColours.push_back("cyan");
  listOfColours.push_back("magenta");
  listOfColours.push_back("yellow");
  listOfColours.push_back("orange");
  listOfColours.push_back("brown");
  t.addParameter("color", listOfColours, "black");
  return t;
}
예제 #28
0
	void Parser::clear()
	{
		if (not pAllOptions.empty())
		{
			OptionList::iterator end = pAllOptions.end();
			for (OptionList::iterator i = pAllOptions.begin(); i != end; ++i)
				delete *i;

			// clear-and-minimize idiom
			OptionsOrderedByShortName emptyShort;
			OptionsOrderedByLongName  emptyLong;
			OptionList emptyOptions;

			emptyShort.swap(pShortNames);
			emptyLong.swap(pLongNames);
			emptyOptions.swap(pAllOptions);

			// the whole content of these 3 containers will be destroyed here
		}

		delete pRemains;
		pRemains = nullptr;
	}
예제 #29
0
    inline Type ns_cert_type(const OptionList& opt) {
      const Option* o = opt.get_ptr("ns-cert-type");
      if (o)
	{
	  const std::string& ct = o->get_optional(1, 16);
	  if (ct == "server")
	    return SERVER;
	  else if (ct == "client")
	    return CLIENT;
	  else
	    throw option_error("ns-cert-type must be 'client' or 'server'");
	}
      return NONE;
    }
예제 #30
0
// Processes interactive option
void Installer::processInteractive()
{
    // process all options
    IConfig* config = m_factory->getConfig();
    // before set any new config file option
    // reread config file
    config->load();

    // look for the option
    OptionList options = config->getOptions();
    for (OptionList::iterator i = options.begin();
         i != options.end(); i++)
    {
        const std::string name = (*i)->getName();
        const std::string oldval = (*i)->getValue();

        std::cout << "Option '" << name << "' has the following value: "
                  << oldval << std::endl;

        if (ask("Do you want to change it [N/y]: "))
        {
            std::string value = get("New value: ");
            setOption((*i)->getName(), value);
        }
    }

    if (ask("Do you want to recreate DB [N/y]: "))
    {
        recreateDB();
    }

    // resources detection
    if (ask("Do you want to detect resources [N/y]: "))
    {
        detectResources();
    }
}