codesearch.isocpp.org by Andrew Tomazos.

Enter a valid C/C++ code snippet...

Searching for `static_cast<size_t>`...

2489599 source files searched.

27515 matches found.

Here is a random sample of matches...


actcd19/main/b/boost1.62/boost1.62_1.62.0+dfsg-10/boost/compute/algorithm/detail/merge_sort_on_cpu.hpp:138:

                                      command_queue &queue)
{
const size_t blocks_no = static_cast<size_t>(
std::ceil(float(count) / block_size)
);


actcd19/main/n/node-iconv/node-iconv_2.3.0-1/.pc/use-glibc-iconv.patch/src/binding.cc:122:

                             &output_size);
int errorno = 0;
if (nconv == static_cast<size_t>(-1)) {
errorno = errno;
}


actcd19/main/a/android-platform-art/android-platform-art_8.1.0+r23-3/compiler/utils/x86/assembler_x86_test.cc:31:

      AssemblerBuffer::EnsureCapacity ensured(&buffer);
buffer.Emit<uint8_t>(0x42);
ASSERT_EQ(static_cast<size_t>(1), buffer.Size());
buffer.Emit<int32_t>(42);
ASSERT_EQ(static_cast<size_t>(5), buffer.Size());


actcd19/main/c/chromium/chromium_72.0.3626.121-1/mojo/core/broker_posix.cc:42:

        PLOG(ERROR) << "Recvmsg error";
error = true;
} else if (static_cast<size_t>(read_result) != message->data_num_bytes()) {
LOG(ERROR) << "Invalid node channel message";
error = true;


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/net/nqe/observation_buffer_unittest.cc:537:

        EXPECT_EQ(110 * host_index,
host_keyed_percentiles[static_cast<uint64_t>(host_index)]);
EXPECT_EQ(static_cast<size_t>(20 * host_index + 1),
host_keyed_counts[static_cast<uint64_t>(host_index)]);
}


actcd19/main/f/firefox/firefox_65.0.1-1/security/ct/CTObjectsExtractor.cpp:264:

          size_t extensionsContextLengthAsSizeT =
static_cast<size_t>(extensionsHeader.GetLength()) +
static_cast<size_t>(extensionsValueLength);
rv = CheckForInputSizeTypeOverflow(extensionsContextLengthAsSizeT);
if (rv != Success) {


actcd19/main/libk/libkml/libkml_1.3.0-5/tests/kml/dom/geometry_test.cc:98:

      Vec3 v(kLon, kLat, kAlt);
coordinates_->add_vec3(v);
ASSERT_EQ(static_cast<size_t>(1),
coordinates_->get_coordinates_array_size());
Vec3 vec3_0 = coordinates_->get_coordinates_array_at(0);


actcd19/main/c/chromium/chromium_72.0.3626.121-1/media/filters/source_buffer_state.cc:308:

        DCHECK_LE(estimated_new_size, SIZE_MAX);
success &= it.second->EvictCodedFrames(
media_time, static_cast<size_t>(estimated_new_size));
}


actcd19/main/m/mathic/mathic_1.0~git20180311-2/src/mathic/HashTable.h:158:

      {
mHashTable.resize(mTableSize);
mMaxCountBeforeRebuild = static_cast<size_t>(mRebuildThreshold * mTableSize);
}


actcd19/main/s/salmon/salmon_0.12.0+ds1-1/include/MultinomialSampler.hpp:51:

            // Find the offset of the element to increment
auto it = std::lower_bound(z.begin(), z.end() - 1, u);
size_t offset = static_cast<size_t>(std::distance(z.begin(), it));

if (*it > u and offset > 0) {


actcd19/main/libr/libreoffice/libreoffice_6.1.5-1/o3tl/qa/test-sorted_vector.cxx:219:

    
CPPUNIT_ASSERT_EQUAL( static_cast<size_t>(1), aVec.erase(p1.get()) );
CPPUNIT_ASSERT_EQUAL( static_cast<size_t>(2), aVec.size() );

aVec.erase(1);


actcd19/main/libr/libreoffice/libreoffice_6.1.5-1/forms/source/component/ListBox.cxx:1635:

                    const std::vector<OUString>& rStrings = getStringItemList();
const Sequence<Any>& rValues = getTypedItemList();
if (rStrings.size() == static_cast<size_t>(rValues.getLength()))
aReturn = lcl_getSingleSelectedEntryTyped( aSelectSequence, rValues );
else


actcd19/main/w/webkit2gtk/webkit2gtk_2.22.7-1/Tools/TestWebKitAPI/Tests/WTF/StringView.cpp:439:

        EXPECT_EQ(static_cast<size_t>(0), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "abcÉ")));
EXPECT_EQ(static_cast<size_t>(0), referenceB.findIgnoringASCIICase(stringViewFromLiteral("A")));
EXPECT_EQ(static_cast<size_t>(0), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCÉ")));

// Not a prefix.


actcd19/main/p/pcl/pcl_1.8.0+dfsg1-6/filters/include/pcl/filters/impl/random_sample.hpp:108:

      {
// Resize output indices to sample size
indices.resize (static_cast<size_t> (sample_size));
if (extract_removed_indices_)
removed_indices_->resize (static_cast<size_t> (N - sample_size));


actcd19/main/a/android-platform-art/android-platform-art_8.1.0+r23-3/runtime/gc/allocator/rosalloc.cc:445:

    
// Insert it.
DCHECK_EQ(fpr->ByteSize(this) % kPageSize, static_cast<size_t>(0));
DCHECK(free_page_runs_.find(fpr) == free_page_runs_.end());
DCHECK(fpr->IsFree());


actcd19/main/q/qt3d-opensource-src/qt3d-opensource-src_5.11.3+dfsg-2/src/3rdparty/assimp/code/FBXConverter.cpp:1583:

    
for ( unsigned int i = 0; i < count; ++i ) {
if ( no_mat_check || static_cast<size_t>( mats[ geo.FaceForVertexIndex( out_idx[ i ] ) ] ) == materialIndex ) {

if ( index_out_indices.back() == no_index_sentinel ) {


actcd19/main/o/opengrm-ngram/opengrm-ngram_1.3.2-3/src/include/ngram/ngram-count.h:246:

      struct PairHash {
size_t operator()(const Pair &p) const {
return (static_cast<size_t>(p.first) * 55697) ^
(static_cast<size_t>(p.second) * 54631);
// TODO(allauzen): run benchmark using Compose's hash function


actcd19/main/p/pugixml/pugixml_1.9-2/tests/test_document.cpp:45:

    
CHECK(length >= 0);
size = static_cast<size_t>(length);
data = new char[size];


actcd19/main/o/orthanc/orthanc_1.5.6+dfsg-1/Core/Compression/ZlibCompressor.cpp:128:

        try
{
uncompressed.resize(static_cast<size_t>(uncompressedSize));
}
catch (...)


actcd19/main/i/imagevis3d/imagevis3d_3.1.0-7/ImageVis3D/UI/Q2DTransferFunction.cpp:151:

      if (!m_pHistImage ||
static_cast<size_t>(m_pHistImage->height()) != m_vHistogram.GetSize().x ||
static_cast<size_t>(m_pHistImage->width()) != m_vHistogram.GetSize().y) {
delete m_pHistImage;
m_pHistImage = new QImage(QSize(int(m_vHistogram.GetSize().x), int(m_vHistogram.GetSize().y)), QImage::Format_RGB32);


actcd19/main/q/qtwebkit-opensource-src/qtwebkit-opensource-src_5.212.0~alpha2-20/Source/ThirdParty/ANGLE/src/libANGLE/validationES2.cpp:104:

            }

if (static_cast<size_t>(xoffset + width) > texture->getWidth(target, level) ||
static_cast<size_t>(yoffset + height) > texture->getHeight(target, level))
{


actcd19/main/m/mono/mono_5.18.0.240+dfsg-2/external/corefx/src/Native/Unix/System.Native/pal_runtimeinformation.cpp:30:

        if (uname(&_utsname) != -1)
{
int r = snprintf(version, static_cast<size_t>(*capacity), "%s %s %s", _utsname.sysname, _utsname.release, _utsname.version);
if (r > *capacity)
{


actcd19/main/g/gromacs/gromacs_2019-2/src/gromacs/restraint/restraintmdmodule.cpp:165:

        if ((cr.dd == nullptr) || (bLocal = cr.dd->ga2la->findHome(site2)))
{
force[static_cast<size_t>(*bLocal)] -= result.force;
}
}


actcd19/main/m/mygui/mygui_3.2.2+dfsg-2/UnitTests/TestApp/pugixml.cpp:2725:

    			xml_encoding native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be;

if (native_encoding != encoding) convert_utf_endian_swap(dest, dest, static_cast<size_t>(end - dest));

return static_cast<size_t>(end - dest) * sizeof(uint16_t);


actcd19/main/z/zeromq3/zeromq3_4.3.1-3/src/stream_engine.cpp:381:

            _outsize = _encoder->encode (&_outpos, 0);

while (_outsize < static_cast<size_t> (out_batch_size)) {
if ((this->*_next_msg) (&_tx_msg) == -1)
break;


actcd19/main/e/erlang-jiffy/erlang-jiffy_0.14.11+dfsg-4/.pc/riscv64/c_src/double-conversion/utils.h:162:

    inline int StrLength(const char* string) {
size_t length = strlen(string);
ASSERT(length == static_cast<size_t>(static_cast<int>(length)));
return static_cast<int>(length);
}


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/net/base/prioritized_dispatcher_unittest.cc:197:

      retrieved_limits = dispatcher_->GetLimits();
ASSERT_EQ(new_limits.total_jobs, retrieved_limits.total_jobs);
ASSERT_EQ(static_cast<size_t>(NUM_PRIORITIES),
retrieved_limits.reserved_slots.size());
for (size_t priority = MINIMUM_PRIORITY; priority <= MAXIMUM_PRIORITY;


actcd19/main/m/mozjs60/mozjs60_60.2.3-2/mfbt/tests/TestIntegerRange.cpp:40:

      MOZ_RELEASE_ASSERT(ptr - array == static_cast<ptrdiff_t>(aN),
"Should iterates N items");
for (size_t i = 0; i < static_cast<size_t>(aN); i++) {
MOZ_RELEASE_ASSERT(array[i] == static_cast<IntType>(i),
"Values should equal to the index");


actcd19/main/m/mariadb-10.3/mariadb-10.3_10.3.12-2/storage/rocksdb/rocksdb/util/core_local.h:72:

        core_idx = Random::GetTLSInstance()->Uniform(1 << size_shift_);
} else {
core_idx = static_cast<size_t>(cpuid & ((1 << size_shift_) - 1));
}
return {AccessAtCore(core_idx), core_idx};


actcd19/main/libr/libreoffice/libreoffice_6.1.5-1/sc/qa/unit/ucalc.cxx:223:

        clearRange(m_pDoc, ScAddress(0,1,0));
rPool.purge();
CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(3), rPool.getCount());
CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(2), rPool.getCountIgnoreCase());


actcd19/main/c/clickhouse/clickhouse_18.16.1+ds-4/dbms/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp:1096:

            res += part->bytes_on_disk;

return static_cast<size_t>(res * DISK_USAGE_COEFFICIENT_TO_RESERVE);
}


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/minidump_writer.cc:1177:

                const char* p = my_strchr(tag, ' ');
if (p) {
tag_len = static_cast<size_t>(p - tag);
value += tag_len + 1;
value_len -= tag_len + 1;


actcd19/main/o/openjfx/openjfx_11.0.2+1-1/modules/javafx.web/src/main/native/Source/WebCore/platform/network/BlobResourceHandle.cpp:124:

    
// Read all the data.
m_data.resize(static_cast<size_t>(response.expectedContentLength()));
static_cast<BlobResourceHandle*>(handle)->readSync(m_data.data(), static_cast<int>(m_data.size()));
completionHandler();


actcd19/main/q/qtwebkit/qtwebkit_2.3.4.dfsg-10/.pc/hurd.diff/Source/WTF/wtf/FastMalloc.cpp:1801:

                size_t length = DLL_Length(&slist->normal);
size_t numSpansToReturn = (i > kMinSpanListsWithSpans) ? length : length / 2;
for (int j = 0; static_cast<size_t>(j) < numSpansToReturn && !DLL_IsEmpty(&slist->normal) && free_committed_pages_ > targetPageCount; j++) {
Span* s = slist->normal.prev;
DLL_Remove(s);


actcd19/main/libr/libreoffice/libreoffice_6.1.5-1/sc/source/filter/xml/XMLStylesExportHelper.cxx:842:

        bool& bIsAutoStyle, sal_Int32& nValidationIndex, sal_Int32& nNumberFormat, const sal_Int32 nRemoveBeforeRow)
{
OSL_ENSURE(static_cast<size_t>(nTable) < aTables.size(), "wrong table");
if (static_cast<size_t>(nTable) >= aTables.size())
return -1;


actcd19/main/b/boost1.62/boost1.62_1.62.0+dfsg-1/boost/iostreams/detail/buffer.hpp:128:

            if (result < amt) {
traits_type::move( this->data(),
ptr_ + static_cast<size_t>(result),
static_cast<size_t>(amt - result) );
}


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/net/disk_cache/blockfile/file_posix.cc:52:

    bool File::Write(const void* buffer, size_t buffer_len, size_t offset) {
DCHECK(base_file_.IsValid());
if (buffer_len > static_cast<size_t>(std::numeric_limits<int32_t>::max()) ||
offset > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
return false;


actcd19/main/r/rocksdb/rocksdb_5.17.2-3/db/compaction.cc:281:

      assert(input_version_ != nullptr);
assert(level_ptrs != nullptr);
assert(level_ptrs->size() == static_cast<size_t>(number_levels_));
if (bottommost_level_) {
return true;


actcd19/main/q/qtwebkit-opensource-src/qtwebkit-opensource-src_5.212.0~alpha2-5/Source/WebCore/platform/image-decoders/gif/GIFImageReader.cpp:367:

            return true;

while (m_currentDecodingFrame < std::min(m_frames.size(), static_cast<size_t>(haltAtFrame))) {
bool frameDecoded = false;
GIFFrameContext* currentFrame = m_frames[m_currentDecodingFrame].get();


actcd19/main/libr/libreoffice/libreoffice_6.0.6~rc1-1/svx/source/items/numfmtsh.cxx:1302:

        if( !aCurrencyFormatList.empty() )
{
if( aCurrencyFormatList.size() > static_cast<size_t>(nEntry) )
return aCurrencyFormatList[nEntry];
}


actcd19/main/c/chromium/chromium_72.0.3626.121-1/third_party/blink/renderer/platform/loader/fetch/memory_cache_test.cc:126:

    // Verifies that setters and getters for cache capacities work correcty.
TEST_F(MemoryCacheTest, CapacityAccounting) {
const size_t kSizeMax = ~static_cast<size_t>(0);
const size_t kTotalCapacity = kSizeMax / 4;
GetMemoryCache()->SetCapacity(kTotalCapacity);


actcd19/main/d/digikam/digikam_5.9.0-1/core/tests/facesengine/asmopencv.h:120:

                              CV_8UC4,
const_cast<uchar*>(inImage.bits()),
static_cast<size_t>(inImage.bytesPerLine())
);


actcd19/main/c/cmake/cmake_3.13.4-1/Source/CTest/cmCTestMemCheckHandler.cxx:914:

        if (!unlimitedOutput &&
totalOutputSize >
static_cast<size_t>(this->CustomMaximumFailedTestOutputSize)) {
ostr << "....\n";
ostr << "Test Output for this test has been truncated see testing"


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/third_party/breakpad/breakpad/src/common/android/breakpad_getcontext_unittest.cc:111:

                offsetof(ucontext_t,uc_mcontext.fpregs));

ASSERT_EQ(static_cast<size_t>(MCONTEXT_FPC_CSR),
offsetof(ucontext_t,uc_mcontext.fpc_csr));
#elif defined(__x86_64__)


actcd19/main/q/qtbase-opensource-src/qtbase-opensource-src_5.11.3+dfsg-5/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d9/VertexBuffer9.cpp:105:

        if (!needsConversion && inputStride == elementSize)
{
size_t copySize = static_cast<size_t>(count) * static_cast<size_t>(inputStride);
memcpy(mapPtr, input, copySize);
}


actcd19/main/c/cataclysm-dda/cataclysm-dda_0.C+git20190228.faafa3a-2/src/iteminfo_query.cpp:15:

    {
for( auto &bit : setBits ) {
set( static_cast<size_t>( bit ) );
}
}


actcd19/main/b/botan/botan_2.9.0-2/src/lib/pubkey/mce/mceliece_key.cpp:118:

       enc.start_cons(SEQUENCE)
.start_cons(SEQUENCE)
.encode(static_cast<size_t>(get_code_length()))
.encode(static_cast<size_t>(get_t()))
.end_cons()


actcd19/main/m/med-fichier/med-fichier_4.0.0+repack-7/python/medenumtest_long_wrap.cc:4971:

        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "med_memfile_vfd_image_size_set" "', argument " "2"" of type '" "size_t""'");
}
arg2 = static_cast< size_t >(val2);
if (arg1) (arg1)->vfd_image_size = arg2;
resultobj = SWIG_Py_Void();


actcd19/main/n/nodejs/nodejs_10.15.2~dfsg-1/deps/v8/src/wasm/wasm-interpreter.cc:2718:

                                        bool enabled) {
InterpreterCode* code = internals_->codemap_.GetCode(function);
size_t size = static_cast<size_t>(code->end - code->start);
// Check bounds for {pc}.
if (pc < code->locals.encoded_size || pc >= size) return false;


actcd19/main/n/nodejs/nodejs_4.6.1~dfsg-1/deps/v8/src/heap/heap-inl.h:417:

        }
} else {
MemMove(dst, src, static_cast<size_t>(byte_size));
}
}


actcd19/main/libo/liborcus/liborcus_0.14.0+really0.13.4-3/src/spreadsheet/document.cpp:424:

    const sheet* document::get_sheet(sheet_t sheet_pos) const
{
if (static_cast<size_t>(sheet_pos) >= mp_impl->m_sheets.size())
return nullptr;


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/third_party/angle/src/libANGLE/validationES.cpp:812:

            bool fillsEntireMip = xoffset == 0 && yoffset == 0 &&
static_cast<size_t>(width) == textureWidth &&
static_cast<size_t>(height) == textureHeight;
bool sizeMultipleOfBlockSize = (width % formatInfo.compressedBlockWidth) == 0 &&
(height % formatInfo.compressedBlockHeight) == 0;


actcd19/main/libr/libreoffice/libreoffice_6.0.6~rc1-1/sw/qa/core/uwriter.cxx:1715:

        aRing3.MoveTo(&aRing1);
CPPUNIT_ASSERT_EQUAL(aRing1.GetRingContainer().size(), static_cast<size_t>(3));
CPPUNIT_ASSERT_EQUAL(aRing2.GetRingContainer().size(), static_cast<size_t>(3));
CPPUNIT_ASSERT_EQUAL(aRing3.GetRingContainer().size(), static_cast<size_t>(3));
CPPUNIT_ASSERT(!aRing1.lonely());


actcd19/main/t/trilinos/trilinos_12.12.1-7/packages/tpetra/core/inout/Tpetra_Details_CooMatrix.hpp:1474:

        // This is ultimately an MPI restriction.
if (static_cast<size_t> (imports.dimension_0 ()) >
static_cast<size_t> (std::numeric_limits<int>::max ())) {
std::ostream& err = this->markLocalErrorAndGetStream ();
err << prefix << "imports.dimension_0() = "


actcd19/main/t/thunderbird/thunderbird_60.5.1-1/modules/pdfium/pdfium/core/fxcrt/fx_basic_wstring.cpp:173:

        return m_pData->m_nDataLength == 0;

return wcslen(ptr) == static_cast<size_t>(m_pData->m_nDataLength) &&
wmemcmp(ptr, m_pData->m_String, m_pData->m_nDataLength) == 0;
}


actcd19/main/s/swift-im/swift-im_3.0.4-1/Swift/Controllers/HighlightManager.cpp:98:

    {
assert(index >= 0 && static_cast<size_t>(index) < rules_->getSize());
return rules_->getRule(static_cast<size_t>(index));
}


actcd19/main/n/nodejs/nodejs_10.15.2~dfsg-1/deps/v8/third_party/antlr4/runtime/Cpp/runtime/src/Recognizer.h:14:

    class ANTLR4CPP_PUBLIC Recognizer {
public:
static const size_t EOF = static_cast<size_t>(
-1); // std::numeric_limits<size_t>::max(); doesn't work in VS 2013.


actcd19/main/n/nghttp2/nghttp2_1.36.0-2/src/allocator.h:112:

      void *alloc(size_t size) {
if (size + sizeof(size_t) >= isolation_threshold) {
auto len = std::max(static_cast<size_t>(16), size);
// We will store the allocated size in size_t field.
auto mb = alloc_mem_block(len + sizeof(size_t));


actcd19/main/p/protobuf/protobuf_2.6.1-2/gtest/src/gtest-port.cc:325:

      const size_t min_count = (repeat == '+') ? 1 : 0;
const size_t max_count = (repeat == '?') ? 1 :
static_cast<size_t>(-1) - 1;
// We cannot call numeric_limits::max() as it conflicts with the
// max() macro on Windows.


actcd19/main/w/webkit2gtk/webkit2gtk_2.18.3-1/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp:2573:

        if (m_cachedStatements[static_cast<size_t>(sql)]) {
if (m_cachedStatements[static_cast<size_t>(sql)]->reset() == SQLITE_OK)
return m_cachedStatements[static_cast<size_t>(sql)].get();
m_cachedStatements[static_cast<size_t>(sql)] = nullptr;
}


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/content/browser/accessibility/web_contents_accessibility_android.cc:1176:

      }
return base::android::ToJavaIntArray(env, coords,
static_cast<size_t>(4 * len));
}


actcd19/main/c/chromium/chromium_72.0.3626.121-1/third_party/webrtc/modules/audio_processing/aec/system_delay_unittest.cc:101:

    
// One frame equals 10 ms of data.
samples_per_frame_ = static_cast<size_t>(sample_rate_hz / 100);
}


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/third_party/skia/tools/debugger/SkDrawCommand.cpp:479:

        const auto mode = paint.getBlendMode();
if (mode != SkBlendMode::kSrcOver) {
SkASSERT(static_cast<size_t>(mode) < SK_ARRAY_COUNT(gBlendModeMap));
(*target)[SKDEBUGCANVAS_ATTRIBUTE_BLENDMODE] =
Json::Value(gBlendModeMap[static_cast<size_t>(mode)]);


actcd19/main/b/bitcoin/bitcoin_0.12.1-0.1/src/leveldb/util/bloom.cc:26:

          : bits_per_key_(bits_per_key) {
// We intentionally round down to reduce probing cost a little bit
k_ = static_cast<size_t>(bits_per_key * 0.69); // 0.69 =~ ln(2)
if (k_ < 1) k_ = 1;
if (k_ > 30) k_ = 30;


actcd19/main/c/chromium/chromium_72.0.3626.121-1/third_party/webrtc/modules/audio_processing/aec3/residual_echo_estimator.cc:53:

      RTC_DCHECK(idx_stop);
if (gain_limiter_running) {
if (static_cast<size_t>(headroom) >
echo_model.render_post_window_size_init) {
*idx_start = spectrum_buffer.OffsetIndex(


actcd19/main/s/shogun/shogun_3.2.0-8/src/shogun/lib/tapkee/external/barnes_hut_sne/vptree.hpp:237:

    			if(heap.size() == static_cast<size_t>(k)) heap.pop(); // remove furthest node from result list (if we already have k results)
heap.push(HeapItem(node->index, dist)); // add current node to result list
if(heap.size() == static_cast<size_t>(k)) _tau = heap.top().dist; // update value of tau (farthest point in result list)
}


actcd19/main/q/qtbase-opensource-src/qtbase-opensource-src_5.10.1+dfsg-5/src/3rdparty/angle/src/common/angleutils.cpp:24:

        // Attempt to just print to the current buffer
int len = vsnprintf(&(outBuffer.front()), outBuffer.size(), fmt, vararg);
if (len < 0 || static_cast<size_t>(len) >= outBuffer.size())
{
// Buffer was not large enough, calculate the required size and resize the buffer


actcd19/main/a/alljoyn-core-1604/alljoyn-core-1604_16.04a+dfsg.1-3/common/unit_test/StringTest.cc:36:

        /* Test find_first_of */
ASSERT_EQ(static_cast<size_t>(3), s.find_first_of('d'));
ASSERT_EQ(static_cast<size_t>(3), s.find_first_of('d', 3));
ASSERT_EQ(static_cast<size_t>(3), s.find_first_of("owed", 3));
ASSERT_EQ(+qcc::String::npos, s.find_first_of('d', 8));


actcd19/main/l/llvm-toolchain-3.8/llvm-toolchain-3.8_3.8.1-23/lldb/source/Core/CxaDemangle.cpp:599:

                    {
sub *= 10;
sub += static_cast<size_t>(*t - '0');
}
if (t == last || *t != '_' || db.template_param.empty())


actcd19/main/f/fauhdlc/fauhdlc_20180504-1/frontend/visitor/ConstantPropagation.cpp:200:

    	assert(ca->elements != NULL);
assert(0 <= ci->value);
const size_t idx = static_cast<size_t>(ci->value);
assert(idx < ca->elements->size());


actcd19/main/i/imagevis3d/imagevis3d_3.1.0-7/Tuvok/IO/uvfDataset.cpp:1173:

                ts->m_vvaMaxMin[0]
[static_cast<size_t>(key.brick[0])]
[static_cast<size_t>(key.brick[1])]
[static_cast<size_t>(key.brick[2])];


actcd19/main/c/chromium/chromium_72.0.3626.121-1/components/viz/service/frame_sinks/video_capture/interprocess_frame_pool_unittest.cc:25:

      EXPECT_TRUE(region.IsValid());
constexpr int kI420BitsPerPixel = 12;
EXPECT_LE(static_cast<size_t>(kSize.GetArea() * kI420BitsPerPixel / 8),
region.GetSize());
}


actcd19/main/w/webkit2gtk/webkit2gtk_2.22.7-1/Source/WebCore/html/HTMLMediaElement.cpp:306:

        static_assert(static_cast<size_t>(HTMLMediaElement::PlaybackWithoutUserGesture::Prevented) == 2, "PlaybackWithoutUserGesture::Prevented is not 2 as expected");
ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
return values[static_cast<size_t>(enumerationValue)];
}


actcd19/main/n/nodejs/nodejs_10.15.2~dfsg-1/deps/v8/src/compiler/instruction-selector.cc:312:

      int rename = virtual_register;
while (true) {
if (static_cast<size_t>(rename) >= virtual_register_rename_.size()) break;
int next = virtual_register_rename_[rename];
if (next == InstructionOperand::kInvalidVirtualRegister) {


actcd19/main/p/psi4/psi4_1.2.1-2/psi4/src/psi4/psimrcc/transform_presort.cc:95:

                      (size_t)memory_required);

if(memory_required < static_cast<size_t>(3) * memory_manager->get_FreeMemory()){
outfile->Printf("\n Presorting is not required");
}


actcd19/main/l/llvm-toolchain-8/llvm-toolchain-8_8~+rc3-1~exp1/lldb/tools/lldb-mi/MICmdCmdData.cpp:1532:

      const size_t nBytesWritten = sbProcess.WriteMemory(
addr, (const void *)m_pBufferMemory, (size_t)m_nCount, error);
if (nBytesWritten != static_cast<size_t>(m_nCount)) {
SetError(
CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_LLDB_ERR_NOT_WRITE_WHOLEBLK),


actcd19/main/f/firefox/firefox_65.0.1-1/gfx/angle/checkout/src/libANGLE/FramebufferAttachment.cpp:31:

                                                                      GLsizei numViews)
{
const size_t numViewsAsSizeT = static_cast<size_t>(numViews);
std::vector<Offset> offsetVector;
offsetVector.reserve(numViewsAsSizeT);


actcd19/main/m/mono/mono_5.18.0.240+dfsg-2/external/corefx/src/Native/Unix/System.Native/pal_runtimeextensions.cpp:15:

        if (uname(&_utsname) != -1)
{
int r = snprintf(version, static_cast<size_t>(*capacity), "%s", _utsname.nodename);
if (r > *capacity)
{


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/net/disk_cache/blockfile/file_ios.cc:217:

      int ret = base_file_.Write(offset, static_cast<const char*>(buffer),
buffer_len);
return (static_cast<size_t>(ret) == buffer_len);
}


actcd19/main/q/quickfix/quickfix_1.14.4+dfsg-1/src/C++/pugixml.cpp:3918:

    
// return buffer
size_t actual_length = static_cast<size_t>(stream.gcount());
assert(actual_length <= read_length);


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/third_party/protobuf/src/google/protobuf/repeated_field.h:1338:

          (std::numeric_limits<size_t>::max() - kRepHeaderSize) / sizeof(Element))
<< "Requested size is too large to fit into size_t.";
size_t bytes = kRepHeaderSize + sizeof(Element) * static_cast<size_t>(new_size);
if (arena == NULL) {
rep_ = static_cast<Rep*>(::operator new(bytes));


actcd19/main/p/psi-plus/psi-plus_1.4.554-1/src/plugins/generic/omemoplugin/src/crypto_ossl.cpp:141:

        QVector<uint8_t> vector(length);
int res = EVP_DigestFinal(static_cast<EVP_MD_CTX *>(context), vector.data(), nullptr);
*output = signal_buffer_create(vector.data(), static_cast<size_t>(vector.size()));
return res == 1 ? SG_SUCCESS : SG_ERR_INVAL;
}


actcd19/main/c/chromium/chromium_72.0.3626.121-1/net/disk_cache/blockfile/file_posix.cc:42:

      DCHECK(base_file_.IsValid());
if (buffer_len > static_cast<size_t>(std::numeric_limits<int32_t>::max()) ||
offset > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
return false;
}


actcd19/main/a/actor-framework/actor-framework_0.16.3-0.2/libcaf_core/src/term.cpp:137:

    std::ostream& operator<<(std::ostream& out, term x) {
if (is_tty(out))
set_term_color(out, tty_codes[static_cast<size_t>(x)]);
else if (x == term::reset_endl)
out << '\n';


actcd19/main/q/qt3d-opensource-src/qt3d-opensource-src_5.11.3+dfsg-2/src/3rdparty/assimp/code/PlyExporter.cpp:97:

        }

outfile->Write(exporter.mOutput.str().c_str(), static_cast<size_t>(exporter.mOutput.tellp()), 1);
}


actcd19/main/r/rapidjson/rapidjson_1.1.0+dfsg2-5/include/rapidjson/reader.h:354:

    
// 16-byte align to the next boundary
const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
while (p != nextAligned)
if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')


actcd19/main/a/alljoyn-core-1604/alljoyn-core-1604_16.04a+dfsg.1-3/common/inc/qcc/String.h:435:

         */
QCC_DEPRECATED_ON(size_t find_last_of(const char c, size_t pos = npos) const, 16.04) {
return (pos == static_cast<size_t>(0)) ? npos : s.find_last_of(c, pos - 1);
}


actcd19/main/libt/libt3widget/libt3widget_1.0.3-1/src/textline.cc:609:

    
for (i = start;
static_cast<size_t>(i) < impl->buffer.size() &&
((newCclass = get_class(impl->buffer, i)) == cclass || newCclass == CLASS_WHITESPACE);
i = adjust_position(i, 1)) {


actcd19/main/o/openclonk/openclonk_8.1-1/src/network/C4NetIO.cpp:1768:

    	iIBufUsage += iSize;
// a prior call to GetRecvBuf should have ensured this
assert(static_cast<size_t>(iIBufUsage) <= IBuf.getSize());
// read packets
size_t iPos = 0, iPacketPos;


actcd19/main/libk/libkml/libkml_1.3.0-5/tests/kml/base/csv_splitter_test.cc:77:

      StringVector cols;
ASSERT_TRUE(csv_splitter.SplitCurrentLine(&cols));
ASSERT_EQ(static_cast<size_t>(2), cols.size());
}


actcd19/main/c/chromium/chromium_72.0.3626.121-1/net/disk_cache/blockfile/file_ios.cc:270:

        return std::numeric_limits<uint32_t>::max();

return static_cast<size_t>(len);
}


actcd19/main/t/trilinos/trilinos_12.12.1-7/packages/intrepid/src/Cell/Intrepid_CellToolsDef.hpp:2620:

          break;
case 2:
dim1 = static_cast<size_t>(points.dimension(0));
pointDim = static_cast<size_t>(points.dimension(1));
break;


actcd19/main/q/qtwebengine-opensource-src/qtwebengine-opensource-src_5.11.3+dfsg-2/src/3rdparty/chromium/gpu/command_buffer/service/texture_manager.cc:752:

      DCHECK_LT(static_cast<size_t>(face_index),
face_infos_.size());
DCHECK_LT(static_cast<size_t>(level),
face_infos_[face_index].level_infos.size());


actcd19/main/g/grpc/grpc_1.16.1-1/test/core/end2end/tests/bad_ping.cc:304:

      op->reserved = nullptr;
op++;
error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops), tag(1),
nullptr);
GPR_ASSERT(GRPC_CALL_OK == error);


actcd19/main/libv/libvmime/libvmime_0.9.2-5/src/vmime/net/imap/IMAPFolderStatus.cpp:201:

    	{
const size_t count =
static_cast <size_t>(resp->number()->value());

if (m_count != count)


actcd19/main/a/android-platform-art/android-platform-art_8.1.0+r23-3/runtime/gc/space/space_test.h:208:

            EXPECT_EQ(bytes_allocated, allocation_size);
if (object_size > 0) {
EXPECT_GE(allocation_size, static_cast<size_t>(object_size));
} else {
EXPECT_GE(allocation_size, 8u);


actcd19/main/a/android-platform-art/android-platform-art_8.1.0+r23-3/runtime/arch/stub_test.cc:1214:

    
for (size_t i = 0; i < arraysize(values); ++i) {
test->Invoke3WithReferrer(static_cast<size_t>(f->GetDexFieldIndex()),
static_cast<size_t>(values[i]),
0U,


actcd19/main/c/csound/csound_6.12.2~dfsg-3/Opcodes/mixer.cpp:175:

        csound::QueryGlobalPointer(csound, "busses", busses);
csound::QueryGlobalPointer(csound, "matrix", matrix);
send = static_cast<size_t>(*isend);
buss = static_cast<size_t>(*ibuss);
createBuss(csound, buss);


actcd19/main/r/retroarch/retroarch_1.7.3+dfsg1-1/deps/peglib/peglib.h:917:

            if (n < 1) {
c.set_error_pos(s);
return static_cast<size_t>(-1);
}
auto ch = s[0];


actcd19/main/b/boost1.62/boost1.62_1.62.0+dfsg-1/boost/compute/system.hpp:205:

            cl_uint count = 0;
clGetPlatformIDs(0, 0, &count);
return static_cast<size_t>(count);
}