/**
* Reverse the 'src' list of RefRecords into the 'dst' list. Don't
* modify 'src'.
*/
void reverseRefRecords(const vector<RefRecord>& src,
vector<RefRecord>& dst,
bool recursive,
bool verbose)
{
dst.clear();
{
vector<RefRecord> cur;
for(int i = src.size()-1; i >= 0; i--) {
bool first = (i == (int)src.size()-1 || src[i+1].first);
if(src[i].len) {
cur.push_back(RefRecord(0, src[i].len, first));
first = false;
}
if(src[i].off) cur.push_back(RefRecord(src[i].off, 0, first));
}
bool mergedLast;
for(int i = 0; i < (int)cur.size(); i++) {
mergedLast = false;
assert(cur[i].off == 0 || cur[i].len == 0);
if(i < (int)cur.size()-1 && cur[i].off != 0 && !cur[i+1].first) {
dst.push_back(RefRecord(cur[i].off, cur[i+1].len, cur[i].first));
i++;
mergedLast = true;
} else {
dst.push_back(cur[i]);
}
}
}
if(verbose) {
cout << "Source: " << endl;
printRecords(cout, src);
cout << "Dest: " << endl;
printRecords(cout, dst);
}
#ifndef NDEBUG
if(!recursive) {
vector<RefRecord> tmp;
reverseRefRecords(dst, tmp, true);
assert_eq(tmp.size(), src.size());
for(size_t i = 0; i < src.size(); i++) {
assert_eq(src[i].len, tmp[i].len);
assert_eq(src[i].off, tmp[i].off);
assert_eq(src[i].first, tmp[i].first);
}
}
#endif
}
void printRecords(FILE *fp, pathList *root)
{
if(root == NULL)
{
return;
}
fprintf(fp, "%s\n%d\n", root->path, root->count);
//printf("\n%-50s\t\t%d", root->path, root->count);
printRecords(fp, root->next);
}
//function to sort by name
//it employs insertion sort
void sortName(struct data *ent, int n, int ch){
struct data curr;
int j,k;
for(j=0;j<n;j++){
memcpy(&curr,&(ent[j]), sizeof(struct data));
for(k=j;k>0;k--){
if(strcmp(ent[k-1].name,curr.name)<=0) //strcmp is used compare the strings
break;
memcpy(&ent[k], &ent[k-1], sizeof(struct data));
}
memcpy(&ent[k], &curr, sizeof(struct data));
}
if(ch)printRecords(ent, n);
else printRecordsReverse(ent, n);
}
//function to sort by time taken to complete the game
//it employs insertion sort
void sortTime(struct data *ent, int n, int ch){
struct data curr;
int j,k;
for(j=0;j<n;j++){
memcpy(&curr,&(ent[j]), sizeof(struct data));
for(k=j;k>0;k--){
if(ent[k-1].time<=curr.time)
break;
memcpy(&ent[k], &ent[k-1], sizeof(struct data));
}
memcpy(&ent[k], &curr, sizeof(struct data));
}
if(ch)printRecords(ent, n);
else printRecordsReverse(ent, n);
}
//function to sort by number of steps
//it employs selection sort
void sortMoves(struct data *ent, int n, int ch){
int i, j, k;
int min;
struct data curr;
for(j=0;j<n;j++){
min=ent[j].moves;
for(k=j;k<n;k++)
if(ent[k].moves<ent[min].moves)
min=k;
memcpy(&curr, &ent[min], sizeof(struct data));
memcpy(&ent[min], &ent[j], sizeof(struct data));
memcpy(&ent[j], &curr, sizeof(struct data));
}
if(ch)printRecords(ent, n);
else printRecordsReverse(ent, n);
}
//function to sort by level
//it employs selection sort
void sortDiff(struct data *ent, int n, int ch){
int i, j, k;
int min;
struct data curr;
for(j=0;j<n;j++){
min=ent[j].diff;
for(k=j;k<n;k++)
if(ent[k].diff<ent[min].diff)
min=k;
memcpy(&curr, &ent[min], sizeof(struct data)); //memcpy is used to copy structures
memcpy(&ent[min], &ent[j], sizeof(struct data));
memcpy(&ent[j], &curr, sizeof(struct data));
}
if(ch)printRecords(ent, n); //if input was 1, print ascending
else printRecordsReverse(ent, n); //if input was 0, print descending
}
void p2(void)
{
struct ExpressLaneRec * eLFront, * eLCurr;
struct Car * c;
c=initCar(1,"CarA");
c->setCarState(c, 61, 2, 4, 1);
eLFront=addCarRec(c,10.23, 10.34, NULL);
c=initCar(1,"CarB");
c->setCarState(c, 110, 4, 2, 0);
eLCurr=addCarRec(c,11.23, 12.34, eLFront);
c=initCar(1,"CarC");
c->setCarState(c, 190, 5, 1, 0);
eLCurr=addCarRec(c, 1.34, 2.32, eLCurr);
printRecords(eLFront);
cleanUpRec(eLFront);
}
void printTree(FILE *fp, treeNode *root)
{
if(root == NULL)
{
return;
}
//printf("\n\n%-30s", root->token);
fprintf(fp, "<list>\n");
fprintf(fp, "%s\n", root->token);
mergeSort( &(root->pathRecords) );
printRecords(fp, root->pathRecords);
fprintf(fp, "</list>\n");
printTree(fp, root->left);
printTree(fp, root->right);
}
static void
testAll (long numVar, long numRecord, long numMaxParent, long percentParent)
{
random_t* randomPtr = random_alloc();
puts("Starting...");
data_t* dataPtr = data_alloc(numVar, numRecord, randomPtr);
assert(dataPtr);
puts("Init:");
net_t* netPtr = data_generate(dataPtr, 0, numMaxParent, percentParent);
net_free(netPtr);
printRecords(dataPtr);
puts("Sort first half from 0:");
data_sort(dataPtr, 0, numRecord/2, 0);
printRecords(dataPtr);
puts("Sort second half from 0:");
data_sort(dataPtr, numRecord/2, numRecord-numRecord/2, 0);
printRecords(dataPtr);
puts("Sort all from mid:");
data_sort(dataPtr, 0, numRecord, numVar/2);
printRecords(dataPtr);
long split = data_findSplit(dataPtr, 0, numRecord, numVar/2);
printf("Split = %li\n", split);
long v;
for (v = 0; v < numVar; v++) {
data_sort(dataPtr, 0, numRecord, v);
long s = data_findSplit(dataPtr, 0, numRecord, v);
if (s < numRecord) {
assert(dataPtr->records[numVar * s + v] == 1);
}
if (s > 0) {
assert(dataPtr->records[numVar * (s - 1) + v] == 0);
}
}
memset(dataPtr->records, 0, dataPtr->numVar * dataPtr->numRecord);
for (v = 0; v < numVar; v++) {
data_sort(dataPtr, 0, numRecord, v);
long s = data_findSplit(dataPtr, 0, numRecord, v);
if (s < numRecord) {
assert(dataPtr->records[numVar * s + v] == 1);
}
if (s > 0) {
assert(dataPtr->records[numVar * (s - 1) + v] == 0);
}
assert(s == numRecord);
}
memset(dataPtr->records, 1, dataPtr->numVar * dataPtr->numRecord);
for (v = 0; v < numVar; v++) {
data_sort(dataPtr, 0, numRecord, v);
long s = data_findSplit(dataPtr, 0, numRecord, v);
if (s < numRecord) {
assert(dataPtr->records[numVar * s + v] == 1);
}
if (s > 0) {
assert(dataPtr->records[numVar * (s - 1) + v] == 0);
}
assert(s == 0);
}
data_free(dataPtr);
}
static int
compareFiles(
char **file)
{
skstream_t *stream[2] = {NULL, NULL};
rwRec rec[2];
int i;
int rv;
int status = 2;
uint64_t rec_count = 0;
int eof = -1;
memset(stream, 0, sizeof(stream));
memset(rec, 0, sizeof(rec));
for (i = 0; i < 2; ++i) {
if ((rv = skStreamCreate(&stream[i], SK_IO_READ, SK_CONTENT_SILK_FLOW))
|| (rv = skStreamBind(stream[i], file[i]))
|| (rv = skStreamOpen(stream[i]))
|| (rv = skStreamReadSilkHeader(stream[i], NULL)))
{
/* Give up if we can't read the beginning of the silk header */
if (rv != SKSTREAM_OK) {
if (!quiet) {
skStreamPrintLastErr(stream[i], rv, &skAppPrintErr);
}
goto END;
}
}
}
while ((rv = skStreamReadRecord(stream[0], &rec[0])) == SKSTREAM_OK) {
rv = skStreamReadRecord(stream[1], &rec[1]);
if (rv != SKSTREAM_OK) {
if (rv == SKSTREAM_ERR_EOF) {
/* file 0 longer than file 1 */
status = 1;
eof = 1;
} else {
if (!quiet) {
skStreamPrintLastErr(stream[1], rv, &skAppPrintErr);
}
status = -1;
}
goto END;
}
++rec_count;
if (0 != memcmp(&rec[0], &rec[1], sizeof(rwRec))) {
status = 1;
goto END;
}
}
if (rv != SKSTREAM_ERR_EOF) {
if (!quiet) {
skStreamPrintLastErr(stream[0], rv, &skAppPrintErr);
}
} else {
rv = skStreamReadRecord(stream[1], &rec[1]);
switch (rv) {
case SKSTREAM_OK:
/* file 1 longer than file 0 */
status = 1;
eof = 0;
break;
case SKSTREAM_ERR_EOF:
/* files identical */
status = 0;
break;
default:
if (!quiet) {
skStreamPrintLastErr(stream[1], rv, &skAppPrintErr);
}
break;
}
}
END:
for (i = 0; i < 2; ++i) {
skStreamDestroy(&stream[i]);
}
if (1 == status && !quiet) {
if (eof != -1) {
printf("%s %s differ: EOF %s\n",
file[0], file[1], file[eof]);
} else {
printf(("%s %s differ: record %" PRIu64 "\n"),
file[0], file[1], rec_count);
#ifdef RWCOMPARE_VERBOSE
printRecords(rec);
#endif
}
}
return status;
}
