MGL::ByteStream#

MGL::ByteStreamクラスはメモリ上のバッファをバイト単位で連続して読み書きするためのクラスです。主にセーブデータや外部リソースなどのバイナリファイルの保存・解析に使用することを想定しており、バッファに対する範囲外アクセスを防止する機能を備えています。

注意

このクラスはバイトオーダーやメモリアライメントといった環境や処理系による差異を解決しません。異なる環境下で共通のバイナリファイルの内容を扱う場合や、アライメント制約の厳しいプロセッサで使用する際にはご注意ください。

宣言
namespace MGL
{
    class ByteStream;
}
型

種類

名前

内容

バージョン

列挙型

ClearType

バッファクリア時の動作タイプ

1.0.0+
メンバ情報

種類

名前

内容

バージョン

関数

コンストラクタ

1.0.0+

関数

SetBuffer

対象バッファを設定

1.0.0+

関数

Clear

バッファの全領域をクリア

1.0.0+

関数

Read

バッファから読み込み

1.0.0+

関数

Write

バッファへ書き込み

1.0.0+

関数

ReadBool

バッファから論理値を読み込み

1.0.0+

関数

WriteBool

バッファに論理値を書き込み

1.0.0+

関数

Fill

指定した値を連続して書き込み

1.0.0+

関数

Skip

指定したサイズ分スキップ

1.0.0+

関数

SetOffset

オフセットを設定

1.0.0+

関数

GetOffset

オフセットを取得

1.0.0+

関数

GetSize

バッファのサイズを取得

1.0.0+

関数

GetCurrentPoint

現在の先頭アドレスを取得

1.0.0+

関数

GetCurrentConstPoint

現在の先頭アドレスを読み込み専用で取得

1.0.0+

関数

IsOverflowed

オーバーフローの発生状況を取得

1.0.0+

ClearType#

バッファクリア時の動作タイプ

宣言#

enum class ClearType
{
    Zero,     //!< ゼロ初期化
    Random,   //!< ランダム初期化
};

説明#

Clearの引数に指定する動作タイプです。詳細はClearの説明を参照してください。

バージョン情報#

MGL 1.0.0

  • 初回リリース

コンストラクタ#

宣言#

namespace MGL
{
    class ByteStream
    {
        // (1) パラメータを設定しないオブジェクトを生成
        constexpr ByteStream() noexcept

        // (2) 対象アドレスとサイズを指定してオブジェクトを生成
        constexpr ByteStream(void *address, size_t size) noexcept

        // (3) 対象アドレスとサイズを指定して読み込み専用のオブジェクトを生成
        constexpr ByteStream(const void *address, size_t size) noexcept
    };
}

引数#

(1) パラメータを設定しないオブジェクトを生成

引数なし

(2) 対象アドレスとサイズを指定してオブジェクトを生成
void *address

設定するバッファの先頭アドレス

size_t size

バッファのサイズ

(3) 対象アドレスとサイズを指定して読み込み専用のオブジェクトを生成
const void *address

設定するバッファの先頭アドレス

size_t size

バッファのサイズ

説明#

ByteStreamクラスのコンストラクタです。

(1)で初期化した場合、SetBufferを用いてバッファアドレスとサイズを指定してから使用します。

(2)と(3)はバッファアドレスとそのサイズを指定して初期化します。両者の違いは引数addressがconstで修飾されているか否かとなります。constで修飾されたアドレスを渡した場合、そのバッファは読み込み専用となり、ByteStreamクラスを通した書き込みを行えなくなります。

利用例#

// バッファを準備
constexpr size_t kBufferSize = 128;
uint8_t buffer[kBufferSize];

// 読み書き可能なストリームを生成
MGL::ByteStream writableStream(buffer, kBufferSize);

// 読み込み専用のストリームを生成
MGL::ByteStream readOnlyStream(static_cast<const void *>(buffer), kBufferSize);

バージョン情報#

MGL 1.0.0

  • 初回リリース

関連#

SetBuffer#

対象バッファを設定

宣言#

namespace MGL
{
    class ByteStream
    {
        // (1) 読み書き可能なバッファを設定
        void SetBuffer(void *address, size_t size) noexcept;

        // (2) 読み込み専用のバッファを設定
        void SetBuffer(const void *address, size_t size) noexcept;
    };
}

引数#

(1) 読み書き可能なバッファを設定
void *address

設定するバッファの先頭アドレス

size_t size

バッファのサイズ

(2) 読み込み専用のバッファを設定
const void *address

設定するバッファの先頭アドレス

size_t size

バッファのサイズ

説明#

対象バッファとサイズを設定します。既に設定されている場合は新たなバッファアドレスで上書きされ、現在の読み込み位置を示すオフセットはクリアされます。

(1)と(2)の違いは引数addressがconstで修飾されているか否かとなります。constで修飾されたアドレスを渡した場合、そのバッファは読み込み専用となり、ByteStreamクラスを通した書き込みを行えなくなります。

利用例#

// バッファを準備
constexpr size_t kBufferSize = 128;
uint8_t buffer[kBufferSize];

// ストリームを準備
MGL::ByteStream stream;

// ストリームにバッファを設定
stream.SetBuffer(buffer, kBufferSize);

... // streamに対する処理

// 別のバッファに読み込み専用で再設定
uint8_t buffer2[kBufferSize];
stream.SetBuffer(static_cast<const void *>(buffer2), kBufferSize);

バージョン情報#

MGL 1.0.0

  • 初回リリース

関連#

Clear#

バッファの全領域をクリア

宣言#

namespace MGL
{
    class ByteStream
    {
        void Clear(ClearType clearType) noexcept;
    };
}

引数#

ClearType clearType

バッファクリアの動作タイプ

戻り値#

bool

成功時にtrue、失敗時にfalse

説明#

ストリームが管理している全バッファ領域を、引数で指定した方法でクリアします。引数とその動作は次の通りです。

ClearType::Zero

全バッファ領域にゼロを書き込みます。

ClearType::Random

全バッファ領域にランダムな値を書き込みます。乱数生成には再現性のない値が用いられます。

ストリームを読み込み専用で初期化している場合、この関数は何もせずにfalseを返します。書き込み可能なストリームに対しては失敗することがなく、常にtrueを返します。

この関数は成否に関わらず、ストリームのオフセットやオーバーフローフラグを変更しません。

利用例#

// バッファを準備
constexpr size_t kBufferSize = 128;
uint8_t buffer[kBufferSize];

// ストリームを準備
MGL::ByteStream stream(buffer, kBufferSize);

// バッファの全領域をゼロでクリア
stream.Clear(MGL::ByteStream::ClearType::Zero);

バージョン情報#

MGL 1.0.0

  • 初回リリース

Read#

バッファから読み込み

宣言#

namespace MGL
{
    class ByteStream
    {
        // (1) 格納先アドレスと読み込みサイズを指定して読み込み
        bool Read(void *dest, size_t size) noexcept

        // (2) 格納先の参照を渡して読み込み
        template<typename T>
        constexpr bool Read(T &value) noexcept

        // (3) 型を指定して戻り値で読み込み
        template<typename T>
        constexpr T Read() noexcept
    };
}

引数#

(1) 格納先アドレスと読み込みサイズを指定して読み込み
void *dest

読み込む値の格納先アドレス

size_t size

読み込むサイズ

(2) 格納先の参照を渡して読み込み
T &value

読み込む値の参照。sizeofでサイズが取得可能な型のみ指定可能

(3) 型を指定して戻り値で読み込み
typename T

読み込む値の型。sizeofでサイズが取得可能な型のみ指定可能

戻り値#

(1) 格納先アドレスと読み込みサイズを指定して読み込み
bool

成功時にtrue、失敗時にfalse

(2) 格納先の参照を渡して読み込み
bool

成功時にtrue、失敗時にfalse

(3) 型を指定して戻り値で読み込み
T

成功時には読み込んだ値、失敗時にはその型の初期値

説明#

ストリームの現在のオフセット位置にあるバッファの内容を、指定したサイズ分取得します。読み込みに成功するとストリームのオフセットがサイズ分加算され、次回の呼び出し以降はその続きから読み込みます。

ストリームに設定されたバッファの範囲外に及ぶサイズを指定した場合、この関数は値の読み込みを行わず、内部のオーバーフローフラグにtrueをセットします。オーバーフローの発生状況はIsOverflowedにて取得可能です。

オーバーフローが発生している場合、この関数は常に失敗しfalseを返します。再試行するにはSetOffsetを使用して適切なオフセットを指定し、オーバーフローフラグをクリアしてください。

(1)は引数に格納先のアドレスと取得サイズを指定します。最も基本的な指定方法ですが、格納先のサイズよりも大きい値を指定するとバッファオーバーフローを起こすため注意が必要です。

(2)は(1)をより安全に扱うためのテンプレート関数です。引数に格納先の変数のみを指定することで、その変数のアドレスとサイズを指定した(1)の関数を呼び出します。引数はsizeofでサイズが取得可能な型である必要があります。

(3)は型を指定して戻り値で読み込み結果を取得するためのテンプレート関数です。この関数は戻り値で成否を判別できず、IsOverflowedを用いる必要があります。この関数も(2)と同様に、sizeofでサイズが取得可能な型を用いる必要があります。

(2)および(3)でbool型を指定した場合、その関数は(1)ではなくReadBoolを呼び出します。この場合、ReadBoolの動作に従い、その処理系のbool型のサイズに依存せずに読み込みサイズが1バイトとなります。

読み込みに成功した場合はtrueが返ります。sizeにストリームの管理サイズを超える値を指定した場合はfalseを返し、IsOverflowedがtrueを返すようになります。

利用例#

// バッファを準備
constexpr size_t kBufferSize = 128;
uint8_t buffer[kBufferSize];

// ストリームを準備してランダムに初期化
MGL::ByteStream stream(buffer, kBufferSize);
stream.Clear(MGL::ByteStream::ClearType::Random);

// (1) 格納先アドレスと読み込みサイズを指定して読み込み
uint32_t a = 0;
stream.Read(&a, sizeof(a));         // 先頭の4バイトをaに読み込み

// (2) 格納先の参照を渡して読み込み
uint16_t b = 0;
stream.Read(b);                     // 次の2バイトをbに読み込み

// (3) 型を指定して戻り値で読み込み
auto c = stream.Read<uint8_t>();    // 次の1バイトをcに読み込み

バージョン情報#

MGL 1.0.0

  • 初回リリース

関連#

Write#

バッファへ書き込み

宣言#

namespace MGL
{
    class ByteStream
    {
        // (1) アドレスとサイズを指定して書き込み
        bool Write(const void *source, size_t size) noexcept;

        // (2) 値のみを渡して書き込み
        template<typename T> constexpr bool Write(T value) noexcept
    };
}

引数#

(1) アドレスとサイズを指定して書き込み
const void *source

書き込むデータの先頭アドレス

size_t size

書き込みサイズ

(2) 値のみを渡して書き込み
T value

書き込む値。sizeofでサイズが取得可能な型のみ指定可能

戻り値#

(1) アドレスとサイズを指定して書き込み
bool

成功時にtrue、失敗時にfalse

(2) 値のみを渡して書き込み
bool

成功時にtrue、失敗時にfalse

説明#

現在のストリームに指定された値を書き込み、書き込んだサイズ分オフセットを進めます。

(1)は書き込みデータの先頭アドレスとサイズを渡して書き込みを行います。最も基本的な指定方法ですが、実際のデータサイズよりも大きな値を指定した場合は範囲外にアクセスしてしまう点にご注意ください。

(2)は(1)をより安全に扱うためのテンプレート関数です。引数に格納先の変数のみを指定することで、その変数のアドレスとサイズを指定した(1)の関数を呼び出します。引数はsizeofでサイズが取得可能な型である必要があります。

(2)でbool型の値のみを渡した場合、その関数は(1)ではなくWriteBoolを呼び出します。この場合、WriteBoolの動作に従い、その処理系のbool型のサイズに依存せずに書き込みサイズが1バイトとなります。

書き込みに成功した場合はtrueを返します。sizeにストリームの管理サイズを超える値を指定した場合はfalseを返し、IsOverflowedがtrueを返すようになります。

オーバーフローが発生している場合、この関数は常に失敗しfalseを返します。再試行するにはSetOffsetを使用して適切なオフセットを指定し、オーバーフローフラグをクリアしてください。

初期化時にconstで修飾されたアドレスを渡してストリームを読み込み専用にした場合、この関数は一切の書き込みを行わず、常にfalseを返します。

利用例#

// 16バイトのバッファを準備
constexpr size_t kBufferSize = 16;
uint8_t buffer[kBufferSize];

// ストリームを準備して0で初期化
MGL::ByteStream stream(buffer, kBufferSize);
stream.Clear(MGL::ByteStream::ClearType::Zero);

// 書き込みテスト用の文字とそのサイズを準備
constexpr const char *kTestString = "Test string";
size_t writeSize = strlen(kTestString) + 1;  // 12バイト（11文字 + 終端記号）

// (1) アドレスとサイズを指定して書き込み
// ここでは文字列のアドレスと、その文字のサイズを指定している
stream.Write(kTestString, writeSize);

// (2) 値のみを渡して書き込み
uint32_t testValue = 0x12345678;    // 4バイトの整数値
stream.Write(testValue);

// このような指定も可能
if (!stream.Write(uint32_t(0x87654321)))
{
    // ただし、既に16バイトを使い切ったバッファに対する書き込みとなるため、
    // 処理に失敗してここに到達する。
}

バージョン情報#

MGL 1.0.0

  • 初回リリース

関連#

ReadBool#

バッファから論理値を読み込み

宣言#

namespace MGL
{
    class ByteStream
    {
        // (1) 論理値を読み込んで引数に格納
        bool ReadBool(bool &flag) noexcept;

        // (2) 論理値を読み込んで戻り値で取得
        bool ReadBool() noexcept;
    };
}

引数#

(1) 論理値を読み込んで引数に格納
bool &flag

読み込んだ論理値の格納先

(2) 論理値を読み込んで戻り値で取得

引数なし

戻り値#

(1) 論理値を読み込んで引数に格納

読み込み成功時にtrue、失敗時にfalse

(2) 論理値を読み込んで戻り値で取得

バッファから読み込んだ論理値。読み込み失敗時にはfalse

説明#

現在のストリームの先頭から1バイト読み込み、ゼロであればfalseを、ゼロ以外であればtrueを取得します。この関数は処理系のbool型のサイズに関わらず、常に論理値を1バイトとして扱います。

(1)は引数に論理値の格納先を指定し、読み込みの成否を戻り値で返します。戻り値はオーバーフローなどの理由で読み込めなかった場合にはfalseとなり、読み込んだ値ではない事にご注意ください。

(2)は読み込んだ論理値を戻り値で返します。読み込みの成否は戻り値からは判別できないため、IsOverflowedと併用してください。

Readのテンプレート関数でbool型を指定した場合、代わりにこの関数が呼び出されます。

オーバーフローが発生している場合、この関数は常に失敗しfalseを返します。再試行するにはSetOffsetを使用して適切なオフセットを指定し、オーバーフローフラグをクリアしてください。

利用例#

// 16バイトのバッファを準備
constexpr size_t kBufferSize = 16;
uint8_t buffer[kBufferSize];

// ストリームを準備してランダムに初期化
MGL::ByteStream stream(buffer, kBufferSize);
stream.Clear(MGL::ByteStream::ClearType::Random);

// (1) 論理値を読み込んで引数に格納
if (bool flag; !stream.ReadBool(flag))
{
    // 読み込みに失敗した場合はここに到達
}
else if (flag)
{
    // 最初の1バイトが0以外であればここに到達
}

// (2) 論理値を読み込んで戻り値で取得
if (stream.ReadBool())
{
    if (stream.IsOverflowed())
    {
        // 読み込みに失敗した場合はここに到達
    }
    else
    {
        // 最初の1バイトが0以外ならここに到達
    }
}

バージョン情報#

MGL 1.0.0

  • 初回リリース

MGL 1.1.11

  • (2)を追加

関連#

WriteBool#

バッファに論理値を書き込み

宣言#

namespace MGL
{
    class ByteStream
    {
        bool WriteBool(bool flag) noexcept;
    };
}

引数#

bool &flag

書き込むフラグ

戻り値#

成功時にtrue、失敗時にfalse

説明#

現在のストリームの先頭に対し、引数でtrueを指定した場合は1を、falseを指定した場合は0を1バイトで書き込みます。この関数は処理系のbool型のサイズに関わらず、常に論理値を1バイトとして扱います。

Writeのテンプレート関数にbool型を指定した場合、代わりにこの関数が呼び出されます。

書き込みに成功した場合はtrueを返します。書き込み中にストリームの管理サイズを超えた場合はfalseを返し、IsOverflowedがtrueを返すようになります。

初期化時にconstで修飾されたアドレスを渡してストリームを読み込み専用にした場合、この関数は一切の書き込みを行わず、常にfalseを返します。

オーバーフローが発生している場合、この関数は常に失敗しfalseを返します。再試行するにはSetOffsetを使用して適切なオフセットを指定し、オーバーフローフラグをクリアしてください。

利用例#

// 16バイトのバッファを準備
constexpr size_t kBufferSize = 16;
uint8_t buffer[kBufferSize];

// ストリームを準備して0で初期化
MGL::ByteStream stream(buffer, kBufferSize);
stream.Clear(MGL::ByteStream::ClearType::Zero);

// 最初の1バイトに true (1バイトで0x01）を書き込み
if (!stream.WriteBool(true))
{
    // 失敗した場合はここに到達
}

バージョン情報#

MGL 1.0.0

  • 初回リリース

関連#

Fill#

指定した値を連続して書き込み

宣言#

namespace MGL
{
    class ByteStream
    {
        bool Fill(uint8_t value, size_t size) noexcept;
    };
}

引数#

uint8_t value

書き込む値

size_t size

書き込みサイズ

戻り値#

bool

成功時にtrue、失敗時にfalse

説明#

ストリームの先頭から、指定した1バイトの値を連続で指定サイズ分書き込みます。

書き込みに成功した場合はtrueを返します。sizeにストリームの管理サイズを超える値を指定した場合はfalseを返し、IsOverflowedがtrueを返すようになります。

初期化時にconstで修飾されたアドレスを渡してストリームを読み込み専用にした場合、この関数は一切の書き込みを行わず、常にfalseを返します。

オーバーフローが発生している場合、この関数は常に失敗しfalseを返します。再試行するにはSetOffsetを使用して適切なオフセットを指定し、オーバーフローフラグをクリアしてください。

利用例#

// 16バイトのバッファを準備
constexpr size_t kBufferSize = 16;
uint8_t buffer[kBufferSize];

// ストリームを準備
MGL::ByteStream stream(buffer, kBufferSize);

// 最初の10バイトを 0x88 で埋める
stream.Fill(0x88, 10);

// 次の6バイトを 0x44 で埋める
stream.Fill(0x44, 6);

// 次の4バイトを 0x00 で埋める（失敗する）
if (!stream.Fill(0x00, 4))
{
    // オーバーフローするためここに到達
}

バージョン情報#

MGL 1.0.0

  • 初回リリース

関連#

Skip#

指定したサイズ分スキップ

宣言#

namespace MGL
{
    class ByteStream
    {
        bool Skip(size_t size) noexcept;
    };
}

引数#

size_t size

スキップするサイズ

戻り値#

bool

成功時にtrue、失敗時にfalse

説明#

現在のストリームの先頭から指定サイズ分スキップし、オフセットを更新します。スキップされたバッファには何も書き込みません。

スキップに成功した場合はtrueが返ります。sizeにストリームの管理サイズを超える値を指定した場合はfalseを返し、IsOverflowedがtrueを返すようになります。

オーバーフローが発生している場合、この関数は常に失敗しfalseを返します。再試行するにはSetOffsetを使用して適切なオフセットを指定し、オーバーフローフラグをクリアしてください。

利用例#

// 16バイトのバッファを準備
constexpr size_t kBufferSize = 16;
uint8_t buffer[kBufferSize];

// ストリームを準備して0で初期化
MGL::ByteStream stream(buffer, kBufferSize);
stream.Clear(MGL::ByteStream::ClearType::Zero);

// 最初の1バイトに 0xFF を書き込み
stream.Write(uint8_t(0xFF));

// 8バイトスキップ
stream.Skip(8);

// スキップ後の場所に 0xCC を書き込み
stream.Write(uint8_t(0xCC));

// バッファの内容を表示
for (size_t i = 0; i < kBufferSize; i++)
{
    MGL_TRACE("%d: %02X", i, buffer[i]);
}
実行結果
 0: FF
 1: 00
 2: 00
 3: 00
 4: 00
 5: 00
 6: 00
 7: 00
 8: 00
 9: CC
10: 00
11: 00
12: 00
13: 00
14: 00
15: 00

バージョン情報#

MGL 1.0.0

  • 初回リリース

関連#

SetOffset#

オフセットを設定

宣言#

namespace MGL
{
    class ByteStream
    {
        bool SetOffset(size_t offset) noexcept;
    };
}

引数#

size_t offset

設定するオフセット

戻り値#

bool

成功時にtrue、失敗時にfalse

説明#

ストリームの現在の先頭を示すオフセット値を指定した値で書き換えます。また、適切なオフセットを指定することでオーバーフローフラグをクリアします。

引数にストリームの管理サイズを超える値を指定した場合はfalseが返り、IsOverflowedがtrueを返すようになります。

オーバフローが発生している状態においては、この関数で適切なオフセットを指定することでオーバーフローフラグがクリアされます。

利用例#

// 8バイトのバッファを準備
constexpr size_t kBufferSize = 8;
uint8_t buffer[kBufferSize];

// ストリームを準備して0で初期化
MGL::ByteStream stream(buffer, kBufferSize);
stream.Clear(MGL::ByteStream::ClearType::Zero);

// オフセットを 6 に設定
stream.SetOffset(6);

// その位置に 0xFF を書き込み
stream.Write(uint8_t(0xFF));

// オフセットを 2 に設定
stream.SetOffset(2);

// その位置に 0xCC を書き込み
stream.Write(uint8_t(0xCC));

// バッファの内容を表示
for (size_t i = 0; i < kBufferSize; i++)
{
    MGL_TRACE("%d: %02X", i, buffer[i]);
}
実行結果
0: 00
1: 00
2: CC
3: 00
4: 00
5: 00
6: FF
7: 00

バージョン情報#

MGL 1.0.0

  • 初回リリース

関連#

GetOffset#

オフセットを取得

宣言#

namespace MGL
{
    class ByteStream
    {
        [[nodiscard]] constexpr size_t GetOffset() const noexcept;
    };
}

戻り値#

size_t

現在のオフセット

説明#

ストリームの現在の先頭位置を示すオフセット値を取得します。

利用例#

// 8バイトのバッファを準備
constexpr size_t kBufferSize = 8;
uint8_t buffer[kBufferSize];

// ストリームを準備
MGL::ByteStream stream(buffer, kBufferSize);

// オフセットを表示
MGL_TRACE("A: offset = %zu", stream.GetOffset());

// 4バイト書き込み
stream.Write(uint32_t(0x12345678));

// 書き込み後のオフセットを表示
MGL_TRACE("B: offset = %zu", stream.GetOffset());

// 8バイト書き込み（オーバーフロにより失敗）
stream.Write(uint64_t(0x12345678));

// 上記の書き込みは失敗したためオフセットは更新されない
MGL_TRACE("C: offset = %zu", stream.GetOffset());
実行結果
A: offset = 0
B: offset = 4
C: offset = 4

バージョン情報#

MGL 1.0.0

  • 初回リリース

関連#

GetSize#

バッファのサイズを取得

宣言#

namespace MGL
{
    class ByteStream
    {
        [[nodiscard]] constexpr size_t GetSize() const noexcept;
    };
}

戻り値#

size_t

ストリームが管理しているバッファのサイズ

説明#

ストリームが管理しているバッファのサイズを取得します。この値はコンストラクタまたはSetBufferで指定するサイズと等価です。

利用例#

// バッファを準備
constexpr size_t kBufferSize = 128;
uint8_t buffer[kBufferSize];

// 読み書き可能なストリームを生成
MGL::ByteStream stream(buffer, kBufferSize);

// ストリームのバッファサイズを表示
MGL_TRACE("GetSize() = %zu", stream.GetSize());
実行結果
GetSize() = 128

バージョン情報#

MGL 1.0.0

  • 初回リリース

関連#

GetCurrentPoint#

現在の先頭アドレスを取得

宣言#

namespace MGL
{
    class ByteStream
    {
        [[nodiscard]] constexpr void *GetCurrentPoint() const noexcept;
    };
}

戻り値#

void *

ストリームの現在の先頭を示すアドレス。失敗時はnullptr

説明#

ストリームの現在の先頭を示すアドレスを取得します。このアドレスは初期化時に指定した先頭アドレスにGetOffsetで取得できる現在のオフセットを加算した値になります。

初期化時にconstで修飾されたアドレスを渡してストリームを読み込み専用にした場合、この関数は取得に失敗しnullptrを返します。読み込み専用のストリームからアドレスを取得する場合はGetCurrentConstPointを使用してください。

利用例#

// 16バイトのバッファを準備
constexpr size_t kBufferSize = 16;
uint8_t buffer[kBufferSize];

// ストリームを準備
MGL::ByteStream stream(buffer, kBufferSize);

// 8バイトスキップした先のアドレスを取得
stream.Skip(8);
auto *current = stream.GetCurrentPoint();

// 先頭アドレスと現在のアドレスを表示
MGL_TRACE("top = %p", buffer);
MGL_TRACE("current = %p", current);

// 読み込み専用で初期化した場合に nullptr となる事を確認してみる
stream.SetBuffer(static_cast<const void *>(buffer), kBufferSize);
stream.Skip(8);
MGL_TRACE("\n読み込み専用での取得結果：")
MGL_TRACE("GetCurrentPoint() = %p", stream.GetCurrentPoint());
MGL_TRACE("GetCurrentConstPoint() = %p", stream.GetCurrentConstPoint());
実行結果
top = 0x16d3b5588
current = 0x16d3b5590

読み込み専用での取得結果：
GetCurrentPoint() = 0x0
GetCurrentConstPoint() = 0x16d3b5590

※アドレスは一例であり、実行環境によって異なります

バージョン情報#

MGL 1.0.0

  • 初回リリース

MGL 1.1.11

  • リネーム: GetCurrentTop → GetCurrentPoint

関連#

GetCurrentConstPoint#

現在の先頭アドレスを読み込み専用で取得

宣言#

namespace MGL
{
    class ByteStream
    {
        [[nodiscard]] constexpr void *GetCurrentConstPoint() const noexcept;
    };
}

戻り値#

const void *

ストリームの現在の先頭を示すアドレス

説明#

ストリームの現在の先頭を示すアドレスを取得します。このアドレスは初期化時に指定した先頭アドレスにGetOffsetで取得できる現在のオフセットを加算した値になります。

この関数はconstで修飾されたアドレスを返すため、取得結果を通して値を書き込む事はできません。その代わりに、GetCurrentPointとは異なり、読み込み専用で初期化されたストリームからでもアドレスの取得が可能です。

利用例#

GetCurrentPointに併記してあるため、そちらを参照してください。

バージョン情報#

MGL 1.0.0

  • 初回リリース

MGL 1.1.11

  • リネーム: GetCurrentTopConst → GetCurrentConstPoint

関連#

IsOverflowed#

オーバーフローの発生状況を取得

宣言#

namespace MGL
{
    class ByteStream
    {
        [[nodiscard]] constexpr bool IsOverflowed() const noexcept;
    };
}

戻り値#

bool

オーバーフローが発生している場合はtrue、発生していない場合はfalse

説明#

ストリームの読み書きによってオーバーフローが発生したかを取得します。

一度オーバーフローが発生した場合、SetOffsetにて適切なオフセットに更新するか、SetBufferにてバッファを再設定するまでtrueを返し続けます。

利用例#

// 128バイトのバッファを準備
constexpr size_t kBufferSize = 128;
uint8_t buffer[kBufferSize];

// ストリームを準備
MGL::ByteStream stream(buffer, kBufferSize);

// 64バイトスキップ
stream.Skip(64);
if (stream.IsOverflowed())
{
    // ここには来ない
}

// さらに64バイトスキップ
stream.Skip(64);
if (stream.IsOverflowed())
{
    // オフセットは末尾に達するが、オーバーフローはしていないため、
    // やはりここには来ない
}

// さらに1バイトスキップ
stream.Skip(1);
if (stream.IsOverflowed())
{
    // オーバーフローが発生し、ここに到達する
}

バージョン情報#

MGL 1.0.0

  • 初回リリース