LECanonicalConversion.h

Go to the documentation of this file.

//# LECanonicalConversion.h: A class with static functions to convert little endian canonical format
//# Copyright (C) 2002
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//#        Internet email: casa-feedback@nrao.edu.
//#        Postal address: AIPS++ Project Office
//#                        National Radio Astronomy Observatory
//#                        520 Edgemont Road
//#                        Charlottesville, VA 22903-2475 USA
 
#ifndef CASA_LECANONICALCONVERSION_H
#define CASA_LECANONICALCONVERSION_H
 
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/casa/OS/Conversion.h>
#include <cstring>
 
 
namespace casacore { //# NAMESPACE CASACORE - BEGIN
 
// Define the little endian canonical sizes of the built-in data types.
// These are the same for all machine architectures.
 
#define SIZE_LECAN_CHAR     1
#define SIZE_LECAN_UCHAR    1
#define SIZE_LECAN_SHORT    2
#define SIZE_LECAN_USHORT   2
#define SIZE_LECAN_INT      4
#define SIZE_LECAN_UINT     4
#define SIZE_LECAN_INT64    8
#define SIZE_LECAN_UINT64   8
#define SIZE_LECAN_FLOAT    4
#define SIZE_LECAN_DOUBLE   8
//#//define SIZE_LECAN_LDOUBLE 16
 
 
// Define for each data format if a conversion is needed from the
// local format to the little endian canonical format (or vice-versa).
// This allows for optimizations in, for example, AipsIO.
// The canonical format is ASCII for strings, IEEE for floating point
// and 2-complement for integers (all most significant bit last)
// with the lengths as shown above.
// The function checkConvert() can be used to check if the flags are
// set correctly.
 
// Conversion is needed for big endian architectures (like SUN),
// because the bytes have to be swapped (thus not for data with length 1).
#define CONVERT_LECAN_CHAR     0
#define CONVERT_LECAN_UCHAR    0
 
#if !defined(AIPS_LITTLE_ENDIAN)
#  define CONVERT_LECAN_SHORT    1
#  define CONVERT_LECAN_USHORT   1
#  define CONVERT_LECAN_INT      1
#  define CONVERT_LECAN_UINT     1
#  define CONVERT_LECAN_INT64    1
#  define CONVERT_LECAN_UINT64   1
#  define CONVERT_LECAN_FLOAT    1
#  define CONVERT_LECAN_DOUBLE   1
//#//#  define CONVERT_LECAN_LDOUBLE  1
#else
 
// Conversion is not needed for IEEE data.
// Change the definitions below if new architectures are being used.
#  define CONVERT_LECAN_SHORT    0
#  define CONVERT_LECAN_USHORT   0
#  define CONVERT_LECAN_INT      0
#  define CONVERT_LECAN_UINT     0
#  define CONVERT_LECAN_INT64    0
#  define CONVERT_LECAN_UINT64   0
#  define CONVERT_LECAN_FLOAT    0
#  define CONVERT_LECAN_DOUBLE   0
// LDOUBLE is 8 bytes on SUN, but 16 bytes canonical.
//#//#  define CONVERT_LECAN_LDOUBLE  1
#endif
 
 
 
// <summary>
// A class with static functions to convert little endian canonical format
// </summary>
 
// <use visibility=export>
 
// <reviewed reviewer="Friso Olnon" date="1996/11/06" tests="tLECanonicalConversion" demos="">
// </reviewed>
 
// <synopsis>
// This class consists of several static functions to convert
// data from local (=native) format to a little endian canonical format.
// The canonical length of each data type is:
// <br>- Bool: 1 bit
// <br>- char: 1 byte
// <br>- short: 2 bytes
// <br>- int: 4 bytes
// <br>- Int64: 8 bytes
// <br>- float: 4 bytes
// <br>- double: 8 bytes
// <br> This canonical format is little-endian IEEE format, so on PCs
// the conversion is only a copy operation. On e.g. SUNs
// however, it involves a byte swap to convert from little
// endian to big endian.
// <p>
// The class also contains conversion functions making it possible to
// specify the number of bytes (in local format) instead of the number
// of values. These functions are included to make it possible to have
// the same signature as memcpy.
// <p>
// The current implementation of this class works on big- and little-endian
// machines using IEEE format. When using on other machines (e.g. VAX)
// the toLocal and fromLocal functions have to be changed.
// <p>
// Note that no functions are provided to handle Bools. Instead class
// <linkto class=Conversion>Conversion</linkto> provides functions to
// convert Bools to/from bits.
// </synopsis>
 
// <example>
// <srcblock>
// void someFunction (const uInt* data, uInt nrval)
// {
//     char* buffer = new char[nrval*LECanonicalConversion::canonicalSize(data)];
//     LECanonicalConversion::fromLocal (buffer, data, nrval);
//     ....
//     delete [] buffer;
// }
// </srcblock>
// </example>
 
// <motivation>
// Casacore data will often be stored in a canonical format.
// To read these data conversion functions are needed.
// However, these functions do not use any other Casacore classes,
// so they can easily be used in any other software system.
// </motivation>
 
// <todo asof="$DATE$">
//  <li> Support data type long double.
// </todo>
 
 
class LECanonicalConversion
{
public:
    // Convert one value from canonical format to local format.
    // The from and to buffer should not overlap.
    // <group>
    static size_t toLocal (char&           to, const void* from);
    static size_t toLocal (unsigned char&  to, const void* from);
    static size_t toLocal (short&          to, const void* from);
    static size_t toLocal (unsigned short& to, const void* from);
    static size_t toLocal (int&            to, const void* from);
    static size_t toLocal (unsigned int&   to, const void* from);
    static size_t toLocal (Int64&          to, const void* from);
    static size_t toLocal (uInt64&         to, const void* from);
    static size_t toLocal (float&          to, const void* from);
    static size_t toLocal (double&         to, const void* from);
    // </group>
    
    // Convert one value from local format to canonical format.
    // The from and to buffer should not overlap.
    // <group>
    static size_t fromLocal (void* to, const char&           from);
    static size_t fromLocal (void* to, const unsigned char&  from);
    static size_t fromLocal (void* to, const short&          from);
    static size_t fromLocal (void* to, const unsigned short& from);
    static size_t fromLocal (void* to, const int&            from);
    static size_t fromLocal (void* to, const unsigned int&   from);
    static size_t fromLocal (void* to, const Int64&          from);
    static size_t fromLocal (void* to, const uInt64&         from);
    static size_t fromLocal (void* to, const float&          from);
    static size_t fromLocal (void* to, const double&         from);
    // </group>
    
    // Convert nr values from canonical format to local format.
    // The from and to buffer should not overlap.
    // <group>
    static size_t toLocal (char*           to, const void* from,
                           size_t nr);
    static size_t toLocal (unsigned char*  to, const void* from,
                           size_t nr);
    static size_t toLocal (short*          to, const void* from,
                           size_t nr);
    static size_t toLocal (unsigned short* to, const void* from,
                           size_t nr);
    static size_t toLocal (int*            to, const void* from,
                           size_t nr);
    static size_t toLocal (unsigned int*   to, const void* from,
                           size_t nr);
    static size_t toLocal (Int64*          to, const void* from,
                           size_t nr);
    static size_t toLocal (uInt64*         to, const void* from,
                           size_t nr);
    static size_t toLocal (float*          to, const void* from,
                           size_t nr);
    static size_t toLocal (double*         to, const void* from,
                           size_t nr);
    // </group>
 
    // Convert nr values from local format to canonical format.
    // The from and to buffer should not overlap.
    // <group>
    static size_t fromLocal (void* to, const char*           from,
                             size_t nr);
    static size_t fromLocal (void* to, const unsigned char*  from,
                             size_t nr);
    static size_t fromLocal (void* to, const short*          from,
                             size_t nr);
    static size_t fromLocal (void* to, const unsigned short* from,
                             size_t nr);
    static size_t fromLocal (void* to, const int*            from,
                             size_t nr);
    static size_t fromLocal (void* to, const unsigned int*   from,
                             size_t nr);
    static size_t fromLocal (void* to, const Int64*          from,
                             size_t nr);
    static size_t fromLocal (void* to, const uInt64*         from,
                             size_t nr);
    static size_t fromLocal (void* to, const float*          from,
                             size_t nr);
    static size_t fromLocal (void* to, const double*         from,
                             size_t nr);
    // </group>
 
    // Convert nr values from canonical format to local format.
    // The from and to buffer should not overlap.
    // <group>
    static size_t toLocalChar     (void* to, const void* from,
                                   size_t nr);
    static size_t toLocalUChar    (void* to, const void* from,
                                   size_t nr);
    static size_t toLocalShort    (void* to, const void* from,
                                   size_t nr);
    static size_t toLocalUShort   (void* to, const void* from,
                                   size_t nr);
    static size_t toLocalInt      (void* to, const void* from,
                                   size_t nr);
    static size_t toLocalUInt     (void* to, const void* from,
                                   size_t nr);
    static size_t toLocalInt64    (void* to, const void* from,
                                   size_t nr);
    static size_t toLocalUInt64   (void* to, const void* from,
                                   size_t nr);
    static size_t toLocalFloat    (void* to, const void* from,
                                   size_t nr);
    static size_t toLocalDouble   (void* to, const void* from,
                                   size_t nr);
    // </group>
 
    // Convert nr values from local format to canonical format.
    // The from and to buffer should not overlap.
    // <group>
    static size_t fromLocalChar     (void* to, const void* from,
                                     size_t nr);
    static size_t fromLocalUChar    (void* to, const void* from,
                                     size_t nr);
    static size_t fromLocalShort    (void* to, const void* from,
                                     size_t nr);
    static size_t fromLocalUShort   (void* to, const void* from,
                                     size_t nr);
    static size_t fromLocalInt      (void* to, const void* from,
                                     size_t nr);
    static size_t fromLocalUInt     (void* to, const void* from,
                                     size_t nr);
    static size_t fromLocalInt64    (void* to, const void* from,
                                     size_t nr);
    static size_t fromLocalUInt64   (void* to, const void* from,
                                     size_t nr);
    static size_t fromLocalFloat    (void* to, const void* from,
                                     size_t nr);
    static size_t fromLocalDouble   (void* to, const void* from,
                                     size_t nr);
    // </group>
    
    // Convert values from canonical format to local format.
    // The from and to buffer should not overlap.
    // The number of values involved is determined from the argument
    // <src>nrbytes</src>, which gives the number of bytes in local format.
    // The signature of this function is the same as <src>memcpy</src>, so
    // that memcpy can directly be used if no conversion is needed.
    // <group>
    static void* byteToLocalChar     (void* to, const void* from,
                      size_t nrbytes);
    static void* byteToLocalUChar    (void* to, const void* from,
                      size_t nrbytes);
    static void* byteToLocalShort    (void* to, const void* from,
                      size_t nrbytes);
    static void* byteToLocalUShort   (void* to, const void* from,
                      size_t nrbytes);
    static void* byteToLocalInt      (void* to, const void* from,
                      size_t nrbytes);
    static void* byteToLocalUInt     (void* to, const void* from,
                      size_t nrbytes);
    static void* byteToLocalInt64    (void* to, const void* from,
                      size_t nrbytes);
    static void* byteToLocalUInt64   (void* to, const void* from,
                      size_t nrbytes);
    static void* byteToLocalFloat    (void* to, const void* from,
                      size_t nrbytes);
    static void* byteToLocalDouble   (void* to, const void* from,
                      size_t nrbytes);
    // </group>
    
    // Convert values from local format to canonical format.
    // The from and to buffer should not overlap.
    // The number of values involved is determined from the argument
    // <src>nrbytes</src>, which gives the number of bytes in local format.
    // The signature of this function is the same as <src>memcpy</src>, so
    // that memcpy can directly be used if no conversion is needed.
    // <group>
    static void* byteFromLocalChar     (void* to, const void* from,
                    size_t nrbytes);
    static void* byteFromLocalUChar    (void* to, const void* from,
                    size_t nrbytes);
    static void* byteFromLocalShort    (void* to, const void* from,
                    size_t nrbytes);
    static void* byteFromLocalUShort   (void* to, const void* from,
                    size_t nrbytes);
    static void* byteFromLocalInt      (void* to, const void* from,
                    size_t nrbytes);
    static void* byteFromLocalUInt     (void* to, const void* from,
                    size_t nrbytes);
    static void* byteFromLocalInt64    (void* to, const void* from,
                    size_t nrbytes);
    static void* byteFromLocalUInt64   (void* to, const void* from,
                    size_t nrbytes);
    static void* byteFromLocalFloat    (void* to, const void* from,
                    size_t nrbytes);
    static void* byteFromLocalDouble   (void* to, const void* from,
                    size_t nrbytes);
    // </group>
    
    // Get the value conversion function for the given type.
    // <group>
    static Conversion::ValueFunction* getToLocal (const char*);
    static Conversion::ValueFunction* getToLocal (const unsigned char*);
    static Conversion::ValueFunction* getToLocal (const short*);
    static Conversion::ValueFunction* getToLocal (const unsigned short*);
    static Conversion::ValueFunction* getToLocal (const int*);
    static Conversion::ValueFunction* getToLocal (const unsigned int*);
    static Conversion::ValueFunction* getToLocal (const Int64*);
    static Conversion::ValueFunction* getToLocal (const uInt64*);
    static Conversion::ValueFunction* getToLocal (const float*);
    static Conversion::ValueFunction* getToLocal (const double*);
    static Conversion::ValueFunction* getFromLocal (const char*);
    static Conversion::ValueFunction* getFromLocal (const unsigned char*);
    static Conversion::ValueFunction* getFromLocal (const short*);
    static Conversion::ValueFunction* getFromLocal (const unsigned short*);
    static Conversion::ValueFunction* getFromLocal (const int*);
    static Conversion::ValueFunction* getFromLocal (const unsigned int*);
    static Conversion::ValueFunction* getFromLocal (const Int64*);
    static Conversion::ValueFunction* getFromLocal (const uInt64*);
    static Conversion::ValueFunction* getFromLocal (const float*);
    static Conversion::ValueFunction* getFromLocal (const double*);
    // </group>
 
    // Get the byte conversion function for the given type.
    // The function <src>memcpy</src> is returned when a conversion
    // is not needed.
    // <group>
    static Conversion::ByteFunction* getByteToLocal (const char*);
    static Conversion::ByteFunction* getByteToLocal (const unsigned char*);
    static Conversion::ByteFunction* getByteToLocal (const short*);
    static Conversion::ByteFunction* getByteToLocal (const unsigned short*);
    static Conversion::ByteFunction* getByteToLocal (const int*);
    static Conversion::ByteFunction* getByteToLocal (const unsigned int*);
    static Conversion::ByteFunction* getByteToLocal (const Int64*);
    static Conversion::ByteFunction* getByteToLocal (const uInt64*);
    static Conversion::ByteFunction* getByteToLocal (const float*);
    static Conversion::ByteFunction* getByteToLocal (const double*);
    static Conversion::ByteFunction* getByteFromLocal (const char*);
    static Conversion::ByteFunction* getByteFromLocal (const unsigned char*);
    static Conversion::ByteFunction* getByteFromLocal (const short*);
    static Conversion::ByteFunction* getByteFromLocal (const unsigned short*);
    static Conversion::ByteFunction* getByteFromLocal (const int*);
    static Conversion::ByteFunction* getByteFromLocal (const unsigned int*);
    static Conversion::ByteFunction* getByteFromLocal (const Int64*);
    static Conversion::ByteFunction* getByteFromLocal (const uInt64*);
    static Conversion::ByteFunction* getByteFromLocal (const float*);
    static Conversion::ByteFunction* getByteFromLocal (const double*);
    // </group>
 
    // Return the canonical length for the various data types.
    // <group>
    static unsigned int canonicalSize (const char*);
    static unsigned int canonicalSize (const unsigned char*);
    static unsigned int canonicalSize (const short*);
    static unsigned int canonicalSize (const unsigned short*);
    static unsigned int canonicalSize (const int*);
    static unsigned int canonicalSize (const unsigned int*);
    static unsigned int canonicalSize (const Int64*);
    static unsigned int canonicalSize (const uInt64*);
    static unsigned int canonicalSize (const float*);
    static unsigned int canonicalSize (const double*);
    //#//static unsigned int canonicalSize (const long double*);
    // </group>
 
    // Reverse 2 bytes.
    static void reverse2 (void* to, const void* from);
 
    // Reverse 4 bytes.
    static void reverse4 (void* to, const void* from);
 
    // Reverse 8 bytes.
    static void reverse8 (void* to, const void* from);
 
    // Move 2 bytes.
    static void move2 (void* to, const void* from);
 
    // Move 4 bytes.
    static void move4 (void* to, const void* from);
 
    // Move 8 bytes.
    static void move8 (void* to, const void* from);
 
private:
    // This class should not be constructed
    // (so declare the constructor private).
    LECanonicalConversion();
};
 
 
inline void LECanonicalConversion::reverse2 (void* to, const void* from)
{
    unsigned short x, xsw;
    memcpy(&x, from, 2);
    xsw = ((x & 0xffu) << 8u) | (x >> 8u);
    memcpy(to, &xsw, 2);
}
 
inline void LECanonicalConversion::reverse4 (void* to, const void* from)
{
    unsigned int x, xsw;
    memcpy(&x, from, 4);
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
    xsw = __builtin_bswap32(x);
#else
    xsw = ((x & 0xffu) << 24u) | ((x & 0xff00u) << 8u) |
          ((x & 0xff0000u) >> 8u) | (x >> 24u);
#endif
    memcpy(to, &xsw, 4);
}
 
inline void LECanonicalConversion::reverse8 (void* to, const void* from)
{
    uInt64 x, xsw;
    memcpy(&x, from, 8);
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
    xsw = __builtin_bswap64(x);
#else
    xsw = ((x & 0xffULL) << 56ULL) |
          ((x & 0xff00ULL) << 40ULL) |
          ((x & 0xff0000ULL) << 24ULL) |
          ((x & 0xff000000ULL) << 8ULL) |
          ((x & 0xff00000000ULL) >> 8ULL) |
          ((x & 0xff0000000000ULL) >> 24ULL) |
          ((x & 0xff000000000000ULL) >> 40ULL) |
          ( x >> 56ULL);
#endif
    memcpy(to, &xsw, 8);
}
 
inline void LECanonicalConversion::move2 (void* to, const void* from)
{
    memcpy(to, from, 2);
}
 
inline void LECanonicalConversion::move4 (void* to, const void* from)
{
    memcpy(to, from, 4);
}
 
inline void LECanonicalConversion::move8 (void* to, const void* from)
{
    /* memcpy is overlap save if size fits into a register */
    if (sizeof(to) < 8) {
        memmove(to, from, 8);
    }
    else {
        memcpy(to, from, 8);
    }
}
 
 
 
inline size_t LECanonicalConversion::toLocal (char& to,
                                              const void* from)
{
    to = *(char*)from;
    return SIZE_LECAN_CHAR;
}
 
inline size_t LECanonicalConversion::toLocal (unsigned char& to,
                                              const void* from)
{
    to = *(unsigned char*)from;
    return SIZE_LECAN_UCHAR;
}
 
inline size_t LECanonicalConversion::toLocal (short& to,
                                              const void* from)
{
    if (sizeof(short) != 2) {
    if (((signed char*)from)[0] < 0) {
        to = -1;
    }else{
        to = 0;
    }
    }
#if !defined(AIPS_LITTLE_ENDIAN)
    reverse2 (&to, from);
#else
    move2 (((char*)&to)+sizeof(short)-2, from);
#endif
    return SIZE_LECAN_SHORT;
}
 
inline size_t LECanonicalConversion::toLocal (unsigned short& to,
                                              const void* from)
{
    if (sizeof(unsigned short) != 2) {
    to = 0;
    }
#if !defined(AIPS_LITTLE_ENDIAN)
    reverse2 (&to, from);
#else
    move2 (((char*)&to)+sizeof(unsigned short)-2, from);
#endif
    return SIZE_LECAN_USHORT;
}
 
inline size_t LECanonicalConversion::toLocal (int& to,
                                              const void* from)
{
    if (sizeof(int) != 4) {
    if (((signed char*)from)[0] < 0) {
        to = -1;
    }else{
        to = 0;
    }
    }
#if !defined(AIPS_LITTLE_ENDIAN)
    reverse4 (&to, from);
#else
    move4 (((char*)&to)+sizeof(int)-4, from);
#endif
    return SIZE_LECAN_INT;
}
 
inline size_t LECanonicalConversion::toLocal (unsigned int& to,
                                              const void* from)
{
    if (sizeof(unsigned int) != 4) {
    to = 0;
    }
#if !defined(AIPS_LITTLE_ENDIAN)
    reverse4 (&to, from);
#else
    move4 (((char*)&to)+sizeof(unsigned int)-4, from);
#endif
    return SIZE_LECAN_UINT;
}
 
inline size_t LECanonicalConversion::toLocal (Int64& to,
                                              const void* from)
{
    if (sizeof(Int64) != 8) {
    if (((signed char*)from)[0] < 0) {
        to = -1;
    }else{
        to = 0;
    }
    }
#if !defined(AIPS_LITTLE_ENDIAN)
    reverse8 (&to, from);
#else
    move8 (((char*)&to)+sizeof(Int64)-8, from);
#endif
    return SIZE_LECAN_INT64;
}
 
inline size_t LECanonicalConversion::toLocal (uInt64& to,
                                              const void* from)
{
    if (sizeof(uInt64) != 8) {
    to = 0;
    }
#if !defined(AIPS_LITTLE_ENDIAN)
    reverse8 (&to, from);
#else
    move8 (((char*)&to)+sizeof(uInt64)-8, from);
#endif
    return SIZE_LECAN_UINT64;
}
 
inline size_t LECanonicalConversion::toLocal (float& to,
                                              const void* from)
{
#if !defined(AIPS_LITTLE_ENDIAN)
    reverse4 (((char*)&to)+sizeof(float)-4, from);
#else
    move4 (&to, from);
#endif
    return SIZE_LECAN_FLOAT;
}
 
inline size_t LECanonicalConversion::toLocal (double& to,
                                              const void* from)
{
#if !defined(AIPS_LITTLE_ENDIAN)
    reverse8 (((char*)&to)+sizeof(double)-8, from);
#else
    move8 (&to, from);
#endif
    return SIZE_LECAN_DOUBLE;
}
 
 
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const char& from)
{
    *(char*)to = from;
    return SIZE_LECAN_CHAR;
}
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const unsigned char& from)
{
    *(unsigned char*)to = from;
    return SIZE_LECAN_UCHAR;
}
 
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const short& from)
{
#if !defined(AIPS_LITTLE_ENDIAN)
    reverse2 (to, &from);
#else
    move2 (to, ((char*)&from)+sizeof(short)-2);
#endif
    return SIZE_LECAN_SHORT;
}
 
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const unsigned short& from)
{
#if !defined(AIPS_LITTLE_ENDIAN)
    reverse2 (to, &from);
#else
    move2 (to, ((char*)&from)+sizeof(unsigned short)-2);
#endif
    return SIZE_LECAN_USHORT;
}
 
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const int& from)
{
#if !defined(AIPS_LITTLE_ENDIAN)
    reverse4 (to, &from);
#else
    move4 (to, ((char*)&from)+sizeof(int)-4);
#endif
    return SIZE_LECAN_INT;
}
 
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const unsigned int& from)
{
#if !defined(AIPS_LITTLE_ENDIAN)
    reverse4 (to, &from);
#else
    move4 (to, ((char*)&from)+sizeof(unsigned int)-4);
#endif
    return SIZE_LECAN_UINT;
}
 
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const Int64& from)
{
#if !defined(AIPS_LITTLE_ENDIAN)
    reverse8 (to, &from);
#else
    move8 (to, ((char*)&from)+sizeof(Int64)-8);
#endif
    return SIZE_LECAN_INT64;
}
 
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const uInt64& from)
{
#if !defined(AIPS_LITTLE_ENDIAN)
    reverse8 (to, &from);
#else
    move8 (to, ((char*)&from)+sizeof(uInt64)-8);
#endif
    return SIZE_LECAN_UINT64;
}
 
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const float& from)
{
#if !defined(AIPS_LITTLE_ENDIAN)
    reverse4 (to, &from);
#else
    move4 (to, &from);
#endif
    return SIZE_LECAN_FLOAT;
}
 
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const double& from)
{
#if !defined(AIPS_LITTLE_ENDIAN)
    reverse8 (to, &from);
#else
    move8 (to, &from);
#endif
    return SIZE_LECAN_FLOAT;
}
 
 
inline size_t LECanonicalConversion::toLocal (char*           to,
                                              const void* from,
                                              size_t nr)
{
    return toLocalChar (to, from, nr);
}
inline size_t LECanonicalConversion::toLocal (unsigned char*  to,
                                              const void* from,
                                              size_t nr)
{
    return toLocalUChar (to, from, nr);
}
inline size_t LECanonicalConversion::toLocal (short*          to,
                                              const void* from,
                                              size_t nr)
{
    return toLocalShort (to, from, nr);
}
inline size_t LECanonicalConversion::toLocal (unsigned short* to,
                                              const void* from,
                                              size_t nr)
{
    return toLocalUShort (to, from, nr);
}
inline size_t LECanonicalConversion::toLocal (int*            to,
                                              const void* from,
                                              size_t nr)
{
    return toLocalInt (to, from, nr);
}
inline size_t LECanonicalConversion::toLocal (unsigned int*   to,
                                              const void* from,
                                              size_t nr)
{
    return toLocalUInt (to, from, nr);
}
inline size_t LECanonicalConversion::toLocal (Int64*          to,
                                              const void* from,
                                              size_t nr)
{
    return toLocalInt64 (to, from, nr);
}
inline size_t LECanonicalConversion::toLocal (uInt64*         to,
                                              const void* from,
                                              size_t nr)
{
    return toLocalUInt64 (to, from, nr);
}
inline size_t LECanonicalConversion::toLocal (float*          to,
                                              const void* from,
                                              size_t nr)
{
    return toLocalFloat (to, from, nr);
}
inline size_t LECanonicalConversion::toLocal (double*         to,
                                              const void* from,
                                              size_t nr)
{
    return toLocalDouble (to, from, nr);
}
 
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const char*           from,
                                                size_t nr)
{
    return fromLocalChar (to, from, nr);
}
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const unsigned char*  from,
                                                size_t nr)
{
    return fromLocalUChar (to, from, nr);
}
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const short*          from,
                                                size_t nr)
{
    return fromLocalShort (to, from, nr);
}
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const unsigned short* from,
                                                size_t nr)
{
    return fromLocalUShort (to, from, nr);
}
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const int*            from,
                                                size_t nr)
{
    return fromLocalInt (to, from, nr);
}
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const unsigned int*   from,
                                                size_t nr)
{
    return fromLocalUInt (to, from, nr);
}
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const Int64*          from,
                                                size_t nr)
{
    return fromLocalInt64 (to, from, nr);
}
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const uInt64*         from,
                                                size_t nr)
{
    return fromLocalUInt64 (to, from, nr);
}
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const float*          from,
                                                size_t nr)
{
    return fromLocalFloat (to, from, nr);
}
inline size_t LECanonicalConversion::fromLocal (void* to,
                                                const double*         from,
                                                size_t nr)
{
    return fromLocalDouble (to, from, nr);
}
 
 
inline Conversion::ValueFunction* LECanonicalConversion::getToLocal
                                                      (const char*)
{
    return toLocalChar;
}
inline Conversion::ValueFunction* LECanonicalConversion::getToLocal
                                                      (const unsigned char*)
{
    return toLocalUChar;
}
inline Conversion::ValueFunction* LECanonicalConversion::getToLocal
                                                      (const short*)
{
    return toLocalShort;
}
inline Conversion::ValueFunction* LECanonicalConversion::getToLocal
                                                      (const unsigned short*)
{
    return toLocalUShort;
}
inline Conversion::ValueFunction* LECanonicalConversion::getToLocal
                                                      (const int*)
{
    return toLocalInt;
}
inline Conversion::ValueFunction* LECanonicalConversion::getToLocal
                                                      (const unsigned int*)
{
    return toLocalUInt;
}
inline Conversion::ValueFunction* LECanonicalConversion::getToLocal
                                                      (const Int64*)
{
    return toLocalInt64;
}
inline Conversion::ValueFunction* LECanonicalConversion::getToLocal
                                                      (const uInt64*)
{
    return toLocalUInt64;
}
inline Conversion::ValueFunction* LECanonicalConversion::getToLocal
                                                      (const float*)
{
    return toLocalFloat;
}
inline Conversion::ValueFunction* LECanonicalConversion::getToLocal
                                                      (const double*)
{
    return toLocalDouble;
}
 
inline Conversion::ValueFunction* LECanonicalConversion::getFromLocal
                                                      (const char*)
{
    return fromLocalChar;
}
inline Conversion::ValueFunction* LECanonicalConversion::getFromLocal
                                                      (const unsigned char*)
{
    return fromLocalUChar;
}
inline Conversion::ValueFunction* LECanonicalConversion::getFromLocal
                                                      (const short*)
{
    return fromLocalShort;
}
inline Conversion::ValueFunction* LECanonicalConversion::getFromLocal
                                                      (const unsigned short*)
{
    return fromLocalUShort;
}
inline Conversion::ValueFunction* LECanonicalConversion::getFromLocal
                                                      (const int*)
{
    return fromLocalInt;
}
inline Conversion::ValueFunction* LECanonicalConversion::getFromLocal
                                                      (const unsigned int*)
{
    return fromLocalUInt;
}
inline Conversion::ValueFunction* LECanonicalConversion::getFromLocal
                                                      (const Int64*)
{
    return fromLocalInt64;
}
inline Conversion::ValueFunction* LECanonicalConversion::getFromLocal
                                                      (const uInt64*)
{
    return fromLocalUInt64;
}
inline Conversion::ValueFunction* LECanonicalConversion::getFromLocal
                                                      (const float*)
{
    return fromLocalFloat;
}
inline Conversion::ValueFunction* LECanonicalConversion::getFromLocal
                                                      (const double*)
{
    return fromLocalDouble;
}
 
 
inline unsigned int LECanonicalConversion::canonicalSize (const char*)
    {return SIZE_LECAN_CHAR;}
inline unsigned int LECanonicalConversion::canonicalSize (const unsigned char*)
    {return SIZE_LECAN_UCHAR;} 
inline unsigned int LECanonicalConversion::canonicalSize (const short*)
    {return SIZE_LECAN_SHORT;}
inline unsigned int LECanonicalConversion::canonicalSize (const unsigned short*)
    {return SIZE_LECAN_USHORT;}
inline unsigned int LECanonicalConversion::canonicalSize (const int*)
    {return SIZE_LECAN_INT;}
inline unsigned int LECanonicalConversion::canonicalSize (const unsigned int*)
    {return SIZE_LECAN_UINT;}
inline unsigned int LECanonicalConversion::canonicalSize (const Int64*)
    {return SIZE_LECAN_INT64;}
inline unsigned int LECanonicalConversion::canonicalSize (const uInt64*)
    {return SIZE_LECAN_UINT64;}
inline unsigned int LECanonicalConversion::canonicalSize (const float*)
    {return SIZE_LECAN_FLOAT;}
inline unsigned int LECanonicalConversion::canonicalSize (const double*)
    {return SIZE_LECAN_DOUBLE;}
//#//inline unsigned int LECanonicalConversion::canonicalSize (const long double*)
//#//    {return SIZE_LECAN_LDOUBLE;}
 
 
 
 
} //# NAMESPACE CASACORE - END
 
#endif