/******************************************************************************
$ID$

The following functions memory copy big-endian data to little-endian data.
 *****************************************************************************/
#include <string.h>

#include "config.h"
#include "EndianSwap/mem.h"
#include "EndianSwap/swapint.h"
#include "EndianSwap/swapfloat.h"

/******************************************************************************
ES_memcpy_short
###############
Copy big-endian short values to little-endian short values. The copy is
done like the standard memcpy function. 

IN:
const short * src: pointer to the memory space to be copied
size_t count: number of short values to copy

OUT:
short * dest : pointer to the destination space memory.

RETURN: 
short * : pointer to dest
*****************************************************************************/
short * ES_memcpy_short(short * dest, const short * src, size_t count)
{
  memcpy(dest, src, count*sizeof(short));

  {
     int i;
    for(i=0; i<count; i++)
      {
	dest[i] = ES_swap_short(&dest[i]);
      }
  }

  return dest;
}

/******************************************************************************
ES_memcpy_int
###############
Copy big-endian int values to little-endian int values. The copy is
done like the standard memcpy function. 

IN:
const int * src: pointer to the memory space to be copied
size_t count: number of int values to copy

OUT:
int * dest : pointer to the destination space memory.

RETURN: 
int * : pointer to dest
 *****************************************************************************/
int * ES_memcpy_int(int * dest, const int * src, size_t count)
{
  memcpy(dest, src, count*sizeof(int));

  {
     int i;
    for(i=0; i<count; i++)
      {
	dest[i] = ES_swap_int(&dest[i]);
      }
  }

  return dest;
}

/******************************************************************************
ES_memcpy_float
###############
Copy big-endian float values to little-endian float values. The copy is
done like the standard memcpy function. 

IN:
const float * src: pointer to the memory space to be copied
size_t count: number of float values to copy

OUT:
float * dest : pointer to the destination space memory.

RETURN: 
float * : pointer to dest
 *****************************************************************************/

float * ES_memcpy_float(float * dest, const float * src, size_t count)
{
  memcpy(dest, src, count*sizeof(float));

  {
     int i;
    for(i=0; i<count; i++)
      {
	dest[i] = ES_swap_float(&dest[i]);
      }
  }

  return dest;
}

/******************************************************************************
ES_memcpy_double
###############
Copy big-endian double values to little-endian double values. The copy is
done like the standard memcpy function. 

IN:
const double * src: pointer to the memory space to be copied
size_t count: number of double values to copy

OUT:
double * dest : pointer to the destination space memory.

RETURN: 
double * : pointer to dest
 *****************************************************************************/

double * ES_memcpy_double(double * dest, const double * src, size_t
			  count)
{
  memcpy(dest, src, count*sizeof(double));

  {
     int i;
    for(i=0; i<count; i++)
      {
	dest[i] = ES_swap_double(&dest[i]);
      }
  }

  return dest;
}

/******************************************************************************
ES_memcpy_swap
###############
Copy big-endian values to little-endian values. The copy is
done like the standard memcpy function. 

IN:
const void * src: pointer to the memory space to be copied
size_t count: number values to copy
size_t size: size of the value basic type.

OUT:
void * dest : pointer to the destination space memory.

RETURN: 
void * : pointer to dest

*****************************************************************************/

void * ES_memcpy_swap(void * dest, const void * src, size_t count,
			size_t size)
{
  memcpy(dest, src, count*size);
 
  {
    int i;
    for(i=0; i<count; i++)
      {
	ES_swap(&((char*)dest)[i*size], size);
      }
  }
   
  return dest;
}

/******************************************************************************
ES_memmove_short
###############
Copy big-endian short values to little-endian short values. The copy is
done like the standard memmove function. 

IN:
const short * src: pointer to the memory space to be copied
size_t count: number of short values to copy

OUT:
short * dest : pointer to the destination space memory.

RETURN: 
short * : pointer to dest
 *****************************************************************************/

short * ES_memmove_short(short * dest, const short * src, size_t count)
{
  memmove(dest, src, count*sizeof(short));

  {
     int i;
    for(i=0; i<count; i++)
      {
	dest[i] = ES_swap_short(&dest[i]);
      }
  }

  return dest;
}

/******************************************************************************
ES_memmove_int
###############
Copy big-endian int values to little-endian int values. The copy is
done like the standard memmove function. 

IN:
const int * src: pointer to the memory space to be copied
size_t count: number of int values to copy

OUT:
int * dest : pointer to the destination space memory.

RETURN: 
int * : pointer to dest
 *****************************************************************************/

int * ES_memmove_int(int * dest, const int * src, size_t count)
{
  memmove(dest, src, count*sizeof(int));

  {
     int i;
    for(i=0; i<count; i++)
      {
	dest[i] = ES_swap_int(&dest[i]);
      }
  }

  return dest;
}

/******************************************************************************
ES_memmove_float
###############
Copy big-endian float values to little-endian float values. The copy is
done like the standard memmove function. 

IN:
const float * src: pointer to the memory space to be copied
size_t count: number of float values to copy

OUT:
float * dest : pointer to the destination space memory.

RETURN: 
float * : pointer to dest
 *****************************************************************************/

float * ES_memmove_float(float * dest, const float * src, size_t count)
{
  memmove(dest, src, count*sizeof(float));

  {
     int i;
    for(i=0; i<count; i++)
      {
	dest[i] = ES_swap_float(&dest[i]);
      }
  }

  return dest;
}

/******************************************************************************
ES_memmove_double
###############
Copy big-endian double values to little-endian double values. The copy is
done like the standard memmove function. 

IN:
const double * src: pointer to the memory space to be copied
size_t count: number of double values to copy

OUT:
double * dest : pointer to the destination space memory.

RETURN: 
double * : pointer to dest

 *****************************************************************************/

double * ES_memmove_double(double * dest, const double * src, size_t
			  count)
{
  memmove(dest, src, count*sizeof(double));

  {
     int i;
    for(i=0; i<count; i++)
      {
	dest[i] = ES_swap_double(&dest[i]);
      }
  }

  return dest;
}

/******************************************************************************
ES_memmove_swap
###############
Copy big-endian values to little-endian values. The copy is
done like the standard memmove function. 

IN:
const void * src: pointer to the memory space to be copied
size_t count: number values to copy
size_t size: size of the value type.

OUT:
void * dest : pointer to the destination space memory.

RETURN: 
void * : pointer to dest
 *****************************************************************************/

void * ES_memmove_swap(void * dest, const void * src, size_t count,
			size_t size)
{
  memmove(dest, src, count*size);
 
  {
    int i;
    for(i=0; i<count; i++)
      {
	ES_swap(&((char*)dest)[i*size], size);
      }
  }
   
  return dest;
}