utils

type Any ¶

type Any interface {
	any
}

Any represents any type

type Comparable ¶

type Comparable interface {
	comparable
}

Comparable represents all comparable types

type ExampleStruct ¶

type ExampleStruct struct {
	ID       int                    `json:"id" xml:"id"`
	Name     string                 `json:"name" xml:"name"`
	Tags     []string               `json:"tags" xml:"tags"`
	Metadata map[string]interface{} `json:"metadata" xml:"metadata"`
}

Example usage types

type GobSerializer ¶

type GobSerializer struct{}

GobSerializer implements Gob serialization

func (s GobSerializer) Deserialize(data []byte, v interface{}) error

func (s GobSerializer) Serialize(v interface{}) ([]byte, error)

type Iterator ¶

type Iterator[T any] interface {
	HasNext() bool
	Next() T
	Reset()
}

Iterator interface defines the basic iterator operations

type JSONSerializer ¶

type JSONSerializer struct {
	PrettyPrint bool
}

JSONSerializer implements JSON serialization

func (s JSONSerializer) Deserialize(data []byte, v interface{}) error

func (s JSONSerializer) Serialize(v interface{}) ([]byte, error)

type LinkedListIterator ¶

type LinkedListIterator[T any] struct {
	// contains filtered or unexported fields
}

LinkedListIterator implements Iterator for linked lists

func NewLinkedListIterator[T any](head *Node[T]) *LinkedListIterator[T]

func (it *LinkedListIterator[T]) HasNext() bool

func (it *LinkedListIterator[T]) Next() T

func (it *LinkedListIterator[T]) Reset()

type MapIterator ¶

type MapIterator[K comparable, V any] struct {
	// contains filtered or unexported fields
}

MapIterator implements Iterator for maps

func NewMapIterator[K comparable, V any](data map[K]V, keyOrder func([]K)) *MapIterator[K, V]

func (it *MapIterator[K, V]) HasNext() bool

func (it *MapIterator[K, V]) Next() (K, V)

func (it *MapIterator[K, V]) Reset()

type Node ¶

type Node[T any] struct {
	Value T
	Next  *Node[T]
}

ArrayToLinkedList converts an array to a singly linked list

func ArrayToLinkedList[T any](arr []T) *Node[T]

type Numeric ¶

type Numeric interface {
	constraints.Integer | constraints.Float
}

Numeric represents all numeric types

type Ordered ¶

type Ordered interface {
	constraints.Ordered
}

Ordered represents all ordered types

type SerializationFormat ¶

type SerializationFormat string

SerializationFormat represents supported serialization formats

const (
	FormatJSON SerializationFormat = "json"
	FormatXML  SerializationFormat = "xml"
	FormatGOB  SerializationFormat = "gob"
)

type SerializationHelper ¶

type SerializationHelper struct {
	Format      SerializationFormat
	PrettyPrint bool
}

SerializationHelper provides helper methods for common serialization tasks

func NewSerializationHelper(format SerializationFormat, prettyPrint bool) *SerializationHelper

func (h *SerializationHelper) Deserialize(data string, v interface{}) error

func (h *SerializationHelper) Serialize(v interface{}) (string, error)

type Serializer ¶

type Serializer interface {
	Serialize(v interface{}) ([]byte, error)
	Deserialize(data []byte, v interface{}) error
}

Serializer interface defines methods for serialization and deserialization

func GetSerializer(format SerializationFormat, prettyPrint bool) (Serializer, error)

type SliceIterator ¶

type SliceIterator[T any] struct {
	// contains filtered or unexported fields
}

SliceIterator implements Iterator for slices

func NewSliceIterator[T any](data []T) *SliceIterator[T]

func (it *SliceIterator[T]) HasNext() bool

func (it *SliceIterator[T]) Next() T

func (it *SliceIterator[T]) Reset()

type TraversalOrder ¶

type TraversalOrder int

TreeIterator implements Iterator for binary trees with different traversal orders

const (
	PreOrder TraversalOrder = iota
	InOrder
	PostOrder
	LevelOrder
)

type TreeIterator ¶

type TreeIterator[T any] struct {
	// contains filtered or unexported fields
}

func NewTreeIterator[T any](root *TreeNode[T], order TraversalOrder) *TreeIterator[T]

func (it *TreeIterator[T]) HasNext() bool

func (it *TreeIterator[T]) Next() T

func (it *TreeIterator[T]) Reset()

type TreeNode ¶

type TreeNode[T any] struct {
	Value T
	Left  *TreeNode[T]
	Right *TreeNode[T]
}

ArrayToBinaryTree converts a level-order array representation to a binary tree

func ArrayToBinaryTree[T any](arr []T) *TreeNode[T]

type XMLSerializer ¶

type XMLSerializer struct {
	PrettyPrint bool
}

XMLSerializer implements XML serialization

func (s XMLSerializer) Deserialize(data []byte, v interface{}) error

func (s XMLSerializer) Serialize(v interface{}) ([]byte, error)