EXPORT_C void TBufBuf::DoWriteL(const TAny* aPtr,TInt aLength)
//
// Consume aLength bytes, taking care of any reallocation.
//
{
__ASSERT_ALWAYS(iMode&EWrite,Panic(EMemCannotWrite));
__ASSERT_DEBUG(aLength>=0,Panic(EMemWriteLengthNegative));
__ASSERT_DEBUG(aLength>0,Panic(EMemWriteNoTransfer));
TInt len=(iMode&EInsert?0:Min(aLength,Buf().Size()-Mark(EWrite)));
if (len>0)
{
TStreamBuf::DoWriteL(aPtr,len);
aPtr=(TUint8*)aPtr+len;
aLength-=len;
}
if (aLength>0)
{
Consolidate();
TInt pos=Pos(EWrite);
Buf().InsertL(pos,aPtr,aLength);
if (Pos(ERead)>pos)
MovePos(ERead,aLength);
SetPos(EWrite,pos+aLength);
}
}
struct node* Fib_Heap_Extract_Min (struct heap* H){ //O(log n)
struct node* z = H->min;
if (z) {
if (z == z->right) { // z - åäèíñòâåííûé â ñïèñêå êîðíåé
H->min = z->child; //ïîìå÷àåì óêàçàòåëü íà íîëü èëè ðåáåíêà
Consolidate(H);
} else {
if (z->child == NULL){
z->left->right = z->right; //óäàëÿåì z èç ñïèñêà êîðíåé
z->right->left = z->left;
H->min = z->right;
Consolidate(H);
} else {
z->left->right = z->child; //óäàëÿåì z èç ñïèñêà êîðíåé
z->right->left = z->child->left;
z->child->left->right = z->right;
z->child->left = z->left;
H->min = z->right;
Consolidate(H);
}
}
H->n--;
}
return z;
}
void Region::EndOperation()
{
if (--fOpLevel == 0)
Consolidate();
ASSERT(fOpLevel >= 0);
}
EXPORT_C void TDesBuf::DoSynchL()
//
// Synchronise descriptor and stream buffer.
//
{
Consolidate();
}
NBNodeEntry *GetNodeEntry(NBNodeHeap *nodeheap)
{
NBNodeEntry *child,*best;
best=nodeheap->head;
if (best==NULL) return NULL;
child = best->child;
if (child != NULL) {
do {
child->parent=0; child=child->succ;
nodeheap->length++;
}
while(child!=best->child);
child->pred->succ=nodeheap->head->succ;
nodeheap->head->succ->pred=child->pred;
nodeheap->head->succ=child;
child->pred=nodeheap->head;
}
best->succ->pred=best->pred;
best->pred->succ=best->succ;
nodeheap->count--; nodeheap->length--;
if (best->succ==best){
nodeheap->head=NULL;
}else {
nodeheap->head=best->succ;
Consolidate(nodeheap);
}
best->child=NULL; best->parent=NULL;
best->succ=NULL; best->pred=NULL;
best->status=neh_expanded;
nodeheap->exps++;
return best;
}
FibonacciHeapNode<Key, Data> * FibonacciHeap<Key, Data>::ExtractMin()
{
FibonacciHeapNode<Key, Data> * ret = m_pMin, * pTraverse;
if (ret != NULL) {
// put children of minimum node in root list
if (ret->m_iDegree > 0) {
ret->m_pFrontChild->m_pLeft = m_pBack;
m_pBack->m_pRight = pTraverse = ret->m_pFrontChild;
ret->m_pBackChild->m_pRight = m_pFront;
m_pBack = m_pFront->m_pLeft = ret->m_pBackChild;
while (true) {
pTraverse->m_pParent = NULL;
if (pTraverse == ret->m_pBackChild) break;
pTraverse = pTraverse->m_pRight;
}
ret->m_pFrontChild = ret->m_pBackChild = NULL;
ret->m_iDegree = 0;
}
// remove minimum node from root list
TempRemove(ret);
if ((m_nLength--) > 0)
Consolidate();
ret->m_pLeft = ret->m_pRight = NULL;
}
return ret;
}
EXPORT_C void TBufBuf::DoSynchL()
//
// Synchronise buffer and stream buffer and compress.
//
{
Consolidate();
Buf().Compress();
}
EXPORT_C TInt TDesBuf::UnderflowL(TInt)
//
// Check if there's any more to be read.
//
{
Consolidate();
return Avail(ERead);
}
typename fibonacci_heap::Node* fibonacci_heap::DeleteMin() {
// z = H.min
Node *z = min;
// If z != NIL
if (z != nullptr) {
// for each child x of z
Node *x = z->child; // First child visited
if (x != nullptr) {
do {
// Remember current childs right neighbor
Node *next = x->right;
// add children to root list of H
min->left->right = x;
x->left = min->left;
min->left = x;
x->right = min;
// x.p = NIL
x->parent = nullptr;
// Look at next child
x = next;
} while (x != z->child);
}
// remove z from the root list of H
min->left->right = min->right;
min->right->left = min->left;
// if z == z.right
if (z == z->right)
min = nullptr; // H.min = NIL
else {
min = z->right;
Consolidate();
}
n--;
}
return z;
}
bool C4MassMoverSet::Save(C4Group &hGroup)
{
int32_t cnt;
// Consolidate
Consolidate();
// Recount
Count=0;
for (cnt=0; cnt<C4MassMoverChunk; cnt++)
if (Set[cnt].Mat!=MNone)
Count++;
// All empty: delete component
if (!Count)
{
hGroup.Delete(C4CFN_MassMover);
return true;
}
// Save set
if (!hGroup.Add(C4CFN_MassMover,Set,Count*sizeof(C4MassMover)))
return false;
// Success
return true;
}
EXPORT_C TStreamPos TDesBuf::DoSeekL(TMark aMark,TStreamLocation aLocation,TInt anOffset)
//
// Position the mark(s) indicated by aMark at anOffset from aLocation.
//
{
Consolidate();
TUint8* ptr=0;
switch (aLocation)
{
case EStreamBeginning:
ptr=Base()+anOffset;
break;
case EStreamMark:
ptr=Ptr(aMark)+anOffset;
break;
case EStreamEnd:
ptr=End(ERead)+anOffset;
break;
default:
Panic(EMemLocationInvalid);
break;
}
TInt r=KErrNone;
if (ptr>End(ERead))
{
ptr=End(ERead);
r=KErrEof;
}
else if (ptr<Base())
{
ptr=Base();
r=KErrEof;
}
//
SetPtr(aMark,ptr);
__LEAVE_IF_ERROR(r);
return TStreamPos(ptr-Base());
}
EXPORT_C TStreamPos TBufBuf::DoSeekL(TMark aMark,TStreamLocation aLocation,TInt anOffset)
//
// Position the mark(s) indicated by aMark at anOffset from aLocation.
//
{
Consolidate();
TInt size=Buf().Size();
switch (aLocation)
{
case EStreamBeginning:
break;
case EStreamMark:
anOffset+=Pos(aMark);
break;
case EStreamEnd:
anOffset+=size;
break;
default:
Panic(EMemLocationInvalid);
break;
}
TInt r=KErrNone;
if (anOffset>size)
{
anOffset=size;
r=KErrEof;
}
else if (anOffset<0)
{
anOffset=0;
r=KErrEof;
}
//
SetPos(aMark,anOffset);
__LEAVE_IF_ERROR(r);
return TStreamPos(anOffset);
}
void C4MassMoverSet::Synchronize()
{
Consolidate();
}
