int sort_book(List *L,int size_L){
int i,j,k;
if(size_L ==1){
printf("\n%d %d %d",L->stu,L->d,L->c);
return 0;
}
for(i = 1;i != size_L; ++i)
for(j = 0; j!=i; ++j){
if((L+i)->sum>=(L+j)->sum)
swap_two(L+i,L+j);
if(((L+i)->sum == (L+j)->sum)&&((L+i)->d>=(L+j)->d))
swap_two(L+i,L+j);
if(((L+i)->sum == (L+j)->sum)&&((L+i)->d==(L+j)->d)&&((L+i)->stu<=(L+j)->stu))
swap_two(L+i,L+j);
}
for(k = 0; k != size_L;++k)
printf("\n%d %d %d",(L+k)->stu,(L+k)->d,(L+k)->c);
}
long int VpfWrite ( void *from, VpfDataType type, long int count, FILE *to )
{
long int retval=0 , i ;
switch ( type ) {
case VpfChar:
retval = (long)fwrite ( from, sizeof (char), count, to ) ;
break ;
case VpfShort:
{
if (MACHINE_BYTE_ORDER != STORAGE_BYTE_ORDER) {
short int stemp ,
*sptr = (short *) from ;
for ( i=0; i < count; i++, sptr++ ) {
swap_two ( (char*)sptr, (char*)&stemp ) ;
retval = (long)fwrite ( &stemp, sizeof (short), 1, to ) ;
}
} else {
retval = (long)fwrite ( from, sizeof (short), count, to ) ;
}
}
break ;
case VpfInteger:
{
if (MACHINE_BYTE_ORDER != STORAGE_BYTE_ORDER) {
long int itemp,
*iptr = (long int *) from ;
for ( i=0; i < count; i++, iptr++ ) {
swap_four ( (char*)iptr, (char*)&itemp ) ;
retval = (long)fwrite ( &itemp, sizeof (long int), 1, to ) ;
}
} else {
retval = (long)fwrite ( from, sizeof (long int), count, to ) ;
}
}
break ;
case VpfFloat:
{
if (MACHINE_BYTE_ORDER != STORAGE_BYTE_ORDER) {
float ftemp ,
*fptr = (float *) from ;
for ( i=0; i < count; i++, fptr++ ) {
swap_four ( (char*)fptr, (char*)&ftemp ) ;
retval = (long)fwrite ( &ftemp, sizeof (float), 1, to ) ;
}
} else {
retval = (long)fwrite ( from, sizeof (long int), count, to ) ;
}
}
break ;
case VpfDouble:
{
if (MACHINE_BYTE_ORDER != STORAGE_BYTE_ORDER) {
double dtemp ,
*dptr = (double *) from ;
for ( i=0; i < count; i++, dptr++ ) {
swap_eight ( (char*)dptr, (char*)&dtemp ) ;
retval = (long)fwrite ( &dtemp, sizeof (double), 1, to ) ;
}
} else {
retval = (long)fwrite ( from, sizeof (double), count, to ) ;
}
}
break ;
case VpfDate: /* only write out 20, not 21 chars */
retval = (long)fwrite ( from, sizeof ( date_type ) - 1, count, to ) ;
break ;
case VpfCoordinate:
{
if (MACHINE_BYTE_ORDER != STORAGE_BYTE_ORDER) {
coordinate_type ctemp ,
*cptr = (coordinate_type *) from ;
for ( i=0; i < count; i++, cptr++ ) {
swap_four ( (char*)&cptr->x, (char*)&ctemp.x ) ;
swap_four ( (char*)&cptr->y, (char*)&ctemp.y ) ;
retval = (long)fwrite ( &ctemp, sizeof (coordinate_type), 1, to ) ;
}
} else {
retval = (long)fwrite ( from, sizeof (coordinate_type), count, to ) ;
}
}
break ;
case VpfDoubleCoordinate:
{
if (MACHINE_BYTE_ORDER != STORAGE_BYTE_ORDER) {
double_coordinate_type dctemp ,
*dcptr = (double_coordinate_type *) from ;
for ( i=0; i < count; i++, dcptr++ ) {
swap_eight ( (char*)&dcptr->x, (char*)&dctemp.x ) ;
swap_eight ( (char*)&dcptr->y, (char*)&dctemp.y ) ;
retval = (long)fwrite ( &dctemp, sizeof (double_coordinate_type),
1, to ) ;
}
} else {
retval = (long)fwrite ( from, sizeof (double_coordinate_type),
count, to ) ;
}
}
break ;
case VpfTriCoordinate:
{
if (MACHINE_BYTE_ORDER != STORAGE_BYTE_ORDER) {
tri_coordinate_type ttemp ,
*tptr = (tri_coordinate_type *) from ;
for ( i=0; i < count; i++, tptr++ ) {
swap_four ( (char*)&tptr->x, (char*)&ttemp.x ) ;
swap_four ( (char*)&tptr->y, (char*)&ttemp.y ) ;
swap_four ( (char*)&tptr->z, (char*)&ttemp.z ) ;
retval = (long)fwrite ( &ttemp, sizeof (tri_coordinate_type), 1, to ) ;
}
} else {
retval = (long)fwrite ( from, sizeof (tri_coordinate_type), count, to ) ;
}
}
break ;
case VpfDoubleTriCoordinate:
{
if (MACHINE_BYTE_ORDER != STORAGE_BYTE_ORDER) {
double_tri_coordinate_type dttemp ,
*dtptr = (double_tri_coordinate_type *) from ;
for ( i=0; i < count; i++, dtptr++ ) {
swap_eight ( (char*)&dtptr->x, (char*)&dttemp.x ) ;
swap_eight ( (char*)&dtptr->y, (char*)&dttemp.y ) ;
swap_eight ( (char*)&dtptr->z, (char*)&dttemp.z ) ;
retval = (long)fwrite ( &dttemp,sizeof (double_tri_coordinate_type),
1, to);
}
} else {
retval = (long)fwrite ( from,sizeof (double_tri_coordinate_type),
count, to);
}
}
break ;
case VpfNull:
/* Do Nothing */
break ;
default:
break ;
}
return retval;
}
ossim_int32 VpfRead ( void *to, VpfDataType type, ossim_int32 count, FILE *from )
{
ossim_int32 retval=0 , i ;
switch ( type ) {
case VpfChar:
retval = (long)fread ( to, sizeof (char), count, from ) ;
break ;
case VpfShort:
{
short int stemp ,
*sptr = (short *) to ;
for ( i=0; i < count; i++ ) {
retval = (long)fread ( &stemp, sizeof (short), 1, from ) ;
if (STORAGE_BYTE_ORDER != MACHINE_BYTE_ORDER)
swap_two ( (char*)&stemp, (char*)sptr ) ;
else
*sptr = stemp;
sptr++ ;
}
}
break ;
case VpfInteger:
{
if (STORAGE_BYTE_ORDER != MACHINE_BYTE_ORDER) {
ossim_int32 itemp,
*iptr = (ossim_int32 *) to ;
for ( i=0; i < count; i++ ) {
retval = (long)fread ( &itemp, sizeof (ossim_int32), 1, from ) ;
swap_four ( (char*)&itemp, (char*)iptr ) ;
iptr++ ;
}
} else {
retval = (long)fread ( to, sizeof (ossim_int32), count, from ) ;
}
}
break ;
case VpfFloat:
{
float ftemp ,
*fptr = (float *) to ;
for ( i=0; i < count; i++ ) {
retval = (long)fread ( &ftemp, sizeof (float), 1, from ) ;
if (STORAGE_BYTE_ORDER != MACHINE_BYTE_ORDER)
swap_four ( (char*)&ftemp, (char*)fptr ) ;
else
*fptr = ftemp;
fptr++ ;
}
}
break ;
case VpfDouble:
{
double dtemp ,
*dptr = (double *) to ;
for ( i=0; i < count; i++ ) {
retval = (long)fread ( &dtemp, sizeof (double), 1, from ) ;
if (STORAGE_BYTE_ORDER != MACHINE_BYTE_ORDER)
swap_eight ( (char*)&dtemp, (char*)dptr ) ;
else
*dptr = dtemp;
dptr++ ;
}
}
break ;
case VpfDate:
{
date_type *dp = (date_type *) to ;
retval = (long)fread(dp,sizeof(date_type)-1,count,from);
}
break ;
case VpfCoordinate:
{
if (STORAGE_BYTE_ORDER != MACHINE_BYTE_ORDER) {
coordinate_type ctemp ,
*cptr = (coordinate_type *) to ;
for ( i=0; i < count; i++ ) {
retval = (long)fread ( &ctemp, sizeof (coordinate_type), 1, from ) ;
swap_four ( (char*)&ctemp.x, (char*)&cptr->x ) ;
swap_four ( (char*)&ctemp.y, (char*)&cptr->y ) ;
cptr++ ;
}
} else {
retval = (long)fread ( to, sizeof (coordinate_type), count, from ) ;
}
}
break ;
case VpfDoubleCoordinate:
{
double_coordinate_type dctemp ,
*dcptr = (double_coordinate_type *) to ;
for ( i=0; i < count; i++ ) {
retval = (long)fread ( &dctemp, sizeof (double_coordinate_type), 1, from ) ;
if (STORAGE_BYTE_ORDER != MACHINE_BYTE_ORDER) {
swap_eight ( (char*)&dctemp.x, (char*)&dcptr->x ) ;
swap_eight ( (char*)&dctemp.y, (char*)&dcptr->y ) ;
} else {
dcptr->x = dctemp.x;
dcptr->y = dctemp.y;
}
dcptr++ ;
}
}
break ;
case VpfTriCoordinate:
{
tri_coordinate_type ttemp ,
*tptr = (tri_coordinate_type *) to ;
for ( i=0; i < count; i++ ) {
retval = (long)fread ( &ttemp, sizeof (tri_coordinate_type), 1, from ) ;
if (STORAGE_BYTE_ORDER != MACHINE_BYTE_ORDER) {
swap_four ( (char*)&ttemp.x, (char*)&tptr->x ) ;
swap_four ( (char*)&ttemp.y, (char*)&tptr->y ) ;
swap_four ( (char*)&ttemp.z, (char*)&tptr->z ) ;
} else {
tptr->x = ttemp.x;
tptr->y = ttemp.y;
tptr->z = ttemp.z;
}
tptr++ ;
}
}
break ;
case VpfDoubleTriCoordinate:
{
double_tri_coordinate_type dttemp ,
*dtptr = (double_tri_coordinate_type *) to ;
for ( i=0; i < count; i++ ) {
retval = (long)fread ( &dttemp, sizeof (double_tri_coordinate_type), 1, from);
if (STORAGE_BYTE_ORDER != MACHINE_BYTE_ORDER) {
swap_eight ( (char*)&dttemp.x, (char*)&dtptr->x ) ;
swap_eight ( (char*)&dttemp.y, (char*)&dtptr->y ) ;
swap_eight ( (char*)&dttemp.z, (char*)&dtptr->z ) ;
} else {
dtptr->x = dttemp.x;
dtptr->y = dttemp.y;
dtptr->z = dttemp.z;
}
dtptr++ ;
}
}
break ;
case VpfNull:
/* Do Nothing */
break ;
default:
break ;
} /* end of switch */
return retval ; /* whatever fread returns */
}
