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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile: itkByteSwapper.h,v $
Language: C++
Date: $Date: 2006-03-18 18:06:25 $
Version: $Revision: 1.15 $
Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
Portions of this code are covered under the VTK copyright.
See VTKCopyright.txt or http://www.kitware.com/VTKCopyright.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 notices for more information.
=========================================================================*/
#ifndef __itkByteSwapper_h
#define __itkByteSwapper_h
#include "itkObject.h"
#include "itkObjectFactory.h"
namespace itk
{
/** \class ByteSwapper
* \brief Perform machine dependent byte swapping.
*
* ByteSwapper is used by I/O classes to perform machine dependent byte
* swapping. Byte swapping is often used when reading or writing binary
* files. Files can either be Big Endian (BE) or Little Endian (LE).
*
* \ingroup IOFilters
* \ingroup OSSystemObjects
*/
template <class T>
class ITK_EXPORT ByteSwapper : public Object
{
public:
/** Standard class typedefs. */
typedef ByteSwapper Self;
typedef Object Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** Work around MSVC bug (including ByteSwapper.h in a templated class). */
typedef std::ostream OStreamType;
/** Run-time type information (and related methods). */
itkTypeMacro(ByteSwapper,Object);
/** Query the machine Endian-ness. */
static bool SystemIsBigEndian ();
static bool SystemIsBE () { return SystemIsBigEndian(); }
static bool SystemIsLittleEndian ();
static bool SystemIsLE () { return SystemIsLittleEndian(); }
/** Generic swap method handles type T. The swapping is
* done in-place. Either 2-byte or 4-byte swapping
* can be handled. Single byte types are not swapped;
* others raise an exception. The method is used to
* swap to and from Big Endian. */
static void SwapFromSystemToBigEndian(T *p);
/** Generic swap method handles type T. The swapping is
* done in-place. Either 2-byte or 4-byte swapping
* can be handled. Single byte types are not swapped;
* others raise an exception. The method is used to
* swap to and from Big Endian. */
static void SwapRangeFromSystemToBigEndian(T *p, unsigned long num);
/** Generic swap method handles type T. The data is
* swapped and written (in binary) to the ostream
* given. A total of num values of type T are written
* and swapped. Either 2-byte or 4-byte swapping
* can be handled. Single byte types are not swapped;
* others raise an exception. The method is used to
* swap to and from Big Endian. */
static void SwapWriteRangeFromSystemToBigEndian(T *p, int num,
OStreamType *fp);
/** Generic swap method handles type T. The swapping is
* done in-place. Either 2-byte or 4-byte swapping
* can be handled. Single byte types are not swapped;
* others raise an exception. The method is used to
* swap to and from Little Endian. */
static void SwapFromSystemToLittleEndian(T *p);
/** Generic swap method handles type T. The swapping is
* done in-place. Either 2-byte or 4-byte swapping
* can be handled. Single byte types are not swapped;
* others raise an exception. The method is used to
* swap to and from Little Endian. */
static void SwapRangeFromSystemToLittleEndian(T *p, unsigned long num);
/** Generic swap method handles type T. The data is
* swapped and written (in binary) to the ostream
* given. A total of num values of type T are written
* and swapped. Either 2-byte or 4-byte swapping
* can be handled. Single byte types are not swapped;
* others raise an exception. The method is used to
* swap to and from Little Endian. */
static void SwapWriteRangeFromSystemToLittleEndian(T *p, int num,
OStreamType *fp);
protected:
ByteSwapper() {}
~ByteSwapper() {}
/** Swap 2 bytes. */
static void Swap2(void *p);
/** Swap a range of two-byte words. Num is the number of two-byte
* words to swap. */
static void Swap2Range(void *p, unsigned long num);
/** Swap and write a range of two-byte words. Num is the number of two-byte
* words to swap and write. */
static void SwapWrite2Range(void *p, unsigned long num, OStreamType *fp);
/** Swap four bytes. */
static void Swap4(void *p);
/** Swap a range of four-byte words. Num is the number of four-byte words
* to swap. */
static void Swap4Range(void *p, unsigned long num);
/** Swap and write a range of four-byte words. Num is the number of four-byte
* words to swap and write. */
static void SwapWrite4Range(void *p, unsigned long num, OStreamType *fp);
/** Swap 8 bytes. */
static void Swap8(void *p);
/** Swap a range of four-byte words. Num is the number of four-byte words
* to swap. */
static void Swap8Range(void *p, unsigned long num);
/** Swap and write a range of 8-byte words. Num is the number of four-byte
* words to swap and write. */
static void SwapWrite8Range(void *p, unsigned long num, OStreamType *fp);
private:
ByteSwapper(const ByteSwapper&); //purposely not implemented
void operator=(const ByteSwapper&); //purposely not implemented
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkByteSwapper.txx"
#endif
#endif
|
