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:
29  kEndianDefault = 0,
32  DEFAULT = kEndianDefault,
33  ENDIAN_LITTLE = kEndianLittle,
34  ENDIAN_BIG = kEndianBig
35  };
36 
37  public:
38  BinaryWriter() NLIB_NOEXCEPT : stream_(NULL),
39  errno_(-1),
40  swap_endian_(false) {}
41  ~BinaryWriter() NLIB_NOEXCEPT { this->Close(); }
42  errno_t Init(EndianSetting endian) NLIB_NOEXCEPT;
43  errno_t Init() NLIB_NOEXCEPT { return Init(kEndianDefault); }
44  errno_t Open(OutputStream* stream) NLIB_NOEXCEPT;
45 
46 #define NLIB_BINW(tp) return this->Write_(static_cast<tp>(x))
47  bool Write(char x) NLIB_NOEXCEPT { NLIB_BINW(uint8_t); }
48  bool Write(signed char x) NLIB_NOEXCEPT { NLIB_BINW(uint8_t); }
49  bool Write(unsigned char x) NLIB_NOEXCEPT { NLIB_BINW(uint8_t); }
50  bool Write(short x) NLIB_NOEXCEPT { NLIB_BINW(uint16_t); } // NOLINT
51  bool Write(unsigned short x) NLIB_NOEXCEPT { NLIB_BINW(uint16_t); } // NOLINT
52  bool Write(int x) NLIB_NOEXCEPT { NLIB_BINW(uint32_t); }
53  bool Write(unsigned int x) NLIB_NOEXCEPT { NLIB_BINW(uint32_t); }
54  bool Write(long x) NLIB_NOEXCEPT { NLIB_BINW(nlib_ulong_compatible_t); } // NOLINT
55  bool Write(unsigned long x) NLIB_NOEXCEPT { NLIB_BINW(nlib_ulong_compatible_t); } // NOLINT
56  bool Write(long long x) NLIB_NOEXCEPT { NLIB_BINW(uint64_t); } // NOLINT
57  bool Write(unsigned long long x) NLIB_NOEXCEPT { NLIB_BINW(uint64_t); } // NOLINT
58  bool Write(float x) NLIB_NOEXCEPT { NLIB_BINW(float); } // NOLINT
59  bool Write(double x) NLIB_NOEXCEPT { NLIB_BINW(double); } // NOLINT
60 #undef NLIB_BINW
61 
62  template <class T>
63  bool Write(T x) NLIB_NOEXCEPT;
64 
65  bool WriteArray(const unsigned char* x, size_t n) NLIB_NOEXCEPT NLIB_NONNULL;
66  bool WriteArray(const unsigned short* x, size_t n) NLIB_NOEXCEPT NLIB_NONNULL; // NOLINT
67  bool WriteArray(const unsigned int* x, size_t n) NLIB_NOEXCEPT NLIB_NONNULL;
68  bool WriteArray(const unsigned long long* x, size_t n) NLIB_NOEXCEPT NLIB_NONNULL; // NOLINT
69  bool WriteArray(const unsigned long* x, size_t n) NLIB_NOEXCEPT { // NOLINT
70 #ifdef NLIB_LP64
71  return this->WriteArray(reinterpret_cast<const unsigned long long*>(x), n); // NOLINT
72 #else
73  return this->WriteArray(reinterpret_cast<const unsigned int*>(x), n);
74 #endif
75  }
76 
77  bool WriteArray(const float* x, size_t n) NLIB_NOEXCEPT NLIB_NONNULL;
78  bool WriteArray(const double* x, size_t n) NLIB_NOEXCEPT NLIB_NONNULL;
79  bool WriteArray(const signed char* x, size_t n) NLIB_NOEXCEPT {
80  return this->WriteArray(reinterpret_cast<const unsigned char*>(x), n);
81  }
82  bool WriteArray(const char* x, size_t n) NLIB_NOEXCEPT {
83  return this->WriteArray(reinterpret_cast<const unsigned char*>(x), n);
84  }
85  bool WriteArray(const short* x, size_t n) NLIB_NOEXCEPT { // NOLINT
86  return this->WriteArray(reinterpret_cast<const unsigned short*>(x), n); // NOLINT
87  }
88  bool WriteArray(const int* x, size_t n) NLIB_NOEXCEPT {
89  return this->WriteArray(reinterpret_cast<const unsigned int*>(x), n);
90  }
91  bool WriteArray(const long* x, size_t n) NLIB_NOEXCEPT { // NOLINT
92 #ifdef NLIB_LP64
93  return this->WriteArray(reinterpret_cast<const unsigned long long*>(x), n); // NOLINT
94 #else
95  return this->WriteArray(reinterpret_cast<const unsigned int*>(x), n);
96 #endif
97  }
98  bool WriteArray(const long long* x, size_t n) NLIB_NOEXCEPT { // NOLINT
99  return this->WriteArray(reinterpret_cast<const unsigned long long*>(x), n); // NOLINT
100  }
101  template <class T>
102  bool WriteArray(const T* x, size_t n) NLIB_NOEXCEPT;
103  template <class T, size_t N>
104  bool WriteArray(const T(&a)[N]) NLIB_NOEXCEPT;
105  bool Flush() NLIB_NOEXCEPT;
106  bool Close() NLIB_NOEXCEPT;
107  void SetError(errno_t e) NLIB_NOEXCEPT {
108  if (errno_ == 0) errno_ = e;
109  }
110  errno_t GetErrorValue() const NLIB_NOEXCEPT { return errno_; }
111  OutputStream* GetStream() NLIB_NOEXCEPT { return stream_; }
112 
113  NLIB_SAFE_BOOL(BinaryWriter, GetErrorValue() == 0)
114 
115  private:
116  bool Write_(uint8_t x) NLIB_NOEXCEPT;
117  bool Write_(uint16_t x) NLIB_NOEXCEPT;
118  bool Write_(uint32_t x) NLIB_NOEXCEPT;
119  bool Write_(uint64_t x) NLIB_NOEXCEPT;
120  bool Write_(float x) NLIB_NOEXCEPT;
121  bool Write_(double x) NLIB_NOEXCEPT;
122  NLIB_VIS_HIDDEN bool WriteStream() NLIB_NOEXCEPT;
123 
124  private:
125  OutputStream* stream_;
126  ErrnoT errno_;
127  bool swap_endian_;
128  detail::MiniBufOut<512> mini_buf_;
129 
131 };
132 
133 namespace binary_writer {
134 
135 template<class T>
136 NLIB_ALWAYS_INLINE bool Write(BinaryWriter* w, T x) { return w->Write(x); }
137 
138 template <class T>
139 NLIB_ALWAYS_INLINE bool WriteArray(BinaryWriter* w, const T* x, size_t n) {
140  return w->WriteArray(x, n);
141 }
142 }
143 
144 template <class T>
146  return binary_writer::Write(this, x);
147 }
148 
149 template <class T>
151  return binary_writer::WriteArray(this, x, n);
152 }
153 
154 template <class T, size_t N>
156  return this->WriteArray(&a[0], N);
157 }
158 
159 NLIB_NAMESPACE_END
160 
161 #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:55
OutputStream * GetStream() noexcept
Gets the stream for the text writer to write to.
Definition: BinaryWriter.h:111
#define NLIB_ALWAYS_INLINE
Indicates that the compiler is forced to perform inline expansion of functions.
Definition: Platform_unix.h:97
Writes in little-endian.
Definition: BinaryWriter.h:30
#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:163
#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:178
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:58
errno_t GetErrorValue() const noexcept
This function can get the cause of the error when writing has failed.
Definition: BinaryWriter.h:110
bool Write(unsigned short x) noexcept
Writes unsigned short-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:51
uint32_t nlib_ulong_compatible_t
Defines an integer type that is compatible with unsigned long using typedef.
Definition: Platform.h:322
errno_t Init() noexcept
Initializes the binary writer using the same endianness as the machine the program is running on...
Definition: BinaryWriter.h:43
#define NLIB_VIS_HIDDEN
Symbols for functions and classes are not made available outside of the library.
Definition: Platform_unix.h:88
~BinaryWriter() noexcept
Destructor. This function does not close the stream.
Definition: BinaryWriter.h:41
#define NLIB_VIS_PUBLIC
Symbols for functions and classes are made available outside of the library.
Definition: Platform_unix.h:89
bool Write(char x) noexcept
Writes char-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:47
Writes in big-endian.
Definition: BinaryWriter.h:31
bool Write(BinaryWriter *w, T x)
You can write user-defined class objects by specializing this function template.
Definition: BinaryWriter.h:136
bool Write(unsigned int x) noexcept
Writes unsigned int-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:53
bool Write(long long x) noexcept
Writes long long-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:56
bool Write(unsigned char x) noexcept
Writes unsigned char-type data as binary to a stream. Returns true if successful. ...
Definition: BinaryWriter.h:49
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:139
void SetError(errno_t e) noexcept
Sets an error. If an error has been set already, this function does not set an error.
Definition: BinaryWriter.h:107
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:98
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:91
Class that wraps errno_t. This class improves visual representations in the Visual Studio debugger...
Definition: Config.h:492
bool Write(long x) noexcept
Writes long-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:54
bool Write(int x) noexcept
Writes int-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:52
bool Write(short x) noexcept
Writes short-type data as binary to a stream. Returns true if successful.
Definition: BinaryWriter.h:50
#define NLIB_NOEXCEPT
Defines noexcept geared to the environment, or the equivalent.
Definition: Config.h:99
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:69
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:88
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:48
#define NLIB_FINAL
Defines final if it is available for use. If not, holds an empty string.
Definition: Config.h:229
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:79
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:82
BinaryWriter() noexcept
Instantiates the object with default parameters (default constructor).
Definition: BinaryWriter.h:38
#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:59
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:57
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:85
int errno_t
Indicates with an int-type typedef that a POSIX error value is returned as the return value...
Definition: NMalloc.h:37