_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q172200 | ReadInt32 | validation | func (r *Reader) ReadInt32() int32 {
if r.err != nil {
return 0
}
var n int
n, r.err = io.ReadFull(r.rd, r.b[:4])
r.cnt += n
if r.err != nil {
return 0
}
return int32(binary.LittleEndian.Uint32(r.b[:4]))
} | go | {
"resource": ""
} |
q172201 | ReadUint32 | validation | func (r *Reader) ReadUint32() uint32 {
if r.err != nil {
return 0
}
var n int
n, r.err = io.ReadFull(r.rd, r.b[:4])
r.cnt += n
if r.err != nil {
return 0
}
return binary.LittleEndian.Uint32(r.b[:4])
} | go | {
"resource": ""
} |
q172202 | ReadInt64 | validation | func (r *Reader) ReadInt64() int64 {
if r.err != nil {
return 0
}
var n int
n, r.err = io.ReadFull(r.rd, r.b[:8])
r.cnt += n
if r.err != nil {
return 0
}
return int64(binary.LittleEndian.Uint64(r.b[:8]))
} | go | {
"resource": ""
} |
q172203 | ReadUint64 | validation | func (r *Reader) ReadUint64() uint64 {
if r.err != nil {
return 0
}
var n int
n, r.err = io.ReadFull(r.rd, r.b[:8])
r.cnt += n
if r.err != nil {
return 0
}
return binary.LittleEndian.Uint64(r.b[:8])
} | go | {
"resource": ""
} |
q172204 | ReadFloat32 | validation | func (r *Reader) ReadFloat32() float32 {
if r.err != nil {
return 0
}
var n int
n, r.err = io.ReadFull(r.rd, r.b[:4])
r.cnt += n
if r.err != nil {
return 0
}
bits := binary.LittleEndian.Uint32(r.b[:4])
return math.Float32frombits(bits)
} | go | {
"resource": ""
} |
q172205 | ReadFloat64 | validation | func (r *Reader) ReadFloat64() float64 {
if r.err != nil {
return 0
}
var n int
n, r.err = io.ReadFull(r.rd, r.b[:8])
r.cnt += n
if r.err != nil {
return 0
}
bits := binary.LittleEndian.Uint64(r.b[:8])
return math.Float64frombits(bits)
} | go | {
"resource": ""
} |
q172206 | ReadCesu8 | validation | func (r *Reader) ReadCesu8(size int) []byte {
if r.err != nil {
return nil
}
p := make([]byte, size)
var n int
n, r.err = io.ReadFull(r.rd, p)
r.cnt += n
if r.err != nil {
return nil
}
r.tr.Reset()
if n, _, r.err = r.tr.Transform(p, p, true); r.err != nil { // inplace transformation
return nil
}
retur... | go | {
"resource": ""
} |
q172207 | NewWriter | validation | func NewWriter(w io.Writer) *Writer {
return &Writer{
wr: bufio.NewWriter(w),
b: make([]byte, writerBufferSize),
tr: unicode.Utf8ToCesu8Transformer,
}
} | go | {
"resource": ""
} |
q172208 | NewWriterSize | validation | func NewWriterSize(w io.Writer, size int) *Writer {
return &Writer{
wr: bufio.NewWriterSize(w, size),
b: make([]byte, writerBufferSize),
tr: unicode.Utf8ToCesu8Transformer,
}
} | go | {
"resource": ""
} |
q172209 | Flush | validation | func (w *Writer) Flush() error {
if w.err != nil {
return w.err
}
return w.wr.Flush()
} | go | {
"resource": ""
} |
q172210 | WriteZeroes | validation | func (w *Writer) WriteZeroes(cnt int) {
if w.err != nil {
return
}
// zero out scratch area
l := cnt
if l > len(w.b) {
l = len(w.b)
}
for i := 0; i < l; i++ {
w.b[i] = 0
}
for i := 0; i < cnt; {
j := cnt - i
if j > len(w.b) {
j = len(w.b)
}
n, _ := w.wr.Write(w.b[:j])
if n != j {
return... | go | {
"resource": ""
} |
q172211 | Write | validation | func (w *Writer) Write(p []byte) {
if w.err != nil {
return
}
w.wr.Write(p)
} | go | {
"resource": ""
} |
q172212 | WriteB | validation | func (w *Writer) WriteB(b byte) { // WriteB as sig differs from WriteByte (vet issues)
if w.err != nil {
return
}
w.wr.WriteByte(b)
} | go | {
"resource": ""
} |
q172213 | WriteBool | validation | func (w *Writer) WriteBool(v bool) {
if w.err != nil {
return
}
if v {
w.wr.WriteByte(1)
} else {
w.wr.WriteByte(0)
}
} | go | {
"resource": ""
} |
q172214 | WriteInt8 | validation | func (w *Writer) WriteInt8(i int8) {
if w.err != nil {
return
}
w.wr.WriteByte(byte(i))
} | go | {
"resource": ""
} |
q172215 | WriteInt16 | validation | func (w *Writer) WriteInt16(i int16) {
if w.err != nil {
return
}
binary.LittleEndian.PutUint16(w.b[:2], uint16(i))
w.wr.Write(w.b[:2])
} | go | {
"resource": ""
} |
q172216 | WriteUint32 | validation | func (w *Writer) WriteUint32(i uint32) {
if w.err != nil {
return
}
binary.LittleEndian.PutUint32(w.b[:4], i)
w.wr.Write(w.b[:4])
} | go | {
"resource": ""
} |
q172217 | WriteInt64 | validation | func (w *Writer) WriteInt64(i int64) {
if w.err != nil {
return
}
binary.LittleEndian.PutUint64(w.b[:8], uint64(i))
w.wr.Write(w.b[:8])
} | go | {
"resource": ""
} |
q172218 | WriteFloat32 | validation | func (w *Writer) WriteFloat32(f float32) {
if w.err != nil {
return
}
bits := math.Float32bits(f)
binary.LittleEndian.PutUint32(w.b[:4], bits)
w.wr.Write(w.b[:4])
} | go | {
"resource": ""
} |
q172219 | WriteFloat64 | validation | func (w *Writer) WriteFloat64(f float64) {
if w.err != nil {
return
}
bits := math.Float64bits(f)
binary.LittleEndian.PutUint64(w.b[:8], bits)
w.wr.Write(w.b[:8])
} | go | {
"resource": ""
} |
q172220 | WriteString | validation | func (w *Writer) WriteString(s string) {
if w.err != nil {
return
}
w.wr.WriteString(s)
} | go | {
"resource": ""
} |
q172221 | WriteCesu8 | validation | func (w *Writer) WriteCesu8(p []byte) int {
if w.err != nil {
return 0
}
w.tr.Reset()
cnt := 0
i := 0
for i < len(p) {
m, n, err := w.tr.Transform(w.b, p[i:], true)
if err != nil && err != transform.ErrShortDst {
w.err = err
return cnt
}
if m == 0 {
w.err = transform.ErrShortDst
return cnt
... | go | {
"resource": ""
} |
q172222 | WriteStringCesu8 | validation | func (w *Writer) WriteStringCesu8(s string) int {
return w.WriteCesu8([]byte(s))
} | go | {
"resource": ""
} |
q172223 | DataType | validation | func (k TypeCode) DataType() DataType {
switch k {
default:
return DtUnknown
case tcTinyint:
return DtTinyint
case tcSmallint:
return DtSmallint
case tcInteger:
return DtInteger
case tcBigint:
return DtBigint
case tcReal:
return DtReal
case tcDouble:
return DtDouble
case tcDate, tcTime, tcTimesta... | go | {
"resource": ""
} |
q172224 | Name | validation | func (f *ResultField) Name() string {
return f.fieldNames.name(f.offsets[columnDisplayName])
} | go | {
"resource": ""
} |
q172225 | NewBasicAuthConnector | validation | func NewBasicAuthConnector(host, username, password string) *Connector {
c := newConnector()
c.host = host
c.username = username
c.password = password
return c
} | go | {
"resource": ""
} |
q172226 | Locale | validation | func (c *Connector) Locale() string {
c.mu.RLock()
defer c.mu.RUnlock()
return c.locale
} | go | {
"resource": ""
} |
q172227 | FetchSize | validation | func (c *Connector) FetchSize() int {
c.mu.RLock()
defer c.mu.RUnlock()
return c.fetchSize
} | go | {
"resource": ""
} |
q172228 | Timeout | validation | func (c *Connector) Timeout() int {
c.mu.RLock()
defer c.mu.RUnlock()
return c.timeout
} | go | {
"resource": ""
} |
q172229 | TLSConfig | validation | func (c *Connector) TLSConfig() *tls.Config {
c.mu.RLock()
defer c.mu.RUnlock()
return c.tlsConfig
} | go | {
"resource": ""
} |
q172230 | SetTLSConfig | validation | func (c *Connector) SetTLSConfig(tlsConfig *tls.Config) error {
c.mu.Lock()
defer c.mu.Unlock()
c.tlsConfig = tlsConfig
return nil
} | go | {
"resource": ""
} |
q172231 | SessionVariables | validation | func (c *Connector) SessionVariables() SessionVariables {
c.mu.RLock()
defer c.mu.RUnlock()
return c.sessionVariables
} | go | {
"resource": ""
} |
q172232 | SetSessionVariables | validation | func (c *Connector) SetSessionVariables(sessionVariables SessionVariables) error {
c.mu.Lock()
defer c.mu.Unlock()
c.sessionVariables = sessionVariables
return nil
} | go | {
"resource": ""
} |
q172233 | BasicAuthDSN | validation | func (c *Connector) BasicAuthDSN() string {
values := url.Values{}
if c.locale != "" {
values.Set(DSNLocale, c.locale)
}
if c.fetchSize != 0 {
values.Set(DSNFetchSize, fmt.Sprintf("%d", c.fetchSize))
}
if c.timeout != 0 {
values.Set(DSNTimeout, fmt.Sprintf("%d", c.timeout))
}
return (&url.URL{
Scheme: ... | go | {
"resource": ""
} |
q172234 | Row | validation | func (f *FieldValues) Row(idx int, dest []driver.Value) {
copy(dest, f.values[idx*f.cols:(idx+1)*f.cols])
} | go | {
"resource": ""
} |
q172235 | readShortUtf8 | validation | func readShortUtf8(rd *bufio.Reader) ([]byte, int) {
size := rd.ReadB()
b := rd.ReadCesu8(int(size))
return b, int(size)
} | go | {
"resource": ""
} |
q172236 | NewLob | validation | func NewLob(rd io.Reader, wr io.Writer) *Lob {
return &Lob{rd: rd, wr: wr}
} | go | {
"resource": ""
} |
q172237 | TokenString | validation | func TokenString(tok rune) string {
if s, ok := tokenString[tok]; ok {
return s
}
return fmt.Sprintf("%q", string(tok))
} | go | {
"resource": ""
} |
q172238 | NewScanner | validation | func NewScanner(str string) *Scanner {
s, _ := scannerPool.Get().(*Scanner)
if s == nil {
s = &Scanner{rd: strings.NewReader(str)}
} else {
s.rd.Reset(str)
}
s.ch = -2
s.err = nil
return s
} | go | {
"resource": ""
} |
q172239 | Next | validation | func (s *Scanner) Next() rune {
s.b.Reset()
ch := s.next()
for unicode.IsSpace(ch) {
ch = s.next()
}
tok := ch
switch {
default:
tok = Undefined
ch = s.next()
case ch == EOF:
break
case isOperator(ch):
tok = Operator
ch = s.scanOperator(ch)
case isDelimiter(ch):
tok = Delimiter
s.b.Wr... | go | {
"resource": ""
} |
q172240 | RandomIdentifier | validation | func RandomIdentifier(prefix string) Identifier {
b := make([]byte, 16)
if _, err := io.ReadFull(rand.Reader, b); err != nil {
panic(err.Error()) // rand should never fail
}
return Identifier(fmt.Sprintf("%s%x", prefix, b))
} | go | {
"resource": ""
} |
q172241 | String | validation | func (i Identifier) String() string {
s := string(i)
if reSimple.MatchString(s) {
return s
}
return strconv.Quote(s)
} | go | {
"resource": ""
} |
q172242 | Parse | validation | func Parse(token string) (result [][]byte, e error) {
parts := strings.Split(token, ".")
result = make([][]byte, len(parts))
for i, part := range parts {
if result[i], e = base64url.Decode(part); e != nil {
return nil, e
}
}
return result, nil
} | go | {
"resource": ""
} |
q172243 | Serialize | validation | func Serialize(parts ...[]byte) string {
result := make([]string, len(parts))
for i, part := range parts {
result[i] = base64url.Encode(part)
}
return strings.Join(result, ".")
} | go | {
"resource": ""
} |
q172244 | Align | validation | func Align(data []byte, bitSize int) []byte {
actual:=len(data)
required:=bitSize >> 3
if (bitSize % 8) > 0 {
required++ //extra byte if needed
}
if (actual >= required) {
return data
}
return append(bytes.Repeat([]byte{0}, required-actual), data...)
} | go | {
"resource": ""
} |
q172245 | Xor | validation | func Xor(left, right []byte) []byte {
result := make([]byte, len(left))
for i := 0; i < len(left); i++ {
result[i] = left[i] ^ right[i]
}
return result
} | go | {
"resource": ""
} |
q172246 | Slice | validation | func Slice(arr []byte, count int) [][]byte {
sliceCount := len(arr) / count
result := make([][]byte, sliceCount)
for i := 0; i < sliceCount; i++ {
start := i * count
end := i*count + count
result[i] = arr[start:end]
}
return result
} | go | {
"resource": ""
} |
q172247 | Random | validation | func Random(byteCount int) ([]byte, error) {
data := make([]byte, byteCount)
if _, err := rand.Read(data); err != nil {
return nil, err
}
return data, nil
} | go | {
"resource": ""
} |
q172248 | Concat | validation | func Concat(arrays ...[]byte) []byte {
var result []byte = arrays[0]
for _, arr := range arrays[1:] {
result = append(result, arr...)
}
return result
} | go | {
"resource": ""
} |
q172249 | Unwrap | validation | func Unwrap(arrays [][]byte) []byte {
var result []byte = arrays[0]
for _, arr := range arrays[1:] {
result = append(result, arr...)
}
return result
} | go | {
"resource": ""
} |
q172250 | UInt64ToBytes | validation | func UInt64ToBytes(value uint64) []byte {
result := make([]byte, 8)
binary.BigEndian.PutUint64(result, value)
return result
} | go | {
"resource": ""
} |
q172251 | UInt32ToBytes | validation | func UInt32ToBytes(value uint32) []byte {
result := make([]byte, 4)
binary.BigEndian.PutUint32(result, value)
return result
} | go | {
"resource": ""
} |
q172252 | Dump | validation | func Dump(arr []byte) string {
var buf bytes.Buffer
buf.WriteString("(")
buf.WriteString(fmt.Sprintf("%v", len(arr)))
buf.WriteString(" bytes)[")
for idx, b := range arr {
buf.WriteString(fmt.Sprintf("%v", b))
if idx != len(arr)-1 {
buf.WriteString(", ")
}
}
buf.WriteString("], Hex: [")
for idx, b ... | go | {
"resource": ""
} |
q172253 | Decode | validation | func Decode(data string) ([]byte,error) {
data = strings.Replace(data, "-", "+", -1) // 62nd char of encoding
data = strings.Replace(data, "_", "/", -1) // 63rd char of encoding
switch(len(data) % 4) { // Pad with trailing '='s
case 0: // no padding
case 2: data+="==" // 2 pad chars
case 3: data... | go | {
"resource": ""
} |
q172254 | Encode | validation | func Encode(data []byte) string {
result := base64.StdEncoding.EncodeToString(data)
result = strings.Replace(result, "+", "-", -1) // 62nd char of encoding
result = strings.Replace(result, "/", "_", -1) // 63rd char of encoding
result = strings.Replace(result, "=", "", -1) // Remove any trailing '='s
return res... | go | {
"resource": ""
} |
q172255 | Decode | validation | func Decode(token string, key interface{}) (string, map[string]interface{}, error) {
payload, headers, err := DecodeBytes(token, key)
if err != nil {
return "", nil, err
}
return string(payload), headers, nil
} | go | {
"resource": ""
} |
q172256 | DecodeBytes | validation | func DecodeBytes(token string, key interface{}) ([]byte, map[string]interface{}, error) {
parts, err := compact.Parse(token)
if err != nil {
return nil, nil, err
}
if len(parts) == 3 {
return verify(parts, key)
}
if len(parts) == 5 {
return decrypt(parts, key)
}
return nil, nil, errors.New(fmt.Sprintf... | go | {
"resource": ""
} |
q172257 | DerivePBKDF2 | validation | func DerivePBKDF2(password, salt []byte, iterationCount, keyBitLength int, h hash.Hash) []byte {
prf := hmac.New(func() hash.Hash { return h }, password)
hLen := prf.Size()
dkLen := keyBitLength >> 3 //size of derived key in bytes
l := int(math.Ceil(float64(dkLen) / float64(hLen))) // l = CEIL (dkLen / hLen)
r :... | go | {
"resource": ""
} |
q172258 | ReadPrivate | validation | func ReadPrivate(raw []byte) (key *ecdsa.PrivateKey,err error) {
var encoded *pem.Block
if encoded, _ = pem.Decode(raw); encoded == nil {
return nil, errors.New("Ecc.ReadPrivate(): Key must be PEM encoded PKCS1 or PKCS8 EC private key")
}
var parsedKey interface{}
if parsedKey,err=x509.ParseECPrivateKey(encod... | go | {
"resource": ""
} |
q172259 | ReadPublic | validation | func ReadPublic(raw []byte) (key *rsa.PublicKey,err error) {
var encoded *pem.Block
if encoded, _ = pem.Decode(raw); encoded == nil {
return nil, errors.New("Rsa.NewPublic(): Key must be PEM encoded PKCS1 X509 certificate or PKIX public key")
}
var parsedKey interface{}
var cert *x509.Certificate
if par... | go | {
"resource": ""
} |
q172260 | AddPkcs7 | validation | func AddPkcs7(data []byte, blockSize int) []byte {
var paddingCount int
if paddingCount = blockSize - (len(data) % blockSize);paddingCount == 0 {
paddingCount=blockSize
}
return append(data, bytes.Repeat([]byte{byte(paddingCount)}, paddingCount)...)
} | go | {
"resource": ""
} |
q172261 | RemovePkcs7 | validation | func RemovePkcs7(padded []byte, blockSize int) []byte {
dataLen:=len(padded)
paddingCount:=int(padded[dataLen-1])
if(paddingCount > blockSize || paddingCount <= 0) {
return padded //data is not padded (or not padded correctly), return as is
}
padding := padded[dataLen-paddingCount : dataLen-1]
for _... | go | {
"resource": ""
} |
q172262 | ContainerMetrics | validation | func (c *Consumer) ContainerMetrics(appGuid string, authToken string) ([]*events.ContainerMetric, error) {
envelopes, err := c.ContainerEnvelopes(appGuid, authToken)
if err != nil {
return nil, err
}
messages := make([]*events.ContainerMetric, 0, len(envelopes))
for _, env := range envelopes {
messages = appen... | go | {
"resource": ""
} |
q172263 | SortRecent | validation | func SortRecent(messages []*events.LogMessage) []*events.LogMessage {
sort.Stable(logMessageSlice(messages))
return messages
} | go | {
"resource": ""
} |
q172264 | SortContainerMetrics | validation | func SortContainerMetrics(messages []*events.ContainerMetric) []*events.ContainerMetric {
sort.Sort(containerMetricSlice(messages))
return messages
} | go | {
"resource": ""
} |
q172265 | New | validation | func New(trafficControllerUrl string, tlsConfig *tls.Config, proxy func(*http.Request) (*url.URL, error)) *Consumer {
if proxy == nil {
proxy = http.ProxyFromEnvironment
}
return &Consumer{
trafficControllerUrl: trafficControllerUrl,
debugPrinter: nullDebugPrinter{},
client: &http.Client{
Transpo... | go | {
"resource": ""
} |
q172266 | TailingLogs | validation | func (c *Consumer) TailingLogs(appGuid, authToken string) (<-chan *events.LogMessage, <-chan error) {
return c.tailingLogs(appGuid, authToken, true)
} | go | {
"resource": ""
} |
q172267 | TailingLogsWithoutReconnect | validation | func (c *Consumer) TailingLogsWithoutReconnect(appGuid string, authToken string) (<-chan *events.LogMessage, <-chan error) {
return c.tailingLogs(appGuid, authToken, false)
} | go | {
"resource": ""
} |
q172268 | Stream | validation | func (c *Consumer) Stream(appGuid string, authToken string) (outputChan <-chan *events.Envelope, errorChan <-chan error) {
return c.runStream(appGuid, authToken, true)
} | go | {
"resource": ""
} |
q172269 | StreamWithoutReconnect | validation | func (c *Consumer) StreamWithoutReconnect(appGuid string, authToken string) (<-chan *events.Envelope, <-chan error) {
return c.runStream(appGuid, authToken, false)
} | go | {
"resource": ""
} |
q172270 | Firehose | validation | func (c *Consumer) Firehose(
subscriptionId string,
authToken string,
) (<-chan *events.Envelope, <-chan error) {
return c.firehose(newFirehose(
subscriptionId,
authToken,
))
} | go | {
"resource": ""
} |
q172271 | FirehoseWithoutReconnect | validation | func (c *Consumer) FirehoseWithoutReconnect(
subscriptionId string,
authToken string,
) (<-chan *events.Envelope, <-chan error) {
return c.firehose(newFirehose(
subscriptionId,
authToken,
WithRetry(false),
))
} | go | {
"resource": ""
} |
q172272 | FilteredFirehose | validation | func (c *Consumer) FilteredFirehose(
subscriptionId string,
authToken string,
filter EnvelopeFilter,
) (<-chan *events.Envelope, <-chan error) {
return c.firehose(newFirehose(
subscriptionId,
authToken,
WithEnvelopeFilter(filter),
))
} | go | {
"resource": ""
} |
q172273 | SetOnConnectCallback | validation | func (c *Consumer) SetOnConnectCallback(cb func()) {
c.callbackLock.Lock()
defer c.callbackLock.Unlock()
c.callback = cb
} | go | {
"resource": ""
} |
q172274 | Close | validation | func (c *Consumer) Close() error {
c.connsLock.Lock()
defer c.connsLock.Unlock()
var errStrings []string
if len(c.conns) == 0 {
return errors.New("connection does not exist")
}
for len(c.conns) > 0 {
if err := c.conns[0].close(); err != nil {
errStrings = append(errStrings, err.Error())
}
c.conns = c... | go | {
"resource": ""
} |
q172275 | zpool | validation | func zpool(arg ...string) ([][]string, error) {
c := command{Command: "zpool"}
return c.Run(arg...)
} | go | {
"resource": ""
} |
q172276 | GetZpool | validation | func GetZpool(name string) (*Zpool, error) {
args := zpoolArgs
args = append(args, name)
out, err := zpool(args...)
if err != nil {
return nil, err
}
// there is no -H
out = out[1:]
z := &Zpool{Name: name}
for _, line := range out {
if err := z.parseLine(line); err != nil {
return nil, err
}
}
re... | go | {
"resource": ""
} |
q172277 | Destroy | validation | func (z *Zpool) Destroy() error {
_, err := zpool("destroy", z.Name)
return err
} | go | {
"resource": ""
} |
q172278 | ListZpools | validation | func ListZpools() ([]*Zpool, error) {
args := []string{"list", "-Ho", "name"}
out, err := zpool(args...)
if err != nil {
return nil, err
}
var pools []*Zpool
for _, line := range out {
z, err := GetZpool(line[0])
if err != nil {
return nil, err
}
pools = append(pools, z)
}
return pools, nil
} | go | {
"resource": ""
} |
q172279 | Error | validation | func (e Error) Error() string {
return fmt.Sprintf("%s: %q => %s", e.Err, e.Debug, e.Stderr)
} | go | {
"resource": ""
} |
q172280 | zfs | validation | func zfs(arg ...string) ([][]string, error) {
c := command{Command: "zfs"}
return c.Run(arg...)
} | go | {
"resource": ""
} |
q172281 | GetDataset | validation | func GetDataset(name string) (*Dataset, error) {
out, err := zfs("list", "-Hp", "-o", dsPropListOptions, name)
if err != nil {
return nil, err
}
ds := &Dataset{Name: name}
for _, line := range out {
if err := ds.parseLine(line); err != nil {
return nil, err
}
}
return ds, nil
} | go | {
"resource": ""
} |
q172282 | Clone | validation | func (d *Dataset) Clone(dest string, properties map[string]string) (*Dataset, error) {
if d.Type != DatasetSnapshot {
return nil, errors.New("can only clone snapshots")
}
args := make([]string, 2, 4)
args[0] = "clone"
args[1] = "-p"
if properties != nil {
args = append(args, propsSlice(properties)...)
}
arg... | go | {
"resource": ""
} |
q172283 | Unmount | validation | func (d *Dataset) Unmount(force bool) (*Dataset, error) {
if d.Type == DatasetSnapshot {
return nil, errors.New("cannot unmount snapshots")
}
args := make([]string, 1, 3)
args[0] = "umount"
if force {
args = append(args, "-f")
}
args = append(args, d.Name)
_, err := zfs(args...)
if err != nil {
return ni... | go | {
"resource": ""
} |
q172284 | Mount | validation | func (d *Dataset) Mount(overlay bool, options []string) (*Dataset, error) {
if d.Type == DatasetSnapshot {
return nil, errors.New("cannot mount snapshots")
}
args := make([]string, 1, 5)
args[0] = "mount"
if overlay {
args = append(args, "-O")
}
if options != nil {
args = append(args, "-o")
args = append... | go | {
"resource": ""
} |
q172285 | ReceiveSnapshot | validation | func ReceiveSnapshot(input io.Reader, name string) (*Dataset, error) {
c := command{Command: "zfs", Stdin: input}
_, err := c.Run("receive", name)
if err != nil {
return nil, err
}
return GetDataset(name)
} | go | {
"resource": ""
} |
q172286 | SendSnapshot | validation | func (d *Dataset) SendSnapshot(output io.Writer) error {
if d.Type != DatasetSnapshot {
return errors.New("can only send snapshots")
}
c := command{Command: "zfs", Stdout: output}
_, err := c.Run("send", d.Name)
return err
} | go | {
"resource": ""
} |
q172287 | Destroy | validation | func (d *Dataset) Destroy(flags DestroyFlag) error {
args := make([]string, 1, 3)
args[0] = "destroy"
if flags&DestroyRecursive != 0 {
args = append(args, "-r")
}
if flags&DestroyRecursiveClones != 0 {
args = append(args, "-R")
}
if flags&DestroyDeferDeletion != 0 {
args = append(args, "-d")
}
if flag... | go | {
"resource": ""
} |
q172288 | Rename | validation | func (d *Dataset) Rename(name string, createParent bool, recursiveRenameSnapshots bool) (*Dataset, error) {
args := make([]string, 3, 5)
args[0] = "rename"
args[1] = d.Name
args[2] = name
if createParent {
args = append(args, "-p")
}
if recursiveRenameSnapshots {
args = append(args, "-r")
}
_, err := zfs(a... | go | {
"resource": ""
} |
q172289 | Snapshot | validation | func (d *Dataset) Snapshot(name string, recursive bool) (*Dataset, error) {
args := make([]string, 1, 4)
args[0] = "snapshot"
if recursive {
args = append(args, "-r")
}
snapName := fmt.Sprintf("%s@%s", d.Name, name)
args = append(args, snapName)
_, err := zfs(args...)
if err != nil {
return nil, err
}
ret... | go | {
"resource": ""
} |
q172290 | Rollback | validation | func (d *Dataset) Rollback(destroyMoreRecent bool) error {
if d.Type != DatasetSnapshot {
return errors.New("can only rollback snapshots")
}
args := make([]string, 1, 3)
args[0] = "rollback"
if destroyMoreRecent {
args = append(args, "-r")
}
args = append(args, d.Name)
_, err := zfs(args...)
return err
} | go | {
"resource": ""
} |
q172291 | Children | validation | func (d *Dataset) Children(depth uint64) ([]*Dataset, error) {
args := []string{"list"}
if depth > 0 {
args = append(args, "-d")
args = append(args, strconv.FormatUint(depth, 10))
} else {
args = append(args, "-r")
}
args = append(args, "-t", "all", "-Hp", "-o", dsPropListOptions)
args = append(args, d.Name... | go | {
"resource": ""
} |
q172292 | Diff | validation | func (d *Dataset) Diff(snapshot string) ([]*InodeChange, error) {
args := []string{"diff", "-FH", snapshot, d.Name}[:]
out, err := zfs(args...)
if err != nil {
return nil, err
}
inodeChanges, err := parseInodeChanges(out)
if err != nil {
return nil, err
}
return inodeChanges, nil
} | go | {
"resource": ""
} |
q172293 | msb32 | validation | func msb32(x uint32) int {
pos := 32
temp := x >> 16
if temp != 0 {
pos -= 16
x = temp
}
temp = x >> 8
if temp != 0 {
pos -= 8
x = temp
}
temp = x >> 4
if temp != 0 {
pos -= 4
x = temp
}
temp = x >> 2
if temp != 0 {
pos -= 2
x = temp
}
temp = x >> 1
if temp != 0 {
return pos - 2
}
re... | go | {
"resource": ""
} |
q172294 | msb64 | validation | func msb64(n uint64) int {
if n <= 0 {
return -1
}
var r, v uint
if n >= 1<<32 {
r += 32
v = uint(n >> 32)
} else {
v = uint(n)
}
if v >= 1<<16 {
r += 16
v >>= 16
}
if v >= 1<<8 {
r += 8
v >>= 8
}
if v >= 1<<4 {
r += 4
v >>= 4
}
if v >= 1<<2 {
r += 2
v >>= 2
}
r += v >> 1
return ... | go | {
"resource": ""
} |
q172295 | EncodeAll | validation | func EncodeAll(src []uint32) ([]uint32, error) {
i := 0
dst := make([]uint32, len(src))
j := 0
for {
if i >= len(src) {
break
}
remaining := src[i:]
if canPack(remaining, 1, 28) {
dst[j] = pack28(src[i : i+28])
i += 28
} else if canPack(remaining, 2, 14) {
dst[j] = pack14(src[i : i+14])
i... | go | {
"resource": ""
} |
q172296 | DecodeAll | validation | func DecodeAll(dst, src []uint32) error {
j := 0
for _, v := range src {
sel := v >> 28
if sel >= 9 {
return fmt.Errorf("invalid selector value: %b", sel)
}
selector[sel].unpack(v, dst[j:])
j += selector[sel].n
}
return nil
} | go | {
"resource": ""
} |
q172297 | canPack | validation | func canPack(src []uint32, bits, n int) bool {
if len(src) < n {
return false
}
end := len(src)
if n < end {
end = n
}
max := uint32((2 << uint32(bits-1)) - 1)
for i := 0; i < end; i++ {
if src[i] > max {
return false
}
}
return true
} | go | {
"resource": ""
} |
q172298 | pack28 | validation | func pack28(in []uint32) uint32 {
return in[0] |
in[1]<<1 |
in[2]<<2 |
in[3]<<3 |
in[4]<<4 |
in[5]<<5 |
in[6]<<6 |
in[7]<<7 |
in[8]<<8 |
in[9]<<9 |
in[10]<<10 |
in[11]<<11 |
in[12]<<12 |
in[13]<<13 |
in[14]<<14 |
in[15]<<15 |
in[16]<<16 |
in[17]<<17 |
in[18]<<18 |
in[19]<<19 |
i... | go | {
"resource": ""
} |
q172299 | pack14 | validation | func pack14(in []uint32) uint32 {
return 1<<28 |
in[0] |
in[1]<<2 |
in[2]<<4 |
in[3]<<6 |
in[4]<<8 |
in[5]<<10 |
in[6]<<12 |
in[7]<<14 |
in[8]<<16 |
in[9]<<18 |
in[10]<<20 |
in[11]<<22 |
in[12]<<24 |
in[13]<<26
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.