# Класс *Bytearray*

*Bytearray* - динамический байтовый массив, реализованный через LuaJIT FFI. По нему можно итерироваться стандартными функциями **pairs** и **ipairs**

<small>Примечание касаемо условных обозначений в документации: псведотип `posint` означает натуральное (положительное ненулевое целое) число.</small>

## Основное
### Создание массива
```lua
local bytes = Bytearray()           -- пустой
local bytes = Bytearray("hello")    -- из строки
local bytes = Bytearray({1,2,3})    -- из таблицы чисел
```

### Методы
```lua
-- Добавляет элемент(ы) в конец массива.
bytes:append(value: int)
bytes:append(values: Bytearray | table<int>)

-- Вставляет данные по индексу.
bytes:insert(index: int, value: int)

-- Удаляет элемент(ы), если передан `count`, удалит `count` кол-во элементов с выбранного индекса.
bytes:remove(index: int, [опционально] count: int)

-- Очищает массив.
bytes:clear()

--[[
Заполняет массив определённым байтом полностью либо в определённом диапазоне.
Логика работы следующая: если параметр size или index равны nil, то указанным байтом будет заполнен весь массив,
    иначе будет заполнен диапазон внутри массива начиная с индекса index и размером size.
В случае выхода заполняемого блока за границы массива генерирует соответствующую ошибку.
]]
bytes:fill(index: posint/nil, size: posint/nil, byte: uint8)

-- Создаёт новый Bytearray, содержащий копию части данных с offset до offset+length
bytes:slice(offset: int, length: int) -> Bytearray

--[[
Копирует блок байт из исходного массива, начиная с индекса srcindex, в массив dst, начиная в нём с индекса dstindex.
В случае выхода за границы исходного, конечного массива, либо при некорректном значении параметра size генерирует соответствующую ошибку.
]]
bytes:copy(srcindex: posint, dst: Bytearray, dstindex: posint, size: posint)

--[[
Безопасно копирует перекрывающиеся области памяти (байт) в пределах одного массива.
В случае выхода за пределы массива начального или конечного диапазона байт генерирует соответствующую ошибку.
]]
bytes:move(fromindex: posint, toindex: posint, size: posint)
```

## View

Это "вьюшки" поверх Bytearray, которые интерпретируют его байты как массив чисел другого размера - **без копирования данных**.

Практически не имеют своих методов, являются простыми объектными ссылками на оригинальный Bytearray.

| Класс        | Тип элементов      | Размер    |
| ------------ | ------------------ | --------- |
| `I8view`     | `int8_t`           | 1 байт    |
| `I16view`    | `int16_t`          | 2 байта   |
| `U16view`    | `uint16_t`         | 2 байта   |
| `I32view`    | `int32_t`          | 4 байта   |
| `U32view`    | `uint32_t`         | 4 байта   |
| `I64view`    | `int64_t`          | 8 байт    |
| `U64view`    | `uint64_t`         | 8 байт    |
| `FLTview`    | `float`            | 4 байта*  |
| `DBLview`    | `double`           | 8 байт*   |

<small>* Размеры "оригинальных" C-шных типов являются платформозависимыми и их точный размер не описан в стандарте языка. В данной таблице предоставлены наиболее распространённые размеры типов.</small>

### Специфические методы "вьюшек"

```lua
--[[
Возвращает размер типа вьюшки. Результат тот же, что и от применения оператора sizeof() из языка C для данного типа.
    Полезно для вьюшек, использующих C-шные типы нефиксированного размера, например те же float или double.
]]
view:typesize() -> posint
```

## Пример использования

```lua
local bytes = Bytearray({1, 0, 2, 0, 250, 255})

local u16 = U16view(bytes)
local i16 = I16view(bytes)

print(u16[1]) -- 1
print(u16[2]) -- 2
print(i16[3]) -- -6 (signed вьюшка)

for _, num in ipairs(i16) do
    print(num)
end -- 1; 2; -6
```