自学教程：C++ variant函数代码示例

//.........这里部分代码省略.........                if(argv.size() >= 2 && argv[argv.size()-2] == "-NSDocumentRevisionsDebugMode" && argv.back() == "YES") {            //XCode passes these arguments by default when debugging -- make sure they are ignored.            argv.resize(argv.size()-2);        }	}	std::cerr << "Build Options:";	for(auto bo : preferences::get_build_options()) {		std::cerr << " " << bo;	}	std::cerr << std::endl;#if defined(UTILITY_IN_PROC)	if(create_utility_in_new_process) {		argv.push_back(utility_name);#if defined(_MSC_VER)		// app name is ignored for windows, we get windows to tell us.		is_child_utility = create_utility_process("", argv);#else 		is_child_utility = create_utility_process(argvec[0], argv);#endif		if(!is_child_utility) {			argv.pop_back();		}#if defined(_MSC_VER)		atexit(terminate_utility_process);#endif	}#endif	if(sys::file_exists("./master-config.cfg")) {		std::cerr << "LOADING CONFIGURATION FROM master-config.cfg" << std::endl;		variant cfg = json::parse_from_file("./master-config.cfg");		if(cfg.is_map()) {			if( cfg["id"].is_null() == false) {				std::cerr << "SETTING MODULE PATH FROM master-config.cfg: " << cfg["id"].as_string() << std::endl;				preferences::set_preferences_path_from_module(cfg["id"].as_string());				//XXX module::set_module_name(cfg["id"].as_string(), cfg["id"].as_string());			}			if(cfg["arguments"].is_null() == false) {				std::vector<std::string> additional_args = cfg["arguments"].as_list_string();				argv.insert(argv.begin(), additional_args.begin(), additional_args.end());				std::cerr << "ADDING ARGUMENTS FROM master-config.cfg:";				for(size_t n = 0; n < cfg["arguments"].num_elements(); ++n) {					std::cerr << " " << cfg["arguments"][n].as_string();				}				std::cerr << std::endl;			}		}	}	stats::record_program_args(argv);	for(size_t n = 0; n < argv.size(); ++n) {		const int argc = argv.size();		const std::string arg(argv[n]);		std::string arg_name, arg_value;		std::string::const_iterator equal = std::find(arg.begin(), arg.end(), '=');		if(equal != arg.end()) {			arg_name = std::string(arg.begin(), equal);			arg_value = std::string(equal+1, arg.end());		}		if(arg_name == "--module") {			if(load_module(arg_value, &argv) != 0) {				std::cerr << "FAILED TO LOAD MODULE: " << arg_value << "/n";

void timage::draw(surface& canvas		, const game_logic::map_formula_callable& variables){	DBG_GUI_D << "Image: draw./n";	/**	 * @todo formulas are now recalculated every draw cycle which is a  bit	 * silly unless there has been a resize. So to optimize we should use an	 * extra flag or do the calculation in a separate routine.	 */	const std::string& name = image_name_(variables);	if(name.empty()) {		DBG_GUI_D << "Image: formula returned no value, will not be drawn./n";		return;	}	/*	 * The locator might return a different surface for every call so we can't	 * cache the output, also not if no formula is used.	 */	surface tmp(image::get_image(image::locator(name)));	if(!tmp) {		ERR_GUI_D << "Image: '" << name << "' not found and won't be drawn./n";		return;	}	image_.assign(make_neutral_surface(tmp));	assert(image_);	src_clip_ = ::create_rect(0, 0, image_->w, image_->h);	game_logic::map_formula_callable local_variables(variables);	local_variables.add("image_original_width", variant(image_->w));	local_variables.add("image_original_height", variant(image_->h));	unsigned w = w_(local_variables);	VALIDATE_WITH_DEV_MESSAGE(			  static_cast<int>(w) >= 0			, _("Image doesn't fit on canvas.")			, (formatter() << "Image '" << name				<< "', w = " << static_cast<int>(w) << ".").str());	unsigned h = h_(local_variables);	VALIDATE_WITH_DEV_MESSAGE(			  static_cast<int>(h) >= 0			, _("Image doesn't fit on canvas.")			, (formatter() << "Image '" << name				<< "', h = " << static_cast<int>(h) << ".").str());	local_variables.add("image_width", variant(w ? w : image_->w));	local_variables.add("image_height", variant(h ? h : image_->h));	const unsigned x = x_(local_variables);	VALIDATE_WITH_DEV_MESSAGE(			  static_cast<int>(x) >= 0			, _("Image doesn't fit on canvas.")			, (formatter() << "Image '" << name				<< "', x = " << static_cast<int>(x) << ".").str());	const unsigned y = y_(local_variables);	VALIDATE_WITH_DEV_MESSAGE(			  static_cast<int>(y) >= 0			, _("Image doesn't fit on canvas.")			, (formatter() << "Image '" << name				<< "', y = " << static_cast<int>(y) << ".").str());	// Copy the data to local variables to avoid overwriting the originals.	SDL_Rect src_clip = src_clip_;	SDL_Rect dst_clip = ::create_rect(x, y, 0, 0);	surface surf;	// Test whether we need to scale and do the scaling if needed.	if(w || h) {		bool done = false;		bool stretch_image = (resize_mode_ == stretch) && (!!w ^ !!h);		if(!w) {			if(stretch_image) {				DBG_GUI_D << "Image: vertical stretch from " << image_->w						<< ',' << image_->h << " to a height of " << h << "./n";				surf = stretch_surface_vertical(image_, h, false);				done = true;			}			w = image_->w;		}		if(!h) {			if(stretch_image) {				DBG_GUI_D << "Image: horizontal stretch from " << image_->w						<< ',' << image_->h << " to a width of " << w << "./n";				surf = stretch_surface_horizontal(image_, w, false);				done = true;			}			h = image_->h;		}		if(!done) {//.........这里部分代码省略.........

 void add( mutable_variant_object& vo, const char* name, const optional<M>& v )const {     if( v.valid() )       vo(name, variant( *v, _max_depth )); }

static QVariant getVariantFromDBusMessage(DBusMessageIter *iter){    dbus_bool_t bool_data;    dbus_int32_t int32_data;    dbus_uint32_t uint32_data;    dbus_int64_t int64_data;    dbus_uint64_t uint64_data;    char *str_data;    char char_data;    int argtype = dbus_message_iter_get_arg_type(iter);    switch (argtype) {    case DBUS_TYPE_BOOLEAN: {        dbus_message_iter_get_basic(iter, &bool_data);        QVariant variant((bool)bool_data);        return variant;    }    case DBUS_TYPE_ARRAY: {        // Handle all arrays here        int elem_type = dbus_message_iter_get_element_type(iter);        DBusMessageIter array_iter;        dbus_message_iter_recurse(iter, &array_iter);        if (elem_type == DBUS_TYPE_BYTE) {            QByteArray byte_array;            do {                dbus_message_iter_get_basic(&array_iter, &char_data);                byte_array.append(char_data);            } while (dbus_message_iter_next(&array_iter));            QVariant variant(byte_array);            return variant;        } else if (elem_type == DBUS_TYPE_STRING) {            QStringList str_list;            do {                dbus_message_iter_get_basic(&array_iter, &str_data);                str_list.append(str_data);            } while (dbus_message_iter_next(&array_iter));            QVariant variant(str_list);            return variant;        } else {            QVariantList variantList;            do {                variantList << getVariantFromDBusMessage(&array_iter);            } while (dbus_message_iter_next(&array_iter));            QVariant variant(variantList);            return variant;        }        break;    }    case DBUS_TYPE_BYTE: {        dbus_message_iter_get_basic(iter, &char_data);        QChar ch(char_data);        QVariant variant(ch);        return variant;    }    case DBUS_TYPE_INT32: {        dbus_message_iter_get_basic(iter, &int32_data);        QVariant variant((int)int32_data);        return variant;    }    case DBUS_TYPE_UINT32: {        dbus_message_iter_get_basic(iter, &uint32_data);        QVariant variant((uint)uint32_data);        return variant;    }    case DBUS_TYPE_OBJECT_PATH:    case DBUS_TYPE_STRING: {        dbus_message_iter_get_basic(iter, &str_data);        QString str(str_data);        QVariant variant(str);        return variant;    }    case DBUS_TYPE_INT64: {        dbus_message_iter_get_basic(iter, &int64_data);        QVariant variant((qlonglong)int64_data);        return variant;    }    case DBUS_TYPE_UINT64: {        dbus_message_iter_get_basic(iter, &uint64_data);        QVariant variant((qulonglong)uint64_data);        return variant;    }    case DBUS_TYPE_DICT_ENTRY:    case DBUS_TYPE_STRUCT: {        // Handle all structs here        DBusMessageIter struct_iter;        dbus_message_iter_recurse(iter, &struct_iter);        QVariantList variantList;        do {            variantList << getVariantFromDBusMessage(&struct_iter);        } while (dbus_message_iter_next(&struct_iter));        QVariant variant(variantList);        return variant;    }    case DBUS_TYPE_VARIANT: {        DBusMessageIter variant_iter;        dbus_message_iter_recurse(iter, &variant_iter);//.........这里部分代码省略.........

	std::set<std::string> already_known;	game_logic::formula_object::visit_variants(obj, boost::bind(add_object_to_set, _1, &objects, &already_known));	std::vector<variant> results_list;	foreach(wml_serializable_formula_callable* item, objects) {		char addr_buf[256];		sprintf(addr_buf, "%p", item);		std::string key(addr_buf);		if(already_known.count(key)) {			continue;		}		results_list.push_back(item->write_to_wml());	}	res[variant("character")] = variant(&results_list);	return variant(&res);}namespace {std::map<intptr_t, wml_serializable_formula_callable_ptr> registered_objects;}void wml_formula_callable_read_scope::register_serialized_object(intptr_t addr, wml_serializable_formula_callable_ptr ptr){	//fprintf(stderr, "REGISTER SERIALIZED: 0x%x/n", (int)addr);	registered_objects[addr] = ptr;}wml_serializable_formula_callable_ptr wml_formula_callable_read_scope::get_serialized_object(intptr_t addr)

//.........这里部分代码省略.........	{ "always_active", "bool" },	{ "activation_border", "int/int|decimal" },	{ "fall_through_platforms", "any" },	{ "has_feet", "bool" },		{ "x_schedule", "any" },	{ "y_schedule", "any" },	{ "rotation_schedule", "any" },	{ "schedule_speed", "any" },		{ "schedule_expires", "any" },		{ "platform_area", "null|[int]" },	{ "platform_offsets", "[int]" },	{ "custom_draw", "list" },		{ "uv_array", "[decimal]" },	{ "xy_array", "[decimal]" },	{ "uv_segments", "[int]" },		{ "draw_primitives", "[object]/[object|map]|map" },	{ "event_handlers", "object" },		{ "use_absolute_screen_coordinates", "bool" },		{ "widgets", "object/[object|map]|object|map" },	{ "widget_list", "[widget]" },	{ "textv", "any" },	{ "body", "any" },	{ "paused", "bool" },	{ "mouseover_delay", "int" },	{ "mouseover_area", "[int]" },	{ "particle_systems", "{string -> object}" },	{ "truez", "bool" },	{ "tx", "decimal" },	{ "ty", "decimal" },	{ "tz", "decimal" },	{ "animated_movements", "[string]" },	{ "ctrl_user_output", "any" },		{ "ctrl_up", "bool" },	{ "ctrl_down", "bool" },	{ "ctrl_left", "bool" },	{ "ctrl_right", "bool" },		{ "ctrl_attack", "bool" },	{ "ctrl_jump", "bool" },	{ "ctrl_tongue", "bool" },	{ "ctrl_user", "any" },	//player-specific	{ "difficulty", "int" },	{ "can_interact", "bool" },	{ "underwater_controls", "bool" },	{ "ctrl_mod_key", "int" },	{ "ctrl_keys", "[string]" },	{ "ctrl_mice", "[[int|string]]" },	{ "ctrl_tilt", "int" },	{ "ctrl_x", "int" },	{ "ctrl_y", "int" },	{ "ctrl_reverse_ab", "bool" },	{ "control_scheme", "string" },	{ "vertical_look", "int" },	{ "control_lock", "null|[string]" },};	ASSERT_EQ(NUM_CUSTOM_OBJECT_PROPERTIES, sizeof(CustomObjectProperties)/sizeof(*CustomObjectProperties));	if(global_entries().empty()) {		for(int n = 0; n != sizeof(CustomObjectProperties)/sizeof(*CustomObjectProperties); ++n) {			global_entries().push_back(entry(CustomObjectProperties[n].id));			const std::string& type = CustomObjectProperties[n].type;			std::string::const_iterator itor = std::find(type.begin(), type.end(), '/');			std::string read_type(type.begin(), itor);			global_entries().back().set_variant_type(parse_variant_type(variant(read_type)));			if(itor != type.end()) {				global_entries().back().write_type = parse_variant_type(variant(std::string(itor+1, type.end())));			}		}		for(int n = 0; n != global_entries().size(); ++n) {			keys_to_slots()[global_entries()[n].id] = n;		}		global_entries()[CUSTOM_OBJECT_ME].set_variant_type(variant_type::get_custom_object());		global_entries()[CUSTOM_OBJECT_SELF].set_variant_type(variant_type::get_custom_object());		const variant_type_ptr builtin = variant_type::get_builtin("level");		global_entries()[CUSTOM_OBJECT_LEVEL].set_variant_type(builtin);	}	global_entries()[CUSTOM_OBJECT_PARENT].type_definition = is_singleton ? this : &instance();	global_entries()[CUSTOM_OBJECT_LIB].type_definition = game_logic::get_library_definition().get();	entries_ = global_entries();}

void tgame_save_oos::pre_show(CVideo& /*video*/, twindow& window){	window.set_canvas_variable("border", variant("default-border"));}

widget_settings_dialog* widget::settings_dialog(int x, int y, int w, int h){	return new widget_settings_dialog(x,y,w,h,this);}dialog_ptr widget::get_settings_dialog(int x, int y, int w, int h){	return settings_dialog(x,y,w,h);}BEGIN_DEFINE_CALLABLE_NOBASE(widget)DEFINE_FIELD(draw_area, "[int]")	std::vector<variant> v;	v.push_back(variant(obj.x_));	v.push_back(variant(obj.y_));	v.push_back(variant(obj.w_));	v.push_back(variant(obj.h_));	return variant(&v);DEFINE_SET_FIELD	std::vector<int> r = value.as_list_int();	ASSERT_LOG(r.size() == 4, "Four values must be supplied to the draw_area attribute");	obj.set_loc(r[0], r[1]);	obj.set_dim(r[2], r[3]);DEFINE_FIELD(rect, "[int]")	std::vector<variant> v;	v.push_back(variant(obj.x_));	v.push_back(variant(obj.y_));	v.push_back(variant(obj.w_));

void SmoothNode::onContextFrame( qint64 pTimeStamp ){	if( pTimeStamp < mLastTime )	{		mLastTime = pTimeStamp;	}	const qreal		IncVal = variant( mPinIncSpeed ).toReal();	const qreal		DecVal = variant( mPinDecSpeed ).toReal();	for( fugio::NodeInterface::UuidPair UP : mNode->pairedPins() )	{		QSharedPointer<fugio::PinInterface> SrcPin = mNode->findPinByLocalId( UP.first );		QSharedPointer<fugio::PinInterface> DstPin = mNode->findPinByLocalId( UP.second );		if( !SrcPin || !DstPin || !DstPin->hasControl() )		{			continue;		}		fugio::VariantInterface			*DstVar = qobject_cast<fugio::VariantInterface *>( DstPin->control()->qobject() );		qreal		CurVal = variant( SrcPin ).toReal();		qreal		OutVal = DstVar->variant().toReal();		if( CurVal == OutVal )		{			continue;		}		qreal		AddVal = 0;		AddVal = qreal( pTimeStamp - mLastTime ) / 1000.0;		if( CurVal > OutVal )		{			AddVal *= IncVal;			if( OutVal + AddVal > CurVal )			{				AddVal = CurVal - OutVal;			}		}		else		{			AddVal *= -DecVal;			if( OutVal + AddVal < CurVal )			{				AddVal = CurVal - OutVal;			}		}		qreal		NewVal = OutVal + AddVal;		if( DstVar->variant().toReal() != NewVal )		{			DstVar->setVariant( OutVal + AddVal );			pinUpdated( DstPin );		}	}	mLastTime = pTimeStamp;}

Variant Object::o_set(CStrRef propName, RefResult val,                      CStrRef context /* = null_string */) {  return o_setRef(propName, variant(val), context);}

	variant query_value(const std::string& key) const {		if(has_self_ && key == "self") {			return variant(this);		}		return get_value(key);	}

 static void save_to_file( const T& v, const std::string& p, bool pretty = true, output_formatting format = stringify_large_ints_and_doubles, uint32_t max_depth = DEFAULT_MAX_RECURSION_DEPTH ) {    save_to_file( variant(v, max_depth), fc::path(p), pretty, format, max_depth ); } 

 static string   to_pretty_string( const T& v, output_formatting format = stringify_large_ints_and_doubles, uint32_t max_depth = DEFAULT_MAX_RECURSION_DEPTH ) {    return to_pretty_string( variant(v, max_depth), format, max_depth ); }

   variant number_from_stream( T& in )   {      fc::stringstream ss;      bool  dot = false;      bool  neg = false;      if( in.peek() == '-')      {        neg = true;        ss.put( in.get() );      }      bool done = false;      try      {        char c;        while((c = in.peek()) && !done)        {          switch( c )          {              case '.':                 if (dot)                    FC_THROW_EXCEPTION(parse_error_exception, "Can't parse a number with two decimal places");                 dot = true;              case '0':              case '1':              case '2':              case '3':              case '4':              case '5':              case '6':              case '7':              case '8':              case '9':                 ss.put( in.get() );                 break;              default:                 if( isalnum( c ) )                 {                    return ss.str() + stringFromToken( in );                 }                done = true;                break;          }        }      }      catch (fc::eof_exception&)      {      }      catch (const std::ios_base::failure&)      {      }      fc::string str = ss.str();      if (str == "-." || str == ".") // check the obviously wrong things we could have encountered        FC_THROW_EXCEPTION(parse_error_exception, "Can't parse token /"${token}/" as a JSON numeric constant", ("token", str));      if( dot )        return parser_type == json::legacy_parser_with_string_doubles ? variant(str) : variant(to_double(str));      if( neg )        return to_int64(str);      return to_uint64(str);   }

 variant wallet_db::get_property( property_enum property_id )const {    auto property_itr = properties.find( property_id );    if( property_itr != properties.end() ) return property_itr->second.value;    return variant(); }

   variant token_from_stream( T& in )   {      std::stringstream ss;      ss.exceptions( std::ifstream::badbit );      bool received_eof = false;      bool done = false;      try      {        char c;        while((c = in.peek()) && !done)        {           switch( c )           {              case 'n':              case 'u':              case 'l':              case 't':              case 'r':              case 'e':              case 'f':              case 'a':              case 's':                 ss.put( in.get() );                 break;              default:                 done = true;                 break;           }        }      }      catch (fc::eof_exception&)      {        received_eof = true;      }      catch (const std::ios_base::failure&)      {        received_eof = true;      }      // we can get here either by processing a delimiter as in "null,"      // an EOF like "null<EOF>", or an invalid token like "nullZ"      fc::string str = ss.str();      if( str == "null" )        return variant();      if( str == "true" )        return true;      if( str == "false" )         return false;      else      {        if (received_eof)        {          if (str.empty())            FC_THROW_EXCEPTION( parse_error_exception, "Unexpected EOF" );          else            return str;        }        else        {          // if we've reached this point, we've either seen a partial          // token ("tru<EOF>") or something our simple parser couldn't          // make out ("falfe")          // A strict JSON parser would signal this as an error, but we          // will just treat the malformed token as an un-quoted string.          return str + stringFromToken(in);;        }      }   }

	FOREACH(AUTO & tmp, canvas())	{		tmp.set_variable("positioner_offset", variant(positioner_offset_));		tmp.set_variable("positioner_length", variant(positioner_length_));	}

CallLinkStatus CallLinkStatus::computeFromCallLinkInfo(    const ConcurrentJITLocker&, CallLinkInfo& callLinkInfo){    if (callLinkInfo.clearedByGC())        return takesSlowPath();        // Note that despite requiring that the locker is held, this code is racy with respect    // to the CallLinkInfo: it may get cleared while this code runs! This is because    // CallLinkInfo::unlink() may be called from a different CodeBlock than the one that owns    // the CallLinkInfo and currently we save space by not having CallLinkInfos know who owns    // them. So, there is no way for either the caller of CallLinkInfo::unlock() or unlock()    // itself to figure out which lock to lock.    //    // Fortunately, that doesn't matter. The only things we ask of CallLinkInfo - the slow    // path count, the stub, and the target - can all be asked racily. Stubs and targets can    // only be deleted at next GC, so if we load a non-null one, then it must contain data    // that is still marginally valid (i.e. the pointers ain't stale). This kind of raciness    // is probably OK for now.        // PolymorphicCallStubRoutine is a GCAwareJITStubRoutine, so if non-null, it will stay alive    // until next GC even if the CallLinkInfo is concurrently cleared. Also, the variants list is    // never mutated after the PolymorphicCallStubRoutine is instantiated. We have some conservative    // fencing in place to make sure that we see the variants list after construction.    if (PolymorphicCallStubRoutine* stub = callLinkInfo.stub()) {        WTF::loadLoadFence();                CallEdgeList edges = stub->edges();                // Now that we've loaded the edges list, there are no further concurrency concerns. We will        // just manipulate and prune this list to our liking - mostly removing entries that are too        // infrequent and ensuring that it's sorted in descending order of frequency.                RELEASE_ASSERT(edges.size());                std::sort(            edges.begin(), edges.end(),            [] (CallEdge a, CallEdge b) {                return a.count() > b.count();            });        RELEASE_ASSERT(edges.first().count() >= edges.last().count());                double totalCallsToKnown = 0;        double totalCallsToUnknown = callLinkInfo.slowPathCount();        CallVariantList variants;        for (size_t i = 0; i < edges.size(); ++i) {            CallEdge edge = edges[i];            // If the call is at the tail of the distribution, then we don't optimize it and we            // treat it as if it was a call to something unknown. We define the tail as being either            // a call that doesn't belong to the N most frequent callees (N =            // maxPolymorphicCallVariantsForInlining) or that has a total call count that is too            // small.            if (i >= Options::maxPolymorphicCallVariantsForInlining()                || edge.count() < Options::frequentCallThreshold())                totalCallsToUnknown += edge.count();            else {                totalCallsToKnown += edge.count();                variants.append(edge.callee());            }        }                // Bail if we didn't find any calls that qualified.        RELEASE_ASSERT(!!totalCallsToKnown == !!variants.size());        if (variants.isEmpty())            return takesSlowPath();                // We require that the distribution of callees is skewed towards a handful of common ones.        if (totalCallsToKnown / totalCallsToUnknown < Options::minimumCallToKnownRate())            return takesSlowPath();                RELEASE_ASSERT(totalCallsToKnown);        RELEASE_ASSERT(variants.size());                CallLinkStatus result;        result.m_variants = variants;        result.m_couldTakeSlowPath = !!totalCallsToUnknown;        return result;    }        CallLinkStatus result;        if (JSFunction* target = callLinkInfo.lastSeenCallee()) {        CallVariant variant(target);        if (callLinkInfo.hasSeenClosure())            variant = variant.despecifiedClosure();        result.m_variants.append(variant);    }        result.m_couldTakeSlowPath = !!callLinkInfo.slowPathCount();    return result;}

 void  chain_interface::set_accumulated_fees( share_type fees ) {    set_property( accumulated_fees, variant(fees) ); }

GetByIdStatus GetByIdStatus::computeForStubInfo(    const ConcurrentJITLocker& locker, CodeBlock* profiledBlock, StructureStubInfo* stubInfo, StringImpl* uid,    CallLinkStatus::ExitSiteData callExitSiteData){    if (!stubInfo || !stubInfo->seen)        return GetByIdStatus(NoInformation);        PolymorphicGetByIdList* list = 0;    State slowPathState = TakesSlowPath;    if (stubInfo->accessType == access_get_by_id_list) {        list = stubInfo->u.getByIdList.list;        for (unsigned i = 0; i < list->size(); ++i) {            const GetByIdAccess& access = list->at(i);            if (access.doesCalls())                slowPathState = MakesCalls;        }    }        // Finally figure out if we can derive an access strategy.    GetByIdStatus result;    result.m_state = Simple;    result.m_wasSeenInJIT = true; // This is interesting for bytecode dumping only.    switch (stubInfo->accessType) {    case access_unset:        return GetByIdStatus(NoInformation);            case access_get_by_id_self: {        Structure* structure = stubInfo->u.getByIdSelf.baseObjectStructure.get();        if (structure->takesSlowPathInDFGForImpureProperty())            return GetByIdStatus(slowPathState, true);        unsigned attributesIgnored;        GetByIdVariant variant;        variant.m_offset = structure->getConcurrently(uid, attributesIgnored);        if (!isValidOffset(variant.m_offset))            return GetByIdStatus(slowPathState, true);                variant.m_structureSet.add(structure);        bool didAppend = result.appendVariant(variant);        ASSERT_UNUSED(didAppend, didAppend);        return result;    }            case access_get_by_id_list: {        for (unsigned listIndex = 0; listIndex < list->size(); ++listIndex) {            Structure* structure = list->at(listIndex).structure();                        ComplexGetStatus complexGetStatus = ComplexGetStatus::computeFor(                profiledBlock, structure, list->at(listIndex).chain(),                list->at(listIndex).chainCount(), uid);                         switch (complexGetStatus.kind()) {            case ComplexGetStatus::ShouldSkip:                continue;                             case ComplexGetStatus::TakesSlowPath:                return GetByIdStatus(slowPathState, true);                             case ComplexGetStatus::Inlineable: {                std::unique_ptr<CallLinkStatus> callLinkStatus;                switch (list->at(listIndex).type()) {                case GetByIdAccess::SimpleInline:                case GetByIdAccess::SimpleStub: {                    break;                }                case GetByIdAccess::Getter: {                    AccessorCallJITStubRoutine* stub = static_cast<AccessorCallJITStubRoutine*>(                        list->at(listIndex).stubRoutine());                    callLinkStatus = std::make_unique<CallLinkStatus>(                        CallLinkStatus::computeFor(                            locker, profiledBlock, *stub->m_callLinkInfo, callExitSiteData));                    break;                }                case GetByIdAccess::CustomGetter:                case GetByIdAccess::WatchedStub:{                    // FIXME: It would be totally sweet to support this at some point in the future.                    // https://bugs.webkit.org/show_bug.cgi?id=133052                    return GetByIdStatus(slowPathState, true);                }                default:                    RELEASE_ASSERT_NOT_REACHED();                }                                 GetByIdVariant variant(                    StructureSet(structure), complexGetStatus.offset(), complexGetStatus.chain(),                    WTF::move(callLinkStatus));                                 if (!result.appendVariant(variant))                    return GetByIdStatus(slowPathState, true);                break;            } }        }                return result;    }            default:        return GetByIdStatus(slowPathState, true);    }        RELEASE_ASSERT_NOT_REACHED();//.........这里部分代码省略.........

void tduel::reset_turn(twindow& window){	std::stringstream str;	str.str("");	str << "misc/digit-big.png~CROP(" << 30 * (turn_ + 1) << ", 0, 30, 45)";	find_widget<tcontrol>(&window, "turn", false, false)->set_label(str.str());	// set up card	for (int index = 0; index < 2; index ++) {		setting* t = setting_ + index;		t->cards_.clear();		if (!t->deadfight_) {			t->deadfight_ = (rand() % 16) < t->skill_;		}		if (!t->fightback_) {			t->fightback_ = (rand() % 64) < t->skill_;		}		char c = index? 'r': 'l';		for (int index2 = 4; index2 >= 0; index2 --) {			str.str("");			str << c << "card" << index2;			ttoggle_button* toggle = find_widget<ttoggle_button>(&window, str.str(), false, false);			if (t->count_ <= index2) {				toggle->set_visible(twidget::INVISIBLE);				continue;			}			if (index == 1) {				toggle->set_active(false);			}			int type = rand() % nb_items;			int point = t->min_point_ + rand() % (t->max_point_ - t->min_point_ + 1);			t->cards_.insert(std::pair<int, int>(type, point));		}		int index2 = 0;		for (std::multimap<int, int>::const_iterator c_itor = t->cards_.begin(); c_itor != t->cards_.end(); ++ c_itor, index2 ++) {			str.str("");			str << c << "card" << index2;			ttoggle_button* toggle = find_widget<ttoggle_button>(&window, str.str(), false, false);			if (index == 0) {				connect_signal_mouse_left_click(					 *toggle					, boost::bind(					  &tduel::on_card					, this					, boost::ref(window)					, index2));			}			for (int i = 0; i < 6; i ++) {				toggle->canvas()[i].set_variable("foreground", variant(menu_items[c_itor->first]));			}			str.str("");			str << c_itor->second;			toggle->set_label(str.str());			// reset lcard/rcard.			toggle->set_value(false);			toggle->set_dirty();		}		// total card		str.str("");		str << c << "total";		ttoggle_button* toggle = find_widget<ttoggle_button>(&window, str.str(), false, false);		for (int i = 0; i < 6; i ++) {			toggle->canvas()[i].set_variable("foreground", variant(""));		}		toggle->set_label("0");		toggle->set_active(false);		// skill		str.str("");		str << c << "skill";		find_widget<tcontrol>(&window, str.str(), false, false)->set_label("");		// deadfight		str.str("");		str << c << "skill0";		toggle = find_widget<ttoggle_button>(&window, str.str(), false, false);		toggle->set_value(false);		for (int i = 0; i < 6; i ++) {			if (t->deadfight_) {				toggle->canvas()[i].set_variable("image", variant("misc/deadfight.png"));			} else {				toggle->canvas()[i].set_variable("image", variant(""));			}		}		if (index == 0) {			toggle->set_active(t->deadfight_);		} else {			toggle->set_active(false);		}		// fightback		str.str("");		str << c << "skill1";		toggle = find_widget<ttoggle_button>(&window, str.str(), false, false);		toggle->set_value(false);		for (int i = 0; i < 6; i ++) {//.........这里部分代码省略.........

 void to_variant( const mutable_variant_object& var,  variant& vo ) {    vo = variant(var); }

void tduel::pre_show(CVideo& /*video*/, twindow& window){	// Override the user value, to make sure it's set properly.	window.set_click_dismiss(false);	// ***** ***** ***** ***** Set up the widgets ***** ***** ***** *****	window.canvas(1).set_variable("left_image", variant(left_.image(true)));	window.canvas(1).set_variable("right_image", variant(right_.image(true)));	window.canvas(1).set_variable("center_image", variant(""));		window.canvas(1).set_variable("hp_left", variant("misc/hp-blue.png"));	window.canvas(1).set_variable("hp_right", variant("misc/hp-red.png"));	window.canvas(1).set_variable("percentage", variant((hp_ * 100) / TOTAL_HP));	std::stringstream str;	tbutton* b = find_widget<tbutton>(&window, "endturn", false, false);	for (int i = 0; i < 4; i ++) {		b->canvas()[i].set_variable("image", variant("misc/ok.png"));	}	find_widget<tcontrol>(&window, "lname", false, false)->set_label(left_.name());	find_widget<tcontrol>(&window, "rname", false, false)->set_label(right_.name());	tcontrol* control = find_widget<tcontrol>(&window, "lforce", false, false);	str.str("");	str << setting_[0].force_ << "(" << hero::adaptability_str2(left_.skill_[hero_skill_hero]).c_str() << ")";	control->set_label(str.str());	control = find_widget<tcontrol>(&window, "rforce", false, false);	str.str("");	str << setting_[1].force_ << "(" << hero::adaptability_str2(right_.skill_[hero_skill_hero]).c_str() << ")";;	control->set_label(str.str());	endturn_ = find_widget<tbutton>(&window, "endturn", false, false);	connect_signal_mouse_left_click(		*endturn_		, boost::bind(			&tduel::end_turn			, this			, boost::ref(window)));	endturn_->set_sound_button_click("hatchet.wav");		lskill0_ = find_widget<ttoggle_button>(&window, "lskill0", false, false);	connect_signal_mouse_left_click(		 *lskill0_		, boost::bind(		  &tduel::on_deadfight		, this		, boost::ref(window)));	lskill1_ = find_widget<ttoggle_button>(&window, "lskill1", false, false);	connect_signal_mouse_left_click(		 *lskill1_		, boost::bind(		  &tduel::on_fightback		, this		, boost::ref(window)));		find_widget<ttoggle_button>(&window, "lturn0", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "lturn0_skill", false, false)->set_visible(twidget::INVISIBLE);	find_widget<tlabel>(&window, "turn0", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "rturn0", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "rturn0_skill", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "lturn1", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "lturn1_skill", false, false)->set_visible(twidget::INVISIBLE);	find_widget<tlabel>(&window, "turn1", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "rturn1", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "rturn1_skill", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "lturn2", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "lturn2_skill", false, false)->set_visible(twidget::INVISIBLE);	find_widget<tlabel>(&window, "turn2", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "rturn2", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "rturn2_skill", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "lturn3", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "lturn3_skill", false, false)->set_visible(twidget::INVISIBLE);	find_widget<tlabel>(&window, "turn3", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "rturn3", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "rturn3_skill", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "lturn4", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "lturn4_skill", false, false)->set_visible(twidget::INVISIBLE);	find_widget<tlabel>(&window, "turn4", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "rturn4", false, false)->set_visible(twidget::INVISIBLE);	find_widget<ttoggle_button>(&window, "rturn4_skill", false, false)->set_visible(twidget::INVISIBLE);	reset_turn(window);}

void ttext::draw(surface& canvas		, const game_logic::map_formula_callable& variables){	assert(variables.has_key("text"));	// We first need to determine the size of the text which need the rendered	// text. So resolve and render the text first and then start to resolve	// the other formulas.	const t_string text = text_(variables); // Bj
C++ variate_generator函数代码示例
C++ variable函数代码示例