EXPORT_C TBool TBtreeInlineIndexOrg::Update(TAny *aNode,TInt aPos,const TDesC8& anEntry) const { __ASSERT_DEBUG(anEntry.Size()<=KeySize(),Panic(EBadEntrySize)); __ASSERT_DEBUG(aPos<Node(aNode)->iHead.iCount,Panic(EBadEntryPos)); Mem::Copy(Entry(Node(aNode),aPos)->iKey,anEntry.Ptr(),KeySize()); return ETrue; }
void IOBus::ElementRealKey( const void* localKey, const int &localKeySize, char *globalkey, int &globalkeySize ) { globalkeySize = 0; if ( DataType::IsValue(m_elementKeyType) || DataType::stream == m_elementKeyType ) { memcpy( &globalkey[globalkeySize], Key(), KeySize() ); globalkeySize += KeySize(); memcpy( &globalkey[globalkeySize], "::", 2 ); globalkeySize += 2; memcpy( &globalkey[globalkeySize], (char*)&localKey, localKeySize ); globalkeySize += localKeySize; globalkey[globalkeySize] = 0; } else { IOBus *p = (IOBus*)localKey; memcpy( &globalkey[globalkeySize], Key(), KeySize() ); globalkeySize += KeySize(); memcpy( &globalkey[globalkeySize], "::", 2 ); globalkeySize += 2; memcpy( &globalkey[globalkeySize], p->Key(), p->KeySize() ); globalkeySize += p->KeySize(); globalkey[globalkeySize] = 0; } }
TBtreeInlineIndexOrg::SNode* TBtreeInlineIndexOrg::DoRedistribute(TAny *aLeftNode,TAny *aRightNode,const TDesC8& aPivot,TBtreePivot& aNewPivot,TInt aInsertPos) const // // Even out the distibution of entries in LeftNode and RightNode // if aInsertPos>=0 we want to insert at this cumulative position so take into account for redistribution // If total entries <=iMaxEntries or >iMaxEntries*2 then return 0 // Otherwise return the node into which insertion should take place // If insertion should be promoted insert position is beyond end of left node, otherwise // the new pivot is copied to aNewPivot // { SNode* const pl=Node(aLeftNode); SNode* const pr=Node(aRightNode); SNode *insertNode=pr; TInt lCount=pl->iHead.iCount; TInt rCount=pr->iHead.iCount; TInt total=lCount+rCount+1; // including pivot entry TInt left=total>>1; if (aInsertPos>=0) { // call from InsertOverflow __ASSERT_DEBUG(aInsertPos<=total,Panic(EBadEntryPos)); if (total>iMaxEntries<<1) return NULL; // no space to insert if (aInsertPos<=left) { if (aInsertPos<left) --left; insertNode=pl; } } else { // from Redistribute if (total<=iMaxEntries) return NULL; // underflow state } pl->iHead.iCount=left; pr->iHead.iCount=total-left-1; // pivot not included TInt pSize=aPivot.Size(); __ASSERT_DEBUG(pSize<=KeySize(),Panic(EBadEntrySize)); if (lCount>left) { // move right TInt move=lCount-left; Mem::Copy(Entry(pr,move),pr->iEntries,rCount*iEntrySize+sizeof(TPageRef)); TUint8 *pp=Mem::Copy(pr->iEntries,Entry(pl,left+1),(move-1)*iEntrySize+sizeof(TPageRef)); Mem::Copy(pp,aPivot.Ptr(),pSize); aNewPivot.Copy(Entry(pl,left)->iKey,KeySize()); // new pivot } else if (lCount<left) { // move left TInt move=left-lCount-1; TUint8 *pp=Mem::Copy(Entry(pl,lCount)->iKey,aPivot.Ptr(),pSize); Mem::Copy(pp,pr->iEntries,move*iEntrySize+sizeof(TPageRef)); aNewPivot.Copy(Entry(pr,move)->iKey,KeySize()); Mem::Copy(pr->iEntries,Entry(pr,move+1),(rCount-move-1)*iEntrySize+sizeof(TPageRef)); } else { // should we ever get here? (lCount==left) aNewPivot=aPivot; } return insertNode; }
EXPORT_C void TBtreeInlineIndexOrg::InsertSplit(TAny *aLeftNode,TAny *aRightNode,TInt aPos,const TDesC8& anEntry,TPageRef aChild,TBtreePivot& aPromote) const // // part of the contract is not to use aPromote before anEntry // We know that aNodePtr is full // prepare right node and use insert-overflow // { __ASSERT_DEBUG(Node(aLeftNode)->iHead.iCount==iMaxEntries,Panic(EIllegalSplit)); __ASSERT_DEBUG(Node(aRightNode)->iHead.iCount==0,Panic(EIllegalSplit)); SNode* const pl=Node(aLeftNode); SNode* const pr=Node(aRightNode); SEntry *pe=Entry(pl,pl->iHead.iCount); --pl->iHead.iCount; Entry(pr,0)->iChild=pe->iChild; TPtrC8 pivot((TUint8*)pe-KeySize(),KeySize()); InsertOverflow(aLeftNode,aRightNode,aPos,ETrue,anEntry,aChild,pivot,aPromote); }
EXPORT_C TBool TBtreeInlineIndexOrg::Insert(TAny *aNode,TInt aPos,const TDesC8& anEntry,TPageRef aChild) const { SNode* const pn=Node(aNode); __ASSERT_DEBUG(aPos<=pn->iHead.iCount,Panic(EBadEntryPos)); if (pn->iHead.iCount==iMaxEntries) return EFalse; TUint8* pe=Entry(pn,aPos)->iKey; Mem::Copy(pe+iEntrySize,pe,iEntrySize*(pn->iHead.iCount-aPos)); TInt size=anEntry.Size(); __ASSERT_ALWAYS(size<=KeySize(),Panic(EBadEntrySize)); *(TPageRef*)Mem::Copy(pe,anEntry.Ptr(),size)=aChild; ++pn->iHead.iCount; return ETrue; }
EXPORT_C void TBtreeInlineIndexOrg::Concatenate(TAny *aLeftNode,const TAny *aRightNode,const TDesC8& aPivot) const // // Join LeftNode and RightNode together in LeftNode // contract says that it will fit // { SNode* const pl=Node(aLeftNode); const SNode* const pr=Node(aRightNode); TInt rCount=pr->iHead.iCount; TInt lCount=pl->iHead.iCount; __ASSERT_DEBUG(lCount+rCount+1<=iMaxEntries,Panic(ECannotConcatenate)); TInt pSize=aPivot.Size(); __ASSERT_DEBUG(pSize<=KeySize(),Panic(EBadEntrySize)); TUint8* pp=Mem::Copy(Entry(pl,lCount)->iKey,aPivot.Ptr(),pSize); Mem::Copy(pp,pr->iEntries,rCount*iEntrySize+sizeof(TPageRef)); pl->iHead.iCount+=rCount+1; }
void GrStyle::WriteKey(uint32_t *key, const GrStyle &style, Apply apply, SkScalar scale, uint32_t flags) { SkASSERT(key); SkASSERT(KeySize(style, apply) >= 0); GR_STATIC_ASSERT(sizeof(uint32_t) == sizeof(SkScalar)); int i = 0; // The scale can influence both the path effect and stroking. We want to preserve the // property that the following two are equal: // 1. WriteKey with apply == kPathEffectAndStrokeRec // 2. WriteKey with apply == kPathEffectOnly followed by WriteKey of a GrStyle made // from SkStrokeRec output by the the path effect (and no additional path effect). // Since the scale can affect both parts of 2 we write it into the key twice. if (style.isDashed()) { GR_STATIC_ASSERT(sizeof(style.dashPhase()) == sizeof(uint32_t)); SkScalar phase = style.dashPhase(); memcpy(&key[i++], &scale, sizeof(SkScalar)); memcpy(&key[i++], &phase, sizeof(SkScalar)); int32_t count = style.dashIntervalCnt(); // Dash count should always be even. SkASSERT(0 == (count & 0x1)); const SkScalar *intervals = style.dashIntervals(); int intervalByteCnt = count * sizeof(SkScalar); memcpy(&key[i], intervals, intervalByteCnt); i += count; } else { SkASSERT(!style.pathEffect()); } if (Apply::kPathEffectAndStrokeRec == apply && style.strokeRec().needToApply()) { memcpy(&key[i++], &scale, sizeof(SkScalar)); enum { kStyleBits = 2, kJoinBits = 2, kCapBits = 32 - kStyleBits - kJoinBits, kJoinShift = kStyleBits, kCapShift = kJoinShift + kJoinBits, }; GR_STATIC_ASSERT(SkStrokeRec::kStyleCount <= (1 << kStyleBits)); GR_STATIC_ASSERT(SkPaint::kJoinCount <= (1 << kJoinBits)); GR_STATIC_ASSERT(SkPaint::kCapCount <= (1 << kCapBits)); // The cap type only matters for unclosed shapes. However, a path effect could unclose // the shape before it is stroked. SkPaint::Cap cap; if ((flags & kClosed_KeyFlag) && !style.pathEffect()) { cap = SkPaint::kButt_Cap; } else { cap = style.strokeRec().getCap(); } key[i++] = style.strokeRec().getStyle() | style.strokeRec().getJoin() << kJoinShift | cap << kCapShift; SkScalar scalar; // Miter limit only affects miter joins scalar = SkPaint::kMiter_Join == style.strokeRec().getJoin() ? style.strokeRec().getMiter() : -1.f; memcpy(&key[i++], &scalar, sizeof(scalar)); scalar = style.strokeRec().getWidth(); memcpy(&key[i++], &scalar, sizeof(scalar)); } SkASSERT(KeySize(style, apply) == i); }
std::uint32_t LegacySymmetricProvider::IVSize(const Mode Mode) { return KeySize(Mode); }
EXPORT_C TPtrC8 TBtreeInlineIndexOrg::Entry(const TAny* aNode,TInt aPos) const { return TPtrC8((const TUint8*)EntryPtr(aNode,aPos),KeySize()); }