Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/valdotle/bit
go module for basic bit operations on bitfields allowing various input type combinations
https://github.com/valdotle/bit
bit bitfield go golang
Last synced: 2 days ago
JSON representation
go module for basic bit operations on bitfields allowing various input type combinations
- Host: GitHub
- URL: https://github.com/valdotle/bit
- Owner: valdotle
- License: mit
- Created: 2023-10-02T15:15:25.000Z (over 1 year ago)
- Default Branch: main
- Last Pushed: 2023-10-02T22:02:27.000Z (over 1 year ago)
- Last Synced: 2023-10-04T00:34:32.265Z (over 1 year ago)
- Topics: bit, bitfield, go, golang
- Language: Go
- Homepage:
- Size: 7.81 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: readme.md
- License: LICENSE
Awesome Lists containing this project
README
[](https://github.com/valdotle/bit)
[](https://godoc.org/github.com/valdotle/bit)
[](https://goreportcard.com/report/github.com/valdotle/bit)
[](https://github.com/valdotle/bit/blob/main/LICENSE)
[](https://github.com/valdotle/bit/tags/)
Module **bit** comes with a variety of utility functions for use with **bitfields**.
The module offers functionality for use with go built-in types (`string`, `int` and `big.Int`) as well as aliases for these types to use methods instead.
The module exposes variations of the following functions:
```go
Has() bool // whether a bitfield includes the flag specified; always only returns a boolean
Add() // add a flag to a bitfield (set corresponding bit to 1 / true)
Flip() // flip a flag's state in a bitfield (flip corresponding bit)
Remove() // remove a flag from a bitfield (set corresponding bit to 0 / false)
```
Note that all functions' (except for `Has()`) return value matches the type of the bitfield. This means, that methods defined on an alias type bitfield return a bitfield of that alias type as well.
The combination of **import path** and function / method **suffix** determines the data type of the bitfield and flag. This is explained in more detail below. **`int` is assumed as the default / most common bitfield type and thus doesn't need to be explicitly specified.** Bitfields of type `string` and `big.Int` are intended to be used where integer limitations are exceeded and **only then**. Since no checks are performed whether a string or bigint passed actually has to be handled as such, all string and bigint related functions **always** use `math/big`'s `big.Int` and thus have a significantly slower performance.
The **import path** determines the type of the bitfield:
```go
import (
"github.com/valdotle/bit/field" // bitfield of type int - Note how it's not "bit/field/int"
stringfield "github.com/valdotle/bit/field/string" // bitfield of type string
"github.com/valdotle/bit/field/big" // bitfield of type big.Int
)
flag := 2
field.Has(9, flag) // false
stringfield.Has("9", flag) // false
big.Has(big.NewInt(9), flag) // false
```
**Methods** are defined at the parent folder of the corresponding function and are implemented as aliases:
```go
import (
"github.com/valdotle/bit" // methods for bitfield of type alias int
"github.com/valdotle/bit/field" // functions for bitfield of type int
)
flag := 2
field.Has(9, flag) // false
bit.Field(9).Has(flag) // false
```
Additionally, function and method name **suffixes** determine the flag's type:
```go
import stringfield "github.com/valdotle/bit/field/string"
field := "9"
stringfield.Has(field, 2) // flag of type int
stringfield.HasString(field, "2") // flag of type string
stringfield.HasBig(field, big.NewInt(2)) // flag of type big.Int
```
Note, that **`int` bitfields don't allow checking against flags of type `string` or `big.Int`** (meaning they don't expose `HasString()` nor `HasBig()`) as those are intended to be used where integer limitations are exceeded and as such can't be parsed as integers anymore.