Merge branch 'xcode-14.1' into DRTVWR-489-emoji
Callum Prentice
commit
fb00bce81a
|
|
@ -194,9 +194,15 @@ if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
|
|||
# development must be done after the build as we do in viewer_manifest.py for
|
||||
# released builds
|
||||
# https://stackoverflow.com/a/54296008
|
||||
# With Xcode 14.1, apparently you must take drastic steps to prevent
|
||||
# implicit signing.
|
||||
set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED NO)
|
||||
set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED NO)
|
||||
# "-" represents "Sign to Run Locally" and empty string represents "Do Not Sign"
|
||||
set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY "")
|
||||
|
||||
set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGN_ENTITLEMENTS "")
|
||||
set(CMAKE_XCODE_ATTRIBUTE_DISABLE_MANUAL_TARGET_ORDER_BUILD_WARNING YES)
|
||||
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_64_TO_32_BIT_CONVERSION NO)
|
||||
set(CMAKE_OSX_ARCHITECTURES "${ARCH}")
|
||||
string(REPLACE "i686" "i386" CMAKE_OSX_ARCHITECTURES "${CMAKE_OSX_ARCHITECTURES}")
|
||||
string(REPLACE "AMD64" "x86_64" CMAKE_OSX_ARCHITECTURES "${CMAKE_OSX_ARCHITECTURES}")
|
||||
|
|
|
|||
|
|
@ -905,14 +905,14 @@ bool unix_post_minidump_callback(const char *dump_dir,
|
|||
// heap allocations in a crash handler.
|
||||
|
||||
// path format: <dump_dir>/<minidump_id>.dmp
|
||||
int dirPathLength = strlen(dump_dir);
|
||||
int idLength = strlen(minidump_id);
|
||||
auto dirPathLength = strlen(dump_dir);
|
||||
auto idLength = strlen(minidump_id);
|
||||
|
||||
// The path must not be truncated.
|
||||
llassert((dirPathLength + idLength + 5) <= LLApp::MAX_MINDUMP_PATH_LENGTH);
|
||||
|
||||
char * path = LLApp::instance()->getMiniDumpFilename();
|
||||
S32 remaining = LLApp::MAX_MINDUMP_PATH_LENGTH;
|
||||
auto remaining = LLApp::MAX_MINDUMP_PATH_LENGTH;
|
||||
strncpy(path, dump_dir, remaining);
|
||||
remaining -= dirPathLength;
|
||||
path += dirPathLength;
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ std::string LLBase64::encode(const U8* input, size_t input_size)
|
|||
&& input_size > 0)
|
||||
{
|
||||
// Yes, it returns int.
|
||||
int b64_buffer_length = apr_base64_encode_len(input_size);
|
||||
int b64_buffer_length = apr_base64_encode_len(narrow(input_size));
|
||||
char* b64_buffer = new char[b64_buffer_length];
|
||||
|
||||
// This is faster than apr_base64_encode() if you know
|
||||
|
|
@ -52,7 +52,7 @@ std::string LLBase64::encode(const U8* input, size_t input_size)
|
|||
b64_buffer_length = apr_base64_encode_binary(
|
||||
b64_buffer,
|
||||
input,
|
||||
input_size);
|
||||
narrow(input_size));
|
||||
output.assign(b64_buffer);
|
||||
delete[] b64_buffer;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@
|
|||
#define LL_LLDEFS_H
|
||||
|
||||
#include "stdtypes.h"
|
||||
#include <type_traits>
|
||||
|
||||
// Often used array indices
|
||||
const U32 VX = 0;
|
||||
|
|
@ -168,80 +169,79 @@ const U32 MAXADDRSTR = 17; // 123.567.901.345 = 15 chars + \0 + 1 for good luc
|
|||
// llclampb(a) // clamps a to [0 .. 255]
|
||||
//
|
||||
|
||||
template <class LLDATATYPE>
|
||||
inline LLDATATYPE llmax(const LLDATATYPE& d1, const LLDATATYPE& d2)
|
||||
template <typename T1, typename T2>
|
||||
inline auto llmax(T1 d1, T2 d2)
|
||||
{
|
||||
return (d1 > d2) ? d1 : d2;
|
||||
}
|
||||
|
||||
template <class LLDATATYPE>
|
||||
inline LLDATATYPE llmax(const LLDATATYPE& d1, const LLDATATYPE& d2, const LLDATATYPE& d3)
|
||||
template <typename T1, typename T2, typename T3>
|
||||
inline auto llmax(T1 d1, T2 d2, T3 d3)
|
||||
{
|
||||
LLDATATYPE r = llmax(d1,d2);
|
||||
auto r = llmax(d1,d2);
|
||||
return llmax(r, d3);
|
||||
}
|
||||
|
||||
template <class LLDATATYPE>
|
||||
inline LLDATATYPE llmax(const LLDATATYPE& d1, const LLDATATYPE& d2, const LLDATATYPE& d3, const LLDATATYPE& d4)
|
||||
template <typename T1, typename T2, typename T3, typename T4>
|
||||
inline auto llmax(T1 d1, T2 d2, T3 d3, T4 d4)
|
||||
{
|
||||
LLDATATYPE r1 = llmax(d1,d2);
|
||||
LLDATATYPE r2 = llmax(d3,d4);
|
||||
auto r1 = llmax(d1,d2);
|
||||
auto r2 = llmax(d3,d4);
|
||||
return llmax(r1, r2);
|
||||
}
|
||||
|
||||
template <class LLDATATYPE>
|
||||
inline LLDATATYPE llmin(const LLDATATYPE& d1, const LLDATATYPE& d2)
|
||||
template <typename T1, typename T2>
|
||||
inline auto llmin(T1 d1, T2 d2)
|
||||
{
|
||||
return (d1 < d2) ? d1 : d2;
|
||||
}
|
||||
|
||||
template <class LLDATATYPE>
|
||||
inline LLDATATYPE llmin(const LLDATATYPE& d1, const LLDATATYPE& d2, const LLDATATYPE& d3)
|
||||
template <typename T1, typename T2, typename T3>
|
||||
inline auto llmin(T1 d1, T2 d2, T3 d3)
|
||||
{
|
||||
LLDATATYPE r = llmin(d1,d2);
|
||||
auto r = llmin(d1,d2);
|
||||
return (r < d3 ? r : d3);
|
||||
}
|
||||
|
||||
template <class LLDATATYPE>
|
||||
inline LLDATATYPE llmin(const LLDATATYPE& d1, const LLDATATYPE& d2, const LLDATATYPE& d3, const LLDATATYPE& d4)
|
||||
template <typename T1, typename T2, typename T3, typename T4>
|
||||
inline auto llmin(T1 d1, T2 d2, T3 d3, T4 d4)
|
||||
{
|
||||
LLDATATYPE r1 = llmin(d1,d2);
|
||||
LLDATATYPE r2 = llmin(d3,d4);
|
||||
auto r1 = llmin(d1,d2);
|
||||
auto r2 = llmin(d3,d4);
|
||||
return llmin(r1, r2);
|
||||
}
|
||||
|
||||
template <class LLDATATYPE>
|
||||
inline LLDATATYPE llclamp(const LLDATATYPE& a, const LLDATATYPE& minval, const LLDATATYPE& maxval)
|
||||
template <typename A, typename MIN, typename MAX>
|
||||
inline A llclamp(A a, MIN minval, MAX maxval)
|
||||
{
|
||||
if ( a < minval )
|
||||
A aminval{ static_cast<A>(minval) }, amaxval{ static_cast<A>(maxval) };
|
||||
if ( a < aminval )
|
||||
{
|
||||
return minval;
|
||||
return aminval;
|
||||
}
|
||||
else if ( a > maxval )
|
||||
else if ( a > amaxval )
|
||||
{
|
||||
return maxval;
|
||||
return amaxval;
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
template <class LLDATATYPE>
|
||||
inline LLDATATYPE llclampf(const LLDATATYPE& a)
|
||||
inline LLDATATYPE llclampf(LLDATATYPE a)
|
||||
{
|
||||
return llmin(llmax(a, (LLDATATYPE)0), (LLDATATYPE)1);
|
||||
return llmin(llmax(a, LLDATATYPE(0)), LLDATATYPE(1));
|
||||
}
|
||||
|
||||
template <class LLDATATYPE>
|
||||
inline LLDATATYPE llclampb(const LLDATATYPE& a)
|
||||
inline LLDATATYPE llclampb(LLDATATYPE a)
|
||||
{
|
||||
return llmin(llmax(a, (LLDATATYPE)0), (LLDATATYPE)255);
|
||||
return llmin(llmax(a, LLDATATYPE(0)), LLDATATYPE(255));
|
||||
}
|
||||
|
||||
template <class LLDATATYPE>
|
||||
inline void llswap(LLDATATYPE& lhs, LLDATATYPE& rhs)
|
||||
{
|
||||
LLDATATYPE tmp = lhs;
|
||||
lhs = rhs;
|
||||
rhs = tmp;
|
||||
std::swap(lhs, rhs);
|
||||
}
|
||||
|
||||
#endif // LL_LLDEFS_H
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@
|
|||
// other Linden headers
|
||||
#include "llexception.h"
|
||||
|
||||
LLDependenciesBase::VertexList LLDependenciesBase::topo_sort(int vertices, const EdgeList& edges) const
|
||||
LLDependenciesBase::VertexList LLDependenciesBase::topo_sort(size_t vertices, const EdgeList& edges) const
|
||||
{
|
||||
// Construct a Boost Graph Library graph according to the constraints
|
||||
// we've collected. It seems as though we ought to be able to capture
|
||||
|
|
|
|||
|
|
@ -126,7 +126,7 @@ public:
|
|||
protected:
|
||||
typedef std::vector< std::pair<std::size_t, std::size_t> > EdgeList;
|
||||
typedef std::vector<std::size_t> VertexList;
|
||||
VertexList topo_sort(int vertices, const EdgeList& edges) const;
|
||||
VertexList topo_sort(size_t vertices, const EdgeList& edges) const;
|
||||
|
||||
/**
|
||||
* refpair is specifically intended to capture a pair of references. This
|
||||
|
|
@ -539,7 +539,7 @@ public:
|
|||
for (typename DepNodeMap::const_iterator nmi = mNodes.begin(), nmend = mNodes.end();
|
||||
nmi != nmend; ++nmi)
|
||||
{
|
||||
int thisnode = vmap[nmi->first];
|
||||
auto thisnode = vmap[nmi->first];
|
||||
// after dependencies: build edges from the named node to this one
|
||||
for (typename DepNode::dep_set::const_iterator ai = nmi->second.after.begin(),
|
||||
aend = nmi->second.after.end();
|
||||
|
|
|
|||
|
|
@ -1514,7 +1514,7 @@ namespace LLError
|
|||
const size_t BUF_SIZE = 64;
|
||||
char time_str[BUF_SIZE]; /* Flawfinder: ignore */
|
||||
|
||||
int chars = strftime(time_str, BUF_SIZE,
|
||||
auto chars = strftime(time_str, BUF_SIZE,
|
||||
"%Y-%m-%dT%H:%M:%SZ",
|
||||
gmtime(&now));
|
||||
|
||||
|
|
|
|||
|
|
@ -178,7 +178,7 @@ private:
|
|||
// store it as a map from name string to position index. Of course that's
|
||||
// easy to generate from the incoming names array, but why do it more than
|
||||
// once?
|
||||
typedef std::map<LLSD::String, LLSD::Integer> IndexMap;
|
||||
typedef std::map<LLSD::String, size_t> IndexMap;
|
||||
IndexMap _indexes;
|
||||
// Generated array of default values, aligned with the array of param names.
|
||||
LLSD _defaults;
|
||||
|
|
@ -197,9 +197,9 @@ LLSDArgsMapper::LLSDArgsMapper(const std::string& function,
|
|||
{
|
||||
LL_ERRS("LLSDArgsMapper") << function << " names must be an array, not " << names << LL_ENDL;
|
||||
}
|
||||
LLSD::Integer nparams(_names.size());
|
||||
auto nparams(_names.size());
|
||||
// From _names generate _indexes.
|
||||
for (LLSD::Integer ni = 0, nend = _names.size(); ni < nend; ++ni)
|
||||
for (size_t ni = 0, nend = _names.size(); ni < nend; ++ni)
|
||||
{
|
||||
_indexes[_names[ni]] = ni;
|
||||
}
|
||||
|
|
@ -214,7 +214,7 @@ LLSDArgsMapper::LLSDArgsMapper(const std::string& function,
|
|||
|
||||
if (defaults.isUndefined() || defaults.isArray())
|
||||
{
|
||||
LLSD::Integer ndefaults = defaults.size();
|
||||
auto ndefaults = defaults.size();
|
||||
// defaults is a (possibly empty) array. Right-align it with names.
|
||||
if (ndefaults > nparams)
|
||||
{
|
||||
|
|
@ -224,10 +224,10 @@ LLSDArgsMapper::LLSDArgsMapper(const std::string& function,
|
|||
|
||||
// Offset by which we slide defaults array right to right-align with
|
||||
// _names array
|
||||
LLSD::Integer offset = nparams - ndefaults;
|
||||
auto offset = nparams - ndefaults;
|
||||
// Fill rightmost _defaults entries from defaults, and mark them as
|
||||
// filled
|
||||
for (LLSD::Integer i = 0, iend = ndefaults; i < iend; ++i)
|
||||
for (size_t i = 0, iend = ndefaults; i < iend; ++i)
|
||||
{
|
||||
_defaults[i + offset] = defaults[i];
|
||||
_has_dft[i + offset] = 1;
|
||||
|
|
@ -247,7 +247,7 @@ LLSDArgsMapper::LLSDArgsMapper(const std::string& function,
|
|||
continue;
|
||||
}
|
||||
|
||||
LLSD::Integer pos = ixit->second;
|
||||
auto pos = ixit->second;
|
||||
// Store default value at that position in the _defaults array.
|
||||
_defaults[pos] = mi->second;
|
||||
// Don't forget to record the fact that we've filled this
|
||||
|
|
@ -301,7 +301,7 @@ LLSD LLSDArgsMapper::map(const LLSD& argsmap) const
|
|||
{
|
||||
// Fill args from array. If there are too many args in passed array,
|
||||
// ignore the rest.
|
||||
LLSD::Integer size(argsmap.size());
|
||||
auto size(argsmap.size());
|
||||
if (size > args.size())
|
||||
{
|
||||
// We don't just use std::min() because we want to sneak in this
|
||||
|
|
@ -338,7 +338,7 @@ LLSD LLSDArgsMapper::map(const LLSD& argsmap) const
|
|||
<< mi->first << "=" << mi->second << LL_ENDL;
|
||||
continue;
|
||||
}
|
||||
LLSD::Integer pos = ixit->second;
|
||||
auto pos = ixit->second;
|
||||
// Store the value at that position in the args array.
|
||||
args[pos] = mi->second;
|
||||
// Don't forget to record the fact that we've filled this
|
||||
|
|
@ -349,7 +349,7 @@ LLSD LLSDArgsMapper::map(const LLSD& argsmap) const
|
|||
|
||||
// Fill any remaining holes from _defaults.
|
||||
LLSD unfilled(LLSD::emptyArray());
|
||||
for (LLSD::Integer i = 0, iend = args.size(); i < iend; ++i)
|
||||
for (size_t i = 0, iend = args.size(); i < iend; ++i)
|
||||
{
|
||||
if (! filled[i])
|
||||
{
|
||||
|
|
@ -503,9 +503,9 @@ struct LLEventDispatcher::MapParamsDispatchEntry: public LLEventDispatcher::Para
|
|||
if (defaults.isArray() || defaults.isUndefined())
|
||||
{
|
||||
// Right-align the params and defaults arrays.
|
||||
LLSD::Integer offset = params.size() - defaults.size();
|
||||
auto offset = params.size() - defaults.size();
|
||||
// Now the name of every defaults[i] is at params[i + offset].
|
||||
for (LLSD::Integer i(0), iend(defaults.size()); i < iend; ++i)
|
||||
for (size_t i(0), iend(defaults.size()); i < iend; ++i)
|
||||
{
|
||||
// Erase this optional param from mRequired.
|
||||
mRequired.erase(params[i + offset].asString());
|
||||
|
|
|
|||
|
|
@ -99,7 +99,7 @@ public:
|
|||
return mSelf;
|
||||
}
|
||||
|
||||
static S32 instanceCount()
|
||||
static size_t instanceCount()
|
||||
{
|
||||
return LockStatic()->mMap.size();
|
||||
}
|
||||
|
|
@ -363,7 +363,7 @@ public:
|
|||
return mSelf;
|
||||
}
|
||||
|
||||
static S32 instanceCount()
|
||||
static size_t instanceCount()
|
||||
{
|
||||
return LockStatic()->mSet.size();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@
|
|||
|
||||
#include "llsd.h"
|
||||
#include "llsdutil.h"
|
||||
#include <algorithm>
|
||||
|
||||
LLKeyData::LLKeyData()
|
||||
:
|
||||
|
|
@ -180,10 +181,10 @@ LLKeyBind::LLKeyBind(const LLSD &key_bind)
|
|||
|
||||
bool LLKeyBind::operator==(const LLKeyBind& rhs)
|
||||
{
|
||||
U32 size = mData.size();
|
||||
auto size = mData.size();
|
||||
if (size != rhs.mData.size()) return false;
|
||||
|
||||
for (U32 i = 0; i < size; i++)
|
||||
for (size_t i = 0; i < size; i++)
|
||||
{
|
||||
if (mData[i] != rhs.mData[i]) return false;
|
||||
}
|
||||
|
|
@ -193,7 +194,7 @@ bool LLKeyBind::operator==(const LLKeyBind& rhs)
|
|||
|
||||
bool LLKeyBind::operator!=(const LLKeyBind& rhs)
|
||||
{
|
||||
U32 size = mData.size();
|
||||
auto size = mData.size();
|
||||
if (size != rhs.mData.size()) return true;
|
||||
|
||||
for (U32 i = 0; i < size; i++)
|
||||
|
|
@ -213,19 +214,23 @@ bool LLKeyBind::isEmpty() const
|
|||
return true;
|
||||
}
|
||||
|
||||
LLKeyBind::data_vector_t::const_iterator LLKeyBind::endNonEmpty() const
|
||||
{
|
||||
// search backwards for last non-empty entry, then turn back into forwards
|
||||
// iterator (.base() call)
|
||||
return std::find_if_not(mData.rbegin(), mData.rend(),
|
||||
[](const auto& kdata){ return kdata.empty(); }).base();
|
||||
}
|
||||
|
||||
LLSD LLKeyBind::asLLSD() const
|
||||
{
|
||||
S32 last = mData.size() - 1;
|
||||
while (mData[last].empty())
|
||||
{
|
||||
last--;
|
||||
}
|
||||
|
||||
LLSD data;
|
||||
for (S32 i = 0; i <= last; ++i)
|
||||
auto end{ endNonEmpty() };
|
||||
for (auto it = mData.begin(); it < end; ++it)
|
||||
{
|
||||
// append even if empty to not affect visual representation
|
||||
data.append(mData[i].asLLSD());
|
||||
// append intermediate entries even if empty to not affect visual
|
||||
// representation
|
||||
data.append(it->asLLSD());
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
|
@ -380,16 +385,10 @@ void LLKeyBind::resetKeyData(S32 index)
|
|||
|
||||
void LLKeyBind::trimEmpty()
|
||||
{
|
||||
S32 last = mData.size() - 1;
|
||||
while (last >= 0 && mData[last].empty())
|
||||
{
|
||||
mData.erase(mData.begin() + last);
|
||||
last--;
|
||||
}
|
||||
mData.erase(endNonEmpty(), mData.end());
|
||||
}
|
||||
|
||||
U32 LLKeyBind::getDataCount()
|
||||
size_t LLKeyBind::getDataCount()
|
||||
{
|
||||
return mData.size();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -95,11 +95,13 @@ public:
|
|||
void clear() { mData.clear(); }
|
||||
// if there any empty LLKeyData in the end of the array, remove them
|
||||
void trimEmpty();
|
||||
U32 getDataCount();
|
||||
size_t getDataCount();
|
||||
|
||||
private:
|
||||
typedef std::vector<LLKeyData> data_vector_t;
|
||||
data_vector_t mData;
|
||||
|
||||
data_vector_t::const_iterator endNonEmpty() const;
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -231,7 +231,8 @@ public:
|
|||
}
|
||||
|*==========================================================================*/
|
||||
|
||||
LL_DEBUGS("EventHost") << "Sending: " << buffer.tellp() << ':';
|
||||
LL_DEBUGS("EventHost") << "Sending: "
|
||||
<< static_cast<U64>(buffer.tellp()) << ':';
|
||||
std::string::size_type truncate(80);
|
||||
if (buffer.tellp() <= truncate)
|
||||
{
|
||||
|
|
@ -244,7 +245,8 @@ public:
|
|||
LL_CONT << LL_ENDL;
|
||||
|
||||
LLProcess::WritePipe& childin(mChild->getWritePipe(LLProcess::STDIN));
|
||||
childin.get_ostream() << buffer.tellp() << ':' << buffer.str() << std::flush;
|
||||
childin.get_ostream() << static_cast<U64>(buffer.tellp())
|
||||
<< ':' << buffer.str() << std::flush;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -96,10 +96,10 @@ LLMD5::LLMD5()
|
|||
// operation, processing another message block, and updating the
|
||||
// context.
|
||||
|
||||
void LLMD5::update (const uint1 *input, const uint4 input_length) {
|
||||
void LLMD5::update (const uint1 *input, const size_t input_length) {
|
||||
|
||||
uint4 input_index, buffer_index;
|
||||
uint4 buffer_space; // how much space is left in buffer
|
||||
size_t input_index, buffer_index;
|
||||
size_t buffer_space; // how much space is left in buffer
|
||||
|
||||
if (finalized){ // so we can't update!
|
||||
std::cerr << "LLMD5::update: Can't update a finalized digest!" << std::endl;
|
||||
|
|
@ -107,14 +107,10 @@ void LLMD5::update (const uint1 *input, const uint4 input_length) {
|
|||
}
|
||||
|
||||
// Compute number of bytes mod 64
|
||||
buffer_index = (unsigned int)((count[0] >> 3) & 0x3F);
|
||||
buffer_index = size_t((count >> 3) & 0x3F);
|
||||
|
||||
// Update number of bits
|
||||
if ( (count[0] += ((uint4) input_length << 3))<((uint4) input_length << 3) )
|
||||
count[1]++;
|
||||
|
||||
count[1] += ((uint4)input_length >> 29);
|
||||
|
||||
count += input_length << 3;
|
||||
|
||||
buffer_space = 64 - buffer_index; // how much space is left in buffer
|
||||
|
||||
|
|
@ -192,7 +188,7 @@ void LLMD5::update(const std::string& s)
|
|||
void LLMD5::finalize (){
|
||||
|
||||
unsigned char bits[8]; /* Flawfinder: ignore */
|
||||
unsigned int index, padLen;
|
||||
size_t index, padLen;
|
||||
static uint1 PADDING[64]={
|
||||
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
|
|
@ -204,11 +200,12 @@ void LLMD5::finalize (){
|
|||
return;
|
||||
}
|
||||
|
||||
// Save number of bits
|
||||
encode (bits, count, 8);
|
||||
// Save number of bits.
|
||||
// Treat count, a uint64_t, as uint4[2].
|
||||
encode (bits, reinterpret_cast<uint4*>(&count), 8);
|
||||
|
||||
// Pad out to 56 mod 64.
|
||||
index = (uint4) ((count[0] >> 3) & 0x3f);
|
||||
index = size_t((count >> 3) & 0x3f);
|
||||
padLen = (index < 56) ? (56 - index) : (120 - index);
|
||||
update (PADDING, padLen);
|
||||
|
||||
|
|
@ -340,8 +337,7 @@ void LLMD5::init(){
|
|||
finalized=0; // we just started!
|
||||
|
||||
// Nothing counted, so count=0
|
||||
count[0] = 0;
|
||||
count[1] = 0;
|
||||
count = 0;
|
||||
|
||||
// Load magic initialization constants.
|
||||
state[0] = 0x67452301;
|
||||
|
|
@ -508,9 +504,9 @@ void LLMD5::transform (const U8 block[64]){
|
|||
|
||||
// Encodes input (UINT4) into output (unsigned char). Assumes len is
|
||||
// a multiple of 4.
|
||||
void LLMD5::encode (uint1 *output, const uint4 *input, const uint4 len) {
|
||||
void LLMD5::encode (uint1 *output, const uint4 *input, const size_t len) {
|
||||
|
||||
unsigned int i, j;
|
||||
size_t i, j;
|
||||
|
||||
for (i = 0, j = 0; j < len; i++, j += 4) {
|
||||
output[j] = (uint1) (input[i] & 0xff);
|
||||
|
|
@ -525,9 +521,9 @@ void LLMD5::encode (uint1 *output, const uint4 *input, const uint4 len) {
|
|||
|
||||
// Decodes input (unsigned char) into output (UINT4). Assumes len is
|
||||
// a multiple of 4.
|
||||
void LLMD5::decode (uint4 *output, const uint1 *input, const uint4 len){
|
||||
void LLMD5::decode (uint4 *output, const uint1 *input, const size_t len){
|
||||
|
||||
unsigned int i, j;
|
||||
size_t i, j;
|
||||
|
||||
for (i = 0, j = 0; j < len; i++, j += 4)
|
||||
output[i] = ((uint4)input[j]) | (((uint4)input[j+1]) << 8) |
|
||||
|
|
|
|||
|
|
@ -86,7 +86,7 @@ class LL_COMMON_API LLMD5 {
|
|||
public:
|
||||
// methods for controlled operation:
|
||||
LLMD5 (); // simple initializer
|
||||
void update (const uint1 *input, const uint4 input_length);
|
||||
void update (const uint1 *input, const size_t input_length);
|
||||
void update (std::istream& stream);
|
||||
void update (FILE *file);
|
||||
void update (const std::string& str);
|
||||
|
|
@ -110,7 +110,7 @@ private:
|
|||
|
||||
// next, the private data:
|
||||
uint4 state[4];
|
||||
uint4 count[2]; // number of *bits*, mod 2^64
|
||||
uint64_t count; // number of *bits*, mod 2^64
|
||||
uint1 buffer[64]; // input buffer
|
||||
uint1 digest[16];
|
||||
uint1 finalized;
|
||||
|
|
@ -120,8 +120,8 @@ private:
|
|||
void transform (const uint1 *buffer); // does the real update work. Note
|
||||
// that length is implied to be 64.
|
||||
|
||||
static void encode (uint1 *dest, const uint4 *src, const uint4 length);
|
||||
static void decode (uint4 *dest, const uint1 *src, const uint4 length);
|
||||
static void encode (uint1 *dest, const uint4 *src, const size_t length);
|
||||
static void decode (uint4 *dest, const uint1 *src, const size_t length);
|
||||
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -111,8 +111,8 @@ LLSD LLMetricPerformanceTesterBasic::analyzeMetricPerformanceLog(std::istream& i
|
|||
{
|
||||
ret[label]["Name"] = iter->second["Name"] ;
|
||||
|
||||
S32 num_of_metrics = tester->getNumberOfMetrics() ;
|
||||
for(S32 index = 0 ; index < num_of_metrics ; index++)
|
||||
auto num_of_metrics = tester->getNumberOfMetrics() ;
|
||||
for(size_t index = 0 ; index < num_of_metrics ; index++)
|
||||
{
|
||||
ret[label][ tester->getMetricName(index) ] = iter->second[ tester->getMetricName(index) ] ;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -67,12 +67,12 @@ public:
|
|||
/**
|
||||
* @return Returns the number of the test metrics in this tester instance.
|
||||
*/
|
||||
S32 getNumberOfMetrics() const { return mMetricStrings.size() ;}
|
||||
auto getNumberOfMetrics() const { return mMetricStrings.size() ;}
|
||||
/**
|
||||
* @return Returns the metric name at index
|
||||
* @param[in] index - Index on the list of metrics managed by this tester instance.
|
||||
*/
|
||||
std::string getMetricName(S32 index) const { return mMetricStrings[index] ;}
|
||||
std::string getMetricName(size_t index) const { return mMetricStrings[index] ;}
|
||||
|
||||
protected:
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -37,9 +37,9 @@ LLMortician::~LLMortician()
|
|||
sGraveyard.remove(this);
|
||||
}
|
||||
|
||||
U32 LLMortician::logClass(std::stringstream &str)
|
||||
size_t LLMortician::logClass(std::stringstream &str)
|
||||
{
|
||||
U32 size = sGraveyard.size();
|
||||
auto size = sGraveyard.size();
|
||||
str << "Mortician graveyard count: " << size;
|
||||
str << " Zealous: " << (sDestroyImmediate ? "True" : "False");
|
||||
if (size == 0)
|
||||
|
|
|
|||
|
|
@ -34,8 +34,8 @@ class LL_COMMON_API LLMortician
|
|||
{
|
||||
public:
|
||||
LLMortician() { mIsDead = FALSE; }
|
||||
static U32 graveyardCount() { return sGraveyard.size(); };
|
||||
static U32 logClass(std::stringstream &str);
|
||||
static auto graveyardCount() { return sGraveyard.size(); };
|
||||
static size_t logClass(std::stringstream &str);
|
||||
static void updateClass();
|
||||
virtual ~LLMortician();
|
||||
void die();
|
||||
|
|
|
|||
|
|
@ -110,7 +110,7 @@ void LLQueuedThread::shutdown()
|
|||
|
||||
// MAIN THREAD
|
||||
// virtual
|
||||
S32 LLQueuedThread::update(F32 max_time_ms)
|
||||
size_t LLQueuedThread::update(F32 max_time_ms)
|
||||
{
|
||||
if (!mStarted)
|
||||
{
|
||||
|
|
@ -123,11 +123,11 @@ S32 LLQueuedThread::update(F32 max_time_ms)
|
|||
return updateQueue(max_time_ms);
|
||||
}
|
||||
|
||||
S32 LLQueuedThread::updateQueue(F32 max_time_ms)
|
||||
size_t LLQueuedThread::updateQueue(F32 max_time_ms)
|
||||
{
|
||||
F64 max_time = (F64)max_time_ms * .001;
|
||||
LLTimer timer;
|
||||
S32 pending = 1;
|
||||
size_t pending = 1;
|
||||
|
||||
// Frame Update
|
||||
if (mThreaded)
|
||||
|
|
@ -164,9 +164,9 @@ void LLQueuedThread::incQueue()
|
|||
|
||||
//virtual
|
||||
// May be called from any thread
|
||||
S32 LLQueuedThread::getPending()
|
||||
size_t LLQueuedThread::getPending()
|
||||
{
|
||||
S32 res;
|
||||
size_t res;
|
||||
lockData();
|
||||
res = mRequestQueue.size();
|
||||
unlockData();
|
||||
|
|
@ -399,7 +399,7 @@ bool LLQueuedThread::check()
|
|||
//============================================================================
|
||||
// Runs on its OWN thread
|
||||
|
||||
S32 LLQueuedThread::processNextRequest()
|
||||
size_t LLQueuedThread::processNextRequest()
|
||||
{
|
||||
QueuedRequest *req;
|
||||
// Get next request from pool
|
||||
|
|
@ -473,8 +473,7 @@ S32 LLQueuedThread::processNextRequest()
|
|||
LLTrace::get_thread_recorder()->pushToParent();
|
||||
}
|
||||
|
||||
S32 pending = getPending();
|
||||
return pending;
|
||||
return getPending();
|
||||
}
|
||||
|
||||
// virtual
|
||||
|
|
@ -511,7 +510,7 @@ void LLQueuedThread::run()
|
|||
|
||||
threadedUpdate();
|
||||
|
||||
int pending_work = processNextRequest();
|
||||
auto pending_work = processNextRequest();
|
||||
|
||||
if (pending_work == 0)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -167,19 +167,19 @@ private:
|
|||
protected:
|
||||
handle_t generateHandle();
|
||||
bool addRequest(QueuedRequest* req);
|
||||
S32 processNextRequest(void);
|
||||
size_t processNextRequest(void);
|
||||
void incQueue();
|
||||
|
||||
public:
|
||||
bool waitForResult(handle_t handle, bool auto_complete = true);
|
||||
|
||||
virtual S32 update(F32 max_time_ms);
|
||||
S32 updateQueue(F32 max_time_ms);
|
||||
|
||||
virtual size_t update(F32 max_time_ms);
|
||||
size_t updateQueue(F32 max_time_ms);
|
||||
|
||||
void waitOnPending();
|
||||
void printQueueStats();
|
||||
|
||||
virtual S32 getPending();
|
||||
virtual size_t getPending();
|
||||
bool getThreaded() { return mThreaded ? true : false; }
|
||||
|
||||
// Request accessors
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ LLRunner::~LLRunner()
|
|||
mRunEvery.clear();
|
||||
}
|
||||
|
||||
S32 LLRunner::run()
|
||||
size_t LLRunner::run()
|
||||
{
|
||||
// We collect all of the runnables which should be run. Since the
|
||||
// runnables are allowed to adjust the run list, we need to copy
|
||||
|
|
|
|||
|
|
@ -85,7 +85,7 @@ public:
|
|||
*
|
||||
* @return Returns the number of runnables run.
|
||||
*/
|
||||
S32 run();
|
||||
size_t run();
|
||||
|
||||
/**
|
||||
* @brief Add a runnable to the run list.
|
||||
|
|
|
|||
|
|
@ -36,6 +36,18 @@
|
|||
#include "llsdserialize.h"
|
||||
#include "stringize.h"
|
||||
|
||||
#include <limits>
|
||||
|
||||
// Defend against a caller forcibly passing a negative number into an unsigned
|
||||
// size_t index param
|
||||
inline
|
||||
bool was_negative(size_t i)
|
||||
{
|
||||
return (i > std::numeric_limits<int>::max());
|
||||
}
|
||||
#define NEGATIVE_EXIT(i) if (was_negative(i)) return
|
||||
#define NEGATIVE_RETURN(i, result) NEGATIVE_EXIT(i) (result)
|
||||
|
||||
#ifndef LL_RELEASE_FOR_DOWNLOAD
|
||||
#define NAME_UNNAMED_NAMESPACE
|
||||
#endif
|
||||
|
|
@ -136,10 +148,10 @@ public:
|
|||
virtual void erase(const String&) { }
|
||||
virtual const LLSD& ref(const String&) const{ return undef(); }
|
||||
|
||||
virtual int size() const { return 0; }
|
||||
virtual LLSD get(Integer) const { return LLSD(); }
|
||||
virtual void erase(Integer) { }
|
||||
virtual const LLSD& ref(Integer) const { return undef(); }
|
||||
virtual size_t size() const { return 0; }
|
||||
virtual LLSD get(size_t) const { return LLSD(); }
|
||||
virtual void erase(size_t) { }
|
||||
virtual const LLSD& ref(size_t) const { return undef(); }
|
||||
|
||||
virtual LLSD::map_const_iterator beginMap() const { return endMap(); }
|
||||
virtual LLSD::map_const_iterator endMap() const { static const std::map<String, LLSD> empty; return empty.end(); }
|
||||
|
|
@ -272,7 +284,7 @@ namespace
|
|||
virtual LLSD::UUID asUUID() const { return LLUUID(mValue); }
|
||||
virtual LLSD::Date asDate() const { return LLDate(mValue); }
|
||||
virtual LLSD::URI asURI() const { return LLURI(mValue); }
|
||||
virtual int size() const { return mValue.size(); }
|
||||
virtual size_t size() const { return mValue.size(); }
|
||||
virtual const LLSD::String& asStringRef() const { return mValue; }
|
||||
};
|
||||
|
||||
|
|
@ -377,9 +389,9 @@ namespace
|
|||
|
||||
virtual bool has(const LLSD::String&) const;
|
||||
|
||||
using LLSD::Impl::get; // Unhiding get(LLSD::Integer)
|
||||
using LLSD::Impl::erase; // Unhiding erase(LLSD::Integer)
|
||||
using LLSD::Impl::ref; // Unhiding ref(LLSD::Integer)
|
||||
using LLSD::Impl::get; // Unhiding get(size_t)
|
||||
using LLSD::Impl::erase; // Unhiding erase(size_t)
|
||||
using LLSD::Impl::ref; // Unhiding ref(size_t)
|
||||
virtual LLSD get(const LLSD::String&) const;
|
||||
virtual LLSD getKeys() const;
|
||||
void insert(const LLSD::String& k, const LLSD& v);
|
||||
|
|
@ -387,7 +399,7 @@ namespace
|
|||
LLSD& ref(const LLSD::String&);
|
||||
virtual const LLSD& ref(const LLSD::String&) const;
|
||||
|
||||
virtual int size() const { return mData.size(); }
|
||||
virtual size_t size() const { return mData.size(); }
|
||||
|
||||
LLSD::map_iterator beginMap() { return mData.begin(); }
|
||||
LLSD::map_iterator endMap() { return mData.end(); }
|
||||
|
|
@ -518,14 +530,14 @@ namespace
|
|||
using LLSD::Impl::get; // Unhiding get(LLSD::String)
|
||||
using LLSD::Impl::erase; // Unhiding erase(LLSD::String)
|
||||
using LLSD::Impl::ref; // Unhiding ref(LLSD::String)
|
||||
virtual int size() const;
|
||||
virtual LLSD get(LLSD::Integer) const;
|
||||
void set(LLSD::Integer, const LLSD&);
|
||||
void insert(LLSD::Integer, const LLSD&);
|
||||
virtual size_t size() const;
|
||||
virtual LLSD get(size_t) const;
|
||||
void set(size_t, const LLSD&);
|
||||
void insert(size_t, const LLSD&);
|
||||
LLSD& append(const LLSD&);
|
||||
virtual void erase(LLSD::Integer);
|
||||
LLSD& ref(LLSD::Integer);
|
||||
virtual const LLSD& ref(LLSD::Integer) const;
|
||||
virtual void erase(size_t);
|
||||
LLSD& ref(size_t);
|
||||
virtual const LLSD& ref(size_t) const;
|
||||
|
||||
LLSD::array_iterator beginArray() { return mData.begin(); }
|
||||
LLSD::array_iterator endArray() { return mData.end(); }
|
||||
|
|
@ -550,85 +562,82 @@ namespace
|
|||
return *this;
|
||||
}
|
||||
}
|
||||
|
||||
int ImplArray::size() const { return mData.size(); }
|
||||
|
||||
LLSD ImplArray::get(LLSD::Integer i) const
|
||||
|
||||
size_t ImplArray::size() const { return mData.size(); }
|
||||
|
||||
LLSD ImplArray::get(size_t i) const
|
||||
{
|
||||
if (i < 0) { return LLSD(); }
|
||||
NEGATIVE_RETURN(i, LLSD());
|
||||
DataVector::size_type index = i;
|
||||
|
||||
|
||||
return (index < mData.size()) ? mData[index] : LLSD();
|
||||
}
|
||||
|
||||
void ImplArray::set(LLSD::Integer i, const LLSD& v)
|
||||
|
||||
void ImplArray::set(size_t i, const LLSD& v)
|
||||
{
|
||||
if (i < 0) { return; }
|
||||
NEGATIVE_EXIT(i);
|
||||
DataVector::size_type index = i;
|
||||
|
||||
|
||||
if (index >= mData.size())
|
||||
{
|
||||
mData.resize(index + 1);
|
||||
}
|
||||
|
||||
|
||||
mData[index] = v;
|
||||
}
|
||||
|
||||
void ImplArray::insert(LLSD::Integer i, const LLSD& v)
|
||||
|
||||
void ImplArray::insert(size_t i, const LLSD& v)
|
||||
{
|
||||
if (i < 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
NEGATIVE_EXIT(i);
|
||||
DataVector::size_type index = i;
|
||||
|
||||
|
||||
if (index >= mData.size()) // tbd - sanity check limit for index ?
|
||||
{
|
||||
mData.resize(index + 1);
|
||||
}
|
||||
|
||||
|
||||
mData.insert(mData.begin() + index, v);
|
||||
}
|
||||
|
||||
|
||||
LLSD& ImplArray::append(const LLSD& v)
|
||||
{
|
||||
mData.push_back(v);
|
||||
return mData.back();
|
||||
}
|
||||
|
||||
void ImplArray::erase(LLSD::Integer i)
|
||||
|
||||
void ImplArray::erase(size_t i)
|
||||
{
|
||||
if (i < 0) { return; }
|
||||
NEGATIVE_EXIT(i);
|
||||
DataVector::size_type index = i;
|
||||
|
||||
|
||||
if (index < mData.size())
|
||||
{
|
||||
mData.erase(mData.begin() + index);
|
||||
}
|
||||
}
|
||||
|
||||
LLSD& ImplArray::ref(LLSD::Integer i)
|
||||
|
||||
LLSD& ImplArray::ref(size_t i)
|
||||
{
|
||||
DataVector::size_type index = i >= 0 ? i : 0;
|
||||
|
||||
DataVector::size_type index = was_negative(i)? 0 : i;
|
||||
|
||||
if (index >= mData.size())
|
||||
{
|
||||
mData.resize(i + 1);
|
||||
mData.resize(index + 1);
|
||||
}
|
||||
|
||||
|
||||
return mData[index];
|
||||
}
|
||||
|
||||
const LLSD& ImplArray::ref(LLSD::Integer i) const
|
||||
const LLSD& ImplArray::ref(size_t i) const
|
||||
{
|
||||
if (i < 0) { return undef(); }
|
||||
NEGATIVE_RETURN(i, undef());
|
||||
DataVector::size_type index = i;
|
||||
|
||||
|
||||
if (index >= mData.size())
|
||||
{
|
||||
return undef();
|
||||
}
|
||||
|
||||
|
||||
return mData[index];
|
||||
}
|
||||
|
||||
|
|
@ -841,9 +850,6 @@ LLSD::LLSD(const Date& v) : impl(0) { ALLOC_LLSD_OBJECT; assign(v); }
|
|||
LLSD::LLSD(const URI& v) : impl(0) { ALLOC_LLSD_OBJECT; assign(v); }
|
||||
LLSD::LLSD(const Binary& v) : impl(0) { ALLOC_LLSD_OBJECT; assign(v); }
|
||||
|
||||
// Convenience Constructors
|
||||
LLSD::LLSD(F32 v) : impl(0) { ALLOC_LLSD_OBJECT; assign((Real)v); }
|
||||
|
||||
// Scalar Assignment
|
||||
void LLSD::assign(Boolean v) { safe(impl).assign(impl, v); }
|
||||
void LLSD::assign(Integer v) { safe(impl).assign(impl, v); }
|
||||
|
|
@ -912,7 +918,7 @@ LLSD LLSD::emptyArray()
|
|||
return v;
|
||||
}
|
||||
|
||||
int LLSD::size() const { return safe(impl).size(); }
|
||||
size_t LLSD::size() const { return safe(impl).size(); }
|
||||
|
||||
LLSD LLSD::get(Integer i) const { return safe(impl).get(i); }
|
||||
void LLSD::set(Integer i, const LLSD& v){ makeArray(impl).set(i, v); }
|
||||
|
|
@ -926,12 +932,12 @@ LLSD& LLSD::with(Integer i, const LLSD& v)
|
|||
LLSD& LLSD::append(const LLSD& v) { return makeArray(impl).append(v); }
|
||||
void LLSD::erase(Integer i) { makeArray(impl).erase(i); }
|
||||
|
||||
LLSD& LLSD::operator[](Integer i)
|
||||
LLSD& LLSD::operator[](size_t i)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_LLSD;
|
||||
return makeArray(impl).ref(i);
|
||||
}
|
||||
const LLSD& LLSD::operator[](Integer i) const
|
||||
const LLSD& LLSD::operator[](size_t i) const
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_LLSD;
|
||||
return safe(impl).ref(i);
|
||||
|
|
@ -956,7 +962,7 @@ static const char *llsd_dump(const LLSD &llsd, bool useXMLFormat)
|
|||
out << LLSDNotationStreamer(llsd);
|
||||
out_string = out.str();
|
||||
}
|
||||
int len = out_string.length();
|
||||
auto len = out_string.length();
|
||||
sStorage = new char[len + 1];
|
||||
memcpy(sStorage, out_string.c_str(), len);
|
||||
sStorage[len] = '\0';
|
||||
|
|
|
|||
|
|
@ -192,7 +192,17 @@ public:
|
|||
|
||||
/** @name Convenience Constructors */
|
||||
//@{
|
||||
LLSD(F32); // F32 -> Real
|
||||
// support construction from size_t et al.
|
||||
template <typename VALUE,
|
||||
typename std::enable_if<std::is_integral<VALUE>::value &&
|
||||
! std::is_same<VALUE, Boolean>::value,
|
||||
bool>::type = true>
|
||||
LLSD(VALUE v): LLSD(Integer(narrow(v))) {}
|
||||
// support construction from F32 et al.
|
||||
template <typename VALUE,
|
||||
typename std::enable_if<std::is_floating_point<VALUE>::value,
|
||||
bool>::type = true>
|
||||
LLSD(VALUE v): LLSD(Real(narrow(v))) {}
|
||||
//@}
|
||||
|
||||
/** @name Scalar Assignment */
|
||||
|
|
@ -275,7 +285,7 @@ public:
|
|||
//@{
|
||||
LLSD(const char*);
|
||||
void assign(const char*);
|
||||
LLSD& operator=(const char* v) { assign(v); return *this; }
|
||||
LLSD& operator=(const char* v) { assign(v); return *this; }
|
||||
//@}
|
||||
|
||||
/** @name Map Values */
|
||||
|
|
@ -313,14 +323,24 @@ public:
|
|||
LLSD& append(const LLSD&);
|
||||
void erase(Integer);
|
||||
LLSD& with(Integer, const LLSD&);
|
||||
|
||||
const LLSD& operator[](Integer) const;
|
||||
LLSD& operator[](Integer);
|
||||
|
||||
// accept size_t so we can index relative to size()
|
||||
const LLSD& operator[](size_t) const;
|
||||
LLSD& operator[](size_t);
|
||||
// template overloads to support int literals, U32 et al.
|
||||
template <typename IDX,
|
||||
typename std::enable_if<std::is_convertible<IDX, size_t>::value,
|
||||
bool>::type = true>
|
||||
const LLSD& operator[](IDX i) const { return (*this)[size_t(i)]; }
|
||||
template <typename IDX,
|
||||
typename std::enable_if<std::is_convertible<IDX, size_t>::value,
|
||||
bool>::type = true>
|
||||
LLSD& operator[](IDX i) { return (*this)[size_t(i)]; }
|
||||
//@}
|
||||
|
||||
/** @name Iterators */
|
||||
//@{
|
||||
int size() const;
|
||||
size_t size() const;
|
||||
|
||||
typedef std::map<String, LLSD>::iterator map_iterator;
|
||||
typedef std::map<String, LLSD>::const_iterator map_const_iterator;
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@
|
|||
#include "lluri.h"
|
||||
|
||||
// File constants
|
||||
static const int MAX_HDR_LEN = 20;
|
||||
static const size_t MAX_HDR_LEN = 20;
|
||||
static const S32 UNZIP_LLSD_MAX_DEPTH = 96;
|
||||
static const char LEGACY_NON_HEADER[] = "<llsd>";
|
||||
const std::string LLSD_BINARY_HEADER("LLSD/Binary");
|
||||
|
|
@ -99,7 +99,7 @@ void LLSDSerialize::serialize(const LLSD& sd, std::ostream& str, ELLSD_Serialize
|
|||
}
|
||||
|
||||
// static
|
||||
bool LLSDSerialize::deserialize(LLSD& sd, std::istream& str, S32 max_bytes)
|
||||
bool LLSDSerialize::deserialize(LLSD& sd, std::istream& str, llssize max_bytes)
|
||||
{
|
||||
LLPointer<LLSDParser> p = NULL;
|
||||
char hdr_buf[MAX_HDR_LEN + 1] = ""; /* Flawfinder: ignore */
|
||||
|
|
@ -252,7 +252,7 @@ F64 ll_ntohd(F64 netdouble)
|
|||
* @return Returns number of bytes read off of the stream. Returns
|
||||
* PARSE_FAILURE (-1) on failure.
|
||||
*/
|
||||
int deserialize_string(std::istream& istr, std::string& value, S32 max_bytes);
|
||||
llssize deserialize_string(std::istream& istr, std::string& value, llssize max_bytes);
|
||||
|
||||
/**
|
||||
* @brief Parse a delimited string.
|
||||
|
|
@ -263,7 +263,7 @@ int deserialize_string(std::istream& istr, std::string& value, S32 max_bytes);
|
|||
* @return Returns number of bytes read off of the stream. Returns
|
||||
* PARSE_FAILURE (-1) on failure.
|
||||
*/
|
||||
int deserialize_string_delim(std::istream& istr, std::string& value, char d);
|
||||
llssize deserialize_string_delim(std::istream& istr, std::string& value, char d);
|
||||
|
||||
/**
|
||||
* @brief Read a raw string off the stream.
|
||||
|
|
@ -277,10 +277,10 @@ int deserialize_string_delim(std::istream& istr, std::string& value, char d);
|
|||
* @return Returns number of bytes read off of the stream. Returns
|
||||
* PARSE_FAILURE (-1) on failure.
|
||||
*/
|
||||
int deserialize_string_raw(
|
||||
llssize deserialize_string_raw(
|
||||
std::istream& istr,
|
||||
std::string& value,
|
||||
S32 max_bytes);
|
||||
llssize max_bytes);
|
||||
|
||||
/**
|
||||
* @brief helper method for dealing with the different notation boolean format.
|
||||
|
|
@ -292,7 +292,7 @@ int deserialize_string_raw(
|
|||
* @return Returns number of bytes read off of the stream. Returns
|
||||
* PARSE_FAILURE (-1) on failure.
|
||||
*/
|
||||
int deserialize_boolean(
|
||||
llssize deserialize_boolean(
|
||||
std::istream& istr,
|
||||
LLSD& data,
|
||||
const std::string& compare,
|
||||
|
|
@ -329,7 +329,7 @@ LLSDParser::LLSDParser()
|
|||
LLSDParser::~LLSDParser()
|
||||
{ }
|
||||
|
||||
S32 LLSDParser::parse(std::istream& istr, LLSD& data, S32 max_bytes, S32 max_depth)
|
||||
S32 LLSDParser::parse(std::istream& istr, LLSD& data, llssize max_bytes, S32 max_depth)
|
||||
{
|
||||
mCheckLimits = (LLSDSerialize::SIZE_UNLIMITED == max_bytes) ? false : true;
|
||||
mMaxBytesLeft = max_bytes;
|
||||
|
|
@ -359,7 +359,7 @@ std::istream& LLSDParser::get(
|
|||
char delim) const
|
||||
{
|
||||
istr.get(s, n, delim);
|
||||
if(mCheckLimits) mMaxBytesLeft -= (int)istr.gcount();
|
||||
if(mCheckLimits) mMaxBytesLeft -= istr.gcount();
|
||||
return istr;
|
||||
}
|
||||
|
||||
|
|
@ -369,7 +369,7 @@ std::istream& LLSDParser::get(
|
|||
char delim) const
|
||||
{
|
||||
istr.get(sb, delim);
|
||||
if(mCheckLimits) mMaxBytesLeft -= (int)istr.gcount();
|
||||
if(mCheckLimits) mMaxBytesLeft -= istr.gcount();
|
||||
return istr;
|
||||
}
|
||||
|
||||
|
|
@ -393,11 +393,11 @@ std::istream& LLSDParser::read(
|
|||
std::streamsize n) const
|
||||
{
|
||||
istr.read(s, n);
|
||||
if(mCheckLimits) mMaxBytesLeft -= (int)istr.gcount();
|
||||
if(mCheckLimits) mMaxBytesLeft -= istr.gcount();
|
||||
return istr;
|
||||
}
|
||||
|
||||
void LLSDParser::account(S32 bytes) const
|
||||
void LLSDParser::account(llssize bytes) const
|
||||
{
|
||||
if(mCheckLimits) mMaxBytesLeft -= bytes;
|
||||
}
|
||||
|
|
@ -502,7 +502,7 @@ S32 LLSDNotationParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) c
|
|||
c = istr.peek();
|
||||
if(isalpha(c))
|
||||
{
|
||||
int cnt = deserialize_boolean(
|
||||
auto cnt = deserialize_boolean(
|
||||
istr,
|
||||
data,
|
||||
NOTATION_FALSE_SERIAL,
|
||||
|
|
@ -532,7 +532,7 @@ S32 LLSDNotationParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) c
|
|||
c = istr.peek();
|
||||
if(isalpha(c))
|
||||
{
|
||||
int cnt = deserialize_boolean(istr,data,NOTATION_TRUE_SERIAL,true);
|
||||
auto cnt = deserialize_boolean(istr,data,NOTATION_TRUE_SERIAL,true);
|
||||
if(PARSE_FAILURE == cnt) parse_count = cnt;
|
||||
else account(cnt);
|
||||
}
|
||||
|
|
@ -608,7 +608,7 @@ S32 LLSDNotationParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) c
|
|||
c = get(istr); // pop the 'l'
|
||||
c = get(istr); // pop the delimiter
|
||||
std::string str;
|
||||
int cnt = deserialize_string_delim(istr, str, c);
|
||||
auto cnt = deserialize_string_delim(istr, str, c);
|
||||
if(PARSE_FAILURE == cnt)
|
||||
{
|
||||
parse_count = PARSE_FAILURE;
|
||||
|
|
@ -631,7 +631,7 @@ S32 LLSDNotationParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) c
|
|||
c = get(istr); // pop the 'd'
|
||||
c = get(istr); // pop the delimiter
|
||||
std::string str;
|
||||
int cnt = deserialize_string_delim(istr, str, c);
|
||||
auto cnt = deserialize_string_delim(istr, str, c);
|
||||
if(PARSE_FAILURE == cnt)
|
||||
{
|
||||
parse_count = PARSE_FAILURE;
|
||||
|
|
@ -663,7 +663,7 @@ S32 LLSDNotationParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) c
|
|||
|
||||
default:
|
||||
parse_count = PARSE_FAILURE;
|
||||
LL_INFOS() << "Unrecognized character while parsing: int(" << (int)c
|
||||
LL_INFOS() << "Unrecognized character while parsing: int(" << int(c)
|
||||
<< ")" << LL_ENDL;
|
||||
break;
|
||||
}
|
||||
|
|
@ -694,7 +694,7 @@ S32 LLSDNotationParser::parseMap(std::istream& istr, LLSD& map, S32 max_depth) c
|
|||
{
|
||||
putback(istr, c);
|
||||
found_name = true;
|
||||
int count = deserialize_string(istr, name, mMaxBytesLeft);
|
||||
auto count = deserialize_string(istr, name, mMaxBytesLeft);
|
||||
if(PARSE_FAILURE == count) return PARSE_FAILURE;
|
||||
account(count);
|
||||
}
|
||||
|
|
@ -776,7 +776,7 @@ S32 LLSDNotationParser::parseArray(std::istream& istr, LLSD& array, S32 max_dept
|
|||
bool LLSDNotationParser::parseString(std::istream& istr, LLSD& data) const
|
||||
{
|
||||
std::string value;
|
||||
int count = deserialize_string(istr, value, mMaxBytesLeft);
|
||||
auto count = deserialize_string(istr, value, mMaxBytesLeft);
|
||||
if(PARSE_FAILURE == count) return false;
|
||||
account(count);
|
||||
data = value;
|
||||
|
|
@ -803,13 +803,13 @@ bool LLSDNotationParser::parseBinary(std::istream& istr, LLSD& data) const
|
|||
{
|
||||
// We probably have a valid raw binary stream. determine
|
||||
// the size, and read it.
|
||||
S32 len = strtol(buf + 2, NULL, 0);
|
||||
auto len = strtol(buf + 2, NULL, 0);
|
||||
if(mCheckLimits && (len > mMaxBytesLeft)) return false;
|
||||
std::vector<U8> value;
|
||||
if(len)
|
||||
{
|
||||
value.resize(len);
|
||||
account((int)fullread(istr, (char *)&value[0], len));
|
||||
account(fullread(istr, (char *)&value[0], len));
|
||||
}
|
||||
c = get(istr); // strip off the trailing double-quote
|
||||
data = value;
|
||||
|
|
@ -1006,7 +1006,7 @@ S32 LLSDBinaryParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) con
|
|||
case '"':
|
||||
{
|
||||
std::string value;
|
||||
int cnt = deserialize_string_delim(istr, value, c);
|
||||
auto cnt = deserialize_string_delim(istr, value, c);
|
||||
if(PARSE_FAILURE == cnt)
|
||||
{
|
||||
parse_count = PARSE_FAILURE;
|
||||
|
|
@ -1093,7 +1093,7 @@ S32 LLSDBinaryParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) con
|
|||
if(size > 0)
|
||||
{
|
||||
value.resize(size);
|
||||
account((int)fullread(istr, (char*)&value[0], size));
|
||||
account(fullread(istr, (char*)&value[0], size));
|
||||
}
|
||||
data = value;
|
||||
}
|
||||
|
|
@ -1107,7 +1107,7 @@ S32 LLSDBinaryParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) con
|
|||
|
||||
default:
|
||||
parse_count = PARSE_FAILURE;
|
||||
LL_INFOS() << "Unrecognized character while parsing: int(" << (int)c
|
||||
LL_INFOS() << "Unrecognized character while parsing: int(" << int(c)
|
||||
<< ")" << LL_ENDL;
|
||||
break;
|
||||
}
|
||||
|
|
@ -1141,7 +1141,7 @@ S32 LLSDBinaryParser::parseMap(std::istream& istr, LLSD& map, S32 max_depth) con
|
|||
case '\'':
|
||||
case '"':
|
||||
{
|
||||
int cnt = deserialize_string_delim(istr, name, c);
|
||||
auto cnt = deserialize_string_delim(istr, name, c);
|
||||
if(PARSE_FAILURE == cnt) return PARSE_FAILURE;
|
||||
account(cnt);
|
||||
break;
|
||||
|
|
@ -1225,7 +1225,7 @@ bool LLSDBinaryParser::parseString(
|
|||
if(size)
|
||||
{
|
||||
buf.resize(size);
|
||||
account((int)fullread(istr, &buf[0], size));
|
||||
account(fullread(istr, &buf[0], size));
|
||||
value.assign(buf.begin(), buf.end());
|
||||
}
|
||||
return true;
|
||||
|
|
@ -1429,7 +1429,7 @@ S32 LLSDNotationFormatter::format_impl(const LLSD& data, std::ostream& ostr,
|
|||
ostr << std::uppercase;
|
||||
auto oldfill(ostr.fill('0'));
|
||||
auto oldwidth(ostr.width());
|
||||
for (int i = 0; i < buffer.size(); i++)
|
||||
for (size_t i = 0; i < buffer.size(); i++)
|
||||
{
|
||||
// have to restate setw() before every conversion
|
||||
ostr << std::setw(2) << (int) buffer[i];
|
||||
|
|
@ -1592,7 +1592,7 @@ void LLSDBinaryFormatter::formatString(
|
|||
/**
|
||||
* local functions
|
||||
*/
|
||||
int deserialize_string(std::istream& istr, std::string& value, S32 max_bytes)
|
||||
llssize deserialize_string(std::istream& istr, std::string& value, llssize max_bytes)
|
||||
{
|
||||
int c = istr.get();
|
||||
if(istr.fail())
|
||||
|
|
@ -1602,7 +1602,7 @@ int deserialize_string(std::istream& istr, std::string& value, S32 max_bytes)
|
|||
return LLSDParser::PARSE_FAILURE;
|
||||
}
|
||||
|
||||
int rv = LLSDParser::PARSE_FAILURE;
|
||||
llssize rv = LLSDParser::PARSE_FAILURE;
|
||||
switch(c)
|
||||
{
|
||||
case '\'':
|
||||
|
|
@ -1622,7 +1622,7 @@ int deserialize_string(std::istream& istr, std::string& value, S32 max_bytes)
|
|||
return rv + 1; // account for the character grabbed at the top.
|
||||
}
|
||||
|
||||
int deserialize_string_delim(
|
||||
llssize deserialize_string_delim(
|
||||
std::istream& istr,
|
||||
std::string& value,
|
||||
char delim)
|
||||
|
|
@ -1632,7 +1632,7 @@ int deserialize_string_delim(
|
|||
bool found_hex = false;
|
||||
bool found_digit = false;
|
||||
U8 byte = 0;
|
||||
int count = 0;
|
||||
llssize count = 0;
|
||||
|
||||
while (true)
|
||||
{
|
||||
|
|
@ -1647,7 +1647,7 @@ int deserialize_string_delim(
|
|||
}
|
||||
|
||||
char next_char = (char)next_byte; // Now that we know it's not EOF
|
||||
|
||||
|
||||
if(found_escape)
|
||||
{
|
||||
// next character(s) is a special sequence.
|
||||
|
|
@ -1725,16 +1725,16 @@ int deserialize_string_delim(
|
|||
return count;
|
||||
}
|
||||
|
||||
int deserialize_string_raw(
|
||||
llssize deserialize_string_raw(
|
||||
std::istream& istr,
|
||||
std::string& value,
|
||||
S32 max_bytes)
|
||||
llssize max_bytes)
|
||||
{
|
||||
int count = 0;
|
||||
llssize count = 0;
|
||||
const S32 BUF_LEN = 20;
|
||||
char buf[BUF_LEN]; /* Flawfinder: ignore */
|
||||
istr.get(buf, BUF_LEN - 1, ')');
|
||||
count += (int)istr.gcount();
|
||||
count += istr.gcount();
|
||||
int c = istr.get();
|
||||
c = istr.get();
|
||||
count += 2;
|
||||
|
|
@ -1743,13 +1743,13 @@ int deserialize_string_raw(
|
|||
// We probably have a valid raw string. determine
|
||||
// the size, and read it.
|
||||
// *FIX: This is memory inefficient.
|
||||
S32 len = strtol(buf + 1, NULL, 0);
|
||||
auto len = strtol(buf + 1, NULL, 0);
|
||||
if((max_bytes>0)&&(len>max_bytes)) return LLSDParser::PARSE_FAILURE;
|
||||
std::vector<char> buf;
|
||||
if(len)
|
||||
{
|
||||
buf.resize(len);
|
||||
count += (int)fullread(istr, (char *)&buf[0], len);
|
||||
count += fullread(istr, (char *)&buf[0], len);
|
||||
value.assign(buf.begin(), buf.end());
|
||||
}
|
||||
c = istr.get();
|
||||
|
|
@ -2038,7 +2038,7 @@ void serialize_string(const std::string& value, std::ostream& str)
|
|||
}
|
||||
}
|
||||
|
||||
int deserialize_boolean(
|
||||
llssize deserialize_boolean(
|
||||
std::istream& istr,
|
||||
LLSD& data,
|
||||
const std::string& compare,
|
||||
|
|
@ -2055,7 +2055,7 @@ int deserialize_boolean(
|
|||
// * set data to LLSD::null
|
||||
// * return LLSDParser::PARSE_FAILURE (-1)
|
||||
//
|
||||
int bytes_read = 0;
|
||||
llssize bytes_read = 0;
|
||||
std::string::size_type ii = 0;
|
||||
char c = istr.peek();
|
||||
while((++ii < compare.size())
|
||||
|
|
@ -2110,7 +2110,7 @@ std::string zip_llsd(LLSD& data)
|
|||
|
||||
U8 out[CHUNK];
|
||||
|
||||
strm.avail_in = source.size();
|
||||
strm.avail_in = narrow(source.size());
|
||||
strm.next_in = (U8*) source.data();
|
||||
U8* output = NULL;
|
||||
|
||||
|
|
@ -2173,7 +2173,7 @@ std::string zip_llsd(LLSD& data)
|
|||
LLUZipHelper::EZipRresult LLUZipHelper::unzip_llsd(LLSD& data, std::istream& is, S32 size)
|
||||
{
|
||||
U8* result = NULL;
|
||||
U32 cur_size = 0;
|
||||
llssize cur_size = 0;
|
||||
z_stream strm;
|
||||
|
||||
const U32 CHUNK = 65536;
|
||||
|
|
@ -2294,7 +2294,7 @@ LLUZipHelper::EZipRresult LLUZipHelper::unzip_llsd(LLSD& data, std::istream& is,
|
|||
//This unzip function will only work with a gzip header and trailer - while the contents
|
||||
//of the actual compressed data is the same for either format (gzip vs zlib ), the headers
|
||||
//and trailers are different for the formats.
|
||||
U8* unzip_llsdNavMesh( bool& valid, unsigned int& outsize, std::istream& is, S32 size )
|
||||
U8* unzip_llsdNavMesh( bool& valid, size_t& outsize, std::istream& is, S32 size )
|
||||
{
|
||||
if (size == 0)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -77,7 +77,7 @@ public:
|
|||
* @return Returns the number of LLSD objects parsed into
|
||||
* data. Returns PARSE_FAILURE (-1) on parse failure.
|
||||
*/
|
||||
S32 parse(std::istream& istr, LLSD& data, S32 max_bytes, S32 max_depth = -1);
|
||||
S32 parse(std::istream& istr, LLSD& data, llssize max_bytes, S32 max_depth = -1);
|
||||
|
||||
/** Like parse(), but uses a different call (istream.getline()) to read by lines
|
||||
* This API is better suited for XML, where the parse cannot tell
|
||||
|
|
@ -194,7 +194,7 @@ protected:
|
|||
* Conceptually const since it only modifies mutable members.
|
||||
* @param bytes The number of bytes read.
|
||||
*/
|
||||
void account(S32 bytes) const;
|
||||
void account(llssize bytes) const;
|
||||
|
||||
protected:
|
||||
/**
|
||||
|
|
@ -205,7 +205,7 @@ protected:
|
|||
/**
|
||||
* @brief The maximum number of bytes left to be parsed.
|
||||
*/
|
||||
mutable S32 mMaxBytesLeft;
|
||||
mutable llssize mMaxBytesLeft;
|
||||
|
||||
/**
|
||||
* @brief Use line-based reading to get text
|
||||
|
|
@ -336,7 +336,7 @@ private:
|
|||
class Impl;
|
||||
Impl& impl;
|
||||
|
||||
void parsePart(const char* buf, int len);
|
||||
void parsePart(const char* buf, llssize len);
|
||||
friend class LLSDSerialize;
|
||||
};
|
||||
|
||||
|
|
@ -756,7 +756,7 @@ public:
|
|||
* @param max_bytes the maximum number of bytes to parse
|
||||
* @return Returns true if the stream appears to contain valid data
|
||||
*/
|
||||
static bool deserialize(LLSD& sd, std::istream& str, S32 max_bytes);
|
||||
static bool deserialize(LLSD& sd, std::istream& str, llssize max_bytes);
|
||||
|
||||
/*
|
||||
* Notation Methods
|
||||
|
|
@ -778,12 +778,12 @@ public:
|
|||
LLSDFormatter::EFormatterOptions(LLSDFormatter::OPTIONS_PRETTY |
|
||||
LLSDFormatter::OPTIONS_PRETTY_BINARY));
|
||||
}
|
||||
static S32 fromNotation(LLSD& sd, std::istream& str, S32 max_bytes)
|
||||
static S32 fromNotation(LLSD& sd, std::istream& str, llssize max_bytes)
|
||||
{
|
||||
LLPointer<LLSDNotationParser> p = new LLSDNotationParser;
|
||||
return p->parse(str, sd, max_bytes);
|
||||
}
|
||||
static LLSD fromNotation(std::istream& str, S32 max_bytes)
|
||||
static LLSD fromNotation(std::istream& str, llssize max_bytes)
|
||||
{
|
||||
LLPointer<LLSDNotationParser> p = new LLSDNotationParser;
|
||||
LLSD sd;
|
||||
|
|
@ -834,12 +834,12 @@ public:
|
|||
LLPointer<LLSDBinaryFormatter> f = new LLSDBinaryFormatter;
|
||||
return f->format(sd, str, LLSDFormatter::OPTIONS_NONE);
|
||||
}
|
||||
static S32 fromBinary(LLSD& sd, std::istream& str, S32 max_bytes, S32 max_depth = -1)
|
||||
static S32 fromBinary(LLSD& sd, std::istream& str, llssize max_bytes, S32 max_depth = -1)
|
||||
{
|
||||
LLPointer<LLSDBinaryParser> p = new LLSDBinaryParser;
|
||||
return p->parse(str, sd, max_bytes, max_depth);
|
||||
}
|
||||
static LLSD fromBinary(std::istream& str, S32 max_bytes, S32 max_depth = -1)
|
||||
static LLSD fromBinary(std::istream& str, llssize max_bytes, S32 max_depth = -1)
|
||||
{
|
||||
LLPointer<LLSDBinaryParser> p = new LLSDBinaryParser;
|
||||
LLSD sd;
|
||||
|
|
@ -867,5 +867,5 @@ public:
|
|||
LL_COMMON_API std::string zip_llsd(LLSD& data);
|
||||
|
||||
|
||||
LL_COMMON_API U8* unzip_llsdNavMesh( bool& valid, unsigned int& outsize,std::istream& is, S32 size);
|
||||
LL_COMMON_API U8* unzip_llsdNavMesh( bool& valid, size_t& outsize,std::istream& is, S32 size);
|
||||
#endif // LL_LLSDSERIALIZE_H
|
||||
|
|
|
|||
|
|
@ -196,12 +196,12 @@ S32 LLSDXMLFormatter::format_impl(const LLSD& data, std::ostream& ostr,
|
|||
// *FIX: memory inefficient.
|
||||
// *TODO: convert to use LLBase64
|
||||
ostr << pre << "<binary encoding=\"base64\">";
|
||||
int b64_buffer_length = apr_base64_encode_len(buffer.size());
|
||||
int b64_buffer_length = apr_base64_encode_len(narrow(buffer.size()));
|
||||
char* b64_buffer = new char[b64_buffer_length];
|
||||
b64_buffer_length = apr_base64_encode_binary(
|
||||
b64_buffer,
|
||||
&buffer[0],
|
||||
buffer.size());
|
||||
narrow(buffer.size()));
|
||||
ostr.write(b64_buffer, b64_buffer_length - 1);
|
||||
delete[] b64_buffer;
|
||||
ostr << "</binary>" << post;
|
||||
|
|
@ -260,7 +260,7 @@ public:
|
|||
S32 parse(std::istream& input, LLSD& data);
|
||||
S32 parseLines(std::istream& input, LLSD& data);
|
||||
|
||||
void parsePart(const char *buf, int len);
|
||||
void parsePart(const char *buf, llssize len);
|
||||
|
||||
void reset();
|
||||
|
||||
|
|
@ -542,7 +542,7 @@ LLSDXMLParser::Impl::findAttribute(const XML_Char* name, const XML_Char** pairs)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
void LLSDXMLParser::Impl::parsePart(const char* buf, int len)
|
||||
void LLSDXMLParser::Impl::parsePart(const char* buf, llssize len)
|
||||
{
|
||||
if ( buf != NULL
|
||||
&& len > 0 )
|
||||
|
|
@ -915,7 +915,7 @@ LLSDXMLParser::~LLSDXMLParser()
|
|||
delete &impl;
|
||||
}
|
||||
|
||||
void LLSDXMLParser::parsePart(const char *buf, int len)
|
||||
void LLSDXMLParser::parsePart(const char *buf, llssize len)
|
||||
{
|
||||
impl.parsePart(buf, len);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -118,7 +118,7 @@ bool skip_to_next_word(std::istream& input_stream)
|
|||
|
||||
bool skip_to_end_of_next_keyword(const char* keyword, std::istream& input_stream)
|
||||
{
|
||||
int key_length = strlen(keyword); /*Flawfinder: ignore*/
|
||||
auto key_length = strlen(keyword); /*Flawfinder: ignore*/
|
||||
if (0 == key_length)
|
||||
{
|
||||
return false;
|
||||
|
|
@ -315,7 +315,7 @@ bool unget_line(const std::string& line, std::istream& input_stream)
|
|||
// returns true if removed last char
|
||||
bool remove_last_char(char c, std::string& line)
|
||||
{
|
||||
int line_size = line.size();
|
||||
auto line_size = line.size();
|
||||
if (line_size > 1
|
||||
&& c == line[line_size - 1])
|
||||
{
|
||||
|
|
@ -330,9 +330,8 @@ bool remove_last_char(char c, std::string& line)
|
|||
// "\\n" ---> '\n' (backslash n becomes carriage return)
|
||||
void unescape_string(std::string& line)
|
||||
{
|
||||
int line_size = line.size();
|
||||
int index = 0;
|
||||
while (index < line_size - 1)
|
||||
auto line_size = line.size();
|
||||
for (size_t index = 0; line_size >= 1 && index < line_size - 1; ++index)
|
||||
{
|
||||
if ('\\' == line[index])
|
||||
{
|
||||
|
|
@ -347,7 +346,6 @@ void unescape_string(std::string& line)
|
|||
line_size--;
|
||||
}
|
||||
}
|
||||
index++;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -356,9 +354,8 @@ void unescape_string(std::string& line)
|
|||
// '\n' ---> "\\n" (carriage return becomes backslash n)
|
||||
void escape_string(std::string& line)
|
||||
{
|
||||
int line_size = line.size();
|
||||
int index = 0;
|
||||
while (index < line_size)
|
||||
auto line_size = line.size();
|
||||
for (size_t index = 0; index < line_size; ++index)
|
||||
{
|
||||
if ('\\' == line[index])
|
||||
{
|
||||
|
|
@ -372,31 +369,27 @@ void escape_string(std::string& line)
|
|||
line_size++;
|
||||
index++;
|
||||
}
|
||||
index++;
|
||||
}
|
||||
}
|
||||
|
||||
// removes '\n' characters
|
||||
void replace_newlines_with_whitespace(std::string& line)
|
||||
{
|
||||
int line_size = line.size();
|
||||
int index = 0;
|
||||
while (index < line_size)
|
||||
auto line_size = line.size();
|
||||
for (size_t index = 0; index < line_size; ++index)
|
||||
{
|
||||
if ('\n' == line[index])
|
||||
{
|
||||
line.replace(index, 1, " ");
|
||||
}
|
||||
index++;
|
||||
}
|
||||
}
|
||||
|
||||
// erases any double-quote characters in 'line'
|
||||
void remove_double_quotes(std::string& line)
|
||||
{
|
||||
int index = 0;
|
||||
int line_size = line.size();
|
||||
while (index < line_size)
|
||||
auto line_size = line.size();
|
||||
for (size_t index = 0; index < line_size; )
|
||||
{
|
||||
if ('"' == line[index])
|
||||
{
|
||||
|
|
@ -424,22 +417,21 @@ void get_keyword_and_value(std::string& keyword,
|
|||
const std::string& line)
|
||||
{
|
||||
// skip initial whitespace
|
||||
int line_size = line.size();
|
||||
int line_index = 0;
|
||||
auto line_size = line.size();
|
||||
size_t line_index = 0;
|
||||
char c;
|
||||
while (line_index < line_size)
|
||||
for ( ; line_index < line_size; ++line_index)
|
||||
{
|
||||
c = line[line_index];
|
||||
if (!LLStringOps::isSpace(c))
|
||||
{
|
||||
break;
|
||||
}
|
||||
line_index++;
|
||||
}
|
||||
|
||||
// get the keyword
|
||||
keyword.clear();
|
||||
while (line_index < line_size)
|
||||
for ( ; line_index < line_size; ++line_index)
|
||||
{
|
||||
c = line[line_index];
|
||||
if (LLStringOps::isSpace(c) || '\r' == c || '\n' == c)
|
||||
|
|
@ -447,7 +439,6 @@ void get_keyword_and_value(std::string& keyword,
|
|||
break;
|
||||
}
|
||||
keyword += c;
|
||||
line_index++;
|
||||
}
|
||||
|
||||
// get the value
|
||||
|
|
@ -465,7 +456,7 @@ void get_keyword_and_value(std::string& keyword,
|
|||
line_index++;
|
||||
}
|
||||
|
||||
while (line_index < line_size)
|
||||
for ( ; line_index < line_size; ++line_index)
|
||||
{
|
||||
c = line[line_index];
|
||||
if ('\r' == c || '\n' == c)
|
||||
|
|
@ -473,7 +464,6 @@ void get_keyword_and_value(std::string& keyword,
|
|||
break;
|
||||
}
|
||||
value += c;
|
||||
line_index++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -142,7 +142,7 @@ std::string rawstr_to_utf8(const std::string& raw)
|
|||
return wstring_to_utf8str(wstr);
|
||||
}
|
||||
|
||||
S32 wchar_to_utf8chars(llwchar in_char, char* outchars)
|
||||
std::ptrdiff_t wchar_to_utf8chars(llwchar in_char, char* outchars)
|
||||
{
|
||||
U32 cur_char = (U32)in_char;
|
||||
char* base = outchars;
|
||||
|
|
@ -193,7 +193,7 @@ S32 wchar_to_utf8chars(llwchar in_char, char* outchars)
|
|||
return outchars - base;
|
||||
}
|
||||
|
||||
S32 utf16chars_to_wchar(const U16* inchars, llwchar* outchar)
|
||||
auto utf16chars_to_wchar(const U16* inchars, llwchar* outchar)
|
||||
{
|
||||
const U16* base = inchars;
|
||||
U16 cur_char = *inchars++;
|
||||
|
|
@ -311,7 +311,7 @@ S32 wstring_utf16_length(const LLWString &wstr, const S32 woffset, const S32 wle
|
|||
// and whose equivalent utf-16 string does not exceeds the given utf16_length.
|
||||
S32 wstring_wstring_length_from_utf16_length(const LLWString & wstr, const S32 woffset, const S32 utf16_length, BOOL *unaligned)
|
||||
{
|
||||
const S32 end = wstr.length();
|
||||
const auto end = wstr.length();
|
||||
BOOL u = FALSE;
|
||||
S32 n = woffset + utf16_length;
|
||||
S32 i = woffset;
|
||||
|
|
@ -427,7 +427,7 @@ LLWString utf8str_to_wstring(const char* utf8str, size_t len)
|
|||
}
|
||||
|
||||
// Check that this character doesn't go past the end of the string
|
||||
S32 end = (len < (i + cont_bytes)) ? len : (i + cont_bytes);
|
||||
auto end = (len < (i + cont_bytes)) ? len : (i + cont_bytes);
|
||||
do
|
||||
{
|
||||
++i;
|
||||
|
|
@ -472,7 +472,7 @@ std::string wstring_to_utf8str(const llwchar* utf32str, size_t len)
|
|||
while (i < len)
|
||||
{
|
||||
char tchars[8]; /* Flawfinder: ignore */
|
||||
S32 n = wchar_to_utf8chars(utf32str[i], tchars);
|
||||
auto n = wchar_to_utf8chars(utf32str[i], tchars);
|
||||
tchars[n] = 0;
|
||||
out += tchars;
|
||||
i++;
|
||||
|
|
|
|||
|
|
@ -666,7 +666,7 @@ ll_convert_forms(ll_convert_alias, LLWString, std::string, utf8str_to_
|
|||
// Same function, better name. JC
|
||||
inline LLWString utf8string_to_wstring(const std::string& utf8_string) { return utf8str_to_wstring(utf8_string); }
|
||||
|
||||
LL_COMMON_API S32 wchar_to_utf8chars(llwchar inchar, char* outchars);
|
||||
LL_COMMON_API std::ptrdiff_t wchar_to_utf8chars(llwchar inchar, char* outchars);
|
||||
|
||||
ll_convert_forms(ll_convert_alias, std::string, LLWString, wstring_to_utf8str);
|
||||
ll_convert_forms(ll_convert_u16_alias, std::string, llutf16string, utf16str_to_utf8str);
|
||||
|
|
|
|||
|
|
@ -273,7 +273,7 @@ LLOSInfo::LLOSInfo() :
|
|||
{
|
||||
const char * DARWIN_PRODUCT_NAME = "Mac OS X";
|
||||
|
||||
S32 major_version, minor_version, bugfix_version = 0;
|
||||
int64_t major_version, minor_version, bugfix_version = 0;
|
||||
|
||||
if (LLGetDarwinOSInfo(major_version, minor_version, bugfix_version))
|
||||
{
|
||||
|
|
@ -454,14 +454,14 @@ LLOSInfo::LLOSInfo() :
|
|||
|
||||
#ifndef LL_WINDOWS
|
||||
// static
|
||||
S32 LLOSInfo::getMaxOpenFiles()
|
||||
long LLOSInfo::getMaxOpenFiles()
|
||||
{
|
||||
const S32 OPEN_MAX_GUESS = 256;
|
||||
const long OPEN_MAX_GUESS = 256;
|
||||
|
||||
#ifdef OPEN_MAX
|
||||
static S32 open_max = OPEN_MAX;
|
||||
static long open_max = OPEN_MAX;
|
||||
#else
|
||||
static S32 open_max = 0;
|
||||
static long open_max = 0;
|
||||
#endif
|
||||
|
||||
if (0 == open_max)
|
||||
|
|
@ -909,7 +909,7 @@ void LLMemoryInfo::stream(std::ostream& s) const
|
|||
// Now stream stats
|
||||
BOOST_FOREACH(const MapEntry& pair, inMap(mStatsMap))
|
||||
{
|
||||
s << pfx << std::setw(key_width+1) << (pair.first + ':') << ' ';
|
||||
s << pfx << std::setw(narrow(key_width+1)) << (pair.first + ':') << ' ';
|
||||
LLSD value(pair.second);
|
||||
if (value.isInteger())
|
||||
s << std::setw(12) << value.asInteger();
|
||||
|
|
@ -1280,7 +1280,7 @@ public:
|
|||
<< " seconds ";
|
||||
}
|
||||
|
||||
S32 precision = LL_CONT.precision();
|
||||
auto precision = LL_CONT.precision();
|
||||
|
||||
LL_CONT << std::fixed << std::setprecision(1) << framerate << '\n'
|
||||
<< LLMemoryInfo();
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ public:
|
|||
S32 mBuild;
|
||||
|
||||
#ifndef LL_WINDOWS
|
||||
static S32 getMaxOpenFiles();
|
||||
static long getMaxOpenFiles();
|
||||
#endif
|
||||
static bool is64Bit();
|
||||
|
||||
|
|
|
|||
|
|
@ -27,7 +27,11 @@
|
|||
#ifndef LL_LLSYS_OBJC_H
|
||||
#define LL_LLSYS_OBJC_H
|
||||
|
||||
bool LLGetDarwinOSInfo(int &major, int &minor, int &patch);
|
||||
#include <cstdint>
|
||||
|
||||
// C++ land doesn't define NSInteger, and we don't want to introduce that for
|
||||
// this one case, so use int64_t instead (which is equivalent).
|
||||
bool LLGetDarwinOSInfo(int64_t &major, int64_t &minor, int64_t &patch);
|
||||
|
||||
|
||||
#endif // LL_LLSYS_OBJC_H
|
||||
|
|
|
|||
|
|
@ -27,12 +27,12 @@
|
|||
#import "llsys_objc.h"
|
||||
#import <AppKit/AppKit.h>
|
||||
|
||||
static int intAtStringIndex(NSArray *array, int index)
|
||||
static auto intAtStringIndex(NSArray *array, int index)
|
||||
{
|
||||
return [(NSString *)[array objectAtIndex:index] integerValue];
|
||||
}
|
||||
|
||||
bool LLGetDarwinOSInfo(int &major, int &minor, int &patch)
|
||||
bool LLGetDarwinOSInfo(int64_t &major, int64_t &minor, int64_t &patch)
|
||||
{
|
||||
if (NSAppKitVersionNumber > NSAppKitVersionNumber10_8)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -82,7 +82,7 @@ public:
|
|||
|
||||
// Limiting the number of pending items prevents unbounded growth of the
|
||||
// underlying queue.
|
||||
LLThreadSafeQueue(U32 capacity = 1024);
|
||||
LLThreadSafeQueue(size_t capacity = 1024);
|
||||
virtual ~LLThreadSafeQueue() {}
|
||||
|
||||
// Add an element to the queue (will block if the queue has reached
|
||||
|
|
@ -179,7 +179,7 @@ public:
|
|||
protected:
|
||||
typedef QueueT queue_type;
|
||||
QueueT mStorage;
|
||||
U32 mCapacity;
|
||||
size_t mCapacity;
|
||||
bool mClosed;
|
||||
|
||||
boost::fibers::timed_mutex mLock;
|
||||
|
|
@ -262,7 +262,7 @@ namespace LL
|
|||
* LLThreadSafeQueue implementation
|
||||
*****************************************************************************/
|
||||
template<typename ElementT, typename QueueT>
|
||||
LLThreadSafeQueue<ElementT, QueueT>::LLThreadSafeQueue(U32 capacity) :
|
||||
LLThreadSafeQueue<ElementT, QueueT>::LLThreadSafeQueue(size_t capacity) :
|
||||
mCapacity(capacity),
|
||||
mClosed(false)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -121,9 +121,14 @@ U32 micro_sleep(U64 us, U32 max_yields)
|
|||
U64 start = get_clock_count();
|
||||
// This is kernel dependent. Currently, our kernel generates software clock
|
||||
// interrupts at 250 Hz (every 4,000 microseconds).
|
||||
const U64 KERNEL_SLEEP_INTERVAL_US = 4000;
|
||||
const S64 KERNEL_SLEEP_INTERVAL_US = 4000;
|
||||
|
||||
S32 num_sleep_intervals = (us - (KERNEL_SLEEP_INTERVAL_US >> 1)) / KERNEL_SLEEP_INTERVAL_US;
|
||||
// Use signed arithmetic to discover whether a sleep is even necessary. If
|
||||
// either 'us' or KERNEL_SLEEP_INTERVAL_US is unsigned, the compiler
|
||||
// promotes the difference to unsigned. If 'us' is less than half
|
||||
// KERNEL_SLEEP_INTERVAL_US, the unsigned difference will be hugely
|
||||
// positive, resulting in a crazy long wait.
|
||||
auto num_sleep_intervals = (S64(us) - (KERNEL_SLEEP_INTERVAL_US >> 1)) / KERNEL_SLEEP_INTERVAL_US;
|
||||
if (num_sleep_intervals > 0)
|
||||
{
|
||||
U64 sleep_time = (num_sleep_intervals * KERNEL_SLEEP_INTERVAL_US) - (KERNEL_SLEEP_INTERVAL_US >> 1);
|
||||
|
|
|
|||
|
|
@ -65,7 +65,7 @@ void TimeBlockTreeNode::setParent( BlockTimerStatHandle* parent )
|
|||
llassert_always(parent != mBlock);
|
||||
llassert_always(parent != NULL);
|
||||
|
||||
TimeBlockTreeNode* parent_tree_node = get_thread_recorder()->getTimeBlockTreeNode(parent->getIndex());
|
||||
TimeBlockTreeNode* parent_tree_node = get_thread_recorder()->getTimeBlockTreeNode(narrow(parent->getIndex()));
|
||||
if (!parent_tree_node) return;
|
||||
|
||||
if (mParent)
|
||||
|
|
|
|||
|
|
@ -340,7 +340,7 @@ inline void claim_alloc(MemStatHandle& measurement, const T& value)
|
|||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
#if LL_TRACE_ENABLED
|
||||
S32 size = MeasureMem<T>::measureFootprint(value);
|
||||
auto size = MeasureMem<T>::measureFootprint(value);
|
||||
if(size == 0) return;
|
||||
MemAccumulator& accumulator = measurement.getCurrentAccumulator();
|
||||
accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)size : (F64)size);
|
||||
|
|
@ -353,7 +353,7 @@ inline void disclaim_alloc(MemStatHandle& measurement, const T& value)
|
|||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
#if LL_TRACE_ENABLED
|
||||
S32 size = MeasureMem<T>::measureFootprint(value);
|
||||
auto size = MeasureMem<T>::measureFootprint(value);
|
||||
if(size == 0) return;
|
||||
MemAccumulator& accumulator = measurement.getCurrentAccumulator();
|
||||
accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)size : -(F64)size);
|
||||
|
|
|
|||
|
|
@ -96,9 +96,9 @@ void AccumulatorBufferGroup::makeCurrent()
|
|||
ThreadRecorder* thread_recorder = get_thread_recorder();
|
||||
AccumulatorBuffer<TimeBlockAccumulator>& timer_accumulator_buffer = mStackTimers;
|
||||
// update stacktimer parent pointers
|
||||
for (S32 i = 0, end_i = mStackTimers.size(); i < end_i; i++)
|
||||
for (size_t i = 0, end_i = mStackTimers.size(); i < end_i; i++)
|
||||
{
|
||||
TimeBlockTreeNode* tree_node = thread_recorder->getTimeBlockTreeNode(i);
|
||||
TimeBlockTreeNode* tree_node = thread_recorder->getTimeBlockTreeNode(narrow(i));
|
||||
if (tree_node)
|
||||
{
|
||||
timer_accumulator_buffer[i].mParent = tree_node->mParent;
|
||||
|
|
|
|||
|
|
@ -606,7 +606,8 @@ void PeriodicRecording::nextPeriod()
|
|||
mCurPeriod = (mCurPeriod + 1) % mRecordingPeriods.size();
|
||||
old_recording.splitTo(getCurRecording());
|
||||
|
||||
mNumRecordedPeriods = llmin((S32)mRecordingPeriods.size() - 1, mNumRecordedPeriods + 1);
|
||||
mNumRecordedPeriods = mRecordingPeriods.empty()? 0 :
|
||||
llmin(mRecordingPeriods.size() - 1, mNumRecordedPeriods + 1);
|
||||
}
|
||||
|
||||
void PeriodicRecording::appendRecording(Recording& recording)
|
||||
|
|
@ -625,21 +626,21 @@ void PeriodicRecording::appendPeriodicRecording( PeriodicRecording& other )
|
|||
getCurRecording().update();
|
||||
other.getCurRecording().update();
|
||||
|
||||
const S32 other_recording_slots = other.mRecordingPeriods.size();
|
||||
const S32 other_num_recordings = other.getNumRecordedPeriods();
|
||||
const S32 other_current_recording_index = other.mCurPeriod;
|
||||
const S32 other_oldest_recording_index = (other_current_recording_index + other_recording_slots - other_num_recordings) % other_recording_slots;
|
||||
const auto other_recording_slots = other.mRecordingPeriods.size();
|
||||
const auto other_num_recordings = other.getNumRecordedPeriods();
|
||||
const auto other_current_recording_index = other.mCurPeriod;
|
||||
const auto other_oldest_recording_index = (other_current_recording_index + other_recording_slots - other_num_recordings) % other_recording_slots;
|
||||
|
||||
// append first recording into our current slot
|
||||
getCurRecording().appendRecording(other.mRecordingPeriods[other_oldest_recording_index]);
|
||||
|
||||
// from now on, add new recordings for everything after the first
|
||||
S32 other_index = (other_oldest_recording_index + 1) % other_recording_slots;
|
||||
auto other_index = (other_oldest_recording_index + 1) % other_recording_slots;
|
||||
|
||||
if (mAutoResize)
|
||||
{
|
||||
// push back recordings for everything in the middle
|
||||
S32 other_index = (other_oldest_recording_index + 1) % other_recording_slots;
|
||||
auto other_index = (other_oldest_recording_index + 1) % other_recording_slots;
|
||||
while (other_index != other_current_recording_index)
|
||||
{
|
||||
mRecordingPeriods.push_back(other.mRecordingPeriods[other_index]);
|
||||
|
|
@ -652,8 +653,8 @@ void PeriodicRecording::appendPeriodicRecording( PeriodicRecording& other )
|
|||
mRecordingPeriods.push_back(other.mRecordingPeriods[other_current_recording_index]);
|
||||
}
|
||||
|
||||
mCurPeriod = mRecordingPeriods.size() - 1;
|
||||
mNumRecordedPeriods = mRecordingPeriods.size() - 1;
|
||||
mCurPeriod = mRecordingPeriods.empty()? 0 : mRecordingPeriods.size() - 1;
|
||||
mNumRecordedPeriods = mCurPeriod;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -682,7 +683,7 @@ void PeriodicRecording::appendPeriodicRecording( PeriodicRecording& other )
|
|||
llassert(num_to_copy >= 1);
|
||||
// advance to last recording period copied, and make that our current period
|
||||
mCurPeriod = (mCurPeriod + num_to_copy - 1) % mRecordingPeriods.size();
|
||||
mNumRecordedPeriods = llmin((S32)mRecordingPeriods.size() - 1, mNumRecordedPeriods + num_to_copy - 1);
|
||||
mNumRecordedPeriods = llmin(mRecordingPeriods.size() - 1, mNumRecordedPeriods + num_to_copy - 1);
|
||||
}
|
||||
|
||||
// end with fresh period, otherwise next appendPeriodicRecording() will merge the first
|
||||
|
|
@ -695,10 +696,10 @@ F64Seconds PeriodicRecording::getDuration() const
|
|||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
F64Seconds duration;
|
||||
S32 num_periods = mRecordingPeriods.size();
|
||||
for (S32 i = 1; i <= num_periods; i++)
|
||||
auto num_periods = mRecordingPeriods.size();
|
||||
for (size_t i = 1; i <= num_periods; i++)
|
||||
{
|
||||
S32 index = (mCurPeriod + num_periods - i) % num_periods;
|
||||
auto index = (mCurPeriod + num_periods - i) % num_periods;
|
||||
duration += mRecordingPeriods[index].getDuration();
|
||||
}
|
||||
return duration;
|
||||
|
|
@ -734,16 +735,16 @@ const Recording& PeriodicRecording::getCurRecording() const
|
|||
return mRecordingPeriods[mCurPeriod];
|
||||
}
|
||||
|
||||
Recording& PeriodicRecording::getPrevRecording( S32 offset )
|
||||
Recording& PeriodicRecording::getPrevRecording( size_t offset )
|
||||
{
|
||||
S32 num_periods = mRecordingPeriods.size();
|
||||
auto num_periods = mRecordingPeriods.size();
|
||||
offset = llclamp(offset, 0, num_periods - 1);
|
||||
return mRecordingPeriods[(mCurPeriod + num_periods - offset) % num_periods];
|
||||
}
|
||||
|
||||
const Recording& PeriodicRecording::getPrevRecording( S32 offset ) const
|
||||
const Recording& PeriodicRecording::getPrevRecording( size_t offset ) const
|
||||
{
|
||||
S32 num_periods = mRecordingPeriods.size();
|
||||
auto num_periods = mRecordingPeriods.size();
|
||||
offset = llclamp(offset, 0, num_periods - 1);
|
||||
return mRecordingPeriods[(mCurPeriod + num_periods - offset) % num_periods];
|
||||
}
|
||||
|
|
@ -790,7 +791,7 @@ void PeriodicRecording::handleSplitTo(PeriodicRecording& other)
|
|||
getCurRecording().splitTo(other.getCurRecording());
|
||||
}
|
||||
|
||||
F64 PeriodicRecording::getPeriodMin( const StatType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
|
||||
F64 PeriodicRecording::getPeriodMin( const StatType<EventAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -812,7 +813,7 @@ F64 PeriodicRecording::getPeriodMin( const StatType<EventAccumulator>& stat, S32
|
|||
: NaN;
|
||||
}
|
||||
|
||||
F64 PeriodicRecording::getPeriodMax( const StatType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
|
||||
F64 PeriodicRecording::getPeriodMax( const StatType<EventAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -835,7 +836,7 @@ F64 PeriodicRecording::getPeriodMax( const StatType<EventAccumulator>& stat, S32
|
|||
}
|
||||
|
||||
// calculates means using aggregates per period
|
||||
F64 PeriodicRecording::getPeriodMean( const StatType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
|
||||
F64 PeriodicRecording::getPeriodMean( const StatType<EventAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -858,7 +859,7 @@ F64 PeriodicRecording::getPeriodMean( const StatType<EventAccumulator>& stat, S3
|
|||
: NaN;
|
||||
}
|
||||
|
||||
F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
|
||||
F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<EventAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -883,7 +884,7 @@ F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<EventAccumulat
|
|||
: NaN;
|
||||
}
|
||||
|
||||
F64 PeriodicRecording::getPeriodMin( const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
|
||||
F64 PeriodicRecording::getPeriodMin( const StatType<SampleAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -905,7 +906,7 @@ F64 PeriodicRecording::getPeriodMin( const StatType<SampleAccumulator>& stat, S3
|
|||
: NaN;
|
||||
}
|
||||
|
||||
F64 PeriodicRecording::getPeriodMax(const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/)
|
||||
F64 PeriodicRecording::getPeriodMax(const StatType<SampleAccumulator>& stat, size_t num_periods /*= S32_MAX*/)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -928,7 +929,7 @@ F64 PeriodicRecording::getPeriodMax(const StatType<SampleAccumulator>& stat, S32
|
|||
}
|
||||
|
||||
|
||||
F64 PeriodicRecording::getPeriodMean( const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
|
||||
F64 PeriodicRecording::getPeriodMean( const StatType<SampleAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -951,7 +952,7 @@ F64 PeriodicRecording::getPeriodMean( const StatType<SampleAccumulator>& stat, S
|
|||
: NaN;
|
||||
}
|
||||
|
||||
F64 PeriodicRecording::getPeriodMedian( const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
|
||||
F64 PeriodicRecording::getPeriodMedian( const StatType<SampleAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -977,7 +978,7 @@ F64 PeriodicRecording::getPeriodMedian( const StatType<SampleAccumulator>& stat,
|
|||
return F64((buf.size() % 2 == 0) ? (buf[buf.size() / 2 - 1] + buf[buf.size() / 2]) / 2 : buf[buf.size() / 2]);
|
||||
}
|
||||
|
||||
F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
|
||||
F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<SampleAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -1003,7 +1004,7 @@ F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<SampleAccumula
|
|||
}
|
||||
|
||||
|
||||
F64Kilobytes PeriodicRecording::getPeriodMin( const StatType<MemAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
|
||||
F64Kilobytes PeriodicRecording::getPeriodMin( const StatType<MemAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -1018,12 +1019,12 @@ F64Kilobytes PeriodicRecording::getPeriodMin( const StatType<MemAccumulator>& st
|
|||
return min_val;
|
||||
}
|
||||
|
||||
F64Kilobytes PeriodicRecording::getPeriodMin(const MemStatHandle& stat, S32 num_periods)
|
||||
F64Kilobytes PeriodicRecording::getPeriodMin(const MemStatHandle& stat, size_t num_periods)
|
||||
{
|
||||
return getPeriodMin(static_cast<const StatType<MemAccumulator>&>(stat), num_periods);
|
||||
}
|
||||
|
||||
F64Kilobytes PeriodicRecording::getPeriodMax(const StatType<MemAccumulator>& stat, S32 num_periods /*= S32_MAX*/)
|
||||
F64Kilobytes PeriodicRecording::getPeriodMax(const StatType<MemAccumulator>& stat, size_t num_periods /*= S32_MAX*/)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -1038,12 +1039,12 @@ F64Kilobytes PeriodicRecording::getPeriodMax(const StatType<MemAccumulator>& sta
|
|||
return max_val;
|
||||
}
|
||||
|
||||
F64Kilobytes PeriodicRecording::getPeriodMax(const MemStatHandle& stat, S32 num_periods)
|
||||
F64Kilobytes PeriodicRecording::getPeriodMax(const MemStatHandle& stat, size_t num_periods)
|
||||
{
|
||||
return getPeriodMax(static_cast<const StatType<MemAccumulator>&>(stat), num_periods);
|
||||
}
|
||||
|
||||
F64Kilobytes PeriodicRecording::getPeriodMean( const StatType<MemAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
|
||||
F64Kilobytes PeriodicRecording::getPeriodMean( const StatType<MemAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -1059,12 +1060,12 @@ F64Kilobytes PeriodicRecording::getPeriodMean( const StatType<MemAccumulator>& s
|
|||
return mean / F64(num_periods);
|
||||
}
|
||||
|
||||
F64Kilobytes PeriodicRecording::getPeriodMean(const MemStatHandle& stat, S32 num_periods)
|
||||
F64Kilobytes PeriodicRecording::getPeriodMean(const MemStatHandle& stat, size_t num_periods)
|
||||
{
|
||||
return getPeriodMean(static_cast<const StatType<MemAccumulator>&>(stat), num_periods);
|
||||
}
|
||||
|
||||
F64Kilobytes PeriodicRecording::getPeriodStandardDeviation( const StatType<MemAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
|
||||
F64Kilobytes PeriodicRecording::getPeriodStandardDeviation( const StatType<MemAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -1089,7 +1090,7 @@ F64Kilobytes PeriodicRecording::getPeriodStandardDeviation( const StatType<MemAc
|
|||
: NaN);
|
||||
}
|
||||
|
||||
F64Kilobytes PeriodicRecording::getPeriodStandardDeviation(const MemStatHandle& stat, S32 num_periods)
|
||||
F64Kilobytes PeriodicRecording::getPeriodStandardDeviation(const MemStatHandle& stat, size_t num_periods)
|
||||
{
|
||||
return getPeriodStandardDeviation(static_cast<const StatType<MemAccumulator>&>(stat), num_periods);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -334,7 +334,7 @@ namespace LLTrace
|
|||
~PeriodicRecording();
|
||||
|
||||
void nextPeriod();
|
||||
S32 getNumRecordedPeriods()
|
||||
auto getNumRecordedPeriods()
|
||||
{
|
||||
// current period counts if not active
|
||||
return mNumRecordedPeriods + (isStarted() ? 0 : 1);
|
||||
|
|
@ -348,24 +348,24 @@ namespace LLTrace
|
|||
const Recording& getLastRecording() const;
|
||||
Recording& getCurRecording();
|
||||
const Recording& getCurRecording() const;
|
||||
Recording& getPrevRecording(S32 offset);
|
||||
const Recording& getPrevRecording(S32 offset) const;
|
||||
Recording& getPrevRecording(size_t offset);
|
||||
const Recording& getPrevRecording(size_t offset) const;
|
||||
Recording snapshotCurRecording() const;
|
||||
|
||||
template <typename T>
|
||||
S32 getSampleCount(const StatType<T>& stat, S32 num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
auto getSampleCount(const StatType<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
||||
S32 num_samples = 0;
|
||||
for (S32 i = 1; i <= num_periods; i++)
|
||||
size_t num_samples = 0;
|
||||
for (size_t i = 1; i <= num_periods; i++)
|
||||
{
|
||||
Recording& recording = getPrevRecording(i);
|
||||
num_samples += recording.getSampleCount(stat);
|
||||
}
|
||||
return num_samples;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// PERIODIC MIN
|
||||
|
|
@ -373,7 +373,7 @@ namespace LLTrace
|
|||
|
||||
// catch all for stats that have a defined sum
|
||||
template <typename T>
|
||||
typename T::value_t getPeriodMin(const StatType<T>& stat, S32 num_periods = S32_MAX)
|
||||
typename T::value_t getPeriodMin(const StatType<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -396,33 +396,33 @@ namespace LLTrace
|
|||
}
|
||||
|
||||
template<typename T>
|
||||
T getPeriodMin(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
|
||||
T getPeriodMin(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
return T(getPeriodMin(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
|
||||
}
|
||||
|
||||
F64 getPeriodMin(const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX);
|
||||
F64 getPeriodMin(const StatType<SampleAccumulator>& stat, size_t num_periods = S32_MAX);
|
||||
template<typename T>
|
||||
T getPeriodMin(const SampleStatHandle<T>& stat, S32 num_periods = S32_MAX)
|
||||
T getPeriodMin(const SampleStatHandle<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
return T(getPeriodMin(static_cast<const StatType<SampleAccumulator>&>(stat), num_periods));
|
||||
}
|
||||
|
||||
F64 getPeriodMin(const StatType<EventAccumulator>& stat, S32 num_periods = S32_MAX);
|
||||
F64 getPeriodMin(const StatType<EventAccumulator>& stat, size_t num_periods = S32_MAX);
|
||||
template<typename T>
|
||||
T getPeriodMin(const EventStatHandle<T>& stat, S32 num_periods = S32_MAX)
|
||||
T getPeriodMin(const EventStatHandle<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
return T(getPeriodMin(static_cast<const StatType<EventAccumulator>&>(stat), num_periods));
|
||||
}
|
||||
|
||||
F64Kilobytes getPeriodMin(const StatType<MemAccumulator>& stat, S32 num_periods = S32_MAX);
|
||||
F64Kilobytes getPeriodMin(const MemStatHandle& stat, S32 num_periods = S32_MAX);
|
||||
F64Kilobytes getPeriodMin(const StatType<MemAccumulator>& stat, size_t num_periods = S32_MAX);
|
||||
F64Kilobytes getPeriodMin(const MemStatHandle& stat, size_t num_periods = S32_MAX);
|
||||
|
||||
template <typename T>
|
||||
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMinPerSec(const StatType<T>& stat, S32 num_periods = S32_MAX)
|
||||
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMinPerSec(const StatType<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -437,7 +437,7 @@ namespace LLTrace
|
|||
}
|
||||
|
||||
template<typename T>
|
||||
typename RelatedTypes<T>::fractional_t getPeriodMinPerSec(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
|
||||
typename RelatedTypes<T>::fractional_t getPeriodMinPerSec(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
return typename RelatedTypes<T>::fractional_t(getPeriodMinPerSec(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
|
||||
|
|
@ -449,7 +449,7 @@ namespace LLTrace
|
|||
|
||||
// catch all for stats that have a defined sum
|
||||
template <typename T>
|
||||
typename T::value_t getPeriodMax(const StatType<T>& stat, S32 num_periods = S32_MAX)
|
||||
typename T::value_t getPeriodMax(const StatType<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -472,33 +472,33 @@ namespace LLTrace
|
|||
}
|
||||
|
||||
template<typename T>
|
||||
T getPeriodMax(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
|
||||
T getPeriodMax(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
return T(getPeriodMax(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
|
||||
}
|
||||
|
||||
F64 getPeriodMax(const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX);
|
||||
F64 getPeriodMax(const StatType<SampleAccumulator>& stat, size_t num_periods = S32_MAX);
|
||||
template<typename T>
|
||||
T getPeriodMax(const SampleStatHandle<T>& stat, S32 num_periods = S32_MAX)
|
||||
T getPeriodMax(const SampleStatHandle<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
return T(getPeriodMax(static_cast<const StatType<SampleAccumulator>&>(stat), num_periods));
|
||||
}
|
||||
|
||||
F64 getPeriodMax(const StatType<EventAccumulator>& stat, S32 num_periods = S32_MAX);
|
||||
F64 getPeriodMax(const StatType<EventAccumulator>& stat, size_t num_periods = S32_MAX);
|
||||
template<typename T>
|
||||
T getPeriodMax(const EventStatHandle<T>& stat, S32 num_periods = S32_MAX)
|
||||
T getPeriodMax(const EventStatHandle<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
return T(getPeriodMax(static_cast<const StatType<EventAccumulator>&>(stat), num_periods));
|
||||
}
|
||||
|
||||
F64Kilobytes getPeriodMax(const StatType<MemAccumulator>& stat, S32 num_periods = S32_MAX);
|
||||
F64Kilobytes getPeriodMax(const MemStatHandle& stat, S32 num_periods = S32_MAX);
|
||||
F64Kilobytes getPeriodMax(const StatType<MemAccumulator>& stat, size_t num_periods = S32_MAX);
|
||||
F64Kilobytes getPeriodMax(const MemStatHandle& stat, size_t num_periods = S32_MAX);
|
||||
|
||||
template <typename T>
|
||||
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMaxPerSec(const StatType<T>& stat, S32 num_periods = S32_MAX)
|
||||
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMaxPerSec(const StatType<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -513,7 +513,7 @@ namespace LLTrace
|
|||
}
|
||||
|
||||
template<typename T>
|
||||
typename RelatedTypes<T>::fractional_t getPeriodMaxPerSec(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
|
||||
typename RelatedTypes<T>::fractional_t getPeriodMaxPerSec(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
return typename RelatedTypes<T>::fractional_t(getPeriodMaxPerSec(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
|
||||
|
|
@ -525,7 +525,7 @@ namespace LLTrace
|
|||
|
||||
// catch all for stats that have a defined sum
|
||||
template <typename T>
|
||||
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMean(const StatType<T >& stat, S32 num_periods = S32_MAX)
|
||||
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMean(const StatType<T >& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -546,32 +546,32 @@ namespace LLTrace
|
|||
}
|
||||
|
||||
template<typename T>
|
||||
typename RelatedTypes<T>::fractional_t getPeriodMean(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
|
||||
typename RelatedTypes<T>::fractional_t getPeriodMean(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
return typename RelatedTypes<T>::fractional_t(getPeriodMean(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
|
||||
}
|
||||
F64 getPeriodMean(const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX);
|
||||
F64 getPeriodMean(const StatType<SampleAccumulator>& stat, size_t num_periods = S32_MAX);
|
||||
template<typename T>
|
||||
typename RelatedTypes<T>::fractional_t getPeriodMean(const SampleStatHandle<T>& stat, S32 num_periods = S32_MAX)
|
||||
typename RelatedTypes<T>::fractional_t getPeriodMean(const SampleStatHandle<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
return typename RelatedTypes<T>::fractional_t(getPeriodMean(static_cast<const StatType<SampleAccumulator>&>(stat), num_periods));
|
||||
}
|
||||
|
||||
F64 getPeriodMean(const StatType<EventAccumulator>& stat, S32 num_periods = S32_MAX);
|
||||
F64 getPeriodMean(const StatType<EventAccumulator>& stat, size_t num_periods = S32_MAX);
|
||||
template<typename T>
|
||||
typename RelatedTypes<T>::fractional_t getPeriodMean(const EventStatHandle<T>& stat, S32 num_periods = S32_MAX)
|
||||
typename RelatedTypes<T>::fractional_t getPeriodMean(const EventStatHandle<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
return typename RelatedTypes<T>::fractional_t(getPeriodMean(static_cast<const StatType<EventAccumulator>&>(stat), num_periods));
|
||||
}
|
||||
|
||||
F64Kilobytes getPeriodMean(const StatType<MemAccumulator>& stat, S32 num_periods = S32_MAX);
|
||||
F64Kilobytes getPeriodMean(const MemStatHandle& stat, S32 num_periods = S32_MAX);
|
||||
F64Kilobytes getPeriodMean(const StatType<MemAccumulator>& stat, size_t num_periods = S32_MAX);
|
||||
F64Kilobytes getPeriodMean(const MemStatHandle& stat, size_t num_periods = S32_MAX);
|
||||
|
||||
template <typename T>
|
||||
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMeanPerSec(const StatType<T>& stat, S32 num_periods = S32_MAX)
|
||||
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMeanPerSec(const StatType<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -593,16 +593,16 @@ namespace LLTrace
|
|||
}
|
||||
|
||||
template<typename T>
|
||||
typename RelatedTypes<T>::fractional_t getPeriodMeanPerSec(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
|
||||
typename RelatedTypes<T>::fractional_t getPeriodMeanPerSec(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
return typename RelatedTypes<T>::fractional_t(getPeriodMeanPerSec(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
|
||||
}
|
||||
|
||||
F64 getPeriodMedian( const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX);
|
||||
F64 getPeriodMedian( const StatType<SampleAccumulator>& stat, size_t num_periods = S32_MAX);
|
||||
|
||||
template <typename T>
|
||||
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMedianPerSec(const StatType<T>& stat, S32 num_periods = S32_MAX)
|
||||
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMedianPerSec(const StatType<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
num_periods = llmin(num_periods, getNumRecordedPeriods());
|
||||
|
|
@ -622,7 +622,7 @@ namespace LLTrace
|
|||
}
|
||||
|
||||
template<typename T>
|
||||
typename RelatedTypes<T>::fractional_t getPeriodMedianPerSec(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
|
||||
typename RelatedTypes<T>::fractional_t getPeriodMedianPerSec(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
return typename RelatedTypes<T>::fractional_t(getPeriodMedianPerSec(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
|
||||
|
|
@ -632,25 +632,25 @@ namespace LLTrace
|
|||
// PERIODIC STANDARD DEVIATION
|
||||
//
|
||||
|
||||
F64 getPeriodStandardDeviation(const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX);
|
||||
F64 getPeriodStandardDeviation(const StatType<SampleAccumulator>& stat, size_t num_periods = S32_MAX);
|
||||
|
||||
template<typename T>
|
||||
typename RelatedTypes<T>::fractional_t getPeriodStandardDeviation(const SampleStatHandle<T>& stat, S32 num_periods = S32_MAX)
|
||||
typename RelatedTypes<T>::fractional_t getPeriodStandardDeviation(const SampleStatHandle<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
return typename RelatedTypes<T>::fractional_t(getPeriodStandardDeviation(static_cast<const StatType<SampleAccumulator>&>(stat), num_periods));
|
||||
}
|
||||
|
||||
F64 getPeriodStandardDeviation(const StatType<EventAccumulator>& stat, S32 num_periods = S32_MAX);
|
||||
F64 getPeriodStandardDeviation(const StatType<EventAccumulator>& stat, size_t num_periods = S32_MAX);
|
||||
template<typename T>
|
||||
typename RelatedTypes<T>::fractional_t getPeriodStandardDeviation(const EventStatHandle<T>& stat, S32 num_periods = S32_MAX)
|
||||
typename RelatedTypes<T>::fractional_t getPeriodStandardDeviation(const EventStatHandle<T>& stat, size_t num_periods = S32_MAX)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
|
||||
return typename RelatedTypes<T>::fractional_t(getPeriodStandardDeviation(static_cast<const StatType<EventAccumulator>&>(stat), num_periods));
|
||||
}
|
||||
|
||||
F64Kilobytes getPeriodStandardDeviation(const StatType<MemAccumulator>& stat, S32 num_periods = S32_MAX);
|
||||
F64Kilobytes getPeriodStandardDeviation(const MemStatHandle& stat, S32 num_periods = S32_MAX);
|
||||
F64Kilobytes getPeriodStandardDeviation(const StatType<MemAccumulator>& stat, size_t num_periods = S32_MAX);
|
||||
F64Kilobytes getPeriodStandardDeviation(const MemStatHandle& stat, size_t num_periods = S32_MAX);
|
||||
|
||||
private:
|
||||
// implementation for LLStopWatchControlsMixin
|
||||
|
|
@ -662,8 +662,8 @@ namespace LLTrace
|
|||
private:
|
||||
std::vector<Recording> mRecordingPeriods;
|
||||
const bool mAutoResize;
|
||||
S32 mCurPeriod;
|
||||
S32 mNumRecordedPeriods;
|
||||
size_t mCurPeriod;
|
||||
size_t mNumRecordedPeriods;
|
||||
};
|
||||
|
||||
PeriodicRecording& get_frame_recording();
|
||||
|
|
|
|||
|
|
@ -125,7 +125,7 @@ ThreadRecorder::~ThreadRecorder()
|
|||
#endif
|
||||
}
|
||||
|
||||
TimeBlockTreeNode* ThreadRecorder::getTimeBlockTreeNode( S32 index )
|
||||
TimeBlockTreeNode* ThreadRecorder::getTimeBlockTreeNode( size_t index )
|
||||
{
|
||||
#if LL_TRACE_ENABLED
|
||||
if (0 <= index && index < mNumTimeBlockTreeNodes)
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ namespace LLTrace
|
|||
void pullFromChildren();
|
||||
void pushToParent();
|
||||
|
||||
TimeBlockTreeNode* getTimeBlockTreeNode(S32 index);
|
||||
TimeBlockTreeNode* getTimeBlockTreeNode(size_t index);
|
||||
|
||||
protected:
|
||||
void init();
|
||||
|
|
|
|||
|
|
@ -81,9 +81,9 @@ void LLWorkerThread::clearDeleteList()
|
|||
}
|
||||
|
||||
// virtual
|
||||
S32 LLWorkerThread::update(F32 max_time_ms)
|
||||
size_t LLWorkerThread::update(F32 max_time_ms)
|
||||
{
|
||||
S32 res = LLQueuedThread::update(max_time_ms);
|
||||
auto res = LLQueuedThread::update(max_time_ms);
|
||||
// Delete scheduled workers
|
||||
std::vector<LLWorkerClass*> delete_list;
|
||||
std::vector<LLWorkerClass*> abort_list;
|
||||
|
|
|
|||
|
|
@ -88,7 +88,7 @@ public:
|
|||
LLWorkerThread(const std::string& name, bool threaded = true, bool should_pause = false);
|
||||
~LLWorkerThread();
|
||||
|
||||
/*virtual*/ S32 update(F32 max_time_ms);
|
||||
/*virtual*/ size_t update(F32 max_time_ms);
|
||||
|
||||
handle_t addWorkRequest(LLWorkerClass* workerclass, S32 param, U32 priority = PRIORITY_NORMAL);
|
||||
|
||||
|
|
|
|||
|
|
@ -26,16 +26,23 @@
|
|||
#ifndef LL_STDTYPES_H
|
||||
#define LL_STDTYPES_H
|
||||
|
||||
#include <cassert>
|
||||
#include <cfloat>
|
||||
#include <climits>
|
||||
#include <limits>
|
||||
#include <type_traits>
|
||||
|
||||
typedef signed char S8;
|
||||
typedef signed char S8;
|
||||
typedef unsigned char U8;
|
||||
typedef signed short S16;
|
||||
typedef unsigned short U16;
|
||||
typedef signed int S32;
|
||||
typedef signed int S32;
|
||||
typedef unsigned int U32;
|
||||
|
||||
// to express an index that might go negative
|
||||
// (ssize_t is provided by SOME compilers, don't collide)
|
||||
typedef typename std::make_signed<size_t>::type llssize;
|
||||
|
||||
#if LL_WINDOWS
|
||||
// https://docs.microsoft.com/en-us/cpp/build/reference/zc-wchar-t-wchar-t-is-native-type
|
||||
// https://docs.microsoft.com/en-us/cpp/cpp/fundamental-types-cpp
|
||||
|
|
@ -45,7 +52,7 @@ typedef unsigned int U32;
|
|||
// The version of clang available with VS 2019 also defines wchar_t as __wchar_t
|
||||
// which is also 16 bits.
|
||||
// In any case, llwchar should be a UTF-32 type.
|
||||
typedef U32 llwchar;
|
||||
typedef U32 llwchar;
|
||||
#else
|
||||
typedef wchar_t llwchar;
|
||||
// What we'd actually want is a simple module-scope 'if constexpr' to test
|
||||
|
|
@ -76,7 +83,7 @@ typedef double F64;
|
|||
typedef S32 BOOL;
|
||||
typedef U8 KEY;
|
||||
typedef U32 MASK;
|
||||
typedef U32 TPACKETID;
|
||||
typedef U32 TPACKETID;
|
||||
|
||||
// Use #define instead of consts to avoid conversion headaches
|
||||
#define S8_MAX (SCHAR_MAX)
|
||||
|
|
@ -118,4 +125,95 @@ typedef U8 LLPCode;
|
|||
typedef int intptr_t;
|
||||
#endif
|
||||
|
||||
/*****************************************************************************
|
||||
* Narrowing
|
||||
*****************************************************************************/
|
||||
/**
|
||||
* narrow() is used to cast a wider type to a narrower type with validation.
|
||||
*
|
||||
* In many cases we take the size() of a container and try to pass it to an
|
||||
* S32 or a U32 parameter. We used to be able to assume that the size of
|
||||
* anything we could fit into memory could be expressed as a 32-bit int. With
|
||||
* 64-bit viewers, though, size_t as returned by size() and length() and so
|
||||
* forth is 64 bits, and the compiler is unhappy about stuffing such values
|
||||
* into 32-bit types.
|
||||
*
|
||||
* It works to force the compiler to truncate, e.g. static_cast<S32>(len) or
|
||||
* S32(len) or (S32)len, but we can do better.
|
||||
*
|
||||
* For:
|
||||
* @code
|
||||
* std::vector<Object> container;
|
||||
* void somefunc(S32 size);
|
||||
* @endcode
|
||||
* call:
|
||||
* @code
|
||||
* somefunc(narrow(container.size()));
|
||||
* @endcode
|
||||
*
|
||||
* narrow() truncates but, in RelWithDebInfo builds, it validates (using
|
||||
* assert()) that the passed value can validly be expressed by the destination
|
||||
* type.
|
||||
*/
|
||||
// narrow_holder is a struct that accepts the passed value as its original
|
||||
// type and provides templated conversion functions to other types. Once we're
|
||||
// building with compilers that support Class Template Argument Deduction, we
|
||||
// can rename this class template 'narrow' and eliminate the narrow() factory
|
||||
// function below.
|
||||
template <typename FROM>
|
||||
class narrow_holder
|
||||
{
|
||||
private:
|
||||
FROM mValue;
|
||||
|
||||
public:
|
||||
narrow_holder(FROM value): mValue(value) {}
|
||||
|
||||
/*---------------------- Narrowing unsigned to signed ----------------------*/
|
||||
template <typename TO,
|
||||
typename std::enable_if<std::is_unsigned<FROM>::value &&
|
||||
std::is_signed<TO>::value,
|
||||
bool>::type = true>
|
||||
inline
|
||||
operator TO() const
|
||||
{
|
||||
// The reason we skip the
|
||||
// assert(value >= std::numeric_limits<TO>::lowest());
|
||||
// like the overload below is that to perform the above comparison,
|
||||
// the compiler promotes the signed lowest() to the unsigned FROM
|
||||
// type, making it hugely positive -- so a reasonable 'value' will
|
||||
// always fail the assert().
|
||||
assert(mValue <= std::numeric_limits<TO>::max());
|
||||
return static_cast<TO>(mValue);
|
||||
}
|
||||
|
||||
/*----------------------- Narrowing all other cases ------------------------*/
|
||||
template <typename TO,
|
||||
typename std::enable_if<! (std::is_unsigned<FROM>::value &&
|
||||
std::is_signed<TO>::value),
|
||||
bool>::type = true>
|
||||
inline
|
||||
operator TO() const
|
||||
{
|
||||
// two different assert()s so we can tell which condition failed
|
||||
assert(mValue <= std::numeric_limits<TO>::max());
|
||||
// Funny, with floating point types min() is "positive epsilon" rather
|
||||
// than "largest negative" -- that's lowest().
|
||||
assert(mValue >= std::numeric_limits<TO>::lowest());
|
||||
// Do we really expect to use this with floating point types?
|
||||
// If so, does it matter if a very small value truncates to zero?
|
||||
//assert(fabs(mValue) >= std::numeric_limits<TO>::min());
|
||||
return static_cast<TO>(mValue);
|
||||
}
|
||||
};
|
||||
|
||||
/// narrow() factory function returns a narrow_holder<FROM>(), which can be
|
||||
/// implicitly converted to the target type.
|
||||
template <typename FROM>
|
||||
inline
|
||||
narrow_holder<FROM> narrow(FROM value)
|
||||
{
|
||||
return { value };
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -335,7 +335,7 @@ namespace tut
|
|||
// Full, partial defaults arrays for params for freena(), freenb()
|
||||
LLSD dft_array_full, dft_array_partial;
|
||||
// Start index of partial defaults arrays
|
||||
const LLSD::Integer partial_offset;
|
||||
const size_t partial_offset;
|
||||
// Full, partial defaults maps for params for freena(), freenb()
|
||||
LLSD dft_map_full, dft_map_partial;
|
||||
// Most of the above are indexed by "a" or "b". Useful to have an
|
||||
|
|
|
|||
|
|
@ -82,7 +82,7 @@ namespace LL
|
|||
using TimePoint = ThreadSafeSchedulePrivate::TimePoint;
|
||||
using Clock = TimePoint::clock;
|
||||
|
||||
ThreadSafeSchedule(U32 capacity=1024):
|
||||
ThreadSafeSchedule(size_t capacity=1024):
|
||||
super(capacity)
|
||||
{}
|
||||
|
||||
|
|
|
|||
|
|
@ -196,7 +196,7 @@ size_t BufferArray::read(size_t pos, void * dst, size_t len)
|
|||
return 0;
|
||||
|
||||
size_t result(0), offset(0);
|
||||
const int block_limit(mBlocks.size());
|
||||
const auto block_limit(mBlocks.size());
|
||||
int block_start(findBlock(pos, &offset));
|
||||
if (block_start < 0)
|
||||
return 0;
|
||||
|
|
@ -228,7 +228,7 @@ size_t BufferArray::write(size_t pos, const void * src, size_t len)
|
|||
return 0;
|
||||
|
||||
size_t result(0), offset(0);
|
||||
const int block_limit(mBlocks.size());
|
||||
const auto block_limit(mBlocks.size());
|
||||
int block_start(findBlock(pos, &offset));
|
||||
|
||||
if (block_start >= 0)
|
||||
|
|
@ -288,7 +288,7 @@ int BufferArray::findBlock(size_t pos, size_t * ret_offset)
|
|||
if (pos >= mLen)
|
||||
return -1; // Doesn't exist
|
||||
|
||||
const int block_limit(mBlocks.size());
|
||||
const int block_limit(narrow(mBlocks.size()));
|
||||
for (int i(0); i < block_limit; ++i)
|
||||
{
|
||||
if (pos < mBlocks[i]->mUsed)
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ LLImageDecodeThread::~LLImageDecodeThread()
|
|||
|
||||
// MAIN THREAD
|
||||
// virtual
|
||||
S32 LLImageDecodeThread::update(F32 max_time_ms)
|
||||
size_t LLImageDecodeThread::update(F32 max_time_ms)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
|
||||
LLMutexLock lock(mCreationMutex);
|
||||
|
|
|
|||
|
|
@ -78,7 +78,7 @@ public:
|
|||
handle_t decodeImage(LLImageFormatted* image,
|
||||
U32 priority, S32 discard, BOOL needs_aux,
|
||||
Responder* responder);
|
||||
S32 update(F32 max_time_ms);
|
||||
size_t update(F32 max_time_ms);
|
||||
|
||||
// Used by unit tests to check the consistency of the thread instance
|
||||
S32 tut_size();
|
||||
|
|
|
|||
|
|
@ -152,24 +152,24 @@ LLSettingsSky::validation_list_t legacyHazeValidationList()
|
|||
{
|
||||
legacyHazeValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_AMBIENT, false, LLSD::TypeArray,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyVectorMinMax, _1, _2,
|
||||
LLSD(LLSDArray(0.0f)(0.0f)(0.0f)("*")),
|
||||
LLSD(LLSDArray(3.0f)(3.0f)(3.0f)("*")))));
|
||||
llsd::array(0.0f, 0.0f, 0.0f, "*"),
|
||||
llsd::array(3.0f, 3.0f, 3.0f, "*"))));
|
||||
legacyHazeValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_BLUE_DENSITY, false, LLSD::TypeArray,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyVectorMinMax, _1, _2,
|
||||
LLSD(LLSDArray(0.0f)(0.0f)(0.0f)("*")),
|
||||
LLSD(LLSDArray(3.0f)(3.0f)(3.0f)("*")))));
|
||||
llsd::array(0.0f, 0.0f, 0.0f, "*"),
|
||||
llsd::array(3.0f, 3.0f, 3.0f, "*"))));
|
||||
legacyHazeValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_BLUE_HORIZON, false, LLSD::TypeArray,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyVectorMinMax, _1, _2,
|
||||
LLSD(LLSDArray(0.0f)(0.0f)(0.0f)("*")),
|
||||
LLSD(LLSDArray(3.0f)(3.0f)(3.0f)("*")))));
|
||||
llsd::array(0.0f, 0.0f, 0.0f, "*"),
|
||||
llsd::array(3.0f, 3.0f, 3.0f, "*"))));
|
||||
legacyHazeValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_HAZE_DENSITY, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(5.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 5.0f))));
|
||||
legacyHazeValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_HAZE_HORIZON, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(5.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 5.0f))));
|
||||
legacyHazeValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_MULTIPLIER, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0001f)(2.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(0.0001f, 2.0f))));
|
||||
legacyHazeValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DISTANCE_MULTIPLIER, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0001f)(1000.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(0.0001f, 1000.0f))));
|
||||
}
|
||||
return legacyHazeValidation;
|
||||
}
|
||||
|
|
@ -180,19 +180,19 @@ LLSettingsSky::validation_list_t rayleighValidationList()
|
|||
if (rayleighValidation.empty())
|
||||
{
|
||||
rayleighValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_WIDTH, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(32768.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 32768.0f))));
|
||||
|
||||
rayleighValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_TERM, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(2.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 2.0f))));
|
||||
|
||||
rayleighValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_SCALE_FACTOR, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(-1.0f)(1.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(-1.0f, 1.0f))));
|
||||
|
||||
rayleighValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_LINEAR_TERM, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(2.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 2.0f))));
|
||||
|
||||
rayleighValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_CONSTANT_TERM, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 1.0f))));
|
||||
}
|
||||
return rayleighValidation;
|
||||
}
|
||||
|
|
@ -203,19 +203,19 @@ LLSettingsSky::validation_list_t absorptionValidationList()
|
|||
if (absorptionValidation.empty())
|
||||
{
|
||||
absorptionValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_WIDTH, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(32768.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 32768.0f))));
|
||||
|
||||
absorptionValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_TERM, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(2.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 2.0f))));
|
||||
|
||||
absorptionValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_SCALE_FACTOR, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(-1.0f)(1.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(-1.0f, 1.0f))));
|
||||
|
||||
absorptionValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_LINEAR_TERM, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(2.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 2.0f))));
|
||||
|
||||
absorptionValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_CONSTANT_TERM, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 1.0f))));
|
||||
}
|
||||
return absorptionValidation;
|
||||
}
|
||||
|
|
@ -226,22 +226,22 @@ LLSettingsSky::validation_list_t mieValidationList()
|
|||
if (mieValidation.empty())
|
||||
{
|
||||
mieValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_WIDTH, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(32768.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 32768.0f))));
|
||||
|
||||
mieValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_TERM, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(2.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 2.0f))));
|
||||
|
||||
mieValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_SCALE_FACTOR, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(-1.0f)(1.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(-1.0f, 1.0f))));
|
||||
|
||||
mieValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_LINEAR_TERM, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(2.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 2.0f))));
|
||||
|
||||
mieValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_CONSTANT_TERM, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 1.0f))));
|
||||
|
||||
mieValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_MIE_ANISOTROPY_FACTOR, false, LLSD::TypeReal,
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
|
||||
boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 1.0f))));
|
||||
}
|
||||
return mieValidation;
|
||||
}
|
||||
|
|
@ -546,89 +546,86 @@ LLSettingsSky::validation_list_t LLSettingsSky::validationList()
|
|||
static validation_list_t validation;
|
||||
|
||||
if (validation.empty())
|
||||
{ // Note the use of LLSD(LLSDArray()()()...) This is due to an issue with the
|
||||
// copy constructor for LLSDArray. Directly binding the LLSDArray as
|
||||
// a parameter without first wrapping it in a pure LLSD object will result
|
||||
// in deeply nested arrays like this [[[[[[[[[[v1,v2,v3]]]]]]]]]]
|
||||
{
|
||||
validation.push_back(Validator(SETTING_BLOOM_TEXTUREID, true, LLSD::TypeUUID));
|
||||
validation.push_back(Validator(SETTING_RAINBOW_TEXTUREID, false, LLSD::TypeUUID));
|
||||
validation.push_back(Validator(SETTING_HALO_TEXTUREID, false, LLSD::TypeUUID));
|
||||
|
||||
validation.push_back(Validator(SETTING_CLOUD_COLOR, true, LLSD::TypeArray,
|
||||
boost::bind(&Validator::verifyVectorMinMax, _1, _2,
|
||||
LLSD(LLSDArray(0.0f)(0.0f)(0.0f)("*")),
|
||||
LLSD(LLSDArray(1.0f)(1.0f)(1.0f)("*")))));
|
||||
llsd::array(0.0f, 0.0f, 0.0f, "*"),
|
||||
llsd::array(1.0f, 1.0f, 1.0f, "*"))));
|
||||
validation.push_back(Validator(SETTING_CLOUD_POS_DENSITY1, true, LLSD::TypeArray,
|
||||
boost::bind(&Validator::verifyVectorMinMax, _1, _2,
|
||||
LLSD(LLSDArray(0.0f)(0.0f)(0.0f)("*")),
|
||||
LLSD(LLSDArray(1.0f)(1.0f)(3.0f)("*")))));
|
||||
llsd::array(0.0f, 0.0f, 0.0f, "*"),
|
||||
llsd::array(1.0f, 1.0f, 3.0f, "*"))));
|
||||
validation.push_back(Validator(SETTING_CLOUD_POS_DENSITY2, true, LLSD::TypeArray,
|
||||
boost::bind(&Validator::verifyVectorMinMax, _1, _2,
|
||||
LLSD(LLSDArray(0.0f)(0.0f)(0.0f)("*")),
|
||||
LLSD(LLSDArray(1.0f)(1.0f)(1.0f)("*")))));
|
||||
llsd::array(0.0f, 0.0f, 0.0f, "*"),
|
||||
llsd::array(1.0f, 1.0f, 1.0f, "*"))));
|
||||
validation.push_back(Validator(SETTING_CLOUD_SCALE, true, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.001f)(3.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.001f, 3.0f))));
|
||||
validation.push_back(Validator(SETTING_CLOUD_SCROLL_RATE, true, LLSD::TypeArray,
|
||||
boost::bind(&Validator::verifyVectorMinMax, _1, _2,
|
||||
LLSD(LLSDArray(-50.0f)(-50.0f)),
|
||||
LLSD(LLSDArray(50.0f)(50.0f)))));
|
||||
llsd::array(-50.0f, -50.0f),
|
||||
llsd::array(50.0f, 50.0f))));
|
||||
validation.push_back(Validator(SETTING_CLOUD_SHADOW, true, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 1.0f))));
|
||||
validation.push_back(Validator(SETTING_CLOUD_TEXTUREID, false, LLSD::TypeUUID));
|
||||
validation.push_back(Validator(SETTING_CLOUD_VARIANCE, false, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 1.0f))));
|
||||
|
||||
validation.push_back(Validator(SETTING_DOME_OFFSET, false, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 1.0f))));
|
||||
validation.push_back(Validator(SETTING_DOME_RADIUS, false, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(1000.0f)(2000.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(1000.0f, 2000.0f))));
|
||||
validation.push_back(Validator(SETTING_GAMMA, true, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(20.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 20.0f))));
|
||||
validation.push_back(Validator(SETTING_GLOW, true, LLSD::TypeArray,
|
||||
boost::bind(&Validator::verifyVectorMinMax, _1, _2,
|
||||
LLSD(LLSDArray(0.2f)("*")(-10.0f)("*")),
|
||||
LLSD(LLSDArray(40.0f)("*")(10.0f)("*")))));
|
||||
llsd::array(0.2f, "*", -10.0f, "*"),
|
||||
llsd::array(40.0f, "*", 10.0f, "*"))));
|
||||
|
||||
validation.push_back(Validator(SETTING_MAX_Y, true, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(10000.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 10000.0f))));
|
||||
validation.push_back(Validator(SETTING_MOON_ROTATION, true, LLSD::TypeArray, &Validator::verifyQuaternionNormal));
|
||||
validation.push_back(Validator(SETTING_MOON_SCALE, false, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.25f)(20.0f))), LLSD::Real(1.0)));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.25f, 20.0f)), LLSD::Real(1.0)));
|
||||
validation.push_back(Validator(SETTING_MOON_TEXTUREID, false, LLSD::TypeUUID));
|
||||
validation.push_back(Validator(SETTING_MOON_BRIGHTNESS, false, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 1.0f))));
|
||||
|
||||
validation.push_back(Validator(SETTING_STAR_BRIGHTNESS, true, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(500.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 500.0f))));
|
||||
validation.push_back(Validator(SETTING_SUNLIGHT_COLOR, true, LLSD::TypeArray,
|
||||
boost::bind(&Validator::verifyVectorMinMax, _1, _2,
|
||||
LLSD(LLSDArray(0.0f)(0.0f)(0.0f)("*")),
|
||||
LLSD(LLSDArray(3.0f)(3.0f)(3.0f)("*")))));
|
||||
llsd::array(0.0f, 0.0f, 0.0f, "*"),
|
||||
llsd::array(3.0f, 3.0f, 3.0f, "*"))));
|
||||
validation.push_back(Validator(SETTING_SUN_ROTATION, true, LLSD::TypeArray, &Validator::verifyQuaternionNormal));
|
||||
validation.push_back(Validator(SETTING_SUN_SCALE, false, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.25f)(20.0f))), LLSD::Real(1.0)));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.25f, 20.0f)), LLSD::Real(1.0)));
|
||||
validation.push_back(Validator(SETTING_SUN_TEXTUREID, false, LLSD::TypeUUID));
|
||||
|
||||
validation.push_back(Validator(SETTING_PLANET_RADIUS, true, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(1000.0f)(32768.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(1000.0f, 32768.0f))));
|
||||
|
||||
validation.push_back(Validator(SETTING_SKY_BOTTOM_RADIUS, true, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(1000.0f)(32768.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(1000.0f, 32768.0f))));
|
||||
|
||||
validation.push_back(Validator(SETTING_SKY_TOP_RADIUS, true, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(1000.0f)(32768.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(1000.0f, 32768.0f))));
|
||||
|
||||
validation.push_back(Validator(SETTING_SUN_ARC_RADIANS, true, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(0.1f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 0.1f))));
|
||||
|
||||
validation.push_back(Validator(SETTING_SKY_MOISTURE_LEVEL, false, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 1.0f))));
|
||||
|
||||
validation.push_back(Validator(SETTING_SKY_DROPLET_RADIUS, false, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(5.0f)(1000.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(5.0f, 1000.0f))));
|
||||
|
||||
validation.push_back(Validator(SETTING_SKY_ICE_LEVEL, false, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 1.0f))));
|
||||
|
||||
validation.push_back(Validator(SETTING_RAYLEIGH_CONFIG, true, LLSD::TypeArray, &validateRayleighLayers));
|
||||
validation.push_back(Validator(SETTING_ABSORPTION_CONFIG, true, LLSD::TypeArray, &validateAbsorptionLayers));
|
||||
|
|
@ -719,7 +716,7 @@ LLSD LLSettingsSky::defaults(const LLSettingsBase::TrackPosition& position)
|
|||
dfltsetting[SETTING_CLOUD_POS_DENSITY1] = LLColor4(1.0000, 0.5260, 1.0000, 0.0).getValue();
|
||||
dfltsetting[SETTING_CLOUD_POS_DENSITY2] = LLColor4(1.0000, 0.5260, 1.0000, 0.0).getValue();
|
||||
dfltsetting[SETTING_CLOUD_SCALE] = LLSD::Real(0.4199);
|
||||
dfltsetting[SETTING_CLOUD_SCROLL_RATE] = LLSDArray(0.0f)(0.0f);
|
||||
dfltsetting[SETTING_CLOUD_SCROLL_RATE] = llsd::array(0.0f, 0.0f);
|
||||
dfltsetting[SETTING_CLOUD_SHADOW] = LLSD::Real(0.2699);
|
||||
dfltsetting[SETTING_CLOUD_VARIANCE] = LLSD::Real(0.0);
|
||||
|
||||
|
|
|
|||
|
|
@ -222,42 +222,38 @@ LLSettingsWater::validation_list_t LLSettingsWater::validationList()
|
|||
static validation_list_t validation;
|
||||
|
||||
if (validation.empty())
|
||||
{ // Note the use of LLSD(LLSDArray()()()...) This is due to an issue with the
|
||||
// copy constructor for LLSDArray. Directly binding the LLSDArray as
|
||||
// a parameter without first wrapping it in a pure LLSD object will result
|
||||
// in deeply nested arrays like this [[[[[[[[[[v1,v2,v3]]]]]]]]]]
|
||||
|
||||
{
|
||||
validation.push_back(Validator(SETTING_BLUR_MULTIPLIER, true, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(-0.5f)(0.5f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(-0.5f, 0.5f))));
|
||||
validation.push_back(Validator(SETTING_FOG_COLOR, true, LLSD::TypeArray,
|
||||
boost::bind(&Validator::verifyVectorMinMax, _1, _2,
|
||||
LLSD(LLSDArray(0.0f)(0.0f)(0.0f)(1.0f)),
|
||||
LLSD(LLSDArray(1.0f)(1.0f)(1.0f)(1.0f)))));
|
||||
llsd::array(0.0f, 0.0f, 0.0f, 1.0f),
|
||||
llsd::array(1.0f, 1.0f, 1.0f, 1.0f))));
|
||||
validation.push_back(Validator(SETTING_FOG_DENSITY, true, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(-10.0f)(10.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(-10.0f, 10.0f))));
|
||||
validation.push_back(Validator(SETTING_FOG_MOD, true, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(20.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 20.0f))));
|
||||
validation.push_back(Validator(SETTING_FRESNEL_OFFSET, true, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 1.0f))));
|
||||
validation.push_back(Validator(SETTING_FRESNEL_SCALE, true, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 1.0f))));
|
||||
validation.push_back(Validator(SETTING_NORMAL_MAP, true, LLSD::TypeUUID));
|
||||
validation.push_back(Validator(SETTING_NORMAL_SCALE, true, LLSD::TypeArray,
|
||||
boost::bind(&Validator::verifyVectorMinMax, _1, _2,
|
||||
LLSD(LLSDArray(0.0f)(0.0f)(0.0f)),
|
||||
LLSD(LLSDArray(10.0f)(10.0f)(10.0f)))));
|
||||
llsd::array(0.0f, 0.0f, 0.0f),
|
||||
llsd::array(10.0f, 10.0f, 10.0f))));
|
||||
validation.push_back(Validator(SETTING_SCALE_ABOVE, true, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(3.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 3.0f))));
|
||||
validation.push_back(Validator(SETTING_SCALE_BELOW, true, LLSD::TypeReal,
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(3.0f)))));
|
||||
boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 3.0f))));
|
||||
validation.push_back(Validator(SETTING_WAVE1_DIR, true, LLSD::TypeArray,
|
||||
boost::bind(&Validator::verifyVectorMinMax, _1, _2,
|
||||
LLSD(LLSDArray(-20.0f)(-20.0f)),
|
||||
LLSD(LLSDArray(20.0f)(20.0f)))));
|
||||
llsd::array(-20.0f, -20.0f),
|
||||
llsd::array(20.0f, 20.0f))));
|
||||
validation.push_back(Validator(SETTING_WAVE2_DIR, true, LLSD::TypeArray,
|
||||
boost::bind(&Validator::verifyVectorMinMax, _1, _2,
|
||||
LLSD(LLSDArray(-20.0f)(-20.0f)),
|
||||
LLSD(LLSDArray(20.0f)(20.0f)))));
|
||||
llsd::array(-20.0f, -20.0f),
|
||||
llsd::array(20.0f, 20.0f))));
|
||||
}
|
||||
|
||||
return validation;
|
||||
|
|
|
|||
|
|
@ -2398,7 +2398,7 @@ bool LLVolume::unpackVolumeFaces(std::istream& is, S32 size)
|
|||
|
||||
mVolumeFaces.resize(face_count);
|
||||
|
||||
for (U32 i = 0; i < face_count; ++i)
|
||||
for (size_t i = 0; i < face_count; ++i)
|
||||
{
|
||||
LLVolumeFace& face = mVolumeFaces[i];
|
||||
|
||||
|
|
|
|||
|
|
@ -337,7 +337,7 @@ void LLNotificationForm::addElement(const std::string& type, const std::string&
|
|||
element["name"] = name;
|
||||
element["text"] = name;
|
||||
element["value"] = value;
|
||||
element["index"] = mFormData.size();
|
||||
element["index"] = LLSD::Integer(mFormData.size());
|
||||
element["enabled"] = enabled;
|
||||
mFormData.append(element);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3194,15 +3194,16 @@ LLSD LLAppViewer::getViewerInfo() const
|
|||
// LLFloaterAbout.
|
||||
LLSD info;
|
||||
auto& versionInfo(LLVersionInfo::instance());
|
||||
info["VIEWER_VERSION"] = LLSDArray(versionInfo.getMajor())(versionInfo.getMinor())(versionInfo.getPatch())(versionInfo.getBuild());
|
||||
info["VIEWER_VERSION"] = llsd::array(versionInfo.getMajor(), versionInfo.getMinor(),
|
||||
versionInfo.getPatch(), versionInfo.getBuild());
|
||||
info["VIEWER_VERSION_STR"] = versionInfo.getVersion();
|
||||
info["CHANNEL"] = versionInfo.getChannel();
|
||||
info["ADDRESS_SIZE"] = ADDRESS_SIZE;
|
||||
std::string build_config = versionInfo.getBuildConfig();
|
||||
if (build_config != "Release")
|
||||
{
|
||||
info["BUILD_CONFIG"] = build_config;
|
||||
}
|
||||
info["ADDRESS_SIZE"] = ADDRESS_SIZE;
|
||||
std::string build_config = versionInfo.getBuildConfig();
|
||||
if (build_config != "Release")
|
||||
{
|
||||
info["BUILD_CONFIG"] = build_config;
|
||||
}
|
||||
|
||||
// return a URL to the release notes for this viewer, such as:
|
||||
// https://releasenotes.secondlife.com/viewer/2.1.0.123456.html
|
||||
|
|
|
|||
|
|
@ -39,6 +39,7 @@
|
|||
#include "llfloaterworldmap.h"
|
||||
#include "llproductinforequest.h"
|
||||
#include "llscrolllistctrl.h"
|
||||
#include "llsdutil.h"
|
||||
#include "llstatusbar.h"
|
||||
#include "lltextbox.h"
|
||||
#include "llscrolllistctrl.h"
|
||||
|
|
@ -79,24 +80,25 @@ BOOL LLFloaterLandHoldings::postBuild()
|
|||
for(S32 i = 0; i < count; ++i)
|
||||
{
|
||||
LLUUID id(gAgent.mGroups.at(i).mID);
|
||||
|
||||
LLSD element;
|
||||
element["id"] = id;
|
||||
element["columns"][0]["column"] = "group";
|
||||
element["columns"][0]["value"] = gAgent.mGroups.at(i).mName;
|
||||
element["columns"][0]["font"] = "SANSSERIF";
|
||||
|
||||
LLUIString areastr = getString("area_string");
|
||||
areastr.setArg("[AREA]", llformat("%d", gAgent.mGroups.at(i).mContribution));
|
||||
element["columns"][1]["column"] = "area";
|
||||
element["columns"][1]["value"] = areastr;
|
||||
element["columns"][1]["font"] = "SANSSERIF";
|
||||
|
||||
grant_list->addElement(element);
|
||||
grant_list->addElement(
|
||||
llsd::map(
|
||||
"id", id,
|
||||
"columns", llsd::array(
|
||||
llsd::map(
|
||||
"column", "group",
|
||||
"value", gAgent.mGroups.at(i).mName,
|
||||
"font", "SANSSERIF"),
|
||||
llsd::map(
|
||||
"column", "area",
|
||||
"value", areastr,
|
||||
"font", "SANSSERIF"))));
|
||||
}
|
||||
|
||||
|
||||
center();
|
||||
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
|
@ -108,8 +110,8 @@ LLFloaterLandHoldings::~LLFloaterLandHoldings()
|
|||
|
||||
void LLFloaterLandHoldings::onOpen(const LLSD& key)
|
||||
{
|
||||
LLScrollListCtrl *list = getChild<LLScrollListCtrl>("parcel list");
|
||||
list->clearRows();
|
||||
LLScrollListCtrl *list = getChild<LLScrollListCtrl>("parcel list");
|
||||
list->clearRows();
|
||||
|
||||
// query_id null is known to be us
|
||||
const LLUUID& query_id = LLUUID::null;
|
||||
|
|
|
|||
|
|
@ -143,7 +143,7 @@ void LLPathfindingNavMesh::handleNavMeshResult(const LLSD &pContent, U32 pNavMes
|
|||
unsigned int binSize = value.size();
|
||||
std::string newStr(reinterpret_cast<const char *>(&value[0]), binSize);
|
||||
std::istringstream streamdecomp( newStr );
|
||||
unsigned int decompBinSize = 0;
|
||||
size_t decompBinSize = 0;
|
||||
bool valid = false;
|
||||
U8* pUncompressedNavMeshContainer = unzip_llsdNavMesh( valid, decompBinSize, streamdecomp, binSize ) ;
|
||||
if ( !valid )
|
||||
|
|
|
|||
|
|
@ -568,11 +568,11 @@ void LLSettingsVOSky::convertAtmosphericsToLegacy(LLSD& legacy, LLSD& settings)
|
|||
legacy[SETTING_BLUE_DENSITY] = ensure_array_4(legacyhaze[SETTING_BLUE_DENSITY], 1.0);
|
||||
legacy[SETTING_BLUE_HORIZON] = ensure_array_4(legacyhaze[SETTING_BLUE_HORIZON], 1.0);
|
||||
|
||||
legacy[SETTING_DENSITY_MULTIPLIER] = LLSDArray(legacyhaze[SETTING_DENSITY_MULTIPLIER].asReal())(0.0f)(0.0f)(1.0f);
|
||||
legacy[SETTING_DISTANCE_MULTIPLIER] = LLSDArray(legacyhaze[SETTING_DISTANCE_MULTIPLIER].asReal())(0.0f)(0.0f)(1.0f);
|
||||
legacy[SETTING_DENSITY_MULTIPLIER] = llsd::array(legacyhaze[SETTING_DENSITY_MULTIPLIER].asReal(), 0.0f, 0.0f, 1.0f);
|
||||
legacy[SETTING_DISTANCE_MULTIPLIER] = llsd::array(legacyhaze[SETTING_DISTANCE_MULTIPLIER].asReal(), 0.0f, 0.0f, 1.0f);
|
||||
|
||||
legacy[SETTING_HAZE_DENSITY] = LLSDArray(legacyhaze[SETTING_HAZE_DENSITY])(0.0f)(0.0f)(1.0f);
|
||||
legacy[SETTING_HAZE_HORIZON] = LLSDArray(legacyhaze[SETTING_HAZE_HORIZON])(0.0f)(0.0f)(1.0f);
|
||||
legacy[SETTING_HAZE_DENSITY] = llsd::array(legacyhaze[SETTING_HAZE_DENSITY], 0.0f, 0.0f, 1.0f);
|
||||
legacy[SETTING_HAZE_HORIZON] = llsd::array(legacyhaze[SETTING_HAZE_HORIZON], 0.0f, 0.0f, 1.0f);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -586,15 +586,15 @@ LLSD LLSettingsVOSky::convertToLegacy(const LLSettingsSky::ptr_t &psky, bool isA
|
|||
legacy[SETTING_CLOUD_COLOR] = ensure_array_4(settings[SETTING_CLOUD_COLOR], 1.0);
|
||||
legacy[SETTING_CLOUD_POS_DENSITY1] = ensure_array_4(settings[SETTING_CLOUD_POS_DENSITY1], 1.0);
|
||||
legacy[SETTING_CLOUD_POS_DENSITY2] = ensure_array_4(settings[SETTING_CLOUD_POS_DENSITY2], 1.0);
|
||||
legacy[SETTING_CLOUD_SCALE] = LLSDArray(settings[SETTING_CLOUD_SCALE])(LLSD::Real(0.0))(LLSD::Real(0.0))(LLSD::Real(1.0));
|
||||
legacy[SETTING_CLOUD_SCALE] = llsd::array(settings[SETTING_CLOUD_SCALE], LLSD::Real(0.0), LLSD::Real(0.0), LLSD::Real(1.0));
|
||||
legacy[SETTING_CLOUD_SCROLL_RATE] = settings[SETTING_CLOUD_SCROLL_RATE];
|
||||
legacy[SETTING_LEGACY_ENABLE_CLOUD_SCROLL] = LLSDArray(LLSD::Boolean(!is_approx_zero(settings[SETTING_CLOUD_SCROLL_RATE][0].asReal())))
|
||||
(LLSD::Boolean(!is_approx_zero(settings[SETTING_CLOUD_SCROLL_RATE][1].asReal())));
|
||||
legacy[SETTING_CLOUD_SHADOW] = LLSDArray(settings[SETTING_CLOUD_SHADOW].asReal())(0.0f)(0.0f)(1.0f);
|
||||
legacy[SETTING_GAMMA] = LLSDArray(settings[SETTING_GAMMA])(0.0f)(0.0f)(1.0f);
|
||||
legacy[SETTING_LEGACY_ENABLE_CLOUD_SCROLL] = llsd::array(LLSD::Boolean(!is_approx_zero(settings[SETTING_CLOUD_SCROLL_RATE][0].asReal())),
|
||||
LLSD::Boolean(!is_approx_zero(settings[SETTING_CLOUD_SCROLL_RATE][1].asReal())));
|
||||
legacy[SETTING_CLOUD_SHADOW] = llsd::array(settings[SETTING_CLOUD_SHADOW].asReal(), 0.0f, 0.0f, 1.0f);
|
||||
legacy[SETTING_GAMMA] = llsd::array(settings[SETTING_GAMMA], 0.0f, 0.0f, 1.0f);
|
||||
legacy[SETTING_GLOW] = ensure_array_4(settings[SETTING_GLOW], 1.0);
|
||||
legacy[SETTING_LIGHT_NORMAL] = ensure_array_4(psky->getLightDirection().getValue(), 0.0f);
|
||||
legacy[SETTING_MAX_Y] = LLSDArray(settings[SETTING_MAX_Y])(0.0f)(0.0f)(1.0f);
|
||||
legacy[SETTING_MAX_Y] = llsd::array(settings[SETTING_MAX_Y], 0.0f, 0.0f, 1.0f);
|
||||
legacy[SETTING_STAR_BRIGHTNESS] = settings[SETTING_STAR_BRIGHTNESS].asReal() / 250.0f; // convert from 0-500 -> 0-2 ala pre-FS-compat changes
|
||||
legacy[SETTING_SUNLIGHT_COLOR] = ensure_array_4(settings[SETTING_SUNLIGHT_COLOR], 1.0f);
|
||||
|
||||
|
|
@ -1062,7 +1062,7 @@ LLSettingsDay::ptr_t LLSettingsVODay::buildFromLegacyPreset(const std::string &n
|
|||
|
||||
newsettings[SETTING_NAME] = name;
|
||||
|
||||
LLSD watertrack = LLSDArray(
|
||||
LLSD watertrack = llsd::array(
|
||||
LLSDMap(SETTING_KEYKFRAME, LLSD::Real(0.0f))
|
||||
(SETTING_KEYNAME, "water:Default"));
|
||||
|
||||
|
|
@ -1077,7 +1077,7 @@ LLSettingsDay::ptr_t LLSettingsVODay::buildFromLegacyPreset(const std::string &n
|
|||
skytrack.append(entry);
|
||||
}
|
||||
|
||||
newsettings[SETTING_TRACKS] = LLSDArray(watertrack)(skytrack);
|
||||
newsettings[SETTING_TRACKS] = llsd::array(watertrack, skytrack);
|
||||
|
||||
LLSD frames(LLSD::emptyMap());
|
||||
|
||||
|
|
@ -1165,7 +1165,7 @@ LLSettingsDay::ptr_t LLSettingsVODay::buildFromLegacyMessage(const LLUUID ®io
|
|||
watersettings[SETTING_NAME] = watername;
|
||||
frames[watername] = watersettings;
|
||||
|
||||
LLSD watertrack = LLSDArray(
|
||||
LLSD watertrack = llsd::array(
|
||||
LLSDMap(SETTING_KEYKFRAME, LLSD::Real(0.0f))
|
||||
(SETTING_KEYNAME, watername));
|
||||
|
||||
|
|
@ -1179,7 +1179,7 @@ LLSettingsDay::ptr_t LLSettingsVODay::buildFromLegacyMessage(const LLUUID ®io
|
|||
|
||||
LLSD newsettings = LLSDMap
|
||||
( SETTING_NAME, "Region (legacy)" )
|
||||
( SETTING_TRACKS, LLSDArray(watertrack)(skytrack))
|
||||
( SETTING_TRACKS, llsd::array(watertrack, skytrack))
|
||||
( SETTING_FRAMES, frames )
|
||||
( SETTING_TYPE, "daycycle" );
|
||||
|
||||
|
|
@ -1360,7 +1360,7 @@ LLSD LLSettingsVODay::convertToLegacy(const LLSettingsVODay::ptr_t &pday)
|
|||
skys[name.str()] = std::static_pointer_cast<LLSettingsSky>((*it).second);
|
||||
|
||||
F32 frame = ((tracksky.size() == 1) && (it == tracksky.begin())) ? -1.0f : (*it).first;
|
||||
llsdcycle.append( LLSDArray(LLSD::Real(frame))(name.str()) );
|
||||
llsdcycle.append( llsd::array(LLSD::Real(frame), name.str()) );
|
||||
}
|
||||
|
||||
LLSD llsdskylist(LLSD::emptyMap());
|
||||
|
|
@ -1373,7 +1373,7 @@ LLSD LLSettingsVODay::convertToLegacy(const LLSettingsVODay::ptr_t &pday)
|
|||
llsdskylist[(*its).first] = llsdsky;
|
||||
}
|
||||
|
||||
return LLSDArray(LLSD::emptyMap())(llsdcycle)(llsdskylist)(llsdwater);
|
||||
return llsd::array(LLSD::emptyMap(), llsdcycle, llsdskylist, llsdwater);
|
||||
}
|
||||
|
||||
LLSettingsSkyPtr_t LLSettingsVODay::getDefaultSky() const
|
||||
|
|
|
|||
|
|
@ -859,12 +859,12 @@ LLTextureCache::~LLTextureCache()
|
|||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//virtual
|
||||
S32 LLTextureCache::update(F32 max_time_ms)
|
||||
size_t LLTextureCache::update(F32 max_time_ms)
|
||||
{
|
||||
static LLFrameTimer timer ;
|
||||
static const F32 MAX_TIME_INTERVAL = 300.f ; //seconds.
|
||||
|
||||
S32 res;
|
||||
size_t res;
|
||||
res = LLWorkerThread::update(max_time_ms);
|
||||
|
||||
mListMutex.lock();
|
||||
|
|
|
|||
|
|
@ -113,7 +113,7 @@ public:
|
|||
LLTextureCache(bool threaded);
|
||||
~LLTextureCache();
|
||||
|
||||
/*virtual*/ S32 update(F32 max_time_ms);
|
||||
/*virtual*/ size_t update(F32 max_time_ms);
|
||||
|
||||
void purgeCache(ELLPath location, bool remove_dir = true);
|
||||
void setReadOnly(BOOL read_only) ;
|
||||
|
|
|
|||
|
|
@ -2879,9 +2879,9 @@ bool LLTextureFetch::updateRequestPriority(const LLUUID& id, F32 priority)
|
|||
// Threads: T*
|
||||
|
||||
//virtual
|
||||
S32 LLTextureFetch::getPending()
|
||||
size_t LLTextureFetch::getPending()
|
||||
{
|
||||
S32 res;
|
||||
size_t res;
|
||||
lockData(); // +Ct
|
||||
{
|
||||
LLMutexLock lock(&mQueueMutex); // +Mfq
|
||||
|
|
@ -2956,7 +2956,7 @@ void LLTextureFetch::commonUpdate()
|
|||
// Threads: Tmain
|
||||
|
||||
//virtual
|
||||
S32 LLTextureFetch::update(F32 max_time_ms)
|
||||
size_t LLTextureFetch::update(F32 max_time_ms)
|
||||
{
|
||||
static LLCachedControl<F32> band_width(gSavedSettings,"ThrottleBandwidthKBPS", 3000.0);
|
||||
|
||||
|
|
@ -2970,7 +2970,7 @@ S32 LLTextureFetch::update(F32 max_time_ms)
|
|||
mNetworkQueueMutex.unlock(); // -Mfnq
|
||||
}
|
||||
|
||||
S32 res = LLWorkerThread::update(max_time_ms);
|
||||
size_t res = LLWorkerThread::update(max_time_ms);
|
||||
|
||||
if (!mThreaded)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -65,7 +65,7 @@ public:
|
|||
class TFRequest;
|
||||
|
||||
// Threads: Tmain
|
||||
/*virtual*/ S32 update(F32 max_time_ms);
|
||||
/*virtual*/ size_t update(F32 max_time_ms);
|
||||
|
||||
// called in the main thread after the TextureCacheThread shuts down.
|
||||
// Threads: Tmain
|
||||
|
|
@ -131,7 +131,7 @@ public:
|
|||
U32 getTotalNumHTTPRequests();
|
||||
|
||||
// Threads: T*
|
||||
S32 getPending();
|
||||
size_t getPending();
|
||||
|
||||
// Threads: T*
|
||||
void lockQueue() { mQueueMutex.lock(); }
|
||||
|
|
|
|||
|
|
@ -6284,7 +6284,7 @@ bool handle_lure_callback(const LLSD& notification, const LLSD& response)
|
|||
// More than OFFER_RECIPIENT_LIMIT targets will overload the message
|
||||
// producing an llerror.
|
||||
LLSD args;
|
||||
args["OFFERS"] = notification["payload"]["ids"].size();
|
||||
args["OFFERS"] = LLSD::Integer(notification["payload"]["ids"].size());
|
||||
args["LIMIT"] = static_cast<int>(OFFER_RECIPIENT_LIMIT);
|
||||
LLNotificationsUtil::add("TooManyTeleportOffers", args);
|
||||
return false;
|
||||
|
|
|
|||
Loading…
Reference in New Issue