endian.h

Go to the documentation of this file.

/*  WFIO - the Wheefun IO Library
    Copyright (C) 2018  Phillip Kilgore

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even t implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
    
    Additionally, you should have recieved a copy of the GNU Classpath 
    exception, which amends the license to generally permit linking against
    the software provided herein.
*/

/* This file was generated by contrib/meta/endian.pl */

#ifndef WFIO_ENDIAN_H
#define WFIO_ENDIAN_H

#include <wfio/type.h>

WFIO_DLL void wfio_convertEndianSI16V2(
    const wfio_sint16_t* src, wfio_endian_t srcEndian,
    wfio_sint16_t* dest, wfio_endian_t destEndian,
    size_t len);

WFIO_ALWAYS_INLINE void wfio_fromHostEndianSI16V2(
    const wfio_sint16_t* src, wfio_sint16_t* dest, 
    wfio_endian_t destEndian, size_t len) {
    wfio_convertEndianSI16V2(src, WFIO_ENDIAN_HOST, dest, destEndian, len);
}

WFIO_ALWAYS_INLINE void wfio_toHostEndianSI16V2(
    const wfio_sint16_t* src, wfio_sint16_t* dest, 
    wfio_endian_t srcEndian, size_t len) {
    wfio_convertEndianSI16V2(src, srcEndian, dest, WFIO_ENDIAN_HOST, len);
}

WFIO_ALWAYS_INLINE void wfio_convertEndianSI16V(wfio_sint16_t* buf, 
    wfio_endian_t src, wfio_endian_t dest,
    size_t len) {
    wfio_convertEndianSI16V2(buf, src, buf, dest, len);
}


WFIO_ALWAYS_INLINE void wfio_fromHostEndianSI16V(
    wfio_sint16_t* buf, wfio_endian_t destEndian, size_t len) {
    wfio_convertEndianSI16V2(buf, WFIO_ENDIAN_HOST, buf, destEndian, len);
}

WFIO_ALWAYS_INLINE void wfio_toHostEndianSI16V(
    wfio_sint16_t* buf, wfio_endian_t srcEndian, size_t len) {
    wfio_convertEndianSI16V2(buf, srcEndian, buf, WFIO_ENDIAN_HOST, len);
}

WFIO_ALWAYS_INLINE wfio_sint16_t wfio_convertEndianSI16(wfio_sint16_t x, 
    wfio_endian_t src, wfio_endian_t dest) {
    wfio_convertEndianSI16V2(&x, src, &x, dest, 1);
    return x;
}

WFIO_ALWAYS_INLINE wfio_sint16_t wfio_fromHostEndianSI16(
    wfio_sint16_t x, wfio_endian_t destEndian) {
    wfio_convertEndianSI16V2(&x, WFIO_ENDIAN_HOST, &x, destEndian, 1);
    return x;
}

WFIO_ALWAYS_INLINE wfio_sint16_t wfio_toHostEndianSI16(
    wfio_sint16_t x, wfio_endian_t srcEndian) {
    wfio_convertEndianSI16V2(&x, srcEndian, &x, WFIO_ENDIAN_HOST, 1);
    return x;
}

WFIO_ALWAYS_INLINE void wfio_convertEndianUI16V2(
    const wfio_uint16_t* src, wfio_endian_t srcEndian,
    wfio_uint16_t* dest, wfio_endian_t destEndian,
    size_t len) {
    wfio_convertEndianSI16V2(
        (const wfio_sint16_t*) src, srcEndian,
        (wfio_sint16_t*) dest, destEndian,
        len);
}

WFIO_ALWAYS_INLINE void wfio_fromHostEndianUI16V2(
    const wfio_uint16_t* src, wfio_uint16_t* dest, 
    wfio_endian_t destEndian, size_t len) {
    wfio_convertEndianUI16V2(src, WFIO_ENDIAN_HOST, dest, destEndian, len);
}

WFIO_ALWAYS_INLINE void wfio_toHostEndianUI16V2(
    const wfio_uint16_t* src, wfio_uint16_t* dest, 
    wfio_endian_t srcEndian, size_t len) {
    wfio_convertEndianUI16V2(src, srcEndian, dest, WFIO_ENDIAN_HOST, len);
}

WFIO_ALWAYS_INLINE void wfio_convertEndianUI16V(wfio_uint16_t* buf, 
    wfio_endian_t src, wfio_endian_t dest,
    size_t len) {
    wfio_convertEndianUI16V2(buf, src, buf, dest, len);
}


WFIO_ALWAYS_INLINE void wfio_fromHostEndianUI16V(
    wfio_uint16_t* buf, wfio_endian_t destEndian, size_t len) {
    wfio_convertEndianUI16V2(buf, WFIO_ENDIAN_HOST, buf, destEndian, len);
}

WFIO_ALWAYS_INLINE void wfio_toHostEndianUI16V(
    wfio_uint16_t* buf, wfio_endian_t srcEndian, size_t len) {
    wfio_convertEndianUI16V2(buf, srcEndian, buf, WFIO_ENDIAN_HOST, len);
}

WFIO_ALWAYS_INLINE wfio_uint16_t wfio_convertEndianUI16(wfio_uint16_t x, 
    wfio_endian_t src, wfio_endian_t dest) {
    wfio_convertEndianUI16V2(&x, src, &x, dest, 1);
    return x;
}

WFIO_ALWAYS_INLINE wfio_uint16_t wfio_fromHostEndianUI16(
    wfio_uint16_t x, wfio_endian_t destEndian) {
    wfio_convertEndianUI16V2(&x, WFIO_ENDIAN_HOST, &x, destEndian, 1);
    return x;
}

WFIO_ALWAYS_INLINE wfio_uint16_t wfio_toHostEndianUI16(
    wfio_uint16_t x, wfio_endian_t srcEndian) {
    wfio_convertEndianUI16V2(&x, srcEndian, &x, WFIO_ENDIAN_HOST, 1);
    return x;
}

WFIO_DLL void wfio_convertEndianSI32V2(
    const wfio_sint32_t* src, wfio_endian_t srcEndian,
    wfio_sint32_t* dest, wfio_endian_t destEndian,
    size_t len);

WFIO_ALWAYS_INLINE void wfio_fromHostEndianSI32V2(
    const wfio_sint32_t* src, wfio_sint32_t* dest, 
    wfio_endian_t destEndian, size_t len) {
    wfio_convertEndianSI32V2(src, WFIO_ENDIAN_HOST, dest, destEndian, len);
}

WFIO_ALWAYS_INLINE void wfio_toHostEndianSI32V2(
    const wfio_sint32_t* src, wfio_sint32_t* dest, 
    wfio_endian_t srcEndian, size_t len) {
    wfio_convertEndianSI32V2(src, srcEndian, dest, WFIO_ENDIAN_HOST, len);
}

WFIO_ALWAYS_INLINE void wfio_convertEndianSI32V(wfio_sint32_t* buf, 
    wfio_endian_t src, wfio_endian_t dest,
    size_t len) {
    wfio_convertEndianSI32V2(buf, src, buf, dest, len);
}


WFIO_ALWAYS_INLINE void wfio_fromHostEndianSI32V(
    wfio_sint32_t* buf, wfio_endian_t destEndian, size_t len) {
    wfio_convertEndianSI32V2(buf, WFIO_ENDIAN_HOST, buf, destEndian, len);
}

WFIO_ALWAYS_INLINE void wfio_toHostEndianSI32V(
    wfio_sint32_t* buf, wfio_endian_t srcEndian, size_t len) {
    wfio_convertEndianSI32V2(buf, srcEndian, buf, WFIO_ENDIAN_HOST, len);
}

WFIO_ALWAYS_INLINE wfio_sint32_t wfio_convertEndianSI32(wfio_sint32_t x, 
    wfio_endian_t src, wfio_endian_t dest) {
    wfio_convertEndianSI32V2(&x, src, &x, dest, 1);
    return x;
}

WFIO_ALWAYS_INLINE wfio_sint32_t wfio_fromHostEndianSI32(
    wfio_sint32_t x, wfio_endian_t destEndian) {
    wfio_convertEndianSI32V2(&x, WFIO_ENDIAN_HOST, &x, destEndian, 1);
    return x;
}

WFIO_ALWAYS_INLINE wfio_sint32_t wfio_toHostEndianSI32(
    wfio_sint32_t x, wfio_endian_t srcEndian) {
    wfio_convertEndianSI32V2(&x, srcEndian, &x, WFIO_ENDIAN_HOST, 1);
    return x;
}

WFIO_ALWAYS_INLINE void wfio_convertEndianUI32V2(
    const wfio_uint32_t* src, wfio_endian_t srcEndian,
    wfio_uint32_t* dest, wfio_endian_t destEndian,
    size_t len) {
    wfio_convertEndianSI32V2(
        (const wfio_sint32_t*) src, srcEndian,
        (wfio_sint32_t*) dest, destEndian,
        len);
}

WFIO_ALWAYS_INLINE void wfio_fromHostEndianUI32V2(
    const wfio_uint32_t* src, wfio_uint32_t* dest, 
    wfio_endian_t destEndian, size_t len) {
    wfio_convertEndianUI32V2(src, WFIO_ENDIAN_HOST, dest, destEndian, len);
}

WFIO_ALWAYS_INLINE void wfio_toHostEndianUI32V2(
    const wfio_uint32_t* src, wfio_uint32_t* dest, 
    wfio_endian_t srcEndian, size_t len) {
    wfio_convertEndianUI32V2(src, srcEndian, dest, WFIO_ENDIAN_HOST, len);
}

WFIO_ALWAYS_INLINE void wfio_convertEndianUI32V(wfio_uint32_t* buf, 
    wfio_endian_t src, wfio_endian_t dest,
    size_t len) {
    wfio_convertEndianUI32V2(buf, src, buf, dest, len);
}


WFIO_ALWAYS_INLINE void wfio_fromHostEndianUI32V(
    wfio_uint32_t* buf, wfio_endian_t destEndian, size_t len) {
    wfio_convertEndianUI32V2(buf, WFIO_ENDIAN_HOST, buf, destEndian, len);
}

WFIO_ALWAYS_INLINE void wfio_toHostEndianUI32V(
    wfio_uint32_t* buf, wfio_endian_t srcEndian, size_t len) {
    wfio_convertEndianUI32V2(buf, srcEndian, buf, WFIO_ENDIAN_HOST, len);
}

WFIO_ALWAYS_INLINE wfio_uint32_t wfio_convertEndianUI32(wfio_uint32_t x, 
    wfio_endian_t src, wfio_endian_t dest) {
    wfio_convertEndianUI32V2(&x, src, &x, dest, 1);
    return x;
}

WFIO_ALWAYS_INLINE wfio_uint32_t wfio_fromHostEndianUI32(
    wfio_uint32_t x, wfio_endian_t destEndian) {
    wfio_convertEndianUI32V2(&x, WFIO_ENDIAN_HOST, &x, destEndian, 1);
    return x;
}

WFIO_ALWAYS_INLINE wfio_uint32_t wfio_toHostEndianUI32(
    wfio_uint32_t x, wfio_endian_t srcEndian) {
    wfio_convertEndianUI32V2(&x, srcEndian, &x, WFIO_ENDIAN_HOST, 1);
    return x;
}

WFIO_DLL void wfio_convertEndianSI64V2(
    const wfio_sint64_t* src, wfio_endian_t srcEndian,
    wfio_sint64_t* dest, wfio_endian_t destEndian,
    size_t len);

WFIO_ALWAYS_INLINE void wfio_fromHostEndianSI64V2(
    const wfio_sint64_t* src, wfio_sint64_t* dest, 
    wfio_endian_t destEndian, size_t len) {
    wfio_convertEndianSI64V2(src, WFIO_ENDIAN_HOST, dest, destEndian, len);
}

WFIO_ALWAYS_INLINE void wfio_toHostEndianSI64V2(
    const wfio_sint64_t* src, wfio_sint64_t* dest, 
    wfio_endian_t srcEndian, size_t len) {
    wfio_convertEndianSI64V2(src, srcEndian, dest, WFIO_ENDIAN_HOST, len);
}

WFIO_ALWAYS_INLINE void wfio_convertEndianSI64V(wfio_sint64_t* buf, 
    wfio_endian_t src, wfio_endian_t dest,
    size_t len) {
    wfio_convertEndianSI64V2(buf, src, buf, dest, len);
}


WFIO_ALWAYS_INLINE void wfio_fromHostEndianSI64V(
    wfio_sint64_t* buf, wfio_endian_t destEndian, size_t len) {
    wfio_convertEndianSI64V2(buf, WFIO_ENDIAN_HOST, buf, destEndian, len);
}

WFIO_ALWAYS_INLINE void wfio_toHostEndianSI64V(
    wfio_sint64_t* buf, wfio_endian_t srcEndian, size_t len) {
    wfio_convertEndianSI64V2(buf, srcEndian, buf, WFIO_ENDIAN_HOST, len);
}

WFIO_ALWAYS_INLINE wfio_sint64_t wfio_convertEndianSI64(wfio_sint64_t x, 
    wfio_endian_t src, wfio_endian_t dest) {
    wfio_convertEndianSI64V2(&x, src, &x, dest, 1);
    return x;
}

WFIO_ALWAYS_INLINE wfio_sint64_t wfio_fromHostEndianSI64(
    wfio_sint64_t x, wfio_endian_t destEndian) {
    wfio_convertEndianSI64V2(&x, WFIO_ENDIAN_HOST, &x, destEndian, 1);
    return x;
}

WFIO_ALWAYS_INLINE wfio_sint64_t wfio_toHostEndianSI64(
    wfio_sint64_t x, wfio_endian_t srcEndian) {
    wfio_convertEndianSI64V2(&x, srcEndian, &x, WFIO_ENDIAN_HOST, 1);
    return x;
}

WFIO_ALWAYS_INLINE void wfio_convertEndianUI64V2(
    const wfio_uint64_t* src, wfio_endian_t srcEndian,
    wfio_uint64_t* dest, wfio_endian_t destEndian,
    size_t len) {
    wfio_convertEndianSI64V2(
        (const wfio_sint64_t*) src, srcEndian,
        (wfio_sint64_t*) dest, destEndian,
        len);
}

WFIO_ALWAYS_INLINE void wfio_fromHostEndianUI64V2(
    const wfio_uint64_t* src, wfio_uint64_t* dest, 
    wfio_endian_t destEndian, size_t len) {
    wfio_convertEndianUI64V2(src, WFIO_ENDIAN_HOST, dest, destEndian, len);
}

WFIO_ALWAYS_INLINE void wfio_toHostEndianUI64V2(
    const wfio_uint64_t* src, wfio_uint64_t* dest, 
    wfio_endian_t srcEndian, size_t len) {
    wfio_convertEndianUI64V2(src, srcEndian, dest, WFIO_ENDIAN_HOST, len);
}

WFIO_ALWAYS_INLINE void wfio_convertEndianUI64V(wfio_uint64_t* buf, 
    wfio_endian_t src, wfio_endian_t dest,
    size_t len) {
    wfio_convertEndianUI64V2(buf, src, buf, dest, len);
}


WFIO_ALWAYS_INLINE void wfio_fromHostEndianUI64V(
    wfio_uint64_t* buf, wfio_endian_t destEndian, size_t len) {
    wfio_convertEndianUI64V2(buf, WFIO_ENDIAN_HOST, buf, destEndian, len);
}

WFIO_ALWAYS_INLINE void wfio_toHostEndianUI64V(
    wfio_uint64_t* buf, wfio_endian_t srcEndian, size_t len) {
    wfio_convertEndianUI64V2(buf, srcEndian, buf, WFIO_ENDIAN_HOST, len);
}

WFIO_ALWAYS_INLINE wfio_uint64_t wfio_convertEndianUI64(wfio_uint64_t x, 
    wfio_endian_t src, wfio_endian_t dest) {
    wfio_convertEndianUI64V2(&x, src, &x, dest, 1);
    return x;
}

WFIO_ALWAYS_INLINE wfio_uint64_t wfio_fromHostEndianUI64(
    wfio_uint64_t x, wfio_endian_t destEndian) {
    wfio_convertEndianUI64V2(&x, WFIO_ENDIAN_HOST, &x, destEndian, 1);
    return x;
}

WFIO_ALWAYS_INLINE wfio_uint64_t wfio_toHostEndianUI64(
    wfio_uint64_t x, wfio_endian_t srcEndian) {
    wfio_convertEndianUI64V2(&x, srcEndian, &x, WFIO_ENDIAN_HOST, 1);
    return x;
}


#endif

/* C++ Bindings */
#ifdef __cplusplus
namespace wfio {
    inline void convertEndian(const wfio::sint16_t* src, wfio::endian_t srcEndian, wfio::sint16_t* dest, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_convertEndianSI16V2(src, srcEndian, dest, destEndian, len);
    }
    
    inline void fromHostEndian(const wfio::sint16_t* src, wfio::sint16_t* dest, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_fromHostEndianSI16V2(src, dest, destEndian, len);
    }
    
    inline void toHostEndian(const wfio::sint16_t* src, wfio::sint16_t* dest, wfio::endian_t srcEndian, size_t len) throw() {
         ::wfio_toHostEndianSI16V2(src, dest, srcEndian, len);
    }
    
    inline void convertEndian(wfio::sint16_t* buf, wfio::endian_t src, wfio::endian_t dest, size_t len) throw() {
         ::wfio_convertEndianSI16V(buf, src, dest, len);
    }
    
    inline void fromHostEndian(wfio::sint16_t* buf, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_fromHostEndianSI16V(buf, destEndian, len);
    }
    
    inline void toHostEndian(wfio::sint16_t* buf, wfio::endian_t srcEndian, size_t len) throw() {
         ::wfio_toHostEndianSI16V(buf, srcEndian, len);
    }
    
    inline wfio_sint16_t convertEndian(wfio::sint16_t x, wfio::endian_t src, wfio::endian_t dest) throw() {
         ::wfio_convertEndianSI16(x, src, dest);
    }
    
    inline wfio_sint16_t fromHostEndian(wfio::sint16_t x, wfio::endian_t destEndian) throw() {
         ::wfio_fromHostEndianSI16(x, destEndian);
    }
    
    inline wfio_sint16_t toHostEndian(wfio::sint16_t x, wfio::endian_t srcEndian) throw() {
         ::wfio_toHostEndianSI16(x, srcEndian);
    }
    
    inline void convertEndian(const wfio::uint16_t* src, wfio::endian_t srcEndian, wfio::uint16_t* dest, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_convertEndianUI16V2(src, srcEndian, dest, destEndian, len);
    }
    
    inline void fromHostEndian(const wfio::uint16_t* src, wfio::uint16_t* dest, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_fromHostEndianUI16V2(src, dest, destEndian, len);
    }
    
    inline void toHostEndian(const wfio::uint16_t* src, wfio::uint16_t* dest, wfio::endian_t srcEndian, size_t len) throw() {
         ::wfio_toHostEndianUI16V2(src, dest, srcEndian, len);
    }
    
    inline void convertEndian(wfio::uint16_t* buf, wfio::endian_t src, wfio::endian_t dest, size_t len) throw() {
         ::wfio_convertEndianUI16V(buf, src, dest, len);
    }
    
    inline void fromHostEndian(wfio::uint16_t* buf, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_fromHostEndianUI16V(buf, destEndian, len);
    }
    
    inline void toHostEndian(wfio::uint16_t* buf, wfio::endian_t srcEndian, size_t len) throw() {
         ::wfio_toHostEndianUI16V(buf, srcEndian, len);
    }
    
    inline wfio_uint16_t convertEndian(wfio::uint16_t x, wfio::endian_t src, wfio::endian_t dest) throw() {
         ::wfio_convertEndianUI16(x, src, dest);
    }
    
    inline wfio_uint16_t fromHostEndian(wfio::uint16_t x, wfio::endian_t destEndian) throw() {
         ::wfio_fromHostEndianUI16(x, destEndian);
    }
    
    inline wfio_uint16_t toHostEndian(wfio::uint16_t x, wfio::endian_t srcEndian) throw() {
         ::wfio_toHostEndianUI16(x, srcEndian);
    }
    
    inline void convertEndian(const wfio::sint32_t* src, wfio::endian_t srcEndian, wfio::sint32_t* dest, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_convertEndianSI32V2(src, srcEndian, dest, destEndian, len);
    }
    
    inline void fromHostEndian(const wfio::sint32_t* src, wfio::sint32_t* dest, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_fromHostEndianSI32V2(src, dest, destEndian, len);
    }
    
    inline void toHostEndian(const wfio::sint32_t* src, wfio::sint32_t* dest, wfio::endian_t srcEndian, size_t len) throw() {
         ::wfio_toHostEndianSI32V2(src, dest, srcEndian, len);
    }
    
    inline void convertEndian(wfio::sint32_t* buf, wfio::endian_t src, wfio::endian_t dest, size_t len) throw() {
         ::wfio_convertEndianSI32V(buf, src, dest, len);
    }
    
    inline void fromHostEndian(wfio::sint32_t* buf, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_fromHostEndianSI32V(buf, destEndian, len);
    }
    
    inline void toHostEndian(wfio::sint32_t* buf, wfio::endian_t srcEndian, size_t len) throw() {
         ::wfio_toHostEndianSI32V(buf, srcEndian, len);
    }
    
    inline wfio_sint32_t convertEndian(wfio::sint32_t x, wfio::endian_t src, wfio::endian_t dest) throw() {
         ::wfio_convertEndianSI32(x, src, dest);
    }
    
    inline wfio_sint32_t fromHostEndian(wfio::sint32_t x, wfio::endian_t destEndian) throw() {
         ::wfio_fromHostEndianSI32(x, destEndian);
    }
    
    inline wfio_sint32_t toHostEndian(wfio::sint32_t x, wfio::endian_t srcEndian) throw() {
         ::wfio_toHostEndianSI32(x, srcEndian);
    }
    
    inline void convertEndian(const wfio::uint32_t* src, wfio::endian_t srcEndian, wfio::uint32_t* dest, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_convertEndianUI32V2(src, srcEndian, dest, destEndian, len);
    }
    
    inline void fromHostEndian(const wfio::uint32_t* src, wfio::uint32_t* dest, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_fromHostEndianUI32V2(src, dest, destEndian, len);
    }
    
    inline void toHostEndian(const wfio::uint32_t* src, wfio::uint32_t* dest, wfio::endian_t srcEndian, size_t len) throw() {
         ::wfio_toHostEndianUI32V2(src, dest, srcEndian, len);
    }
    
    inline void convertEndian(wfio::uint32_t* buf, wfio::endian_t src, wfio::endian_t dest, size_t len) throw() {
         ::wfio_convertEndianUI32V(buf, src, dest, len);
    }
    
    inline void fromHostEndian(wfio::uint32_t* buf, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_fromHostEndianUI32V(buf, destEndian, len);
    }
    
    inline void toHostEndian(wfio::uint32_t* buf, wfio::endian_t srcEndian, size_t len) throw() {
         ::wfio_toHostEndianUI32V(buf, srcEndian, len);
    }
    
    inline wfio_uint32_t convertEndian(wfio::uint32_t x, wfio::endian_t src, wfio::endian_t dest) throw() {
         ::wfio_convertEndianUI32(x, src, dest);
    }
    
    inline wfio_uint32_t fromHostEndian(wfio::uint32_t x, wfio::endian_t destEndian) throw() {
         ::wfio_fromHostEndianUI32(x, destEndian);
    }
    
    inline wfio_uint32_t toHostEndian(wfio::uint32_t x, wfio::endian_t srcEndian) throw() {
         ::wfio_toHostEndianUI32(x, srcEndian);
    }
    
    inline void convertEndian(const wfio::sint64_t* src, wfio::endian_t srcEndian, wfio::sint64_t* dest, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_convertEndianSI64V2(src, srcEndian, dest, destEndian, len);
    }
    
    inline void fromHostEndian(const wfio::sint64_t* src, wfio::sint64_t* dest, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_fromHostEndianSI64V2(src, dest, destEndian, len);
    }
    
    inline void toHostEndian(const wfio::sint64_t* src, wfio::sint64_t* dest, wfio::endian_t srcEndian, size_t len) throw() {
         ::wfio_toHostEndianSI64V2(src, dest, srcEndian, len);
    }
    
    inline void convertEndian(wfio::sint64_t* buf, wfio::endian_t src, wfio::endian_t dest, size_t len) throw() {
         ::wfio_convertEndianSI64V(buf, src, dest, len);
    }
    
    inline void fromHostEndian(wfio::sint64_t* buf, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_fromHostEndianSI64V(buf, destEndian, len);
    }
    
    inline void toHostEndian(wfio::sint64_t* buf, wfio::endian_t srcEndian, size_t len) throw() {
         ::wfio_toHostEndianSI64V(buf, srcEndian, len);
    }
    
    inline wfio_sint64_t convertEndian(wfio::sint64_t x, wfio::endian_t src, wfio::endian_t dest) throw() {
         ::wfio_convertEndianSI64(x, src, dest);
    }
    
    inline wfio_sint64_t fromHostEndian(wfio::sint64_t x, wfio::endian_t destEndian) throw() {
         ::wfio_fromHostEndianSI64(x, destEndian);
    }
    
    inline wfio_sint64_t toHostEndian(wfio::sint64_t x, wfio::endian_t srcEndian) throw() {
         ::wfio_toHostEndianSI64(x, srcEndian);
    }
    
    inline void convertEndian(const wfio::uint64_t* src, wfio::endian_t srcEndian, wfio::uint64_t* dest, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_convertEndianUI64V2(src, srcEndian, dest, destEndian, len);
    }
    
    inline void fromHostEndian(const wfio::uint64_t* src, wfio::uint64_t* dest, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_fromHostEndianUI64V2(src, dest, destEndian, len);
    }
    
    inline void toHostEndian(const wfio::uint64_t* src, wfio::uint64_t* dest, wfio::endian_t srcEndian, size_t len) throw() {
         ::wfio_toHostEndianUI64V2(src, dest, srcEndian, len);
    }
    
    inline void convertEndian(wfio::uint64_t* buf, wfio::endian_t src, wfio::endian_t dest, size_t len) throw() {
         ::wfio_convertEndianUI64V(buf, src, dest, len);
    }
    
    inline void fromHostEndian(wfio::uint64_t* buf, wfio::endian_t destEndian, size_t len) throw() {
         ::wfio_fromHostEndianUI64V(buf, destEndian, len);
    }
    
    inline void toHostEndian(wfio::uint64_t* buf, wfio::endian_t srcEndian, size_t len) throw() {
         ::wfio_toHostEndianUI64V(buf, srcEndian, len);
    }
    
    inline wfio_uint64_t convertEndian(wfio::uint64_t x, wfio::endian_t src, wfio::endian_t dest) throw() {
         ::wfio_convertEndianUI64(x, src, dest);
    }
    
    inline wfio_uint64_t fromHostEndian(wfio::uint64_t x, wfio::endian_t destEndian) throw() {
         ::wfio_fromHostEndianUI64(x, destEndian);
    }
    
    inline wfio_uint64_t toHostEndian(wfio::uint64_t x, wfio::endian_t srcEndian) throw() {
         ::wfio_toHostEndianUI64(x, srcEndian);
    }
    
}
#endif