nlib
BinaryWriter.h
Go to the documentation of this file.
1 
2 /*--------------------------------------------------------------------------------*
3  Project: CrossRoad
4  Copyright (C)Nintendo All rights reserved.
5 
6  These coded instructions, statements, and computer programs contain proprietary
7  information of Nintendo and/or its licensed developers and are protected by
8  national and international copyright laws. They may not be disclosed to third
9  parties or copied or duplicated in any form, in whole or in part, without the
10  prior written consent of Nintendo.
11 
12  The content herein is highly confidential and should be handled accordingly.
13  *--------------------------------------------------------------------------------*/
14 
15 #pragma once
16 #ifndef INCLUDE_NN_NLIB_BINARYWRITER_H_
17 #define INCLUDE_NN_NLIB_BINARYWRITER_H_
18 
19 #include "nn/nlib/Config.h"
20 #include "nn/nlib/Swap.h"
21 #include "nn/nlib/OutputStream.h"
22 
23 NLIB_NAMESPACE_BEGIN
24 NLIB_EXPIMP_TEMPLATE(detail::MiniBufOut<512>);
25 
27  public:
28  enum EndianSetting { kEndianDefault = 0, kEndianLittle, kEndianBig };
29 
30  public:
31  BinaryWriter() NLIB_NOEXCEPT : stream_(nullptr), errno_(-1), swap_endian_(false) {}
32  ~BinaryWriter() NLIB_NOEXCEPT { this->Close(); }
33  errno_t Init(EndianSetting endian) NLIB_NOEXCEPT;
34  errno_t Init() NLIB_NOEXCEPT { return Init(kEndianDefault); }
35  errno_t Open(OutputStream* stream) NLIB_NOEXCEPT;
36 
37 #define NLIB_BINW(tp) return this->Write_(static_cast<tp>(x))
38  bool Write(char x) NLIB_NOEXCEPT { NLIB_BINW(uint8_t); }
39  bool Write(signed char x) NLIB_NOEXCEPT { NLIB_BINW(uint8_t); }
40  bool Write(unsigned char x) NLIB_NOEXCEPT { NLIB_BINW(uint8_t); }
41  bool Write(short x) NLIB_NOEXCEPT { NLIB_BINW(uint16_t); }
42  bool Write(unsigned short x) NLIB_NOEXCEPT { NLIB_BINW(uint16_t); }
43  bool Write(int x) NLIB_NOEXCEPT { NLIB_BINW(uint32_t); }
44  bool Write(unsigned int x) NLIB_NOEXCEPT { NLIB_BINW(uint32_t); }
45  bool Write(long x) NLIB_NOEXCEPT { NLIB_BINW(nlib_ulong_compatible_t); }
46  bool Write(unsigned long x) NLIB_NOEXCEPT { NLIB_BINW(nlib_ulong_compatible_t); }
47  bool Write(long long x) NLIB_NOEXCEPT { NLIB_BINW(uint64_t); }
48  bool Write(unsigned long long x) NLIB_NOEXCEPT { NLIB_BINW(uint64_t); }
49  bool Write(float x) NLIB_NOEXCEPT { NLIB_BINW(float); }
50  bool Write(double x) NLIB_NOEXCEPT { NLIB_BINW(double); }
51 #undef NLIB_BINW
52 
53  template<class T>
54  bool Write(T x) NLIB_NOEXCEPT;
55 
56  bool WriteArray(const unsigned char* x, size_t n) NLIB_NOEXCEPT NLIB_NONNULL;
57  bool WriteArray(const unsigned short* x, size_t n) NLIB_NOEXCEPT NLIB_NONNULL;
58  bool WriteArray(const unsigned int* x, size_t n) NLIB_NOEXCEPT NLIB_NONNULL;
59  bool WriteArray(const unsigned long long* x, size_t n) NLIB_NOEXCEPT NLIB_NONNULL;
60  bool WriteArray(const unsigned long* x, size_t n) NLIB_NOEXCEPT {
61 #ifdef NLIB_LP64
62  return this->WriteArray(reinterpret_cast<const unsigned long long*>(x), n);
63 #else
64  return this->WriteArray(reinterpret_cast<const unsigned int*>(x), n);
65 #endif
66  }
67 
68  bool WriteArray(const float* x, size_t n) NLIB_NOEXCEPT NLIB_NONNULL;
69  bool WriteArray(const double* x, size_t n) NLIB_NOEXCEPT NLIB_NONNULL;
70  bool WriteArray(const signed char* x, size_t n) NLIB_NOEXCEPT {
71  return this->WriteArray(reinterpret_cast<const unsigned char*>(x), n);
72  }
73  bool WriteArray(const char* x, size_t n) NLIB_NOEXCEPT {
74  return this->WriteArray(reinterpret_cast<const unsigned char*>(x), n);
75  }
76  bool WriteArray(const short* x, size_t n) NLIB_NOEXCEPT {
77  return this->WriteArray(reinterpret_cast<const unsigned short*>(x), n);
78  }
79  bool WriteArray(const int* x, size_t n) NLIB_NOEXCEPT {
80  return this->WriteArray(reinterpret_cast<const unsigned int*>(x), n);
81  }
82  bool WriteArray(const long* x, size_t n) NLIB_NOEXCEPT {
83 #ifdef NLIB_LP64
84  return this->WriteArray(reinterpret_cast<const unsigned long long*>(x), n);
85 #else
86  return this->WriteArray(reinterpret_cast<const unsigned int*>(x), n);
87 #endif
88  }
89  bool WriteArray(const long long* x, size_t n) NLIB_NOEXCEPT {
90  return this->WriteArray(reinterpret_cast<const unsigned long long*>(x), n);
91  }
92  template<class T>
93  bool WriteArray(const T* x, size_t n) NLIB_NOEXCEPT;
94  template<class T, size_t N>
95  bool WriteArray(const T (&a)[N]) NLIB_NOEXCEPT;
96  bool Flush() NLIB_NOEXCEPT;
97  bool Close() NLIB_NOEXCEPT;
98  void SetError(errno_t e) NLIB_NOEXCEPT {
99  if (errno_ == 0) errno_ = e;
100  }
101  errno_t GetErrorValue() const NLIB_NOEXCEPT { return errno_; }
102  OutputStream* GetStream() NLIB_NOEXCEPT { return stream_; }
103 
104  NLIB_SAFE_BOOL(BinaryWriter, GetErrorValue() == 0)
105 
106  private:
107  bool Write_(uint8_t x) NLIB_NOEXCEPT;
108  bool Write_(uint16_t x) NLIB_NOEXCEPT;
109  bool Write_(uint32_t x) NLIB_NOEXCEPT;
110  bool Write_(uint64_t x) NLIB_NOEXCEPT;
111  bool Write_(float x) NLIB_NOEXCEPT;
112  bool Write_(double x) NLIB_NOEXCEPT;
113  NLIB_VIS_HIDDEN bool WriteStream() NLIB_NOEXCEPT;
114 
115  private:
116  OutputStream* stream_;
117  ErrnoT errno_;
118  bool swap_endian_;
119  detail::MiniBufOut<512> mini_buf_;
120 
122 };
123 
124 namespace binary_writer {
125 
126 template<class T>
128  return w->Write(x);
129 }
130 
131 template<class T>
132 NLIB_ALWAYS_INLINE bool WriteArray(BinaryWriter* w, const T* x, size_t n) {
133  return w->WriteArray(x, n);
134 }
135 } // namespace binary_writer
136 
137 template<class T>
139  return binary_writer::Write(this, x);
140 }
141 
142 template<class T>
144  return binary_writer::WriteArray(this, x, n);
145 }
146 
147 template<class T, size_t N>
149  return this->WriteArray(&a[0], N);
150 }
151 
152 NLIB_NAMESPACE_END
153 
154 #endif // INCLUDE_NN_NLIB_BINARYWRITER_H_
bool Write(unsigned long x) noexcept
Writes unsigned long-type data as binary to a stream. Returns true if successful. ...
Definition: BinaryWriter.h:46
OutputStream * GetStream() noexcept
Gets the stream for the text writer to write to.
Definition: BinaryWriter.h:102
#define NLIB_ALWAYS_INLINE
Indicates that the compiler is forced to perform inline expansion of functions.
Definition: Platform_unix.h:95
Writes in little-endian.
Definition: BinaryWriter.h:28
#define NLIB_DISALLOW_COPY_AND_ASSIGN(TypeName)
Prohibits use of the copy constructor and assignment operator for the class specified by TypeName...
Definition: Config.h:183
#define NLIB_SAFE_BOOL(class_name, exp)
Defines a safe operator bool function in the class. Uses the C++11 explicit bool if it is available f...
Definition: Config.h:199
bool WriteArray(const unsigned char *x, size_t n) noexcept
Writes an unsigned char-type array as binary to a stream. Returns true if successful. If n is 0, it will also successfully complete.
bool Write(float x) noexcept
Writes float-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:49
errno_t GetErrorValue() const noexcept
This function can get the cause of the error when writing has failed.
Definition: BinaryWriter.h:101
bool Write(unsigned short x) noexcept
Writes unsigned short-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:42
uint32_t nlib_ulong_compatible_t
Defines an integer type that is compatible with unsigned long using typedef.
Definition: Platform.h:324
errno_t Init() noexcept
Initializes the binary writer using the same endianness as the machine the program is running on...
Definition: BinaryWriter.h:34
#define NLIB_VIS_HIDDEN
Symbols for functions and classes are not made available outside of the library.
Definition: Platform_unix.h:86
~BinaryWriter() noexcept
Destructor. This function does not close the stream.
Definition: BinaryWriter.h:32
#define NLIB_VIS_PUBLIC
Symbols for functions and classes are made available outside of the library.
Definition: Platform_unix.h:87
bool Write(char x) noexcept
Writes char-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:38
bool Write(BinaryWriter *w, T x)
You can write user-defined class objects by specializing this function template.
Definition: BinaryWriter.h:127
bool Write(unsigned int x) noexcept
Writes unsigned int-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:44
bool Write(long long x) noexcept
Writes long long-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:47
bool Write(unsigned char x) noexcept
Writes unsigned char-type data as binary to a stream. Returns true if successful. ...
Definition: BinaryWriter.h:40
bool WriteArray(BinaryWriter *w, const T *x, size_t n)
You can write user-defined class objects by specializing this function template.
Definition: BinaryWriter.h:132
bool WriteArray(const long long *x, size_t n) noexcept
Writes a long long-type array as binary to a stream. Returns true if successful. If n is 0...
Definition: BinaryWriter.h:89
bool WriteArray(const long *x, size_t n) noexcept
Writes a long-type array as binary to a stream. Returns true if successful. If n is 0...
Definition: BinaryWriter.h:82
Class that wraps errno_t. This class improves visual representations in the Visual Studio debugger...
Definition: Config.h:404
bool Write(long x) noexcept
Writes long-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:45
bool Write(int x) noexcept
Writes int-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:43
bool Write(short x) noexcept
Writes short-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:41
#define NLIB_NOEXCEPT
Defines noexcept geared to the environment, or the equivalent.
Definition: Config.h:109
A file that contains the configuration information for each development environment.
EndianSetting
Specifies the endianness.
Definition: BinaryWriter.h:28
bool WriteArray(const unsigned long *x, size_t n) noexcept
Writes an unsigned long-type array as binary to a stream. Returns true if successful. If n is 0, it will also successfully complete.
Definition: BinaryWriter.h:60
bool WriteArray(const int *x, size_t n) noexcept
Writes an int-type array as binary to a stream. Returns true if successful. If n is 0...
Definition: BinaryWriter.h:79
The class for writing binary to streams (to OutputStream).
Definition: BinaryWriter.h:26
bool Write(signed char x) noexcept
Writes signed char-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:39
#define NLIB_FINAL
Defines final if it is available for use. If not, holds an empty string.
Definition: Config.h:250
bool WriteArray(const signed char *x, size_t n) noexcept
Writes a signed char-type array as binary to a stream. Returns true if successful. If n is 0, it will also successfully complete.
Definition: BinaryWriter.h:70
Defines the base class for output streams.
bool WriteArray(const char *x, size_t n) noexcept
Writes a char-type array as binary to a stream. Returns true if successful. If n is 0...
Definition: BinaryWriter.h:73
BinaryWriter() noexcept
Instantiates the object with default parameters (default constructor).
Definition: BinaryWriter.h:31
#define NLIB_NONNULL
Indicates that you cannot specify NULL for all arguments.
bool Write(double x) noexcept
Writes double-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:50
The base class for output streams. This class cannot be instantiated.
Definition: OutputStream.h:30
bool Write(unsigned long long x) noexcept
Writes unsigned long long-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:48
bool WriteArray(const short *x, size_t n) noexcept
Writes a short-type array as binary to a stream. Returns true if successful. If n is 0...
Definition: BinaryWriter.h:76
int errno_t
Indicates with an int-type typedef that a POSIX error value is returned as the return value...
Definition: NMalloc.h:37