hash_slice

hash_slice

import "github.com/Compogo/types/hash_slice"

Index

• Constants
• Variables
• type HashSlice
  • func NewHashSlice[T comparable]() *HashSlice[T]
  • func NewHashSliceFrom[T comparable](items ...T) (*HashSlice[T], error)
  • func (hs *HashSlice[T]) Add(item T) (int, error)
  • func (hs *HashSlice[T]) All() iter.Seq2[int, T]
  • func (hs *HashSlice[T]) Append(items ...T) (err error)
  • func (hs *HashSlice[T]) Contains(item T) bool
  • func (hs *HashSlice[T]) GetByIndex(index int) (T, error)
  • func (hs *HashSlice[T]) IndexOf(item T) int
  • func (hs *HashSlice[T]) Items() []T
  • func (hs *HashSlice[T]) Len() int
  • func (hs *HashSlice[T]) Remove(item T)
  • func (hs *HashSlice[T]) RemoveByIndex(index int) (err error)
  • func (hs *HashSlice[T]) Replace(index int, item T) (err error)
  • func (hs *HashSlice[T]) Reset()

Constants

NoneIndex — специальное значение, возвращаемое методом IndexOf, если элемент не найден в HashSlice.

const NoneIndex = -1

Variables

Ошибки, возвращаемые при работе с HashSlice.

var (
    // AlreadyExistsError возникает при попытке добавить уже существующий элемент.
    // HashSlice гарантирует уникальность элементов, повторное добавление запрещено.
    AlreadyExistsError = errors.New("already exists")

    // OutOfRangeError возникает при попытке доступа к элементу по индексу,
    // выходящему за пределы допустимого диапазона.
    OutOfRangeError = errors.New("out of range")
)

type HashSlice

HashSlice представляет собой структуру данных, сочетающую слайс и хэш-таблицу. Сохраняет порядок добавления элементов, обеспечивает быстрый поиск по значению и гарантирует уникальность всех элементов.

Внутренняя реализация:

• Слайс items хранит элементы в порядке добавления
• Linker хранит отображение элемент -> индекс для быстрого поиска

Тип T должен быть сравниваемым (comparable).

type HashSlice[T comparable] struct {
    // contains filtered or unexported fields
}

func NewHashSlice

func NewHashSlice[T comparable]() *HashSlice[T]

NewHashSlice создаёт пустой HashSlice.

Пример:

hs := NewHashSlice[string]()
hs.Add("hello")
hs.Add("world")

func NewHashSliceFrom

func NewHashSliceFrom[T comparable](items ...T) (*HashSlice[T], error)

NewHashSliceFrom создаёт новый HashSlice и заполняет его переданными элементами. Если среди переданных элементов есть дубликаты, возвращает ошибку AlreadyExistsError.

Пример:

hs, err := NewHashSliceFrom("apple", "banana", "cherry")
if err != nil {
    log.Fatal(err)
}

hs, err := NewHashSliceFrom(1, 2, 2) // ошибка: элемент 2 уже существует

func (*HashSlice[T]) Add

func (hs *HashSlice[T]) Add(item T) (int, error)

Add добавляет один элемент в конец HashSlice. Возвращает индекс добавленного элемента. Если элемент уже существует, возвращает ошибку AlreadyExistsError.

Пример:

hs := NewHashSlice[string]()
idx, err := hs.Add("apple")
fmt.Println(idx) // 0

_, err = hs.Add("apple") // ошибка: already exists

func (*HashSlice[T]) All

func (hs *HashSlice[T]) All() iter.Seq2[int, T]

All возвращает итератор для обхода всех элементов HashSlice. Реализует интерфейс iter.Seq2, позволяя использовать range в цикле. Возвращает пары (индекс, значение) в порядке добавления элементов.

Пример:

hs, _ := NewHashSliceFrom("apple", "banana", "cherry")
for index, value := range hs.All() {
    fmt.Printf("%d: %s\n", index, value)
}
// Вывод:
// 0: apple
// 1: banana
// 2: cherry

Итерацию можно прервать досрочно:

for index, value := range hs.All() {
    if value == "banana" {
        break
    }
}

func (*HashSlice[T]) Append

func (hs *HashSlice[T]) Append(items ...T) (err error)

Append добавляет несколько элементов в конец HashSlice. Если какой-либо из элементов уже существует, возвращает ошибку AlreadyExistsError.

Пример:

hs := NewHashSlice[string]()
err := hs.Append("apple", "banana", "cherry")
if err != nil {
    log.Fatal(err)
}

func (*HashSlice[T]) Contains

func (hs *HashSlice[T]) Contains(item T) bool

Contains проверяет, содержится ли элемент в HashSlice. Сложность: O(1)

Пример:

hs, _ := NewHashSliceFrom("apple", "banana")
fmt.Println(hs.Contains("apple"))  // true
fmt.Println(hs.Contains("grape"))  // false

func (*HashSlice[T]) GetByIndex

func (hs *HashSlice[T]) GetByIndex(index int) (T, error)

GetByIndex возвращает элемент по индексу. Если индекс выходит за пределы диапазона, возвращает ошибку OutOfRangeError. Сложность: O(1)

Пример:

hs, _ := NewHashSliceFrom("apple", "banana", "cherry")
item, err := hs.GetByIndex(1)
fmt.Println(item) // banana

_, err = hs.GetByIndex(10) // ошибка: out of range

func (*HashSlice[T]) IndexOf

func (hs *HashSlice[T]) IndexOf(item T) int

IndexOf возвращает индекс элемента в HashSlice. Если элемент не найден, возвращает NoneIndex (-1). Сложность: O(1)

Пример:

hs, _ := NewHashSliceFrom("apple", "banana", "cherry")
fmt.Println(hs.IndexOf("banana")) // 1
fmt.Println(hs.IndexOf("grape"))  // -1

func (*HashSlice[T]) Items

func (hs *HashSlice[T]) Items() []T

Items возвращает срез всех элементов в порядке добавления. Возвращаемый срез является ссылкой на внутренние данные — не изменяйте его! Сложность: O(1)

Пример:

hs, _ := NewHashSliceFrom("a", "b", "c")
for _, item := range hs.Items() {
    fmt.Println(item)
}

func (*HashSlice[T]) Len

func (hs *HashSlice[T]) Len() int

Len возвращает количество элементов в HashSlice. Сложность: O(1)

Пример:

hs, _ := NewHashSliceFrom("a", "b", "c")
fmt.Println(hs.Len()) // 3

func (*HashSlice[T]) Remove

func (hs *HashSlice[T]) Remove(item T)

Remove удаляет элемент из HashSlice по его значению. Если элемент не найден, метод ничего не делает. После удаления индексы всех последующих элементов уменьшаются на 1. Сложность: O(n) из-за перестроения индексов

Пример:

hs, _ := NewHashSliceFrom("apple", "banana", "cherry")
hs.Remove("banana")
// теперь hs содержит: ["apple", "cherry"]
fmt.Println(hs.IndexOf("cherry")) // 1 (было 2)

func (*HashSlice[T]) RemoveByIndex

func (hs *HashSlice[T]) RemoveByIndex(index int) (err error)

RemoveByIndex удаляет элемент по индексу. Возвращает ошибку OutOfRangeError, если индекс невалиден. После удаления индексы всех последующих элементов уменьшаются на 1. Сложность: O(n) из-за перестроения индексов

Пример:

hs, _ := NewHashSliceFrom("apple", "banana", "cherry")
err := hs.RemoveByIndex(1) // удаляет "banana"
// теперь hs содержит: ["apple", "cherry"]

func (*HashSlice[T]) Replace

func (hs *HashSlice[T]) Replace(index int, item T) (err error)

Replace заменяет элемент по указанному индексу на новый. Возвращает ошибку, если индекс невалиден или новый элемент уже существует. Сложность: O(1)

Пример:

hs, _ := NewHashSliceFrom("apple", "banana", "cherry")
err := hs.Replace(1, "grape") // заменяет "banana" на "grape"
// теперь hs содержит: ["apple", "grape", "cherry"]

err = hs.Replace(1, "apple") // ошибка: already exists

func (*HashSlice[T]) Reset

func (hs *HashSlice[T]) Reset()

Reset очищает HashSlice, удаляя все элементы. Сложность: O(n)

Пример:

hs, _ := NewHashSliceFrom("apple", "banana", "cherry")
hs.Reset()
fmt.Println(hs.Len()) // 0

Generated by gomarkdoc