github.com/cilium/statedb@v0.3.2/index/int.go (about)

     1  // SPDX-License-Identifier: Apache-2.0
     2  // Copyright Authors of Cilium
     3  
     4  package index
     5  
     6  import (
     7  	"encoding/binary"
     8  	"strconv"
     9  )
    10  
    11  // The indexing functions on integers should use big-endian encoding.
    12  // This allows prefix searching on integers as the most significant
    13  // byte is first.
    14  // For example to find 16-bit key larger than 260 (0x0104) from 3 (0x0003)
    15  // and 270 (0x0109)
    16  //   00 (3) < 01 (260) => skip,
    17  //   01 (270) >= 01 (260) => 09 > 04 => found!
    18  
    19  func Int(n int) Key {
    20  	return Int32(int32(n))
    21  }
    22  
    23  func IntString(s string) (Key, error) {
    24  	return Int32String(s)
    25  }
    26  
    27  func Int64(n int64) Key {
    28  	return Uint64(uint64(n))
    29  }
    30  
    31  func Int64String(s string) (Key, error) {
    32  	n, err := strconv.ParseInt(s, 10, 64)
    33  	if err != nil {
    34  		return Key{}, err
    35  	}
    36  	return Uint64(uint64(n)), nil
    37  }
    38  
    39  func Int32(n int32) Key {
    40  	return Uint32(uint32(n))
    41  }
    42  
    43  func Int32String(s string) (Key, error) {
    44  	n, err := strconv.ParseInt(s, 10, 32)
    45  	if err != nil {
    46  		return Key{}, err
    47  	}
    48  	return Uint32(uint32(n)), nil
    49  }
    50  
    51  func Int16(n int16) Key {
    52  	return Uint16(uint16(n))
    53  }
    54  
    55  func Int16String(s string) (Key, error) {
    56  	n, err := strconv.ParseInt(s, 10, 16)
    57  	if err != nil {
    58  		return Key{}, err
    59  	}
    60  	return Uint16(uint16(n)), nil
    61  }
    62  
    63  func Uint64(n uint64) Key {
    64  	return binary.BigEndian.AppendUint64(nil, n)
    65  }
    66  
    67  func Uint64String(s string) (Key, error) {
    68  	n, err := strconv.ParseUint(s, 10, 64)
    69  	if err != nil {
    70  		return Key{}, err
    71  	}
    72  	return Uint64(n), nil
    73  }
    74  
    75  func Uint32(n uint32) Key {
    76  	return binary.BigEndian.AppendUint32(nil, n)
    77  }
    78  
    79  func Uint32String(s string) (Key, error) {
    80  	n, err := strconv.ParseUint(s, 10, 32)
    81  	if err != nil {
    82  		return Key{}, err
    83  	}
    84  	return Uint32(uint32(n)), nil
    85  }
    86  
    87  func Uint16(n uint16) Key {
    88  	return binary.BigEndian.AppendUint16(nil, n)
    89  }
    90  
    91  func Uint16String(s string) (Key, error) {
    92  	n, err := strconv.ParseUint(s, 10, 16)
    93  	if err != nil {
    94  		return Key{}, err
    95  	}
    96  	return Uint16(uint16(n)), nil
    97  }