/usr/include/vtk-7.1/vtkByteSwap.h is in libvtk7-dev 7.1.1+dfsg1-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 | /*=========================================================================
Program: Visualization Toolkit
Module: vtkByteSwap.h
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
/**
* @class vtkByteSwap
* @brief perform machine dependent byte swapping
*
* vtkByteSwap is used by other classes to perform machine dependent byte
* swapping. Byte swapping is often used when reading or writing binary
* files.
*/
#ifndef vtkByteSwap_h
#define vtkByteSwap_h
#include "vtkCommonCoreModule.h" // For export macro
#include "vtkObject.h"
class VTKCOMMONCORE_EXPORT vtkByteSwap : public vtkObject
{
public:
static vtkByteSwap *New();
vtkTypeMacro(vtkByteSwap,vtkObject);
//@{
/**
* Type-safe swap signatures to swap for storage in either Little
* Endian or Big Endian format. Swapping is performed according to
* the true size of the type given.
*/
#define VTK_BYTE_SWAP_DECL(T) \
static void SwapLE(T* p); \
static void SwapBE(T* p); \
static void SwapLERange(T* p, size_t num); \
static void SwapBERange(T* p, size_t num); \
static bool SwapLERangeWrite(const T* p, size_t num, FILE* file); \
static bool SwapBERangeWrite(const T* p, size_t num, FILE* file); \
static void SwapLERangeWrite(const T* p, size_t num, ostream* os); \
static void SwapBERangeWrite(const T* p, size_t num, ostream* os)
VTK_BYTE_SWAP_DECL(float);
VTK_BYTE_SWAP_DECL(double);
VTK_BYTE_SWAP_DECL(char);
VTK_BYTE_SWAP_DECL(short);
VTK_BYTE_SWAP_DECL(int);
VTK_BYTE_SWAP_DECL(long);
VTK_BYTE_SWAP_DECL(long long);
VTK_BYTE_SWAP_DECL(signed char);
VTK_BYTE_SWAP_DECL(unsigned char);
VTK_BYTE_SWAP_DECL(unsigned short);
VTK_BYTE_SWAP_DECL(unsigned int);
VTK_BYTE_SWAP_DECL(unsigned long);
VTK_BYTE_SWAP_DECL(unsigned long long);
#undef VTK_BYTE_SWAP_DECL
//@}
//@{
/**
* Swap 2, 4, or 8 bytes for storage as Little Endian.
*/
static void Swap2LE(void* p);
static void Swap4LE(void* p);
static void Swap8LE(void* p);
//@}
//@{
/**
* Swap a block of 2-, 4-, or 8-byte segments for storage as Little Endian.
*/
static void Swap2LERange(void* p, size_t num);
static void Swap4LERange(void* p, size_t num);
static void Swap8LERange(void* p, size_t num);
//@}
//@{
/**
* Swap a block of 2-, 4-, or 8-byte segments for storage as Little Endian.
* The results are written directly to a file to avoid temporary storage.
*/
static bool SwapWrite2LERange(void const* p, size_t num, FILE* f);
static bool SwapWrite4LERange(void const* p, size_t num, FILE* f);
static bool SwapWrite8LERange(void const* p, size_t num, FILE* f);
static void SwapWrite2LERange(void const* p, size_t num, ostream* os);
static void SwapWrite4LERange(void const* p, size_t num, ostream* os);
static void SwapWrite8LERange(void const* p, size_t num, ostream* os);
//@}
//@{
/**
* Swap 2, 4, or 8 bytes for storage as Big Endian.
*/
static void Swap2BE(void* p);
static void Swap4BE(void* p);
static void Swap8BE(void* p);
//@}
//@{
/**
* Swap a block of 2-, 4-, or 8-byte segments for storage as Big Endian.
*/
static void Swap2BERange(void* p, size_t num);
static void Swap4BERange(void* p, size_t num);
static void Swap8BERange(void* p, size_t num);
//@}
//@{
/**
* Swap a block of 2-, 4-, or 8-byte segments for storage as Big Endian.
* The results are written directly to a file to avoid temporary storage.
*/
static bool SwapWrite2BERange(void const* p, size_t num, FILE* f);
static bool SwapWrite4BERange(void const* p, size_t num, FILE* f);
static bool SwapWrite8BERange(void const* p, size_t num, FILE* f);
static void SwapWrite2BERange(void const* p, size_t num, ostream* os);
static void SwapWrite4BERange(void const* p, size_t num, ostream* os);
static void SwapWrite8BERange(void const* p, size_t num, ostream* os);
//@}
/**
* Swaps the bytes of a buffer. Uses an arbitrary word size, but
* assumes the word size is divisible by two.
*/
static void SwapVoidRange(void *buffer, size_t numWords, size_t wordSize);
protected:
vtkByteSwap();
~vtkByteSwap() VTK_OVERRIDE;
private:
vtkByteSwap(const vtkByteSwap&) VTK_DELETE_FUNCTION;
void operator=(const vtkByteSwap&) VTK_DELETE_FUNCTION;
};
#endif
// VTK-HeaderTest-Exclude: vtkByteSwap.h
|