Skip to content

Buffer.Utils

Getting Started

The Utils component in Buffer serves to, for example, calculate the number of bytes required or directly convert a number of bytes to Kilobytes, Megabytes, or Gigabytes.

Methods

Getting the required bytes

To get the specific number of bytes, you will need a Schema and a table containing the values.

Note

This function is used in Buffer.Serialize. I recommend reading that page if you are lost.

 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
local Buffer = require(somewhere.Buffer)

local Utils = Buffer.Utils

--[[
    I really recommend to put : Buffer.BufferSchema for type checking, but it's optional.

    For any other type exepct String you will just need to put for example :

    {
        MyMessage = "String8" --> 8 is the max length of the string
    }

    but for non-defined length you will need to put something like this:

    {
        MyMessage = {
            Type = "String",
            Length = number
        }
    }

    Please note that when you put a string padding characters (string.char(31)) will be added to fill the remaining spaces
    but for example when you will call : Buffer.Deserialize(YourSchema,BufferComponent)

    all added characters will be automaticly removed
]]
local Schema : Buffer.BufferSchema = {
    MyMessage = {
        Type = "String",
        Length = 14,
    }
}

--Simple values (type checking is optional)
local Values : Buffer.BufferSchemaValue = {
    MyMessage = "Hello World"
}

print(Utils.GetRequiredBytes(Schema,Values)) --> this will return 14

Converting bytes

To convert bytes to Kilobytes, etc., the ConvertTo function would be used.

local Buffer = require(somewhere.Buffer)

local Utils = Buffer.Utils

--This will convert the current bytes to Kilobytes

print(Utils.ConvertByte("Kilobytes",1024)) --> this will return 1

--First argument is the convertion and second argument is the bytes
-- Supported convertions: Kilobytes, Megabytes, Gigabytes

GetEquivalentBytesInfoFromNumber

Used in Buffer.WriteAny, this give the exact byte required depending on the number.

1
local b = Utils.GetEquivalentBytesInfoFromNumber(65535) -- this will return 2 cause it will required 2 bytes to write 65535

@return : {bits : number, bytes : number, @isUnsigned : boolean }

Info

isUnsigned purpose is only for Buffer.WriteAny to detect signed numbers, you can still use it if you have to do some use case with u/i numbers

GetByteCodeValueFromType

Used in Buffer.WriteStruct. this resolves the byte code identifier associated with a given value.

Determines the most efficient byte representation for a value based on its type and characteristics. This byte code is later used for serialization to encode the value in a compact binary format.

1
2
local byteCode = Utils.GetByteCodeValueFromType(-1)
print(byteCode) -- will print 2 cause its the current byte code of the type (I8)

@param value any -- Value to analyze @return number -- Byte code representing the value type