LLHTTPClient::ResponderPtr newResult() { mSawError = false; mStatus = 0; mSawCompleted = false; mSawCompletedHeader = false; mResult.clear(); mHeader.clear(); mResultDeleted = false; return Result::build(*this); }
void sd_object::test<2>() { const std::string decoded("random"); //const std::string encoded("cmFuZG9t\n"); const std::string streamed("b(6)\"random\""); typedef std::vector<U8> buf_t; buf_t buf; std::copy( decoded.begin(), decoded.end(), std::back_insert_iterator<buf_t>(buf)); LLSD sd; sd = buf; std::stringstream str; S32 count = LLSDSerialize::toNotation(sd, str); ensure_equals("output count", count, 1); std::string actual(str.str()); ensure_equals("formatted binary encoding", actual, streamed); sd.clear(); LLSDSerialize::fromNotation(sd, str, str.str().size()); std::vector<U8> after; after = sd.asBinary(); ensure_equals("binary decoded size", after.size(), decoded.size()); ensure("binary decoding", (0 == memcmp( &after[0], decoded.c_str(), decoded.size()))); }
S32 LLSDNotationParser::parseMap(std::istream& istr, LLSD& map) const { // map: { string:object, string:object } map = LLSD::emptyMap(); S32 parse_count = 0; char c = get(istr); if(c == '{') { // eat commas, white bool found_name = false; std::string name; c = get(istr); while(c != '}' && istr.good()) { if(!found_name) { if((c == '\"') || (c == '\'') || (c == 's')) { putback(istr, c); found_name = true; int count = deserialize_string(istr, name, mMaxBytesLeft); if(PARSE_FAILURE == count) return PARSE_FAILURE; account(count); } c = get(istr); } else { if(isspace(c) || (c == ':')) { c = get(istr); continue; } putback(istr, c); LLSD child; S32 count = doParse(istr, child); if(count > 0) { // There must be a value for every key, thus // child_count must be greater than 0. parse_count += count; map.insert(name, child); } else { return PARSE_FAILURE; } found_name = false; c = get(istr); } } if(c != '}') { map.clear(); return PARSE_FAILURE; } } return parse_count; }
void llsdutil_object::test<4>() { LLSD sd; LLVector3 vec1(-1.0, 2.0, -3.0); sd = ll_sd_from_vector3(vec1); LLVector3 vec2 = ll_vector3_from_sd(sd); ensure_equals("vector3 -> sd -> vector3: 1", vec1, vec2); LLVector3 vec3(sd); ensure_equals("vector3 -> sd -> vector3: 2", vec1, vec3); sd.clear(); vec1.setVec(0., 0., 0.); sd = ll_sd_from_vector3(vec1); vec2 = ll_vector3_from_sd(sd); ensure_equals("vector3 -> sd -> vector3: 3", vec1, vec2); sd.clear(); }
void SDTestObject::test<2>() // setting and fetching scalar types { SDCleanupCheck check; LLSD v; v = true; ensureTypeAndValue("set true", v, true); v = false; ensureTypeAndValue("set false", v, false); v = true; ensureTypeAndValue("set true again", v, true); v = 42; ensureTypeAndValue("set to 42", v, 42); v = 0; ensureTypeAndValue("set to zero", v, 0); v = -12345; ensureTypeAndValue("set to neg", v, -12345); v = 2000000000; ensureTypeAndValue("set to big", v, 2000000000); v = 3.14159265359; ensureTypeAndValue("set to pi", v, 3.14159265359); ensure_not_equals("isn't float", v.asReal(), (float)3.14159265359); v = 6.7e256; ensureTypeAndValue("set to big", v, 6.7e256); LLUUID nullUUID; LLUUID newUUID; newUUID.generate(); v = nullUUID; ensureTypeAndValue("set to null UUID", v, nullUUID); v = newUUID; ensureTypeAndValue("set to new UUID", v, newUUID); v = nullUUID; ensureTypeAndValue("set to null again", v, nullUUID); // strings must be tested with two types of string objects std::string s = "now is the time"; const char* cs = "for all good zorks"; v = s; ensureTypeAndValue("set to std::string", v, s); v = cs; ensureTypeAndValue("set to const char*", v, cs); LLDate epoch; LLDate aDay("2001-10-22T10:11:12.00Z"); v = epoch; ensureTypeAndValue("set to epoch", v, epoch); v = aDay; ensureTypeAndValue("set to a day", v, aDay); LLURI path("http://slurl.com/secondlife/Ambleside/57/104/26/"); v = path; ensureTypeAndValue("set to a uri", v, path); const char source[] = "once in a blue moon"; std::vector<U8> data; copy(&source[0], &source[sizeof(source)], back_inserter(data)); v = data; ensureTypeAndValue("set to data", v, data); v.clear(); ensure("reset to undefined", v.type() == LLSD::TypeUndefined); }
void SDTestObject::test<10>() // map operations { SDCleanupCheck check; LLSD v; ensure("undefined has no members", !v.has("amy")); ensure("undefined get() is undefined", v.get("bob").isUndefined()); v = LLSD::emptyMap(); ensure("empty map is a map", v.isMap()); ensure("empty map has no members", !v.has("cam")); ensure("empty map get() is undefined", v.get("don").isUndefined()); v.clear(); v.insert("eli", 43); ensure("insert converts to map", v.isMap()); ensure("inserted key is present", v.has("eli")); ensureTypeAndValue("inserted value", v.get("eli"), 43); v.insert("fra", false); ensure("first key still present", v.has("eli")); ensure("second key is present", v.has("fra")); ensureTypeAndValue("first value", v.get("eli"), 43); ensureTypeAndValue("second value", v.get("fra"), false); v.erase("eli"); ensure("first key now gone", !v.has("eli")); ensure("second key still present", v.has("fra")); ensure("first value gone", v.get("eli").isUndefined()); ensureTypeAndValue("second value sill there", v.get("fra"), false); v.erase("fra"); ensure("second key now gone", !v.has("fra")); ensure("second value gone", v.get("fra").isUndefined()); v["gil"] = (std::string)"good morning"; ensure("third key present", v.has("gil")); ensureTypeAndValue("third key value", v.get("gil"), "good morning"); const LLSD& cv = v; // FIX ME IF POSSIBLE ensure("missing key", cv["ham"].isUndefined()); ensure("key not present", !v.has("ham")); LLSD w = 43; const LLSD& cw = w; // FIX ME IF POSSIBLE int i = cw["ian"]; ensureTypeAndValue("other missing value", i, 0); ensure("other missing key", !w.has("ian")); ensure("no conversion", w.isInteger()); LLSD x; x = v; ensure("copy map type", x.isMap()); ensureTypeAndValue("copy map value gil", x.get("gil"), "good morning"); }
void lllogininstance_object::test<1>() { set_test_name("Test Simple Success And Disconnect"); // Test default connect. logininstance->connect(credentials); ensure_equals("Default connect uri", gLoginURI, VIEWERLOGIN_URI); // Dummy success response. LLSD response; response["state"] = "online"; response["change"] = "connect"; response["progress"] = 1.0; response["transfer_rate"] = 7; response["data"] = "test_data"; gTestPump.post(response); ensure("Success response", logininstance->authSuccess()); ensure_equals("Test Response Data", logininstance->getResponse().asString(), "test_data"); logininstance->disconnect(); ensure_equals("Called Login Module Disconnect", gDisconnectCalled, true); response.clear(); response["state"] = "offline"; response["change"] = "disconnect"; response["progress"] = 0.0; response["transfer_rate"] = 0; response["data"] = "test_data"; gTestPump.post(response); ensure("Disconnected", !(logininstance->authSuccess())); }
int deserialize_boolean( std::istream& istr, LLSD& data, const std::string& compare, bool value) { // // this method is a little goofy, because it gets the stream at // the point where the t or f has already been // consumed. Basically, parse for a patch to the string passed in // starting at index 1. If it's a match: // * assign data to value // * return the number of bytes read // otherwise: // * set data to LLSD::null // * return LLSDParser::PARSE_FAILURE (-1) // int bytes_read = 0; std::string::size_type ii = 0; char c = istr.peek(); while((++ii < compare.size()) && (tolower(c) == (int)compare[ii]) && istr.good()) { istr.ignore(); ++bytes_read; c = istr.peek(); } if(compare.size() != ii) { data.clear(); return LLSDParser::PARSE_FAILURE; } data = value; return bytes_read; }
void SDTestObject::test<11>() // array operations { SDCleanupCheck check; LLSD v; ensure_equals("undefined has no size", v.size(), 0); ensure("undefined get() is undefined", v.get(0).isUndefined()); v = LLSD::emptyArray(); ensure("empty array is an array", v.isArray()); ensure_equals("empty array has no size", v.size(), 0); ensure("empty map get() is undefined", v.get(0).isUndefined()); v.clear(); v.append(88); v.append("noodle"); v.append(true); ensure_equals("appened array size", v.size(), 3); ensure("append array is an array", v.isArray()); ensureTypeAndValue("append 0", v[0], 88); ensureTypeAndValue("append 1", v[1], "noodle"); ensureTypeAndValue("append 2", v[2], true); v.insert(0, 77); v.insert(2, "soba"); v.insert(4, false); ensure_equals("inserted array size", v.size(), 6); ensureTypeAndValue("post insert 0", v[0], 77); ensureTypeAndValue("post insert 1", v[1], 88); ensureTypeAndValue("post insert 2", v[2], "soba"); ensureTypeAndValue("post insert 3", v[3], "noodle"); ensureTypeAndValue("post insert 4", v[4], false); ensureTypeAndValue("post insert 5", v[5], true); ensureTypeAndValue("get 1", v.get(1), 88); v.set(1, "hot"); ensureTypeAndValue("set 1", v.get(1), "hot"); v.erase(3); ensure_equals("post erase array size", v.size(), 5); ensureTypeAndValue("post erase 0", v[0], 77); ensureTypeAndValue("post erase 1", v[1], "hot"); ensureTypeAndValue("post erase 2", v[2], "soba"); ensureTypeAndValue("post erase 3", v[3], false); ensureTypeAndValue("post erase 4", v[4], true); v.append(34); ensure_equals("size after append", v.size(), 6); ensureTypeAndValue("post append 5", v[5], 34); LLSD w; w = v; ensure("copy array type", w.isArray()); ensure_equals("copy array size", w.size(), 6); ensureTypeAndValue("copy array 0", w[0], 77); ensureTypeAndValue("copy array 1", w[1], "hot"); ensureTypeAndValue("copy array 2", w[2], "soba"); ensureTypeAndValue("copy array 3", w[3], false); ensureTypeAndValue("copy array 4", w[4], true); ensureTypeAndValue("copy array 5", w[5], 34); }
// virtual S32 LLSDBinaryParser::doParse(std::istream& istr, LLSD& data) const { /** * Undefined: '!'<br> * Boolean: 't' for true 'f' for false<br> * Integer: 'i' + 4 bytes network byte order<br> * Real: 'r' + 8 bytes IEEE double<br> * UUID: 'u' + 16 byte unsigned integer<br> * String: 's' + 4 byte integer size + string<br> * strings also secretly support the notation format * Date: 'd' + 8 byte IEEE double for seconds since epoch<br> * URI: 'l' + 4 byte integer size + string uri<br> * Binary: 'b' + 4 byte integer size + binary data<br> * Array: '[' + 4 byte integer size + all values + ']'<br> * Map: '{' + 4 byte integer size every(key + value) + '}'<br> * map keys are serialized as s + 4 byte integer size + string or in the * notation format. */ char c; c = get(istr); if(!istr.good()) { return 0; } S32 parse_count = 1; switch(c) { case '{': { S32 child_count = parseMap(istr, data); if((child_count == PARSE_FAILURE) || data.isUndefined()) { parse_count = PARSE_FAILURE; } else { parse_count += child_count; } if(istr.fail()) { llinfos << "STREAM FAILURE reading binary map." << llendl; parse_count = PARSE_FAILURE; } break; } case '[': { S32 child_count = parseArray(istr, data); if((child_count == PARSE_FAILURE) || data.isUndefined()) { parse_count = PARSE_FAILURE; } else { parse_count += child_count; } if(istr.fail()) { llinfos << "STREAM FAILURE reading binary array." << llendl; parse_count = PARSE_FAILURE; } break; } case '!': data.clear(); break; case '0': data = false; break; case '1': data = true; break; case 'i': { U32 value_nbo = 0; read(istr, (char*)&value_nbo, sizeof(U32)); /*Flawfinder: ignore*/ data = (S32)ntohl(value_nbo); if(istr.fail()) { llinfos << "STREAM FAILURE reading binary integer." << llendl; } break; } case 'r': { F64 real_nbo = 0.0; read(istr, (char*)&real_nbo, sizeof(F64)); /*Flawfinder: ignore*/ data = ll_ntohd(real_nbo); if(istr.fail()) { llinfos << "STREAM FAILURE reading binary real." << llendl; } break; } case 'u': { LLUUID id; read(istr, (char*)(&id.mData), UUID_BYTES); /*Flawfinder: ignore*/ data = id; if(istr.fail()) { llinfos << "STREAM FAILURE reading binary uuid." << llendl; } break; } case '\'': case '"': { std::string value; int cnt = deserialize_string_delim(istr, value, c); if(PARSE_FAILURE == cnt) { parse_count = PARSE_FAILURE; } else { data = value; account(cnt); } if(istr.fail()) { llinfos << "STREAM FAILURE reading binary (notation-style) string." << llendl; parse_count = PARSE_FAILURE; } break; } case 's': { std::string value; if(parseString(istr, value)) { data = value; } else { parse_count = PARSE_FAILURE; } if(istr.fail()) { llinfos << "STREAM FAILURE reading binary string." << llendl; parse_count = PARSE_FAILURE; } break; } case 'l': { std::string value; if(parseString(istr, value)) { data = LLURI(value); } else { parse_count = PARSE_FAILURE; } if(istr.fail()) { llinfos << "STREAM FAILURE reading binary link." << llendl; parse_count = PARSE_FAILURE; } break; } case 'd': { F64 real = 0.0; read(istr, (char*)&real, sizeof(F64)); /*Flawfinder: ignore*/ data = LLDate(real); if(istr.fail()) { llinfos << "STREAM FAILURE reading binary date." << llendl; parse_count = PARSE_FAILURE; } break; } case 'b': { // We probably have a valid raw binary stream. determine // the size, and read it. U32 size_nbo = 0; read(istr, (char*)&size_nbo, sizeof(U32)); /*Flawfinder: ignore*/ S32 size = (S32)ntohl(size_nbo); if(mCheckLimits && (size > mMaxBytesLeft)) { parse_count = PARSE_FAILURE; } else { std::vector<U8> value; if(size > 0) { value.resize(size); account(fullread(istr, (char*)&value[0], size)); } data = value; } if(istr.fail()) { llinfos << "STREAM FAILURE reading binary." << llendl; parse_count = PARSE_FAILURE; } break; } default: parse_count = PARSE_FAILURE; llinfos << "Unrecognized character while parsing: int(" << (int)c << ")" << llendl; break; } if(PARSE_FAILURE == parse_count) { data.clear(); } return parse_count; }
// virtual S32 LLSDNotationParser::doParse(std::istream& istr, LLSD& data) const { // map: { string:object, string:object } // array: [ object, object, object ] // undef: ! // boolean: true | false | 1 | 0 | T | F | t | f | TRUE | FALSE // integer: i#### // real: r#### // uuid: u#### // string: "g'day" | 'have a "nice" day' | s(size)"raw data" // uri: l"escaped" // date: d"YYYY-MM-DDTHH:MM:SS.FFZ" // binary: b##"ff3120ab1" | b(size)"raw data" char c; c = istr.peek(); while(isspace(c)) { // pop the whitespace. c = get(istr); c = istr.peek(); continue; } if(!istr.good()) { return 0; } S32 parse_count = 1; switch(c) { case '{': { S32 child_count = parseMap(istr, data); if((child_count == PARSE_FAILURE) || data.isUndefined()) { parse_count = PARSE_FAILURE; } else { parse_count += child_count; } if(istr.fail()) { llinfos << "STREAM FAILURE reading map." << llendl; parse_count = PARSE_FAILURE; } break; } case '[': { S32 child_count = parseArray(istr, data); if((child_count == PARSE_FAILURE) || data.isUndefined()) { parse_count = PARSE_FAILURE; } else { parse_count += child_count; } if(istr.fail()) { llinfos << "STREAM FAILURE reading array." << llendl; parse_count = PARSE_FAILURE; } break; } case '!': c = get(istr); data.clear(); break; case '0': c = get(istr); data = false; break; case 'F': case 'f': ignore(istr); c = istr.peek(); if(isalpha(c)) { int cnt = deserialize_boolean( istr, data, NOTATION_FALSE_SERIAL, false); if(PARSE_FAILURE == cnt) parse_count = cnt; else account(cnt); } else { data = false; } if(istr.fail()) { llinfos << "STREAM FAILURE reading boolean." << llendl; parse_count = PARSE_FAILURE; } break; case '1': c = get(istr); data = true; break; case 'T': case 't': ignore(istr); c = istr.peek(); if(isalpha(c)) { int cnt = deserialize_boolean(istr,data,NOTATION_TRUE_SERIAL,true); if(PARSE_FAILURE == cnt) parse_count = cnt; else account(cnt); } else { data = true; } if(istr.fail()) { llinfos << "STREAM FAILURE reading boolean." << llendl; parse_count = PARSE_FAILURE; } break; case 'i': { c = get(istr); S32 integer = 0; istr >> integer; data = integer; if(istr.fail()) { llinfos << "STREAM FAILURE reading integer." << llendl; parse_count = PARSE_FAILURE; } break; } case 'r': { c = get(istr); F64 real = 0.0; istr >> real; data = real; if(istr.fail()) { llinfos << "STREAM FAILURE reading real." << llendl; parse_count = PARSE_FAILURE; } break; } case 'u': { c = get(istr); LLUUID id; istr >> id; data = id; if(istr.fail()) { llinfos << "STREAM FAILURE reading uuid." << llendl; parse_count = PARSE_FAILURE; } break; } case '\"': case '\'': case 's': if(!parseString(istr, data)) { parse_count = PARSE_FAILURE; } if(istr.fail()) { llinfos << "STREAM FAILURE reading string." << llendl; parse_count = PARSE_FAILURE; } break; case 'l': { c = get(istr); // pop the 'l' c = get(istr); // pop the delimiter std::string str; int cnt = deserialize_string_delim(istr, str, c); if(PARSE_FAILURE == cnt) { parse_count = PARSE_FAILURE; } else { data = LLURI(str); account(cnt); } if(istr.fail()) { llinfos << "STREAM FAILURE reading link." << llendl; parse_count = PARSE_FAILURE; } break; } case 'd': { c = get(istr); // pop the 'd' c = get(istr); // pop the delimiter std::string str; int cnt = deserialize_string_delim(istr, str, c); if(PARSE_FAILURE == cnt) { parse_count = PARSE_FAILURE; } else { data = LLDate(str); account(cnt); } if(istr.fail()) { llinfos << "STREAM FAILURE reading date." << llendl; parse_count = PARSE_FAILURE; } break; } case 'b': if(!parseBinary(istr, data)) { parse_count = PARSE_FAILURE; } if(istr.fail()) { llinfos << "STREAM FAILURE reading data." << llendl; parse_count = PARSE_FAILURE; } break; default: parse_count = PARSE_FAILURE; llinfos << "Unrecognized character while parsing: int(" << (int)c << ")" << llendl; break; } if(PARSE_FAILURE == parse_count) { data.clear(); } return parse_count; }
LLSD FSData::resolveClientTag(LLUUID id, bool new_system, LLColor4 color){ //WS: Create a new LLSD based on the data from the LegacyClientList if LLSD curtag; curtag["uuid"]=id.asString(); curtag["id_based"]=new_system; curtag["tex_color"]=color.getValue(); // If we don't want to display anything...return if(gSavedSettings.getU32("FSClientTagsVisibility2") == 0) { return curtag; } //WS: Do we want to use Legacy Clienttags? if(gSavedSettings.getU32("FSUseLegacyClienttags") > 0) { if(LegacyClientList.has(id.asString())) { curtag=LegacyClientList[id.asString()]; } else { if(id == LLUUID("5d9581af-d615-bc16-2667-2f04f8eeefe4"))//green { curtag["name"]="Phoenix"; curtag["color"] = LLColor4::green.getValue(); curtag["alt"] = "ed63fbd0-589e-fe1d-a3d0-16905efaa96b"; } else if(id == LLUUID("e35f7d40-6071-4b29-9727-5647bdafb5d5"))//white { curtag["name"] = "Phoenix"; curtag["color"] = LLColor4::white.getValue(); curtag["alt"] = "ed63fbd0-589e-fe1d-a3d0-16905efaa96b"; } else if(id == LLUUID("ae4e92fb-023d-23ba-d060-3403f953ab1a"))//pink { curtag["name"] = "Phoenix"; curtag["color"] = LLColor4::pink.getValue(); curtag["alt"] = "ed63fbd0-589e-fe1d-a3d0-16905efaa96b"; } else if(id == LLUUID("e71b780e-1a57-400d-4649-959f69ec7d51"))//red { curtag["name"] = "Phoenix"; curtag["color"] = LLColor4::red.getValue(); curtag["alt"] = "ed63fbd0-589e-fe1d-a3d0-16905efaa96b"; } else if(id == LLUUID("c1c189f5-6dab-fc03-ea5a-f9f68f90b018"))//orange { curtag["name"] = "Phoenix"; curtag["color"] = LLColor4::orange.getValue(); curtag["alt"] = "ed63fbd0-589e-fe1d-a3d0-16905efaa96b"; } else if(id == LLUUID("8cf0577c-22d3-6a73-523c-15c0a90d6c27")) //purple { curtag["name"] = "Phoenix"; curtag["color"] = LLColor4::purple.getValue(); curtag["alt"] = "ed63fbd0-589e-fe1d-a3d0-16905efaa96b"; } else if(id == LLUUID("5f0e7c32-38c3-9214-01f0-fb16a5b40128"))//yellow { curtag["name"] = "Phoenix"; curtag["color"] = LLColor4::yellow.getValue(); curtag["alt"] = "ed63fbd0-589e-fe1d-a3d0-16905efaa96b"; } else if(id == LLUUID("5bb6e4a6-8e24-7c92-be2e-91419bb0ebcb"))//blue { curtag["name"] = "Phoenix"; curtag["color"] = LLColor4::blue.getValue(); curtag["alt"] = "ed63fbd0-589e-fe1d-a3d0-16905efaa96b"; } else if(id == LLUUID("ed63fbd0-589e-fe1d-a3d0-16905efaa96b"))//default (red) { curtag["name"] = "Phoenix"; curtag["color"] = LLColor4::red.getValue(); } else if(id == LLUUID("c228d1cf-4b5d-4ba8-84f4-899a0796aa97"))//viewer 2.0 { curtag["name"] = "LL Viewer"; } else if(id == LLUUID("cc7a030f-282f-c165-44d2-b5ee572e72bf")) { curtag["name"] = "Imprudence"; } else if(id == LLUUID("54d93609-1392-2a93-255c-a9dd429ecca5")) { curtag["name"] = "Emergence"; } else if(id == LLUUID("8873757c-092a-98fb-1afd-ecd347566fcd")) { curtag["name"] = "Ascent"; } else if(id == LLUUID("f25263b7-6167-4f34-a4ef-af65213b2e39")) { curtag["name"] = "Singularity"; } if(curtag.has("name")) curtag["tpvd"]=true; } } // Filtering starts here: //WS: If the current tag has an "alt" definied and we don't want multiple colors. Resolve the alt. if((gSavedSettings.getU32("FSColorClienttags") == 1) && curtag.has("alt")) { curtag = resolveClientTag(curtag["alt"], new_system, color); } //WS: If we have a tag using the new system, check if we want to display it's name and/or color if(new_system) { if(gSavedSettings.getU32("FSClientTagsVisibility2") >= 3) { // strnlen() doesn't exist on OS X before 10.7. -- TS char tag_temp[UUID_BYTES+1]; strncpy(tag_temp,(const char*)&id.mData[0], UUID_BYTES); tag_temp[UUID_BYTES] = '\0'; U32 tag_len = strlen(tag_temp); std::string clienttagname = std::string((const char*)&id.mData[0], tag_len); LLStringFn::replace_ascii_controlchars(clienttagname, LL_UNKNOWN_CHAR); curtag["name"] = clienttagname; } if(gSavedSettings.getU32("FSColorClienttags") >= 3 || curtag["tpvd"].asBoolean()) { if(curtag["tpvd"].asBoolean() && gSavedSettings.getU32("FSColorClienttags") < 3) { if(color == LLColor4::blue || color == LLColor4::yellow || color == LLColor4::purple || color == LLColor4((F32)0.99,(F32)0.39,(F32)0.12,(F32)1) || color == LLColor4::red || color == LLColor4((F32)0.99,(F32)0.56,(F32)0.65,(F32)1) || color == LLColor4::white || color == LLColor4::green) { curtag["color"] = color.getValue(); } } else { curtag["color"] = color.getValue(); } } } //If we only want to display tpvd viewer. And "tpvd" is not available or false, then // clear the data, but keep the basedata (like uuid, id_based and tex_color) for (maybe) later displaying. if(gSavedSettings.getU32("FSClientTagsVisibility2") <= 1 && (!curtag.has("tpvd") || !curtag["tpvd"].asBoolean())) { curtag.clear(); } curtag["uuid"]=id.asString(); curtag["id_based"]=new_system; curtag["tex_color"]=color.getValue(); return curtag; }