SFXRingBuffer

リングバッファを表すクラスです。

#include <SFXRingBuffer.h.hpp>

class SFXRingBuffer;

SFMTYPEDEFCLASS(SFXRingBuffer)

協調図

解説

SFXRingBuffer クラスは、リングバッファを表すクラスです。

リングバッファとは、 (概念上) 環状に配置されたメモリのことです。その上を右回りに進む書き込みポインターと読み込みポインターがあります。

リングバッファにデータを書き込むと、書き込みポインターが進みます。読み込みポインターは、書き込みポインターで書き込まれた位置まで読み込むことができます。

書き込み操作により読み込みポインターを通り越すことはできません。

使用例

UInt32 wsize, rsize;

// リングバッファのインスタンスを作成する
SFXRingBuffer ring;

// 256 byte のメモリを割り当てる
ring.Allocate(256);

// メモリ割り当て直後はバッファの内容は空なので
// 書き込み可能なサイズは wsize = 256 となる
wsize = ring.GetWritableSize();

// メモリ割り当て直後は、読み込み可能なデータはなし
// rsize = 0 となる
rsize = ring.GetReadableSize();

// 4 byte のデータを書き込む
SInt32 n = 123;
ring.Write(&n, sizeof(n));

// 残りの書き込み可能なサイズは wsize = 256 - 4 となる
wsize = ring.GetWritableSize();

// 読み込み可能なサイズは rsize = 4 となる
rsize = ring.GetReadableSize();

// 4 byte のデータを読み込む
SInt32 m;
ring.Read(&m, sizeof(m));

if (n == m) {
  // OK
}

参照

リングバッファ

メンバ

コンストラクタ/デストラクタ
SFXRingBuffer( `Void` ) SFXRingBuffer クラスのコンストラクタです。
~SFXRingBuffer( `Void` ) SFXRingBuffer クラスのデストラクタです。

パブリック関数
`SFCError`	Allocate( `UInt32` size ) バッファメモリを割り当てます。
static `SFXRingBufferConstRef`	EmptyInstance( `Void` ) 空のリングバッファを取得します。
`SInt32`	FirstIndexOf( `SFXBufferConstRef` buffer , `SInt32` index = SINT32_MINIMUM ) FirstIndexOf( `Byte` byte , `SInt32` index = SINT32_MINIMUM ) FirstIndexOf( `VoidConstPtr` buffer , `UInt32` size , `SInt32` index = SINT32_MINIMUM ) リングバッファを基点から検索して、指定したデータと一致する最初のインデックスを取得します。
`Void`	Free( `Void` ) バッファメモリを解放します。
`VoidConstPtr`	GetReadableBuffer( `UInt32Ptr` size ) 読み込みポインターを取得します。
`UInt32`	GetReadableSize( `Void` ) 読み込み可能なサイズを取得します。
`UInt32`	GetSize( `Void` ) 割り当てられているバッファメモリのサイズを取得します。
`VoidPtr`	GetWritableBuffer( `UInt32Ptr` size ) 書き込みポインターを取得します。
`UInt32`	GetWritableSize( `Void` ) 書き込み可能なサイズを取得します。
`SInt32`	LastIndexOf( `SFXBufferConstRef` buffer , `SInt32` index = SINT32_MAXIMUM ) LastIndexOf( `Byte` byte , `SInt32` index = SINT32_MAXIMUM ) LastIndexOf( `VoidConstPtr` buffer , `UInt32` buffer , `SInt32` index = SINT32_MAXIMUM ) リングバッファを終点から検索して、指定したデータと一致する最後のインデックスを取得します。
`SFCError`	Read( `VoidPtr` buffer , `UInt32` size ) Read( `SFXBufferPtr` buffer ) データを読み込みます。
`Void`	Reset( `Void` ) 書き込まれたデータをクリアします。
`SFCError`	SeekRead( `UInt32` size ) 読み込みポインターを進めます。
`SFCError`	SeekWrite( `UInt32` size ) 書き込みポインターを進めます。
`SFCError`	Write( `VoidConstPtr` buffer , `UInt32` size ) Write( `SFXBufferConstRef` buffer ) データを書き込みます。

SFXRingBuffer::SFXRingBuffer

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

[ public, explicit ]
SFXRingBuffer(Void);

解説

コンストラクタではバッファの割り当ては行われません。SFXRingBuffer::Allocate 関数を呼び出す必要があります。

参照

SFXRingBuffer::Allocate

SFXRingBuffer::~SFXRingBuffer

SFXRingBuffer クラスのデストラクタです。

[ public ]
~SFXRingBuffer(Void);

解説

バッファメモリが割り当てられている場合は、自動的に Free 関数を呼び出して、バッファメモリを解放します。

参照

SFXRingBuffer::Free

SFXRingBuffer::Allocate

バッファメモリを割り当てます。

[ public ]
SFCError Allocate(
    UInt32 size   // 割り当てるメモリサイズ
);

戻り値

成功したとき : SFERR_NO_ERROR
メモリ不足のとき : SFERR_NO_MEMORY

解説

使う前にAllocate 関数でバッファメモリを割り当てる必要があります。

割り当てを行わずに他の関数を呼び出した場合の挙動は未定義です。

使用例

SFXRingBuffer ring;

// 256 byte のメモリを割り当てる
if (ring.Allocate(256) == SFERR_NO_ERROR) {
    ...
}

参照

SFXRingBuffer::Free

SFXRingBuffer::EmptyInstance

空のリングバッファを取得します。

[ public, static ]
SFXRingBufferConstRef EmptyInstance(Void);

解説

空のリングバッファを表すインスタンスを取得します。

SFXRingBuffer::FirstIndexOf

リングバッファを基点から検索して、指定したデータと一致する最初のインデックスを取得します。

[ public, const ]
SInt32 FirstIndexOf(
    SFXBufferConstRef buffer        // 検索するバッファ
    SInt32 index = SINT32_MINIMUM   // 検索開始位置
);

[ public, const ]
SInt32 FirstIndexOf(
    VoidConstPtr buffer             // 検索するバッファ
    UInt32 size                     // 検索するバッファのサイズ
    SInt32 index = SINT32_MINIMUM   // 検索開始位置
);

[ public, const ]
SInt32 FirstIndexOf(
    Byte byte                       // 検索する Byte データ
    SInt32 index = SINT32_MINIMUM   // 検索開始位置
);

戻り値

成功したとき : 見つかった位置のインデックス
失敗したとき : -1

解説

リングバッファを基点 (読み込みポインター) から終点 (書き込みポインター) に向かって検索し、最初に見つかった位置のインデックスを取得します。

インデックスは読み込みポインターの位置を 0 として数えます。

検索開始位置を指定することで、基点以外の位置から検索できます。

使用例

static ByteConst data[] = {
        '1', '2', '3', '4', '5', '6', '7', '8'
    };
SFXRingBuffer ring;
SFXBuffer buffer;

// リング バッファのサイズを 256 バイトに設定する
if (ring.Allocate(256) == SFERR_NO_ERROR) {

    // 8 バイトのデータを書き込む
    if (ring.Write(data, sizeof(data)) == SFERR_NO_ERROR) {
        
        // 文字列を基点から検索してインデックスを取得する
        TRACE("FirstIndexOf('2') = %d", ring.FirstIndexOf('2'));  // FirstIndexOf('2') = 1
        TRACE("FirstIndexOf('9') = %d", ring.FirstIndexOf('9'));  // FirstIndexOf('9') = -1
    }
}

参照

SFXRingBuffer::LastIndexOf

SFXRingBuffer::Free

バッファメモリを解放します。

[ public ]
Void Free(Void);

解説

Allocate 関数により割り当てられたバッファメモリを解放します。割り当てられていない場合は何も行いません。

使用例

SFXRingBuffer ring;

// 256 byte のメモリを割り当てる
if (ring.Allocate(256) == SFERR_NO_ERROR) {
    ...
    
    ring.Free();  // 明示的なメモリの解放
}

参照

SFXRingBuffer::Allocate

SFXRingBuffer::GetReadableBuffer

読み込みポインターを取得します。

[ public, const ]
VoidConstPtr GetReadableBuffer(
    UInt32Ptr size   // 読み込み可能サイズを返す
);

解説

内部で割り当てられているバッファメモリ上の読み込みポインターを返します。このポインターを使って、内部バッファから直接データを読み込むことができます。

size には、取得した読み込みポインターで読み込み可能なサイズを返します。このサイズは GetReadableSize 関数で返されるサイズと一致するとは限らず、それ以下の値になります。

GetReadableBuffer 関数を使って GetReadableSize 関数で返されるサイズだけ読み込みを行いたい場合は、 GetReadableBuffer 関数, SeekRead 関数を複数回呼び出す必要があります。

使用例

リングバッファから読み込み可能なデータを、すべてストリームに出力します。

Void WriteRingBufferToFile(SFXBinaryStreamWriterRef stream, SFXRingBufferRef ring)
{
    UInt32 totalSize;   // リング バッファに読み込み可能な総サイズ

    totalSize = ring.GetReadableSize();
    while (totalSize > 0) {
        UInt32 readableSize;
        VoidPtr readPtr;     // 読み込みポインター
 
        readPtr = ring.GetReadableBuffer(&readableSize);
        stream.Write(readPtr, readableSize);
        ring.SeekRead(readPtr, readableSize);

        totalSize -= readableSize;
    }
}

参照

SFXRingBuffer::GetReadableBuffer | SFXRingBuffer::GetReadableSize | SFXRingBuffer::SeekRead

SFXRingBuffer::GetReadableSize

読み込み可能なサイズを取得します。

[ public, const ]
UInt32 GetReadableSize(Void);

使用例

static ByteConst data[] = {
        '1', '2', '3', '4', '5', '6', '7', '8'
};
SFXRingBuffer ring;
SFXBuffer buffer;

// リング バッファのサイズを 256 バイトに設定する
if (ring.Allocate(256) == SFERR_NO_ERROR) {

    TRACE("GetSize = %d", ring.GetSize());                  // GetSize = 256
    TRACE("GetWritableSize = %d", ring.GetWritableSize());  // GetWritableSize = 256
    TRACE("GetReadableSize = %d", ring.GetReadableSize());  // GetReadableSize = 0
		

    // 8 バイトのデータを書き込む
    if (ring.Write(data, sizeof(data)) == SFERR_NO_ERROR) {

        TRACE("GetSize = %d", ring.GetSize());                   // GetSize = 256
        TRACE("GetWritableSize = %d", ring.GetWritableSize());   // GetWritableSize = 248
        TRACE("GetReadableSize = %d", ring.GetReadableSize());   // GetReadableSize = 8

        // 読み込み用のバッファを確保する
        buffer.SetSize(4);

        // 4 バイトのデータを読み込む
        if (ring.Read(&buffer) == SFERR_NO_ERROR) {

            TRACE("GetSize = %d", ring.GetSize());                   // GetSize = 256
            TRACE("GetWritableSize = %d", ring.GetWritableSize());   // GetWritableSize = 252
            TRACE("GetReadableSize = %d", ring.GetReadableSize());   // GetReadableSize = 4

        }
    }
}

参照

SFXRingBuffer::GetReadableBuffer | SFXRingBuffer::GetWritableSize

SFXRingBuffer::GetSize

割り当てられているバッファメモリのサイズを取得します。

[ public, const ]
UInt32 GetSize(Void);

解説

リングバッファの特性から、 GetSize = GetWritableSize + GetReadableSize となります。

使用例

static ByteConst data[] = {
        '1', '2', '3', '4', '5', '6', '7', '8'
};
SFXRingBuffer ring;
SFXBuffer buffer;

// リング バッファのサイズを 256 バイトに設定する
if (ring.Allocate(256) == SFERR_NO_ERROR) {

    TRACE("GetSize = %d", ring.GetSize());                  // GetSize = 256
    TRACE("GetWritableSize = %d", ring.GetWritableSize());  // GetWritableSize = 256
    TRACE("GetReadableSize = %d", ring.GetReadableSize());  // GetReadableSize = 0
		

    // 8 バイトのデータを書き込む
    if (ring.Write(data, sizeof(data)) == SFERR_NO_ERROR) {

        TRACE("GetSize = %d", ring.GetSize());                   // GetSize = 256
        TRACE("GetWritableSize = %d", ring.GetWritableSize());   // GetWritableSize = 248
        TRACE("GetReadableSize = %d", ring.GetReadableSize());   // GetReadableSize = 8

        // 読み込み用のバッファを確保する
        buffer.SetSize(4);

        // 4 バイトのデータを読み込む
        if (ring.Read(&buffer) == SFERR_NO_ERROR) {

            TRACE("GetSize = %d", ring.GetSize());                   // GetSize = 256
            TRACE("GetWritableSize = %d", ring.GetWritableSize());   // GetWritableSize = 252
            TRACE("GetReadableSize = %d", ring.GetReadableSize());   // GetReadableSize = 4

        }
    }
}

参照

SFXRingBuffer::GetReadableSize | SFXRingBuffer::GetWritableSize

SFXRingBuffer::GetWritableBuffer

書き込みポインターを取得します。

[ public ]
VoidPtr GetWritableBuffer(
    UInt32Ptr size   // 書き込み可能サイズを返す
);

解説

内部で割り当てられているバッファメモリ上の書き込みポインターを返します。このポインターを使って、内部バッファに直接データを書き込みことができます。

size には、取得した書き込みポインターで書き込み可能なサイズを返しますこのサイズは GetWritableSize 関数で返されるサイズと一致するとは限らず、以下の値になります。

GetWritableBuffer 関数を使って GetWritableSize 関数で返されるサイズだけ書き込みを行いたい場合は、 GetWritableBuffer 関数, SeekWrite 関数を複数回呼び出す必要があります。

使用例

ストリームからデータを読み込んで、リングバッファに書き込めるだけ書き込みます。

Void WriteRingBufferFromFile(SFXBinaryStreamReaderRef stream, SFXRingBufferRef ring)
{
    UInt32 totalSize;  // リングバッファに書き込み可能な総サイズ
    UInt32 availSize;  // ファイルから読み込み可能な総サイズ

    totalSize = ring.GetWritableSize();
    availSize = stream.GetReadableSize();

    while (totalSize > 0 && availSize > 0) {
        UInt32 writableSize;
        VoidPtr writePtr;
        UInt32 writtenSize;  // 実際に書き込んだサイズ
 
        writePtr = ring.GetWritableBuffer(&writableSize);
        {
            writtenSize = (availSize < writableSize) ? availSize : writableSize;
            stream.Read(writePtr, writtenSize);
        }
        ring.SeekRead(readPtr, readableSize);

        totalSize -= writtenSize;
        availSize -= writtenSize;
    }
}

参照

SFXRingBuffer::GetWritableBuffer | SFXRingBuffer::GetWritableSize | SFXRingBuffer::SeekWrite

SFXRingBuffer::GetWritableSize

書き込み可能なサイズを取得します。

[ public, const ]
UInt32 GetWritableSize(Void);

使用例

static ByteConst data[] = {
        '1', '2', '3', '4', '5', '6', '7', '8'
};
SFXRingBuffer ring;
SFXBuffer buffer;

// リング バッファのサイズを 256 バイトに設定する
if (ring.Allocate(256) == SFERR_NO_ERROR) {

    TRACE("GetSize = %d", ring.GetSize());                  // GetSize = 256
    TRACE("GetWritableSize = %d", ring.GetWritableSize());  // GetWritableSize = 256
    TRACE("GetReadableSize = %d", ring.GetReadableSize());  // GetReadableSize = 0
		

    // 8 バイトのデータを書き込む
    if (ring.Write(data, sizeof(data)) == SFERR_NO_ERROR) {

        TRACE("GetSize = %d", ring.GetSize());                   // GetSize = 256
        TRACE("GetWritableSize = %d", ring.GetWritableSize());   // GetWritableSize = 248
        TRACE("GetReadableSize = %d", ring.GetReadableSize());   // GetReadableSize = 8

        // 読み出し用のバッファを確保する
        buffer.SetSize(4);

        // 4 バイトのデータを読み込む
        if (ring.Read(&buffer) == SFERR_NO_ERROR) {

            TRACE("GetSize = %d", ring.GetSize());                   // GetSize = 256
            TRACE("GetWritableSize = %d", ring.GetWritableSize());   // GetWritableSize = 252
            TRACE("GetReadableSize = %d", ring.GetReadableSize());   // GetReadableSize = 4

        }
    }
}

参照

SFXRingBuffer::GetWritableBuffer | SFXRingBuffer::GetReadableSize

SFXRingBuffer::LastIndexOf

リングバッファを終点から検索して、指定したデータと一致する最後のインデックスを取得します。

[ public, const ]
SInt32 LastIndexOf(
    SFXBufferConstRef buffer        // 検索するバッファ
    SInt32 index = SINT32_MAXIMUM   // 検索開始位置
);

[ public, const ]
SInt32 LastIndexOf(
    VoidConstPtr buffer             // 検索するバッファ
    UInt32 buffer                   // 検索するバッファのサイズ
    SInt32 index = SINT32_MAXIMUM   // 検索開始位置
);

[ public, const ]
SInt32 LastIndexOf(
    Byte byte                       // 検索する Byte データ
    SInt32 index = SINT32_MAXIMUM   // 検索開始位置
);

戻り値

成功したとき : 見つかった位置のインデックス
失敗したとき : -1

解説

リングバッファを終点 (書き込みポインター) から基点 (読み込みポインター) に向かって検索し、最初に見つかった位置のインデックスを取得します。

インデックスは読み込みポインターの位置を 0 として数えます。

検索開始位置を指定することで、終点以外の位置から検索できます。

使用例

static ByteConst data[] = {
        '1', '2', '3', '4', '5', '6', '7', '8'
    };
SFXRingBuffer ring;
SFXBuffer buffer;

// リング バッファのサイズを 256 バイトに設定する
if (ring.Allocate(256) == SFERR_NO_ERROR) {

    // 8 バイトのデータを書き込む
    if (ring.Write(data, sizeof(data)) == SFERR_NO_ERROR) {
        
        // Byte データを終点から検索してインデックスを取得する
        TRACE("LastIndexOf('2') = %d", ring.LastIndexOf('2'));  // LastIndexOf('2') = 1
        TRACE("LastIndexOf('9') = %d", ring.LastIndexOf('9'));  // LastIndexOf('9') = -1
    }
}

参照

SFXRingBuffer::FirstIndexOf

SFXRingBuffer::Read

データを読み込みます。

[ public ]
SFCError Read(
    VoidPtr buffer   // 読み込んだデータを格納するアドレス
    UInt32 size      // 読み込むサイズ
);

[ public ]
SFCError Read(
    SFXBufferPtr buffer   // 読み込んだデータを格納するバッファ
);

戻り値

成功したとき : SFERR_NO_ERROR
引数が不正なとき : SFERR_INVALID_PARAM
サイズが SFXRingBuffer::GetReadableSize 関数で取得できる値を超えるとき : SFERR_FAILED

使用例

 static ByteConst data[] = {
        '1', '2', '3', '4', '5', '6', '7', '8'
    };
SFXRingBuffer ring;
SFXBuffer buffer;

// リング バッファのサイズを 256 バイトに設定する
if (ring.Allocate(256) == SFERR_NO_ERROR) {

    // 8 バイトのデータを書き込む
    if (ring.Write(data, sizeof(data)) == SFERR_NO_ERROR) {

        // 読み出し用のバッファを確保する
        buffer.SetSize(4);

        // 4 バイトのデータを読み込む
        if (ring.Read(&buffer) == SFERR_NO_ERROR) {

            // リング バッファの内容を表示する
            TRACE("%c, %c, %c, %c", buffer[0], buffer[1], buffer[2], buffer[3]); // 1, 2, 3, 4
                
        }
    }
}

参照

SFXRingBuffer::Write

SFXRingBuffer::Reset

書き込まれたデータをクリアします。

[ public ]
Void Reset(Void);

解説

読み込み可能なサイズは 0 になり、書き込み可能なサイズはバッファサイズに等しくなります。

参照

SFXRingBuffer::GetReadableSize | SFXRingBuffer::GetWritableSize

SFXRingBuffer::SeekRead

読み込みポインターを進めます。

[ public ]
SFCError SeekRead(
    UInt32 size   // 読み込みポインターを進めるサイズ
);

戻り値

成功したとき : SFERR_NO_ERROR
サイズが SFXRingBuffer::GetReadableSize 関数で取得できる値を超えるとき : SFERR_FAILED

解説

SeekRead 関数は、読み込みポインターを size だけ進めます。

使用例

 static ByteConst data[] = {
        '1', '2', '3', '4', '5', '6', '7', '8'
    };
SFXRingBuffer ring;
SFXBuffer buffer;

// リング バッファのサイズを 256 バイトに設定する
if (ring.Allocate(256) == SFERR_NO_ERROR) {

    // 8 バイトのデータを書き込み
    if (ring.Write(data, sizeof(data)) == SFERR_NO_ERROR) {

        // 読み込み用のバッファを確保する
        buffer.SetSize(4);

        // 読み込みポインターを進める
        ring.SeekRead(2);

        // 4 バイトのデータを読み込む
        if (ring.Read(&buffer) == SFERR_NO_ERROR) {

            // リング バッファの内容を表示する
            TRACE("%c, %c, %c, %c", buffer[0], buffer[1], buffer[2], buffer[3]); // 3, 4, 5, 6
                
        }
    }
}

参照

SFXRingBuffer::GetReadableBuffer | SFXRingBuffer::GetReadableSize

SFXRingBuffer::SeekWrite

書き込みポインターを進めます。

[ public ]
SFCError SeekWrite(
    UInt32 size   // 書き込みポインターを進めるサイズ
);

戻り値

成功したとき : SFERR_NO_ERROR
サイズが SFXRingBuffer::GetWritableSize で取得できる値を超えるとき : SFERR_FAILED

解説

SeekWrite 関数は、書き込みポインターを size だけ進めます。

使用例

 static ByteConst data[] = {
        '1', '2', '3', '4', '5', '6', '7', '8'
    };
SFXRingBuffer ring;
SFXBuffer buffer;

// リング バッファのサイズを 256 バイトに設定する
if (ring.Allocate(256) == SFERR_NO_ERROR) {

    // 書き込みポインターを進める
    ring.SeekWrite(2);

    // 8 バイトのデータを書き込み
    if (ring.Write(data, sizeof(data)) == SFERR_NO_ERROR) {

        // 読み込み用のバッファを確保する
        buffer.SetSize(4);

        // 4 バイトのデータを読み込む
        if (ring.Read(&buffer) == SFERR_NO_ERROR) {

            // リング バッファの内容を表示する
            TRACE("%c, %c, %c, %c", buffer[0], buffer[1], buffer[2], buffer[3]); // , , 1, 2
                
        }
    }
}

参照

SFXRingBuffer::GetWritableBuffer | SFXRingBuffer::GetWritableSize

SFXRingBuffer::Write

データを書き込みます。

[ public ]
SFCError Write(
    VoidConstPtr buffer   // 書き込むデータのアドレス
    UInt32 size           // 書き込むサイズ
);

[ public ]
SFCError Write(
    SFXBufferConstRef buffer   // 書き込むバッファ
);

戻り値

成功したとき : SFERR_NO_ERROR
引数が不正なとき : SFERR_INVALID_PARAM
サイズが SFXRingBuffer::GetWritableSize で取得できる値を超えるとき : SFERR_FAILED

使用例

 static ByteConst data[] = {
        '1', '2', '3', '4', '5', '6', '7', '8'
    };
SFXRingBuffer ring;
SFXBuffer buffer;

// リング バッファのサイズを 256 バイトに設定する
if (ring.Allocate(256) == SFERR_NO_ERROR) {

    // 8 バイトのデータを書き込む
    if (ring.Write(data, sizeof(data)) == SFERR_NO_ERROR) {

        // 読み込み用のバッファを確保する
        buffer.SetSize(4);

        // 4 バイトのデータを読み込む
        if (ring.Read(&buffer) == SFERR_NO_ERROR) {

            // リング バッファの内容を表示する
            TRACE("%c, %c, %c, %c", buffer[0], buffer[1], buffer[2], buffer[3]); // 1, 2, 3, 4
                
        }
    }
}

参照

SFXRingBuffer::Read