162 lines
4.3 KiB
Go
162 lines
4.3 KiB
Go
|
|
|
|
package common
|
|
|
|
|
|
import "encoding/binary"
|
|
import "fmt"
|
|
|
|
|
|
|
|
|
|
func PrepareKeyToString (_namespace string, _key uint64) (string, error) {
|
|
if _key_0, _error := PrepareKey (_namespace, _key); _error == nil {
|
|
return EncodeKeyToString (_namespace, _key_0)
|
|
} else {
|
|
return "", _error
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
func EncodeKeyToString (_namespace string, _key uint64) (string, error) {
|
|
var _buffer [8]byte
|
|
if _error := EncodeKeyToBytes_0 (_namespace, _key, _buffer[:]); _error == nil {
|
|
return string (_buffer[:]), nil
|
|
} else {
|
|
return "", _error
|
|
}
|
|
}
|
|
|
|
|
|
func EncodeKeyToBytes (_namespace string, _key uint64) ([]byte, error) {
|
|
_buffer := make ([]byte, 8)
|
|
_error := EncodeKeyToBytes_0 (_namespace, _key, _buffer)
|
|
return _buffer, _error
|
|
}
|
|
|
|
|
|
func EncodeKeyToBytes_0 (_namespace string, _key uint64, _buffer []byte) (error) {
|
|
if len (_buffer) != 8 {
|
|
return fmt.Errorf ("[890eef13] invalid key buffer length!")
|
|
}
|
|
_prefix := KeyNamespacePrefix (_namespace)
|
|
if _prefix == 0 {
|
|
return fmt.Errorf ("[8c6ba154] invalid key namespace `%s`!", _namespace)
|
|
}
|
|
_keyPrefix := byte (_key >> 56)
|
|
if _keyPrefix != _prefix {
|
|
return fmt.Errorf ("[85a5c362] invalid key prefix `%0x` for `%d`!", _key, _keyPrefix)
|
|
}
|
|
if (_key << 8) == 0 {
|
|
return fmt.Errorf ("[c8fa7817] invalid key zero!")
|
|
}
|
|
binary.BigEndian.PutUint64 (_buffer, _key)
|
|
return nil
|
|
}
|
|
|
|
|
|
|
|
|
|
func PrepareKey (_namespace string, _key uint64) (uint64, error) {
|
|
if _key == 0 {
|
|
return 0, fmt.Errorf ("[355f64d0] invalid key zero!")
|
|
}
|
|
if _key >= (1 << 24) {
|
|
return 0, fmt.Errorf ("[aba09b4d] invalid key value `%d`!", _key)
|
|
}
|
|
_prefix := KeyNamespacePrefix (_namespace)
|
|
if _prefix == 0 {
|
|
return 0, fmt.Errorf ("[feece73b] invalid key namespace `%s`!", _namespace)
|
|
}
|
|
_keyString := fmt.Sprintf ("%08x", _key)
|
|
_keyBytes := []byte (_keyString)
|
|
_keyBytes[0] = _prefix
|
|
_keyValue := binary.BigEndian.Uint64 (_keyBytes)
|
|
return _keyValue, nil
|
|
}
|
|
|
|
|
|
|
|
|
|
func KeyNamespacePrefix (_namespace string) (byte) {
|
|
switch _namespace {
|
|
case NamespaceFilesContent : return NamespaceFilesContentPrefix
|
|
case NamespaceFilesIndex : return NamespaceFilesIndexPrefix
|
|
case NamespaceFoldersContent : return NamespaceFoldersContentPrefix
|
|
case NamespaceFoldersIndex : return NamespaceFoldersIndexPrefix
|
|
case NamespaceRedirectsContent : return NamespaceRedirectsContentPrefix
|
|
case NamespaceRedirectsIndex : return NamespaceRedirectsIndexPrefix
|
|
case NamespaceDataContent : return NamespaceDataContentPrefix
|
|
case NamespaceDataMetadata : return NamespaceDataMetadataPrefix
|
|
case NamespaceHeaderName : return NamespaceHeaderNamePrefix
|
|
case NamespaceHeaderValue : return NamespaceHeaderValuePrefix
|
|
default : return '0'
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
func EncodeKeysPairToString (_namespace1 string, _key1 uint64, _namespace2 string, _key2 uint64) (string, error) {
|
|
var _buffer [16]byte
|
|
if _error := EncodeKeysPairToBytes_0 (_namespace1, _key1, _namespace2, _key2, _buffer[:]); _error == nil {
|
|
return string (_buffer[:]), nil
|
|
} else {
|
|
return "", _error
|
|
}
|
|
}
|
|
|
|
|
|
func EncodeKeysPairToBytes_0 (_namespace1 string, _key1 uint64, _namespace2 string, _key2 uint64, _buffer []byte) (error) {
|
|
if len (_buffer) != 16 {
|
|
return fmt.Errorf ("[c6f09bfb] invalid keys buffer length!")
|
|
}
|
|
if _error := EncodeKeyToBytes_0 (_namespace1, _key1, _buffer[0:8]); _error != nil {
|
|
return _error
|
|
}
|
|
if _error := EncodeKeyToBytes_0 (_namespace2, _key2, _buffer[8:16]); _error != nil {
|
|
return _error
|
|
}
|
|
return nil
|
|
}
|
|
|
|
|
|
|
|
|
|
func DecodeKeysPair (_buffer []byte) (uint64, uint64, error) {
|
|
if len (_buffer) != 16 {
|
|
return 0, 0, fmt.Errorf ("[dd6ba461] invalid key buffer length!")
|
|
}
|
|
_key1 := binary.BigEndian.Uint64 (_buffer[0:8])
|
|
_key2 := binary.BigEndian.Uint64 (_buffer[8:16])
|
|
return _key1, _key2, nil
|
|
}
|
|
|
|
|
|
func DecodeKey (_namespace string, _buffer []byte) (uint64, error) {
|
|
if len (_buffer) != 8 {
|
|
return 0, fmt.Errorf ("[5096a85e] invalid key buffer length!")
|
|
}
|
|
_prefix := KeyNamespacePrefix (_namespace)
|
|
if _prefix == 0 {
|
|
return 0, fmt.Errorf ("[7fcffef8] invalid key namespace `%s`!", _namespace)
|
|
}
|
|
_key := DecodeKey_9 (_buffer)
|
|
_keyPrefix := byte (_key >> 56)
|
|
if _keyPrefix != _prefix {
|
|
return 0, fmt.Errorf ("[a8a94763] invalid key prefix `%0x` for `%d`!", _key, _keyPrefix)
|
|
}
|
|
if (_key << 8) == 0 {
|
|
return 0, fmt.Errorf ("[481159b4] invalid key zero!")
|
|
}
|
|
return _key, nil
|
|
}
|
|
|
|
|
|
func DecodeKey_9 (_buffer []byte) (uint64) {
|
|
_key := binary.BigEndian.Uint64 (_buffer)
|
|
return _key
|
|
}
|
|
|