C++ Options函数代码示例

static void
Usage (
    void)
{

    printf ("Usage:    %s [Options] [Files]\n\n", CompilerName);
    Options ();
}

void IniFile::AddSection(const std::string& name)
{
	Sections::iterator it = _settings.find( name );
	if( it == _settings.end() )
	{
		_settings.insert( make_pair( name, Options() ) );
	}
}

void
Usage (
    void)
{

    printf ("Usage:    %s [Options] [InputFile]\n\n", CompilerName);
    Options ();
}

namespace VskParser
{
  /// Options struct is additional information that helps building a skeleton
  /// that can be used in kinematics or dynamics simulation. VSK file format
  /// itself doesn't provide essential properties for it such as body's shape,
  /// mass, and inertia.
  struct Options
  {
    /// Resource retriever. LocalResourceRetriever is used if it's nullptr.
    common::ResourceRetrieverPtr retrieverOrNullptr;

    /// The default shape for body node is ellipsoid. The size of ellipsoid of
    /// each body node are determined by the relative transformation from a body
    /// node and its child body node. defaultEllipsoidSize is used for body
    /// nodes that don't have child body node.
    Eigen::Vector3d defaultEllipsoidSize;

    /// Ratio of shorter radii of each ellipsoid to the longest radius where
    /// the longest radius is the distance between a body and its child body
    /// node.
    double thicknessRatio;

    /// Density of each ellipsoid that are used to compute mass.
    double density;

    /// Lower limit of joint position
    double jointPositionLowerLimit;

    /// Upper limit of joint position
    double jointPositionUpperLimit;

    /// Joint damping coefficient
    double jointDampingCoefficient;

    /// Joint Coulomb friction
    double jointFriction;

    /// Remove end BodyNodes with no Shape segment
    bool removeEndBodyNodes;

    /// Constructor
    Options(const common::ResourceRetrieverPtr& retrieverOrNullptr = nullptr,
            const Eigen::Vector3d& defaultEllipsoidSize
                = Eigen::Vector3d::Constant(0.05),
            double thicknessRatio = 0.35,
            double density = 1e+3,
            double jointPositionLowerLimit = -math::constantsd::pi(),
            double jointPositionUpperLimit = +math::constantsd::pi(),
            double jointDampingCoefficient = 0.1,
            double jointFriction = 0.0,
            bool removeEndBodyNodes = false);
  };

  /// Read Skeleton from VSK file
  dynamics::SkeletonPtr readSkeleton(const common::Uri& fileUri,
                                     Options options = Options());

} // namespace VskParser

 TEST(ParameterFileMetnoKalman, invalidFile) {
    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
    Util::setShowError(false);
    // Wrongly formatted file
    EXPECT_FALSE(ParameterFileMetnoKalman::isValid("testing/files/parameters.txt"));
    EXPECT_DEATH(ParameterFileMetnoKalman(Options("testing/files/parameters.txt")), ".*");
    // Empty file
    EXPECT_FALSE(ParameterFileMetnoKalman::isValid("testing/files/nonexistaiowenwenrewoi.txt"));
    EXPECT_DEATH(ParameterFileMetnoKalman(Options("testing/files/nonexistaiowenwenrewoi.txt")), ".*");
    // One missing value on a row
    EXPECT_FALSE(ParameterFileMetnoKalman::isValid("testing/files/kalmanInvalid1.txt"));
    EXPECT_DEATH(ParameterFileMetnoKalman(Options("testing/files/kalmanInvalid1.txt")), ".*");
    // Wrong number of columns (header says 20, in reallity its 23)
    EXPECT_FALSE(ParameterFileMetnoKalman::isValid("testing/files/kalmanInvalid2.txt"));
    EXPECT_DEATH(ParameterFileMetnoKalman(Options("testing/files/kalmanInvalid2.txt")), ".*");
    // Missing number of times in header
    EXPECT_FALSE(ParameterFileMetnoKalman::isValid("testing/files/kalmanInvalid3.txt"));
    EXPECT_DEATH(ParameterFileMetnoKalman(Options("testing/files/kalmanInvalid3.txt")), ".*");
    // Text in station ID
    EXPECT_FALSE(ParameterFileMetnoKalman::isValid("testing/files/kalmanInvalid4.txt"));
    EXPECT_DEATH(ParameterFileMetnoKalman(Options("testing/files/kalmanInvalid4.txt")), ".*");
    // Non-existant file
    EXPECT_FALSE(ParameterFileMetnoKalman::isValid("testing/files/kalman98yewd98ywe89.txt"));
    EXPECT_DEATH(ParameterFileMetnoKalman(Options("testing/files/kalman98yewd98ywe89.txt")), ".*");
 }

static void
Usage (
    void)
{

    printf ("%s\n", ASL_COMPLIANCE);
    printf ("Usage:    %s [Options] [Files]\n\n", ASL_INVOCATION_NAME);
    Options ();
}

Options VarSelectorFind::makeOptionsObs(std::string iVariable) const {
    std::stringstream ss;
    ss << "tag=bogus ";
    ss << "class=SelectorAnalog obsSet=wfrt.mv-obs analogMetric=normMetric ";
    ss << "numAnalogs=200 averager=mean normalize=1 dayWidth=365 ";
    ss << "variables=";
    ss << iVariable;
    return Options(ss.str());
}

int LibvlcCamera::PrimeCapture() {
  Info("Priming capture from %s", mPath.c_str());

  StringVector opVect = split(Options(), ",");

  // Set transport method as specified by method field, rtpUni is default
  if ( Method() == "rtpMulti" )
    opVect.push_back("--rtsp-mcast");
  else if ( Method() == "rtpRtsp" )
    opVect.push_back("--rtsp-tcp");
  else if ( Method() == "rtpRtspHttp" )
    opVect.push_back("--rtsp-http");

  opVect.push_back("--no-audio");

  if ( opVect.size() > 0 ) {
    mOptArgV = new char*[opVect.size()];
    Debug(2, "Number of Options: %d",opVect.size());
    for (size_t i=0; i< opVect.size(); i++) {
      opVect[i] = trimSpaces(opVect[i]);
      mOptArgV[i] = (char *)opVect[i].c_str();
      Debug(2, "set option %d to '%s'", i,  opVect[i].c_str());
    }
  }

  mLibvlcInstance = libvlc_new(opVect.size(), (const char* const*)mOptArgV);
  if ( mLibvlcInstance == NULL ) {
    Error("Unable to create libvlc instance due to: %s", libvlc_errmsg());
    return -1;
  }

  mLibvlcMedia = libvlc_media_new_location(mLibvlcInstance, mPath.c_str());
  if ( mLibvlcMedia == NULL ) {
    Error("Unable to open input %s due to: %s", mPath.c_str(), libvlc_errmsg());
    return -1;
  }

  mLibvlcMediaPlayer = libvlc_media_player_new_from_media(mLibvlcMedia);
  if ( mLibvlcMediaPlayer == NULL ) {
    Error("Unable to create player for %s due to: %s", mPath.c_str(), libvlc_errmsg());
    return -1;
  }

  libvlc_video_set_format(mLibvlcMediaPlayer, mTargetChroma.c_str(), width, height, width * mBpp);
  libvlc_video_set_callbacks(mLibvlcMediaPlayer, &LibvlcLockBuffer, &LibvlcUnlockBuffer, NULL, &mLibvlcData);

  mLibvlcData.bufferSize = width * height * mBpp;
  // Libvlc wants 32 byte alignment for images (should in theory do this for all image lines)
  mLibvlcData.buffer = (uint8_t*)zm_mallocaligned(64, mLibvlcData.bufferSize);
  mLibvlcData.prevBuffer = (uint8_t*)zm_mallocaligned(64, mLibvlcData.bufferSize);
  
  mLibvlcData.newImage.setValueImmediate(false);

  libvlc_media_player_play(mLibvlcMediaPlayer);

  return 0;
}

void MenuPrincipal()
{
    SDL_Event event;
    int VariablePourSon=0;
    copt Charger;
    Comp_menu_princp(&Charger);
    Blitterc_p(&Charger);
    int continuer=1;
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch( event.type )
        {
        case SDL_QUIT:
            continuer=0;
            LibererComposantsMenuPrincipal(&Charger);
            exit(0);
            break;
        case SDL_MOUSEBUTTONUP:
            if (collision(event.button.x, event.button.y, Charger.pos_jouer))
            {
                continuer=0;
                LibererComposantsMenuPrincipal(&Charger);
                Choix();
            }
            else if (collision(event.button.x,event.button.y, Charger.pos_options))
            {
                continuer=0;
                LibererComposantsMenuPrincipal(&Charger);
                Options();
            }
            else if (collision(event.button.x,event.button.y, Charger.pos_aide))
            {
                continuer=0;
                LibererComposantsMenuPrincipal(&Charger);
                Aide();
            }
             else if (collision(event.button.x,event.button.y, Charger.pos_quit))
            {
                continuer=0;
                LibererComposantsMenuPrincipal(&Charger);
                exit(0);
            }
            break;
        case SDL_KEYDOWN: /* Si appui d'une touche */
            switch (event.key.keysym.sym)
            {
            case SDLK_s:
                Blitterc_p(&Charger);
                ModifierSon (&VariablePourSon);
                break;
            default:
                break;
            }
        }
    }
}

JobBurner::JobBurner( const JobAssignment & jobAssignment, Slave * slave, int options )
: QObject( slave )
, mSlave( slave )
, mCmd( 0 )
, mJobAssignment( jobAssignment )
, mJob( jobAssignment.job() )
, mLoaded( false )
, mOutputTimer( 0 )
, mMemTimer( 0 )
, mLogFlushTimer( 0 )
, mCheckupTimer( 0 )
, mState( StateNew )
, mOptions( Options(options) )
, mCurrentCopy( 0 )
, mLogFilesReady( false )
, mLogFile( 0 )
, mLogStream( 0 )
, mCmdPid( 0 )
{
	mOutputTimer = new QTimer( this );
	connect( mOutputTimer, SIGNAL( timeout() ), SLOT( updateOutput() ) );

	mMemTimer = new QTimer( this );
	connect( mMemTimer, SIGNAL( timeout() ), SLOT( checkMemory() ) );

	mCheckupTimer = new QTimer( this );
	connect( mCheckupTimer, SIGNAL( timeout() ), SLOT( checkup() ) );
    mCheckupTimer->start(30000);
	
	/* Ensure we are actually assigned some tasks to work on */
	mTaskAssignments = mJobAssignment.jobTaskAssignments();
	if( mTaskAssignments.isEmpty() ) {
		jobErrored( QString("JobAssignment has no assigned tasks, Job Assignment key: %1").arg(mJobAssignment.key()) );
		return;
	}

	// Double check that we are still assigned
	mJobAssignment.reload();
	if( mJobAssignment.jobAssignmentStatus().status() != "ready" ) {
		LOG_1( "JobAssignment no longer ready, cancelling the burn" );
		cancel();
		return;
	}

	/* Make sure each of the tasks are still valid, some could have already been unassigned or cancelled */
	/* Also verify that the jobtask record matches the assignment */
	mTasks = JobTask::table()->records( mTaskAssignments.keys( JobTaskAssignment::schema()->field("fkeyjobtask")->pos() ), /*select=*/true, /*useCache=*/false );
	foreach( JobTaskAssignment jta, mTaskAssignments ) {
		JobTask task = jta.jobTask();
		if( jta.jobAssignmentStatus().status() != "ready" || task.status() != "assigned" || task.host() != Host::currentHost() ) {
			LOG_1( QString("JobTask no longer assigned, discarding. keyJobTask: %1  keyJobTaskAssignment: %2  jobtask status: %3 jobtaskassignment status: %4")
				.arg(task.key()).arg(jta.key()).arg(task.status()).arg(jta.jobAssignmentStatus().status()) );
			mTaskAssignments -= jta;
			mTasks -= task;
		}
	}

void MyApplication::run(){
	Options option;
	option.load(*conf);

	std::string data_db_dir = app_args.work_dir + "/data";
	std::string meta_db_dir = app_args.work_dir + "/meta";

	log_info("ssdb-server %s", APP_VERSION);
	log_info("conf_file        : %s", app_args.conf_file.c_str());
	log_info("log_level        : %s", Logger::shared()->level_name().c_str());
	log_info("log_output       : %s", Logger::shared()->output_name().c_str());
	log_info("log_rotate_size  : %" PRId64, Logger::shared()->rotate_size());

	log_info("main_db          : %s", data_db_dir.c_str());
	log_info("meta_db          : %s", meta_db_dir.c_str());
	log_info("cache_size       : %d MB", option.cache_size);
	log_info("block_size       : %d KB", option.block_size);
	log_info("write_buffer     : %d MB", option.write_buffer_size);
	log_info("max_open_files   : %d", option.max_open_files);
	log_info("compaction_speed : %d MB/s", option.compaction_speed);
	log_info("compression      : %s", option.compression.c_str());
	log_info("binlog           : %s", option.binlog? "yes" : "no");
	log_info("sync_speed       : %d MB/s", conf->get_num("replication.sync_speed"));

	SSDB *data_db = NULL;
	SSDB *meta_db = NULL;
	data_db = SSDB::open(option, data_db_dir);
	if(!data_db){
		log_fatal("could not open data db: %s", data_db_dir.c_str());
		fprintf(stderr, "could not open data db: %s\n", data_db_dir.c_str());
		exit(1);
	}

	meta_db = SSDB::open(Options(), meta_db_dir);
	if(!meta_db){
		log_fatal("could not open meta db: %s", meta_db_dir.c_str());
		fprintf(stderr, "could not open meta db: %s\n", meta_db_dir.c_str());
		exit(1);
	}

	NetworkServer *net = NULL;	
	SSDBServer *server;
	net = NetworkServer::init(*conf);
	server = new SSDBServer(data_db, meta_db, *conf, net);
	
	log_info("pidfile: %s, pid: %d", app_args.pidfile.c_str(), (int)getpid());
	log_info("ssdb server started.");
	net->serve();
	
	delete net;
	delete server;
	delete meta_db;
	delete data_db;

	log_info("%s exit.", APP_NAME);
}

  void SensApplication::Initialize()
  {
    DBG_START_METH("SensApplication::Initialize", dbg_verbosity);

    const std::string prefix = ""; // I should be getting this somewhere else...

    Options()->GetIntegerValue("n_sens_steps",n_sens_steps_, prefix.c_str());
    Options()->GetBoolValue("run_sens", run_sens_, prefix.c_str());
    Options()->GetBoolValue("compute_red_hessian", compute_red_hessian_, prefix.c_str());

    // make sure run_sens and skip_finalize_solution_call are consistent
    if (run_sens_ || compute_red_hessian_) {
      Options()->SetStringValue("skip_finalize_solution_call", "yes");
    }
    else {
      Options()->SetStringValue("skip_finalize_solution_call", "no");
    }

  }

void UBasicVolumeComponent::TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction)
{
	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);

	if (m_octree.IsValid())
	{
		// Traverse all the nodes and see if they need to be updated,
		// if so we queue a task.
		m_octree->Traverse([=](FSparseOctreeNode* node) -> ETraverseOptions
		{
			if (node->m_hasChildren)
			{
				return ETraverseOptions::Continue;
			}

			if (!node->IsUpToDate() && !node->IsSceduled() && !node->IsTaskRunning())
			{
				node->m_lastSceduledForUpdate = FTimespan(0, 0, FPlatformTime::Seconds());
				node->m_bTaskRunning = true;

				FVoreealExtractorOptions Options(TWeakPtr<FSparseOctree>(m_octree), node->m_selfId, node->m_bounds, 0);

				if (bOverrideExtractor)
				{
					Options.bOverrideExtractor = true;
					Options.ExtractorType = ExtractorType;
				}

				SCOPE_CYCLE_COUNTER(STAT_RequestMesh);

				AddTask(GetVolume(), Options);
			}

			return ETraverseOptions::Continue;
		});

		// Get Finished Tasks
		TSharedPtr<FVoreealMesh> Task;
		while (FindFinishedTask(Task))
		{
			if (Task.IsValid())
			{
				FVoreealMesh* Mesh = Task.Get();

				Mesh->CreateSection(MeshComponent, true);

				FSparseOctreeNode* Node = m_octree->GetNodeAt(Mesh->GetOptions().Identifier);
				Node->m_meshLastChanged = FTimespan(0, 0, FPlatformTime::Seconds());
				Node->m_bTaskRunning = false;

				SCOPE_CYCLE_COUNTER(STAT_ReturnMesh);
			}
		}
	}
}

IniFile::Options IniFile::GetAllKeyValues(const std::string& section) const
{
	Sections::const_iterator i = _settings.find(section);

	if (i == _settings.end())
	{
		return Options(); // not found
	}

	return i->second;
}

    GeoJSONVT(const mapbox::geometry::feature_collection<double>& features_,
              const Options& options_ = Options())
        : options(options_) {

        const uint32_t z2 = std::pow(2, options.maxZoom);

        auto converted = detail::convert(features_, (options.tolerance / options.extent) / z2);
        auto features = detail::wrap(converted, double(options.buffer) / options.extent);

        splitTile(features, 0, 0, 0);
    }