android::SparseBitSet::nextSetBit

     39 FontCollection::FontCollection(const vector<FontFamily*>& typefaces) :
     40     mMaxChar(0) {
     41     AutoMutex _l(gMinikinLock);
     42     mId = sNextId++;
     43     vector<uint32_t> lastChar;
     44     size_t nTypefaces = typefaces.size();
     45 #ifdef VERBOSE_DEBUG
     46     ALOGD("nTypefaces = %d\n", nTypefaces);
     47 #endif
     48     const FontStyle defaultStyle;
     49     for (size_t i = 0; i < nTypefaces; i++) {
     50         FontFamily* family = typefaces[i];
     51         MinikinFont* typeface = family->getClosestMatch(defaultStyle).font;
     52         if (typeface == NULL) {
     53             continue;
     54         }
     55         family->RefLocked();
     56         mFamilies.push_back(family);  // emplace_back would be better
     57         const SparseBitSet* coverage = family->getCoverage();
     58         mMaxChar = max(mMaxChar, coverage->length());
     59         lastChar.push_back(coverage->nextSetBit(0)); ＜＝＝＝＝＝＝＝＝

                // vector<uint32_t> lastChar;

                // lastChar.push_back(uint32_t)

                // void push_back( const TYPE &val );
                // push_back() 関数は val をベクタの末尾に追加する。

     60     }
     61     nTypefaces = mFamilies.size();
     62     LOG_ALWAYS_FATAL_IF(nTypefaces == 0,
     63         "Font collection must have at least one valid typeface");
     64     size_t nPages = (mMaxChar + kPageMask) >> kLogCharsPerPage;
     65     size_t offset = 0;
     66     for (size_t i = 0; i < nPages; i++) {
     67         Range dummy;
     68         mRanges.push_back(dummy);
     69         Range* range = &mRanges.back();
     70 #ifdef VERBOSE_DEBUG
     71         ALOGD("i=%d: range start = %d\n", i, offset);
     72 #endif
     73         range->start = offset;
     74         for (size_t j = 0; j < nTypefaces; j++) {
     75             if (lastChar[j] < (i + 1) << kLogCharsPerPage) {
     76                 FontFamily* family = mFamilies[j];
     77                 mFamilyVec.push_back(family);
     78                 offset++;
     79                 uint32_t nextChar = family->getCoverage()->nextSetBit((i + 1) << kLogCharsPerPage);
     80 #ifdef VERBOSE_DEBUG
     81                 ALOGD("nextChar = %d (j = %d)\n", nextChar, j);
     82 #endif
     83                 lastChar[j] = nextChar;
     84             }
     85         }
     86         range->end = offset;
     87     }
     88 }

    113 uint32_t SparseBitSet::nextSetBit(uint32_t fromIndex) const {
    114     if (fromIndex >= mMaxVal) {
    115         return kNotFound;
    116     }
    117     uint32_t fromPage = fromIndex >> kLogValuesPerPage;
    118     const element* bitmap = &mBitmaps[mIndices[fromPage]];
    119     uint32_t offset = (fromIndex & kPageMask) >> kLogBitsPerEl;
    120     element e = bitmap[offset] & (kElAllOnes >> (fromIndex & kElMask));
    121     if (e != 0) {
    122         return (fromIndex & ~kElMask) + CountLeadingZeros(e);
    123     }
    124     for (uint32_t j = offset + 1; j < (1 << (kLogValuesPerPage - kLogBitsPerEl)); j++) {
    125         e = bitmap[j];
    126         if (e != 0) {
    127             return (fromIndex & ~kPageMask) + (j << kLogBitsPerEl) + CountLeadingZeros(e);
    128         }
    129     }
    130     uint32_t maxPage = (mMaxVal + kPageMask) >> kLogValuesPerPage;
    131     for (uint32_t page = fromPage + 1; page < maxPage; page++) {
    132         uint32_t index = mIndices[page];
    133         if (index == mZeroPageIndex) {
    134             continue;
    135         }
    136         bitmap = &mBitmaps[index];
    137         for (uint32_t j = 0; j < (1 << (kLogValuesPerPage - kLogBitsPerEl)); j++) {
    138             e = bitmap[j];
    139             if (e != 0) {
    140                 return (page << kLogValuesPerPage) + (j << kLogBitsPerEl) + CountLeadingZeros(e);
    141             }
    142         }
    143     }
    144     return kNotFound;
    145 }