C++ configure函数代码示例

/** constructor read attributes for this GeoImage through dictionary*/
GeoImage::GeoImage(ArgDict & dict)
{
  init();
  configure(dict);
}

void process_event_message(const events::event_message& message) {
	auto process_start_time = chrono::tsc_clock::now();

	auto& metric_ptr = metrics_map[message.destination_name];

	bool empty_metric = false;

	switch (metric_ptr.which()) {
		case metrics::metric_index::COUNTER:
			if (boost::get<metrics::counter*>(metric_ptr) == 0) {
				empty_metric = true;
			}
			break;
		case metrics::metric_index::GAUGE:
			if (boost::get<metrics::gauge*>(metric_ptr) == 0) {
				empty_metric = true;
			}
			break;
		case metrics::metric_index::TIMER:
			if (boost::get<metrics::timer*>(metric_ptr) == 0) {
				empty_metric = true;
			}
			break;
		case metrics::metric_index::ATTRIBUTE:
			if (boost::get<metrics::attribute*>(metric_ptr) == 0) {
				empty_metric = true;
			}
			break;
	}

	if (empty_metric) {
		rapidjson::Value* pattern_cfg = config::select_pattern(message.destination_name);

		switch (message.destination_type) {
			case events::event_destination_type::COUNTER:
				{
					auto counter_opts = config::metrics::counter_opts;
					if (pattern_cfg) {
						counter_opts.configure(*pattern_cfg);
					}
					metric_ptr = new metrics::counter(counter_opts);
					break;
				}
			case events::event_destination_type::GAUGE:
				{
					auto gauge_opts = config::metrics::gauge_opts;
					if (pattern_cfg) {
						gauge_opts.configure(*pattern_cfg);
					}
					metric_ptr = new metrics::gauge(gauge_opts);
					break;
				}
			case events::event_destination_type::TIMER:
				{
					auto timer_opts = config::metrics::timer_opts;
					if (pattern_cfg) {
						timer_opts.configure(*pattern_cfg);
					}
					metric_ptr = new metrics::timer(timer_opts);
					break;
				}
			case events::event_destination_type::ATTRIBUTE:
				{
					metric_ptr = new metrics::attribute();
					break;
				}
		}
	}

	process_event_message(metric_ptr, message);

	auto process_end_time = chrono::tsc_clock::now();

	stats::process_time.set(
			chrono::duration::convert_to(metrics::timer::value_unit, process_end_time - process_start_time).count(),
			process_end_time
		);

	stats::size.set(size(), process_end_time);
}

BOOL player_impl::open(const char *movie, int media_type, int render_type)
{
	// 如果未关闭原来的媒体, 则先关闭.
	if (m_avplay || m_source)
		close();

	// 未创建窗口, 无法播放, 返回失败.
	if (!IsWindow(m_hwnd))
		return FALSE;

	char filename[MAX_PATH];
	int len = strlen(movie) + 1;

	strcpy(filename, movie);

	uint64_t file_lentgh = 0;
	if (media_type == MEDIA_TYPE_FILE || media_type == MEDIA_TYPE_BT)
	{
		file_lentgh = file_size(movie);
		if (file_lentgh < 0)
		{
			::logger("get file size failed!\n");
			return FALSE;
		}
	}

	do {
		// 创建avplay.
		m_avplay = alloc_avplay_context();
		if (!m_avplay)
		{
			::logger("allocate avplay context failed!\n");
			break;
		}

		// 为avplay创建demux.
		demux_context *demux = alloc_demux_context();
		configure(m_avplay, demux, MEDIA_DEMUX);

		// 目前只有除youku之外, 都使用generic_demux.
		if (media_type != MEDIA_TYPE_YK)
		{
			demux->init_demux = generic_init_demux;
			demux->read_packet = generic_read_packet;
			demux->seek_packet = generic_packet_seek;
			demux->read_pause = generic_read_pause;
			demux->read_play = generic_read_play;
			demux->stream_index = generic_stream_index;
			demux->query_avcodec_id = generic_query_avcodec_id;
			demux->destory = generic_destory;
		}
		else
		{
			// TODO: 实现youku相关的demux.
			break;
		}

		// 初始化avplay.
		if (initialize(m_avplay, filename, media_type, demux) != 0)
		{
			::logger("initialize avplay failed!\n");
			break;
		}

		// TODO: 如果是bt类型, 则在此得到视频文件列表, 并添加到m_media_list.
		// if (media_type == MEDIA_TYPE_BT)
		// {
		// 	bt_source_info *bt_info = &m_avplay->m_source_ctx->info.bt;
		// 	for (int i = 0; i < bt_info->info_size; i++)
		// 	{
		// 		std::string name = std::string(bt_info->info[i].file_name);
		// 		m_media_list.insert(std::make_pair(filename, name));
		// 	}
		// }

		// 分配音频和视频的渲染器.
		m_audio = alloc_audio_render();
		if (!m_audio)
		{
			::logger("allocate audio render failed!\n");
			break;
		}

		m_video = alloc_video_render(m_hwnd);
		if (!m_video)
		{
			::logger("allocate video render failed!\n");
			break;
		}

		// 初始化音频和视频渲染器.
		init_audio(m_audio);
		init_video(m_video, render_type);

		// 配置音频视频渲染器.
		configure(m_avplay, m_video, VIDEO_RENDER);
		configure(m_avplay, m_audio, AUDIO_RENDER);

		// 得到视频宽高.
		if (m_avplay->m_video_ctx)
//.........这里部分代码省略.........

int main(int argc, char* argv[]) {
	signal(SIGSEGV, as_sig_handle_segv);
	signal(SIGTERM, as_sig_handle_term);
	

	fprintf(stdout, "\nAerospike act - device IO test\n");
	fprintf(stdout, "Copyright 2011 by Aerospike. All rights reserved.\n\n");

	if (! configure(argc, argv)) {
		exit(-1);
	}

	set_schedulers();
	srand(time(NULL));
	//	rand_seed(g_rand_64_buffer);

	salter salters[g_num_write_buffers ? g_num_write_buffers : 1];

	g_salters = salters;

	if (! create_salters()) {
		exit(-1);
	}

	device devices[g_num_devices];
	g_devices = devices;

	g_p_large_block_read_histogram = histogram_create();
	g_p_large_block_write_histogram = histogram_create();
	g_p_raw_read_histogram = histogram_create();
	g_p_read_histogram = histogram_create();

	g_run_start_ms = cf_getms();

	uint64_t run_stop_ms = g_run_start_ms + g_run_ms;

	g_running = 1;
	int n;
	for (n = 0; n < g_num_devices; n++) 
	{
		device* p_device = &g_devices[n];
		p_device->name = g_device_names[n];
		p_device->p_fd_queue = cf_queue_create(sizeof(int), true);
		discover_num_blocks(p_device);
		create_large_block_read_buffer(p_device);
		p_device->p_raw_read_histogram = histogram_create();
		sprintf(p_device->histogram_tag, "%-18s", p_device->name);

		if (pthread_create(&p_device->large_block_read_thread, NULL,
					run_large_block_reads, (void*)p_device)) 
		{
			fprintf(stdout, "Error: create large block read thread %d\n", n);
			exit(-1);
		}

		if (pthread_create(&p_device->large_block_write_thread, NULL,
					run_large_block_writes, (void*)p_device)) 
		{
			fprintf(stdout, "Error: create write thread %d\n", n);
			exit(-1);
		}

	}

	aio_context_t aio_context = 0;
	if(io_setup(MAXEVENTS, &aio_context) != 0)
	{
		fprintf(stdout, "Error: AIO context not set up \n");
		exit(-1);
	}
	create_async_info_queue();

	/* read events generating thread */
	pthread_t read_generator;
	if (pthread_create(&read_generator, NULL, &generate_async_reads, (void*)&aio_context)) 
	{
		fprintf(stdout, "Error: create read generator thread\n");
		exit(-1);
	}
	
	/* Create the worker threads */
	pthread_t workers[g_worker_threads];
	int j;
	for (j = 0; j < g_worker_threads; j++) 
	{ 
		if (pthread_create(&workers[j], NULL, &worker_func , (void *)(&aio_context))) 
		{
			fprintf(stdout, "Error: creating worker thread %d failed\n", j);
			exit(-1);
		}	
	}
 
	fprintf(stdout, "\n");
	uint64_t now_ms;
	uint64_t time_count = 0;
	int nanosleep_ret = -1;
	struct timespec initial,remaining;
	while ((now_ms = cf_getms()) < run_stop_ms && g_running) 
	{	
		time_count++;
//.........这里部分代码省略.........

int16 XSERDPort::open(uint16 config)
{
	// Don't open NULL name devices
	if (device_name == NULL)
		return openErr;

	// Init variables
	io_killed = false;
	quitting = false;

	// Open port, according to the syntax of the path
	if (device_name[0] == '|') {
		// Open a process via ptys
		if (!open_pty())
			goto open_error;
	}
	else if (!strcmp(device_name, "midi")) {
		// MIDI:  not yet implemented
		return openErr;
	}
	else {
		// Device special file
		fd = ::open(device_name, O_RDWR);
		if (fd < 0)
			goto open_error;

#if defined(__linux__)
		// Parallel port?
		struct stat st;
		if (fstat(fd, &st) == 0)
			if (S_ISCHR(st.st_mode))
				protocol = ((MAJOR(st.st_rdev) == LP_MAJOR) ? parallel : serial);
#elif defined(__FreeBSD__) || defined(__NetBSD__)
		// Parallel port?
		struct stat st;
		if (fstat(fd, &st) == 0)
			if (S_ISCHR(st.st_mode))
				protocol = (((st.st_rdev >> 16) == 16) ? parallel : serial);
#endif
	}

	// Configure port for raw mode
	if (protocol == serial || protocol == pty) {
		if (tcgetattr(fd, &mode) < 0)
			goto open_error;
		cfmakeraw(&mode);
		mode.c_cflag |= HUPCL;
		mode.c_cc[VMIN] = 1;
		mode.c_cc[VTIME] = 0;
		tcsetattr(fd, TCSAFLUSH, &mode);
	}
	configure(config);

	// Start input/output threads
	input_thread_cancel = false;
	output_thread_cancel = false;
	if (sem_init(&input_signal, 0, 0) < 0)
		goto open_error;
	if (sem_init(&output_signal, 0, 0) < 0)
		goto open_error;
	input_thread_active = (pthread_create(&input_thread, &thread_attr, input_func, this) == 0);
	output_thread_active = (pthread_create(&output_thread, &thread_attr, output_func, this) == 0);
	if (!input_thread_active || !output_thread_active)
		goto open_error;
	return noErr;

open_error:
	if (input_thread_active) {
		input_thread_cancel = true;
#ifdef HAVE_PTHREAD_CANCEL
		pthread_cancel(input_thread);
#endif
		pthread_join(input_thread, NULL);
		sem_destroy(&input_signal);
		input_thread_active = false;
	}
	if (output_thread_active) {
		output_thread_cancel = true;
#ifdef HAVE_PTHREAD_CANCEL
		pthread_cancel(output_thread);
#endif
		pthread_join(output_thread, NULL);
		sem_destroy(&output_signal);
		output_thread_active = false;
	}
	if (fd > 0) {
		::close(fd);
		fd = -1;
	}
	return openErr;
}

int main(int argc, char *argv[])
{
  assert(sizeof(localbuf) >= getpagesize());

  close(STDIN_FILENO);
  setlocale(LC_ALL, "C");

  if (!configure(argc, argv)) return EXIT_FAILURE;

  if (unlikely(!read_proc_swaps()) ||
      unlikely(!activate_old_swaps()) ||
      unlikely(!check_memory_status()))
    return EXIT_FAILURE;

  if (erase) return retire_all() ? EXIT_SUCCESS : EXIT_FAILURE;

  install_sigs();

  if (unlikely(!startpidfile())) return EXIT_FAILURE;

  /* Do a first iteration here so we can report any startup errors, and if we're
   * going to run as a daemon, we can do so in a steady state.
   */
  handle_requirements();

  /* If we're going to fork(), this is the last chance to read /proc/swaps in a
   * nonempty state before we do so.  Make one last attempt to check its format.
   */
  if (!proc_swaps_parsed())
  {
    if (!read_proc_swaps()) return EXIT_FAILURE;
#ifndef NO_CONFIG
    if (!quiet && !proc_swaps_parsed())
      fputs("[/proc/swaps is empty, so cannot check its format]\n", stderr);
#endif
  }

  if (godaemon)
  {
#ifndef NO_CONFIG
    if (verbose) logm(LOG_DEBUG, "daemonizing...");
#endif
    const pid_t pid = daemonize();
    if (unlikely(pid < 0))
    {
      rmpidfile();
      return EXIT_FAILURE;
    }
    if (pid > 0)
    {
      /* New process, so new pid.  Parent process rewrites pidfile.  We do this
       * from the parent, not the child process so that we're sure that the
       * pidfile is in a stable state when the parent exits.
       */
      lseek(pidfd, 0, SEEK_SET);
#ifndef NO_CONFIG
      if (verbose) logm(LOG_DEBUG, "got process id %d", pid);
#endif
      return writepid(pid) ? EXIT_SUCCESS : EXIT_FAILURE;
    }
  }

  finishpidfile();

  if (godaemon)
  {
    close(STDERR_FILENO);
    close(STDOUT_FILENO);

    // From here on std output is pointless in daemon mode.  Use syslog instead.
    log_start(argv[0]);
  }

  // Central loop
  for (++runclock; !stop; ++runclock)
  {
    if (unlikely(print_status))		print_status = false,	dump_stats();
    else if (unlikely(adjust_swap))	adjust_swap = false,	request_diet();
    else 			        handle_requirements();

    sleep(1);
  }

  int result = EXIT_SUCCESS;

#ifndef NO_CONFIG
  /* If we're worried about attackers getting unguarded access to the disk, we
   * need to retire and erase all swap files to keep them secret.
   */
  if (paranoid && !retire_all()) result = EXIT_FAILURE;
#endif

  rmpidfile();
  log_close();

  return result;
}

	SphericalCamera(Stream *stream, InstanceManager *manager)
	 : Sensor(stream, manager) {
		configure();
	}

 void configure_callback(home_command_manager::home_command_managerConfig &config, uint32_t level)
 {
     configure();
 }

/**
\brief
    Function associated with the widget.
*/
int entryFunc (
	ClientData data,
	Tcl_Interp *interp,
	int objc,
	Tcl_Obj * const objv[] )
{

#ifdef DEBUG_ENTRY  g_print ( "entryFunc\n" );
#endif


	static const char *cmds[] = { "delete", "configure", "cget", "onChanged", "class", "get", "clear", "set",  "setPosition", NULL };
	enum cmdIdx { DeleteIdx, ConfigureIdx, CgetIdx, OnChangedIdx, ClassIdx, GetIdx, ClearIdx, SetIdx, SetPositionIdx };

	EntryParams *para = ( EntryParams * ) data;
	//GtkWidget *widget = GTK_WIDGET ( para->entry );

	int idx;

	if ( objc < 2 )
	{
		Tcl_WrongNumArgs ( interp, 1, objv, "command" );
		return TCL_ERROR;
	}

	if ( Tcl_GetIndexFromObj ( interp, objv[1], cmds, "command",
							   TCL_EXACT, &idx ) != TCL_OK )
		return TCL_ERROR;

	switch ( idx )
	{
		case SetPositionIdx:
			{


				if ( 1 )
				{
					gtk_entry_set_position ( GTK_WIDGET ( para->entry ) , Tcl_GetString ( objv[2] ) );
				}

				else
				{
					gtk_editable_set_position ( GTK_EDITABLE ( GTK_WIDGET ( para->entry ) ) , Tcl_GetString ( objv[2] ) );
				}
			}

			break;
		case SetIdx:
			{
				/* simply set the text to nothing */
				gtk_entry_set_text ( para->entry, Tcl_GetString ( objv[2] ) );
			}

			break;
		case GetIdx:
			{
				/* equivalent to widget cget -value */
				Tcl_Obj *obj = NULL;

				obj = Tcl_NewStringObj ( gtk_entry_get_text ( para->entry  ), -1 );

				if ( obj != NULL )
				{
					Tcl_SetObjResult ( interp, obj );
					return TCL_OK;
				}
			}

			break;
		case ClearIdx:
			{
				/* simply set the text to nothing */
				gtk_entry_set_text ( para->entry, "" );
			}

			break;
		case ClassIdx:
			{

				Tcl_SetObjResult ( interp, Tcl_NewStringObj ( "entry", -1 ) );
			}
			break;
		case DeleteIdx:
			{
				return gnoclDelete ( interp, GTK_WIDGET ( para->entry ), objc, objv );
			}
		case ConfigureIdx:
			{
#ifdef DEBUG_ENTRY
				g_print ( "entryFunc ConfigureIdx\n" );
#endif
				int ret = TCL_ERROR;

				if ( gnoclParseAndSetOptions ( interp, objc - 1, objv + 1,
											   entryOptions, G_OBJECT ( para->entry ) ) == TCL_OK )
				{
//.........这里部分代码省略.........

int fimg2d4x_bitblt(struct fimg2d_control *ctrl)
{
	int ret = 0;
	enum addr_space addr_type;
	struct fimg2d_context *ctx;
	struct fimg2d_bltcmd *cmd;
	unsigned long *pgd;

	fimg2d_debug("%s : enter blitter\n", __func__);

	while (1) {
		cmd = fimg2d_get_command(ctrl);
		if (!cmd)
			break;

		ctx = cmd->ctx;
		ctx->state = CTX_READY;

#ifdef CONFIG_PM_RUNTIME
		if (fimg2d4x_get_clk_cnt(ctrl->clock) == false)
			fimg2d_err("2D clock is not set\n");
#endif

		addr_type = cmd->image[IDST].addr.type;

		atomic_set(&ctrl->busy, 1);
		perf_start(cmd, PERF_SFR);
		ret = ctrl->configure(ctrl, cmd);
		perf_end(cmd, PERF_SFR);
		if (IS_ERR_VALUE(ret)) {
			fimg2d_err("failed to configure\n");
			ctx->state = CTX_ERROR;
			goto fail_n_del;
		}

		ctx->vma_lock = vma_lock_mapping(ctx->mm, prefbuf, MAX_IMAGES - 1);

		if (fimg2d_check_pgd(ctx->mm, cmd)) {
			ret = -EFAULT;
			goto fail_n_unmap;
		}

		if (addr_type == ADDR_USER || addr_type == ADDR_USER_CONTIG) {
			if (!ctx->mm || !ctx->mm->pgd) {
				atomic_set(&ctrl->busy, 0);
				fimg2d_err("ctx->mm:0x%p or ctx->mm->pgd:0x%p\n",
					       ctx->mm,
					       (ctx->mm) ? ctx->mm->pgd : NULL);
				ret = -EPERM;
				goto fail_n_unmap;
			}
			pgd = (unsigned long *)ctx->mm->pgd;
#ifdef FIMG2D_IOVMM_PAGETABLE
			if (iovmm_activate(ctrl->dev)) {
				fimg2d_err("failed to iovmm activate\n");
				ret = -EPERM;
				goto fail_n_unmap;
			}
#else
			if (exynos_sysmmu_enable(ctrl->dev,
					(unsigned long)virt_to_phys(pgd))) {
				fimg2d_err("failed to sysmme enable\n");
				ret = -EPERM;
				goto fail_n_unmap;
			}
#endif
			fimg2d_debug("%s : sysmmu enable: pgd %p ctx %p seq_no(%u)\n",
				__func__, pgd, ctx, cmd->blt.seq_no);

			//exynos_sysmmu_set_pbuf(ctrl->dev, nbufs, prefbuf);
			fimg2d_debug("%s : set smmu prefbuf\n", __func__);
		}

		fimg2d4x_pre_bitblt(ctrl, cmd);

		perf_start(cmd, PERF_BLIT);
		/* start blit */
		fimg2d_debug("%s : start blit\n", __func__);
		ctrl->run(ctrl);
		ret = fimg2d4x_blit_wait(ctrl, cmd);
		perf_end(cmd, PERF_BLIT);

#ifdef FIMG2D_IOVMM_PAGETABLE
		if (addr_type == ADDR_USER || addr_type == ADDR_USER_CONTIG)
			iovmm_deactivate(ctrl->dev);
#else
		if (addr_type == ADDR_USER || addr_type == ADDR_USER_CONTIG)
			exynos_sysmmu_disable(ctrl->dev);
#endif

fail_n_unmap:
		perf_start(cmd, PERF_UNMAP);
		if (addr_type == ADDR_USER || addr_type == ADDR_USER_CONTIG) {
			fimg2d4x_cleanup_pgtable(ctrl, cmd, ISRC, true);
			fimg2d4x_cleanup_pgtable(ctrl, cmd, IMSK, false);
			fimg2d4x_cleanup_pgtable(ctrl, cmd, IDST, true);
			fimg2d_debug("sysmmu disable\n");
		}
		perf_end(cmd, PERF_UNMAP);
fail_n_del:
//.........这里部分代码省略.........

/** Sets up the application - returns false if the user chooses to abandon configuration. */
bool AApplication::setup(void)
{
    mRoot = new Root();

    setupResources("media/common/");

    bool carryOn = configure();
    if (!carryOn) return false;

    chooseSceneManager();

    // Set default mipmap level (NB some APIs ignore this)
    TextureManager::getSingleton().setDefaultNumMipmaps(5);

    ResourceGroupManager::getSingleton().initialiseResourceGroup("Bootstrap");
    ResourceGroupManager::getSingleton().initialiseResourceGroup(GUI_RESOURCE_GROUP);
    ResourceGroupManager::getSingleton().initialiseResourceGroup("General");

    ScriptsCamera = mSceneMgr->createCamera("ScriptsCamera");
    ScriptsCamera->setNearClipDistance(5);
    ScriptsCamera->setFarClipDistance(0);

    CombatCamera = mSceneMgr->createCamera("CombatCamera");
    CombatCamera->setNearClipDistance(5);
    CombatCamera->setFarClipDistance(0);

    Ogre::SceneNode *node = mSceneMgr->getRootSceneNode()->createChildSceneNode();
    node->attachObject(ScriptsCamera);

    createCamera();
    createViewports();

    Core *Instance = Core::GetInstance();
    Instance->SetSceneManager(mSceneMgr);
    Instance->SetApplication(this);

    InitGui();

    if (0!=Instance->Init())
        return false;

    //CurrentListener = GUISystem::GetInstance();
    //mRoot->addFrameListener(CurrentListener);

    /*MaterialPtr fade = Ogre::MaterialManager::getSingleton().create("FadeMaterial", "General");
    fade->getTechnique(0)->getPass(0)->setSceneBlending(SBT_TRANSPARENT_ALPHA);*/

    createFrameListener();

    AACommandsFrameListener *commands_listener = AACommandsFrameListener::GetInstance();
    commands_listener->Init(mWindow);
    commands_listener->SetCurrentHandler(Instance);
    mRoot->addFrameListener(commands_listener);

    EditorFrameListener *editor_listener = EditorFrameListener::GetInstance();
    editor_listener->Init(mWindow);

    CombatFrameListener::GetInstance()->Init(mWindow);

    ComixFrameListener::GetInstance()->Init(mWindow);
    //SetCurrentGameState(AApplication::GS_STUDIOINTRO);
    SetCurrentGameState(AApplication::GS_COMIX);

    ComixFrameHandler *handler = new ComixFrameHandler();
    TiXmlElement *xml = ObjectsLibrary::GetParsed("logo_intro.xml");
    handler->Parse(xml);
    delete xml;
    ComixFrameListener *listener = ComixFrameListener::GetInstance();
    listener->SetCurrentHandler(handler);

    CommonDeclarations::PlayIntroMusic(true);

    //handler->Show(0);
    //handler->SetActive(0, true);

    //handler->Show(1);
    //handler->SetActive(1, true);

    //SetCurrentGameState(AApplication::GS_GUI);
    //GUISystem::GetInstance()->GetIntroMenu()->Show();

    //GUISystem::GetInstance()->Show();

    return true;
}

int
main(int argc, char **argv)
{
    krb5_error_code ret;
    krb5_context context;
    krb5_kdc_configuration *config;
    int optidx = 0;

    setprogname(argv[0]);

    ret = krb5_init_context(&context);
    if (ret == KRB5_CONFIG_BADFORMAT)
	errx (1, "krb5_init_context failed to parse configuration file");
    else if (ret)
	errx (1, "krb5_init_context failed: %d", ret);

    ret = krb5_kt_register(context, &hdb_get_kt_ops);
    if (ret)
	errx (1, "krb5_kt_register(HDB) failed: %d", ret);

    config = configure(context, argc, argv, &optidx);

#ifdef HAVE_SIGACTION
    {
	struct sigaction sa;

	sa.sa_flags = 0;
	sa.sa_handler = sigterm;
	sigemptyset(&sa.sa_mask);

	sigaction(SIGINT, &sa, NULL);
	sigaction(SIGTERM, &sa, NULL);
#ifdef SIGXCPU
	sigaction(SIGXCPU, &sa, NULL);
#endif

	sa.sa_handler = SIG_IGN;
#ifdef SIGPIPE
	sigaction(SIGPIPE, &sa, NULL);
#endif
    }
#else
    signal(SIGINT, sigterm);
    signal(SIGTERM, sigterm);
#ifdef SIGXCPU
    signal(SIGXCPU, sigterm);
#endif
#ifdef SIGPIPE
    signal(SIGPIPE, SIG_IGN);
#endif
#endif
#ifdef __APPLE__
    bonjour_announce(context, config);
#endif
    pidfile(NULL);

    switch_environment();

    loop(context, config);
    krb5_free_context(context);
    return 0;
}

// virtual
LLIOPipe::EStatus LLURLRequest::process_impl(
	const LLChannelDescriptors& channels,
	buffer_ptr_t& buffer,
	bool& eos,
	LLSD& context,
	LLPumpIO* pump)
{
	PUMP_DEBUG;
	LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST);
	//llinfos << "LLURLRequest::process_impl()" << llendl;
	if(!buffer) return STATUS_ERROR;
	switch(mState)
	{
	case STATE_INITIALIZED:
	{
		PUMP_DEBUG;
		// We only need to wait for input if we are uploading
		// something.
		if(((HTTP_PUT == mAction) || (HTTP_POST == mAction)) && !eos)
		{
			// we're waiting to get all of the information
			return STATUS_BREAK;
		}

		// *FIX: bit of a hack, but it should work. The configure and
		// callback method expect this information to be ready.
		mDetail->mResponseBuffer = buffer.get();
		mDetail->mChannels = channels;
		if(!configure())
		{
			return STATUS_ERROR;
		}
		mState = STATE_WAITING_FOR_RESPONSE;

		// *FIX: Maybe we should just go to the next state now...
		return STATUS_BREAK;
	}
	case STATE_WAITING_FOR_RESPONSE:
	case STATE_PROCESSING_RESPONSE:
	{
		PUMP_DEBUG;
		LLIOPipe::EStatus status = STATUS_BREAK;
		mDetail->mCurlRequest->perform();
		while(1)
		{
			CURLcode result;
			bool newmsg = mDetail->mCurlRequest->getResult(&result);
			if(!newmsg)
			{
				// we're still waiting or prcessing, check how many
				// bytes we have accumulated.
				const S32 MIN_ACCUMULATION = 100000;
				if(pump && (mDetail->mByteAccumulator > MIN_ACCUMULATION))
				{
					// This is a pretty sloppy calculation, but this
					// tries to make the gross assumption that if data
					// is coming in at 56kb/s, then this transfer will
					// probably succeed. So, if we're accumlated
					// 100,000 bytes (MIN_ACCUMULATION) then let's
					// give this client another 2s to complete.
					const F32 TIMEOUT_ADJUSTMENT = 2.0f;
					mDetail->mByteAccumulator = 0;
					pump->adjustTimeoutSeconds(TIMEOUT_ADJUSTMENT);
				}

				// keep processing
				break;
			}

			mState = STATE_HAVE_RESPONSE;
			switch(result)
			{
				case CURLE_OK:
				case CURLE_WRITE_ERROR:
					// NB: The error indication means that we stopped the
					// writing due the body limit being reached
					if(mCompletionCallback && pump)
					{
						LLURLRequestComplete* complete = NULL;
						complete = (LLURLRequestComplete*)
							mCompletionCallback.get();
						complete->responseStatus(
								result == CURLE_OK
									? STATUS_OK : STATUS_STOP);
						LLPumpIO::links_t chain;
						LLPumpIO::LLLinkInfo link;
						link.mPipe = mCompletionCallback;
						link.mChannels = LLBufferArray::makeChannelConsumer(
							channels);
						chain.push_back(link);
						pump->respond(chain, buffer, context);
						mCompletionCallback = NULL;
					}
					break;
				case CURLE_FAILED_INIT:
				case CURLE_COULDNT_CONNECT:
					status = STATUS_NO_CONNECTION;
					break;
				default:
//.........这里部分代码省略.........

void RayShape2DSW::set_data(const Variant& p_data) {

	length=p_data;
	configure(Rect2(0,0,0.001,length));
}

	ABC(Stream *stream, InstanceManager *manager)
		: BSDF(stream, manager) {

		configure();
	}