/*
-------------------------------------------------------------------------
-------------------------------------------------------------------------
*/
TBool CExPolicy_Server::IsTimeBeforeL(TTime& aTime,TTime& aCompare)
{
TBool IsBefore(EFalse);
TTimeIntervalMinutes MinInterval(0);
TTimeIntervalHours HourInterval(0);
TTimeIntervalSeconds SecInterval(0);
TTime TimeNow;
TimeNow.HomeTime();
TTimeIntervalDays DaysInterval = aTime.DaysFrom(aCompare);
if(DaysInterval.Int() <= 0)
{
aTime.HoursFrom(aCompare,HourInterval);
if(HourInterval.Int() <= 0)
{
aTime.MinutesFrom(aCompare,MinInterval);
if(MinInterval.Int() <= 0)
{
aTime.SecondsFrom(aCompare, SecInterval);
if(SecInterval.Int() <= 0)
{
IsBefore = ETrue;
}
}
}
}
return IsBefore;
}
int main()
{
T=MakeTANGGAL(2,12,1989);
T1=MakeTANGGAL(2,12,1989);
TulisTANGGAL(T);TulisTANGGAL(T1);
printf("Prev Day 2/12/1989 : ");TulisTANGGAL(PrevDay(T));
printf("Next Day 2/12/1989 : ");TulisTANGGAL(NextDay(T));
printf("Next 15 Day 2/12/1989 : ");TulisTANGGAL(NextNday(T,15));
printf("Prev 15 Day 2/12/1989 : ");TulisTANGGAL(PrevNDay(T,15));
printf("Tanggal 2/12/1989 ada : %4d hari",HariKe(T));printf("\n");
printf("hari ke- %4d jatuh pada tanggal :",HariKe(T));TulisTANGGAL(DayOfYear(HariKe(T),Year(T)));printf("\n");
printf("IsEqD T dan T1 ? %s\n",(IsEqD(T,T1)?"true":"false"));
printf("IsBefore T dan T1 ? %s\n",(IsBefore(T,T1)?"true":"false"));
printf("IsAfter T dan T1 ? %s\n",(IsAfter(T,T1)?"true":"false"));
printf("IsKabisat T ?%s\n",(IsKabisat(Year(T))?"true":"false"));
printf("IsKabisat 1972 ? %s\n",(IsKabisat(1972)?"true":"false"));
printf("#hari/tahun : 100/1972 ? ");TulisTANGGAL(DayOfYear(100,1972));
return 0;
}
void QuickSort(void *base, size_t nelem, size_t width,
int (*cmp)(const void *, const void *))
{
struct __QuickSortStack { size_t left, right; };
if (nelem <= 1)
return;
// Create a pseudo-stack to avoid recursion
char * base_char = (char *) base;
const size_t stackSize = 128;
__QuickSortStack * stack = new __QuickSortStack[stackSize];
char * tmp = new char [width];
if ((stack == NULL) || (tmp == NULL))
error("Out of memory in QuickSort routine");
size_t stackIdx = 0;
// Size of minimum partition to median of three
const size_t Threshold = 7;
// current partitions
size_t lsize, rsize;
size_t l, mid, r;
size_t scanl, scanr, pivot;
l = 0;
r = nelem - 1;
while (TRUE)
{
while (r > l)
{
if (r - l > Threshold)
// QuickSort : median of three partitioning
{
mid = (r + l) / 2;
// sort l, mid, and r
if (IsBefore(mid, l))
Exchange(mid, l);
if (IsBefore(r, l))
Exchange(r, l);
if (IsBefore(r, mid))
Exchange(r, mid);
// set up for partitioning...
pivot = r - 1;
Exchange(mid, pivot);
scanl = l + 1;
scanr = r - 2;
}
else
{
// set up random partition -- faster
pivot = r;
scanl = l;
scanr = r - 1;
}
while (TRUE)
{
// scan from left for element >= pivot
while ((scanl < r) && IsBefore(scanl, pivot))
++scanl;
while ((scanr > l) && IsBefore(pivot, scanr))
--scanr;
// if scans have met, we are done
if (scanl >= scanr)
break;
Exchange(scanl, scanr);
if (scanl < r)
++scanl;
if (scanr > l)
--scanr;
}
// Exchange final element
Exchange(pivot, scanl);
// Place largest partition on stack
lsize = scanl - l;
rsize = r - scanl;
if (lsize > rsize)
{
// if size is one we are done
++ stackIdx;
if (stackIdx == stackSize)
error("Out of Stack in QuickSort routine");
stack[stackIdx].left = l;
stack[stackIdx].right = scanl - 1;
if ( rsize != 0 )
l = scanl + 1;
else
break;
}
else
{
// if size is one we are done
++ stackIdx;
if (stackIdx == stackSize)
error("Out of Stack in QuickSort routine");
stack[stackIdx].left = scanl + 1;
stack[stackIdx].right = r;
if ( lsize != 0 )
r = scanl - 1;
else
break;
}
}
// iterate with values from stack
if (stackIdx)
{
l = stack[stackIdx].left;
r = stack[stackIdx].right;
--stackIdx;
}
else
break;
}
delete [] stack;
delete [] tmp;
}
Link * Linked_List::Add(unsigned long ID,unsigned long parentID,char *pStr, void * lpItemData,unsigned long uiInsertAfter,unsigned long uiInsertBefore)
{
Link * insertAfter=last;
Link * insertBefore=0;
Link * parent=0;
if (uiInsertAfter)
{
Link *l =Find(uiInsertAfter);
if (l)
insertAfter=l;
}
if (parentID)
{
if (lastparent && lastparent->Item()==parentID)
{
parent=insertAfter=lastparent;
}
else
{
// Emb 28/6/95 : performance improvement using Find()
Link * l = Find(parentID);
if (l)
parent=lastparent=insertAfter=l;
// original code, masqued :
//for (Link *l=first; l && !parent;l=l->Next())
// {
// if (l->Item()==parentID)
// {
// parent=lastparent=insertAfter=l;
// }
// }
}
if (parent)
{
if (!parent->hasChild)
{
uiInsertAfter=parent->Item();
parent->hasChild=1;
}
int lev=parent->Level()+1;
for (Link *l2=parent->Next();l2;l2=l2->Next())
{
if (l2->Parent()!=parent && l2->Level()<=lev)
break;
insertAfter=l2;
if (uiInsertAfter && l2->Item()==uiInsertAfter)
break;
}
}
else
{
//for (LinkNonResolved *l =firstNonResolved;l && l->Next(); l= (LinkNonResolved *) l->Next());
LinkNonResolved *ll =new LinkNonResolved(ID,firstNonResolved,pStr,parentID,lpItemData);
if (ll && !firstNonResolved)
firstNonResolved=ll;
return 0;
}
}
if (bSort && !uiInsertAfter && pStr)
{
for (Link *l = parent ? parent->Next():first ; l && !insertBefore; l=l->Next())
{
if ((l->Parent()==parent) && IsBefore(pStr,l->String()))
{
insertBefore=l;
}
}
}
if (uiInsertBefore)
{
Link *l =Find(uiInsertBefore);
if (l && ((parent==l) || (parent==l->Parent())))
{
insertBefore=l;
}
}
Link *l =new Link(ID,parent,insertAfter,insertBefore,pStr,lpItemData);
if (l)
{
count++;
current=l;
if (!l->Prev())
first=l;
if (!l->Next())
last=l;
if (insertBefore && insertBefore==first)
first=l;
if (firstNonResolved)
ResolveLink(ID);
}
return l;
}
