util

package main

import (
	"fmt"
	"log"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	const (
		encValue = "zz"       // Base58 encoded of value 3363
		expect   = uint(3363) // unsigned expect value
	)

	// Decode to uint
	actual, err := util.Base58ToUInt(encValue)
	if err != nil {
		log.Fatal(err)
	}

	if expect == actual {
		fmt.Println("it is a valid checksum!")
	}

}

Output:

it is a valid checksum!

package main

import (
	"fmt"
	"log"
	"os"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	pathDirToMove := "/tmp"

	// Move working directory and defer switch back the diretory
	funcReturn := util.ChDir(pathDirToMove)
	defer funcReturn()

	pathDirCurrent, err := os.Getwd()
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(pathDirCurrent)
}

Output:

/tmp

package main

import (
	"fmt"
	"log"
	"os"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	// Move to current user home dir and defer moving back to original
	funcReturn := util.ChDirHome()
	defer funcReturn()

	/* Get dir infos to check if the current dir is user's home */
	pathDirHome, err := os.UserHomeDir()
	if err != nil {
		log.Fatal(err)
	}

	pathDirCurr, err := os.Getwd()
	if err != nil {
		log.Fatal(err)
	}

	// Assert
	if pathDirCurr == pathDirHome {
		fmt.Println("moved to user's home dir")
	} else {
		log.Fatalf("failed to move dir. Home: %v, Current: %v", pathDirHome, pathDirCurr)
	}

}

Output:

moved to user's home dir

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	// Bytes in big endian
	input := []byte{0, 0, 0, 0, 0, 0, 48, 57} // = uint64(12345)

	resultUint64 := util.ConvBytes2Uint(input)
	fmt.Println(resultUint64)

	// To convert uint64 to []byte use ConvUint2Bytes().
	resultByteSlice := util.ConvUint2Bytes(resultUint64)
	fmt.Println(resultByteSlice)

}

Output:

12345
[48 57]

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	input := uint(12345) // 0x30 0x39

	resultByteSlice := util.ConvUint2Bytes(input)

	fmt.Println(resultByteSlice)
	fmt.Printf("%#v\n", resultByteSlice)

	resultUint64 := util.ConvBytes2Uint(resultByteSlice)
	fmt.Println(resultUint64)

}

Output:

[48 57]
[]byte{0x30, 0x39}
12345

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	input := -123456789

	resultByteSlice := util.ConvUint2Bytes(uint(input)) // note the uint conversion
	resultUint64 := util.ConvBytes2Uint(resultByteSlice)

	fmt.Println(input)
	fmt.Println(int64(resultUint64)) // note the int64
}

Output:

-123456789
-123456789

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"path/filepath"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	// Get file paths to copy from and to
	from := getPathFileToCopyFrom()
	to := getPathFileToCopyTo()

	// Copy file
	if err := util.CopyFile(from, to); err != nil {
		log.Fatal(err)
	}

	// Read copied contents for testing
	contByte, err := ioutil.ReadFile(to)
	if err != nil {
		log.Fatal(err)
	}

	// Require Equal
	expect := "This is a dummy text at /testdata/dummy.txt.\n"

	if actual := string(contByte); expect != actual {
		log.Fatalf("output file does not match to input.\nexpect: %vactual: %v", expect, actual)
	}

	fmt.Println("ok")

	// Clean up copied file
	if err = os.RemoveAll(to); err != nil {
		log.Fatal(err)
	}

}

func getPathFileToCopyFrom() string {
	return filepath.Join(util.GetPathDirRepo(), "testdata", "dummy.txt")
}

func getPathFileToCopyTo() string {
	pathDirTemp := os.TempDir()
	nameFileTemp := util.RandStr(32) + ".txt"

	return filepath.Join(pathDirTemp, nameFileTemp)
}

Output:

ok

package main

import (
	"fmt"
	"log"
	"os"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	// Create temp file under temp dir with the name "foo-*.json"
	p, err := util.CreateTemp("", "foo-*.json")
	if err != nil {
		log.Fatalf("%v", err)
	}
	defer p.Close() // Don't forget to close it

	pathSaved := p.Name() // Get the file path

	// Do  something with the file
	if util.IsFile(pathSaved) {
		fmt.Println("file exists")
	}

	// Clean up the temp file
	os.Remove(pathSaved)

	if !util.IsFile(pathSaved) {
		fmt.Println("temp file cleaned")
	}

}

Output:

file exists
temp file cleaned

package main

import (
	"fmt"
	"log"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	input := "abcdefg"

	// Encode
	encoded, err := util.EncodeBase58([]byte(input))
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Encoded:", encoded)

	// Decode
	decoded, err := util.DecodeBase58(encoded)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Decoded:", string(decoded))

}

Output:

Encoded: 4h3c6xC6Mc
Decoded: abcdefg

package main

import (
	"fmt"
	"log"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	input := "abcdefg"

	result, err := util.EncodeBase58([]byte(input))
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(result)
}

Output:

4h3c6xC6Mc

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
	"github.com/pkg/errors"
)

func main() {
	/*
		Example to mock OsExit in ExitOnErr
	*/
	// Backup and defer restoration
	oldOsExit := util.OsExit
	defer func() {
		util.OsExit = oldOsExit
	}()

	// Mock OsExit
	util.OsExit = func(code int) {
		fmt.Println("the exit code was:", code)
	}

	// Create error
	err := errors.New("foo")

	util.ExitOnErr(err)

}

Output:

the exit code was: 1

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	data := struct {
		Foo string `json:"foo" mapstructure:"foo"`
	}{
		Foo: "bar",
	}

	prettyJSON := util.FmtStructPretty(data)

	fmt.Println(prettyJSON)
}

Output:

{
  "foo": "bar"
}

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	data := []string{
		"foo",
		"bar",
	}

	prettyJSON := util.FmtStructPretty(data)

	fmt.Println(prettyJSON)
}

Output:

[
  "foo",
  "bar"
]

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	fmt.Printf("%b\n", util.GenMask(0))
	fmt.Printf("%b\n", util.GenMask(1))
	fmt.Printf("%b\n", util.GenMask(2))
	fmt.Printf("%b\n", util.GenMask(4))
	fmt.Printf("%b\n", util.GenMask(11))
	fmt.Printf("%b\n", util.GenMask(64))
	fmt.Printf("%b\n", util.GenMask(65))   // Max is 64
	fmt.Printf("%b\n", util.GenMask(1024)) // Max is 64

}

Output:

0
1
11
1111
11111111111
1111111111111111111111111111111111111111111111111111111111111111
1111111111111111111111111111111111111111111111111111111111111111
1111111111111111111111111111111111111111111111111111111111111111

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	listMods := util.GetMods()

	for _, modInfo := range listMods {
		fmt.Println(modInfo["name"])
		fmt.Println(modInfo["path"])
		fmt.Println(modInfo["version"])
	}
}

Output:

a
n/a
n/a

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	nameBin := util.GetNameBin()

	fmt.Println(nameBin)

}

Output:

util.test

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	pathDir, cleanup := util.GetTempDir()
	defer cleanup()

	if util.IsDir(pathDir) {
		fmt.Println("directory exists")
	}
}

Output:

directory exists

package main

import (
	"fmt"
	"log"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	input := "foo"
	lenHash := 16

	hashed, err := util.HashBLAKE3(input, lenHash)
	if err != nil {
		// Do something with the error
		log.Fatalf("failed to hash: %v", err)
	}

	fmt.Println("Hashed value:", hashed)
	fmt.Println("Length:", len(hashed))
}

Output:

Hashed value: 7STCqaLBnDB6EKXi
Length: 16

package main

import (
	"fmt"
	"log"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	data := struct {
		Foo string
		Bar int
	}{
		Foo: "hoge fuga",
		Bar: 1,
	}

	hash1, err := util.HashStruct(data, 16) // 16 char length
	if err != nil {
		log.Fatalf("hash error: %v", err)
	}

	fmt.Println("Hash value before change:", hash1)

	data.Bar = 2 // Change value

	hash2, err := util.HashStruct(data, 16) // 16 char length
	if err != nil {
		log.Fatalf("hash error: %v", err)
	}

	fmt.Println("Hash value after change :", hash2)

}

Output:

Hash value before change: 4KcWDdX1qXnGBV4U
Hash value after change : 6aESjhTWhk3Tv91h

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	msg := util.HereDoc(`
        Here Title
            Here description
	`)

	fmt.Println(msg)

}

Output:

Here Title
    Here description

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	input := `
        Here Title
            Here description
`
	indent := "> " // prefix of each line

	fmt.Println(util.HereDoc(input, indent))

}

Output:

> Here Title
>     Here description
>

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	// Existing dir
	if util.IsDir("../testdata/sample_data") {
		fmt.Println("is dir")
	}

	// Not existing dir
	if !util.IsDir("./foobar") {
		fmt.Println("not a dir")
	}

	// File exists but not a dir
	if !util.IsDir("./IsDir_test.go") {
		fmt.Println("not a dir")
	}

}

Output:

is dir
not a dir
not a dir

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	fmt.Println(util.IsFile("./IsFile_test.go"))
	fmt.Println(util.IsFile("./non-existing-file.txt"))
	fmt.Println(util.IsFile("../util")) // Existing but is a dir

}

Output:

true
false
false

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	if target := "/foo/bar/buz.json"; util.IsNameFileJSON(target) {
		fmt.Println(target, "is a JSON file")
	}

}

Output:

/foo/bar/buz.json is a JSON file

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	fmt.Println(util.PathExists("./PathExists_test.go"))
	fmt.Println(util.PathExists("../util"))
	fmt.Println(util.PathExists("./non-existing"))

}

Output:

true
true
false

package main

import (
	"fmt"
	"log"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	length := 16

	for i := 0; i < 1000; i++ {
		h1 := util.RandStr(length)
		h2 := util.RandStr(length)

		if h1 == h2 {
			log.Fatalf("the result did collide\nh1: %v\nh2: %v\n", h1, h2)
		}
	}

	fmt.Println("ok")
}

Output:

ok

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	input := "foo bar"
	sum8 := uint(0b11111111) // 8bit mask = 255 = checksum between 1-255

	checksum := util.SUM(sum8, input)
	fmt.Printf("%d (0x%x, %T)\n", checksum, checksum, checksum)

}

Output:

156 (0x9c, uint)

package main

import (
	"fmt"
	"log"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	const (
		input     = "foo bar"
		sumBase58 = uint(3363) // 3363 is the max number of 2 digit Base58 = "zz"
	)

	// Create checksum
	checksum := util.SUM(sumBase58, input)
	fmt.Printf("Checksum: %v (0x%x, 0b%b, %T)\n", checksum, checksum, checksum, checksum)

	// Encode to Base58
	enc, err := util.UIntToBase58(checksum)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Base58 encoded: %v (%T)\n", enc, enc)
}

Output:

Checksum: 666 (0x29a, 0b1010011010, uint)
Base58 encoded: CV (string)

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	input := util.RandStr(1024) // 1024 char length random string

	sum8 := uint(255) // checksum for max 8bit = 0b11111111 = 0d255

	checksum := util.SUM(sum8, input)

	// Verify
	if util.VerifySUM(sum8, input, checksum) {
		fmt.Print("verify success! checksum of the input is valid")
	}

}

Output:

verify success! checksum of the input is valid

package main

import (
	"fmt"
	"log"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	// In base58(BTC), zero becomes "1". See EncodeBase58().
	inputZero := uint(0)
	if encZero, err := util.UIntToBase58(inputZero); err != nil {
		log.Fatal(err)
	} else {
		fmt.Println(encZero) // note that the result is in 2 digit -> "11"
	}

	inputTen := uint(10)
	if encTen, err := util.UIntToBase58(inputTen); err != nil {
		log.Fatal(err)
	} else {
		fmt.Println(encTen)
	}

	inputHuge := uint(123456789)
	if encHuge, err := util.UIntToBase58(inputHuge); err != nil {
		log.Fatal(err)
	} else {
		fmt.Println(encHuge)
	}

}

Output:

11
1B
BukQL

This function is used when you need a more accurate checksum in 2 digit string.

package main

import (
	"fmt"
	"log"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	input := uint(3363) // 3363 is the max value of 2 digit Base58 "zz"

	// Encode the checksum to Base58 as a string
	enc, err := util.UIntToBase58(input)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Encoded checksum: %v (%T)", enc, enc)

}

Output:

Encoded checksum: zz (string)

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	data := []string{
		"one",
		"one",
		"two",
		"two",
		"three",
		"three",
	}
	fmt.Println(util.UniqSliceString(data))
}

Output:

[one two three]

package main

import (
	"fmt"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	const (
		input  = "abcdefghijk"    // target data
		bitLen = uint(0b11111111) // 0b11111111 = 255
	)

	// Create checksum between 1-255
	checksum := util.SUM(bitLen, input)
	fmt.Printf("Checksum is: %v (0b%b)\n", checksum, checksum)

	// Verify
	if util.VerifySUM(bitLen, input, checksum) {
		fmt.Println("Check result: ok")
	} else {
		fmt.Println("Check result: ng")
	}

}

Output:

Checksum is: 103 (0b1100111)
Check result: ok

package main

import (
	"fmt"
	"log"

	"github.com/KEINOS/go-utiles/util"
)

func main() {
	data := "foo bar"

	pathFile, deferCleanUp, err := util.WriteTmpFile(data)
	if err != nil {
		log.Fatal(err)
	}

	defer deferCleanUp()

	read, err := util.ReadFile(pathFile)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(string(read))
}

Output:

foo bar