id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
14,800 | elodina/go-avro | schema.go | ParseSchemaWithRegistry | func ParseSchemaWithRegistry(rawSchema string, schemas map[string]Schema) (Schema, error) {
var schema interface{}
if err := json.Unmarshal([]byte(rawSchema), &schema); err != nil {
schema = rawSchema
}
return schemaByType(schema, schemas, "")
} | go | func ParseSchemaWithRegistry(rawSchema string, schemas map[string]Schema) (Schema, error) {
var schema interface{}
if err := json.Unmarshal([]byte(rawSchema), &schema); err != nil {
schema = rawSchema
}
return schemaByType(schema, schemas, "")
} | [
"func",
"ParseSchemaWithRegistry",
"(",
"rawSchema",
"string",
",",
"schemas",
"map",
"[",
"string",
"]",
"Schema",
")",
"(",
"Schema",
",",
"error",
")",
"{",
"var",
"schema",
"interface",
"{",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"rawSchema",
")",
",",
"&",
"schema",
")",
";",
"err",
"!=",
"nil",
"{",
"schema",
"=",
"rawSchema",
"\n",
"}",
"\n\n",
"return",
"schemaByType",
"(",
"schema",
",",
"schemas",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // ParseSchemaWithRegistry parses a given schema using the provided registry for type lookup.
// Registry will be filled up during parsing.
// May return an error if schema is not parsable or has insufficient information about any type. | [
"ParseSchemaWithRegistry",
"parses",
"a",
"given",
"schema",
"using",
"the",
"provided",
"registry",
"for",
"type",
"lookup",
".",
"Registry",
"will",
"be",
"filled",
"up",
"during",
"parsing",
".",
"May",
"return",
"an",
"error",
"if",
"schema",
"is",
"not",
"parsable",
"or",
"has",
"insufficient",
"information",
"about",
"any",
"type",
"."
] | 0c8185d9a3ba82aeac98db3313a268a5b6df99b5 | https://github.com/elodina/go-avro/blob/0c8185d9a3ba82aeac98db3313a268a5b6df99b5/schema.go#L920-L927 |
14,801 | elodina/go-avro | schema.go | MustParseSchema | func MustParseSchema(rawSchema string) Schema {
s, err := ParseSchema(rawSchema)
if err != nil {
panic(err)
}
return s
} | go | func MustParseSchema(rawSchema string) Schema {
s, err := ParseSchema(rawSchema)
if err != nil {
panic(err)
}
return s
} | [
"func",
"MustParseSchema",
"(",
"rawSchema",
"string",
")",
"Schema",
"{",
"s",
",",
"err",
":=",
"ParseSchema",
"(",
"rawSchema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"s",
"\n",
"}"
] | // MustParseSchema is like ParseSchema, but panics if the given schema cannot be parsed. | [
"MustParseSchema",
"is",
"like",
"ParseSchema",
"but",
"panics",
"if",
"the",
"given",
"schema",
"cannot",
"be",
"parsed",
"."
] | 0c8185d9a3ba82aeac98db3313a268a5b6df99b5 | https://github.com/elodina/go-avro/blob/0c8185d9a3ba82aeac98db3313a268a5b6df99b5/schema.go#L930-L936 |
14,802 | elodina/go-avro | schema.go | getProperties | func getProperties(v map[string]interface{}) map[string]interface{} {
props := make(map[string]interface{})
for name, value := range v {
if !isReserved(name) {
props[name] = value
}
}
return props
} | go | func getProperties(v map[string]interface{}) map[string]interface{} {
props := make(map[string]interface{})
for name, value := range v {
if !isReserved(name) {
props[name] = value
}
}
return props
} | [
"func",
"getProperties",
"(",
"v",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"props",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"for",
"name",
",",
"value",
":=",
"range",
"v",
"{",
"if",
"!",
"isReserved",
"(",
"name",
")",
"{",
"props",
"[",
"name",
"]",
"=",
"value",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"props",
"\n",
"}"
] | // gets custom string properties from a given schema | [
"gets",
"custom",
"string",
"properties",
"from",
"a",
"given",
"schema"
] | 0c8185d9a3ba82aeac98db3313a268a5b6df99b5 | https://github.com/elodina/go-avro/blob/0c8185d9a3ba82aeac98db3313a268a5b6df99b5/schema.go#L1151-L1159 |
14,803 | elodina/go-avro | data_file.go | NewDataFileReader | func NewDataFileReader(filename string, datumReader DatumReader) (*DataFileReader, error) {
buf, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
return newDataFileReaderBytes(buf, datumReader)
} | go | func NewDataFileReader(filename string, datumReader DatumReader) (*DataFileReader, error) {
buf, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
return newDataFileReaderBytes(buf, datumReader)
} | [
"func",
"NewDataFileReader",
"(",
"filename",
"string",
",",
"datumReader",
"DatumReader",
")",
"(",
"*",
"DataFileReader",
",",
"error",
")",
"{",
"buf",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"newDataFileReaderBytes",
"(",
"buf",
",",
"datumReader",
")",
"\n",
"}"
] | // NewDataFileReader creates a new DataFileReader for a given file and using the given DatumReader to read the data from that file.
// May return an error if the file contains invalid data or is just missing. | [
"NewDataFileReader",
"creates",
"a",
"new",
"DataFileReader",
"for",
"a",
"given",
"file",
"and",
"using",
"the",
"given",
"DatumReader",
"to",
"read",
"the",
"data",
"from",
"that",
"file",
".",
"May",
"return",
"an",
"error",
"if",
"the",
"file",
"contains",
"invalid",
"data",
"or",
"is",
"just",
"missing",
"."
] | 0c8185d9a3ba82aeac98db3313a268a5b6df99b5 | https://github.com/elodina/go-avro/blob/0c8185d9a3ba82aeac98db3313a268a5b6df99b5/data_file.go#L61-L68 |
14,804 | elodina/go-avro | data_file.go | newDataFileReaderBytes | func newDataFileReaderBytes(buf []byte, datumReader DatumReader) (reader *DataFileReader, err error) {
if len(buf) < len(magic) || !bytes.Equal(magic, buf[0:4]) {
return nil, NotAvroFile
}
dec := NewBinaryDecoder(buf)
blockDecoder := NewBinaryDecoder(nil)
reader = &DataFileReader{
data: buf,
dec: dec,
blockDecoder: blockDecoder,
datum: datumReader,
}
if reader.header, err = readObjFileHeader(dec); err != nil {
return nil, err
}
schema, err := ParseSchema(string(reader.header.Meta[schemaKey]))
if err != nil {
return nil, err
}
reader.datum.SetSchema(schema)
reader.block = &DataBlock{}
if reader.hasNextBlock() {
if err := reader.NextBlock(); err != nil {
return nil, err
}
}
return reader, nil
} | go | func newDataFileReaderBytes(buf []byte, datumReader DatumReader) (reader *DataFileReader, err error) {
if len(buf) < len(magic) || !bytes.Equal(magic, buf[0:4]) {
return nil, NotAvroFile
}
dec := NewBinaryDecoder(buf)
blockDecoder := NewBinaryDecoder(nil)
reader = &DataFileReader{
data: buf,
dec: dec,
blockDecoder: blockDecoder,
datum: datumReader,
}
if reader.header, err = readObjFileHeader(dec); err != nil {
return nil, err
}
schema, err := ParseSchema(string(reader.header.Meta[schemaKey]))
if err != nil {
return nil, err
}
reader.datum.SetSchema(schema)
reader.block = &DataBlock{}
if reader.hasNextBlock() {
if err := reader.NextBlock(); err != nil {
return nil, err
}
}
return reader, nil
} | [
"func",
"newDataFileReaderBytes",
"(",
"buf",
"[",
"]",
"byte",
",",
"datumReader",
"DatumReader",
")",
"(",
"reader",
"*",
"DataFileReader",
",",
"err",
"error",
")",
"{",
"if",
"len",
"(",
"buf",
")",
"<",
"len",
"(",
"magic",
")",
"||",
"!",
"bytes",
".",
"Equal",
"(",
"magic",
",",
"buf",
"[",
"0",
":",
"4",
"]",
")",
"{",
"return",
"nil",
",",
"NotAvroFile",
"\n",
"}",
"\n\n",
"dec",
":=",
"NewBinaryDecoder",
"(",
"buf",
")",
"\n",
"blockDecoder",
":=",
"NewBinaryDecoder",
"(",
"nil",
")",
"\n",
"reader",
"=",
"&",
"DataFileReader",
"{",
"data",
":",
"buf",
",",
"dec",
":",
"dec",
",",
"blockDecoder",
":",
"blockDecoder",
",",
"datum",
":",
"datumReader",
",",
"}",
"\n\n",
"if",
"reader",
".",
"header",
",",
"err",
"=",
"readObjFileHeader",
"(",
"dec",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"schema",
",",
"err",
":=",
"ParseSchema",
"(",
"string",
"(",
"reader",
".",
"header",
".",
"Meta",
"[",
"schemaKey",
"]",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"reader",
".",
"datum",
".",
"SetSchema",
"(",
"schema",
")",
"\n",
"reader",
".",
"block",
"=",
"&",
"DataBlock",
"{",
"}",
"\n\n",
"if",
"reader",
".",
"hasNextBlock",
"(",
")",
"{",
"if",
"err",
":=",
"reader",
".",
"NextBlock",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"reader",
",",
"nil",
"\n",
"}"
] | // separated out mainly for testing currently, will be refactored later for io.Reader paradigm | [
"separated",
"out",
"mainly",
"for",
"testing",
"currently",
"will",
"be",
"refactored",
"later",
"for",
"io",
".",
"Reader",
"paradigm"
] | 0c8185d9a3ba82aeac98db3313a268a5b6df99b5 | https://github.com/elodina/go-avro/blob/0c8185d9a3ba82aeac98db3313a268a5b6df99b5/data_file.go#L71-L103 |
14,805 | elodina/go-avro | data_file.go | NextBlock | func (reader *DataFileReader) NextBlock() error {
blockCount, err := reader.dec.ReadLong()
if err != nil {
return err
}
blockSize, err := reader.dec.ReadLong()
if err != nil {
return err
}
if blockSize > math.MaxInt32 || blockSize < 0 {
return fmt.Errorf("Block size invalid or too large: %d", blockSize)
}
block := reader.block
if block.Data == nil || int64(len(block.Data)) < blockSize {
block.Data = make([]byte, blockSize)
}
block.BlockRemaining = blockCount
block.NumEntries = blockCount
block.BlockSize = int(blockSize)
err = reader.dec.ReadFixedWithBounds(block.Data, 0, int(block.BlockSize))
if err != nil {
return err
}
syncBuffer := make([]byte, syncSize)
err = reader.dec.ReadFixed(syncBuffer)
if err != nil {
return err
}
if !bytes.Equal(syncBuffer, reader.header.Sync) {
return InvalidSync
}
reader.blockDecoder.SetBlock(reader.block)
return nil
} | go | func (reader *DataFileReader) NextBlock() error {
blockCount, err := reader.dec.ReadLong()
if err != nil {
return err
}
blockSize, err := reader.dec.ReadLong()
if err != nil {
return err
}
if blockSize > math.MaxInt32 || blockSize < 0 {
return fmt.Errorf("Block size invalid or too large: %d", blockSize)
}
block := reader.block
if block.Data == nil || int64(len(block.Data)) < blockSize {
block.Data = make([]byte, blockSize)
}
block.BlockRemaining = blockCount
block.NumEntries = blockCount
block.BlockSize = int(blockSize)
err = reader.dec.ReadFixedWithBounds(block.Data, 0, int(block.BlockSize))
if err != nil {
return err
}
syncBuffer := make([]byte, syncSize)
err = reader.dec.ReadFixed(syncBuffer)
if err != nil {
return err
}
if !bytes.Equal(syncBuffer, reader.header.Sync) {
return InvalidSync
}
reader.blockDecoder.SetBlock(reader.block)
return nil
} | [
"func",
"(",
"reader",
"*",
"DataFileReader",
")",
"NextBlock",
"(",
")",
"error",
"{",
"blockCount",
",",
"err",
":=",
"reader",
".",
"dec",
".",
"ReadLong",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"blockSize",
",",
"err",
":=",
"reader",
".",
"dec",
".",
"ReadLong",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"blockSize",
">",
"math",
".",
"MaxInt32",
"||",
"blockSize",
"<",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"blockSize",
")",
"\n",
"}",
"\n\n",
"block",
":=",
"reader",
".",
"block",
"\n",
"if",
"block",
".",
"Data",
"==",
"nil",
"||",
"int64",
"(",
"len",
"(",
"block",
".",
"Data",
")",
")",
"<",
"blockSize",
"{",
"block",
".",
"Data",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"blockSize",
")",
"\n",
"}",
"\n",
"block",
".",
"BlockRemaining",
"=",
"blockCount",
"\n",
"block",
".",
"NumEntries",
"=",
"blockCount",
"\n",
"block",
".",
"BlockSize",
"=",
"int",
"(",
"blockSize",
")",
"\n",
"err",
"=",
"reader",
".",
"dec",
".",
"ReadFixedWithBounds",
"(",
"block",
".",
"Data",
",",
"0",
",",
"int",
"(",
"block",
".",
"BlockSize",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"syncBuffer",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"syncSize",
")",
"\n",
"err",
"=",
"reader",
".",
"dec",
".",
"ReadFixed",
"(",
"syncBuffer",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"!",
"bytes",
".",
"Equal",
"(",
"syncBuffer",
",",
"reader",
".",
"header",
".",
"Sync",
")",
"{",
"return",
"InvalidSync",
"\n",
"}",
"\n",
"reader",
".",
"blockDecoder",
".",
"SetBlock",
"(",
"reader",
".",
"block",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // NextBlock tells this DataFileReader to skip current block and move to next one.
// May return an error if the block is malformed or no more blocks left to read. | [
"NextBlock",
"tells",
"this",
"DataFileReader",
"to",
"skip",
"current",
"block",
"and",
"move",
"to",
"next",
"one",
".",
"May",
"return",
"an",
"error",
"if",
"the",
"block",
"is",
"malformed",
"or",
"no",
"more",
"blocks",
"left",
"to",
"read",
"."
] | 0c8185d9a3ba82aeac98db3313a268a5b6df99b5 | https://github.com/elodina/go-avro/blob/0c8185d9a3ba82aeac98db3313a268a5b6df99b5/data_file.go#L154-L191 |
14,806 | elodina/go-avro | data_file.go | NewDataFileWriter | func NewDataFileWriter(output io.Writer, schema Schema, datumWriter DatumWriter) (writer *DataFileWriter, err error) {
encoder := NewBinaryEncoder(output)
datumWriter.SetSchema(schema)
sync := []byte("1234567890abcdef") // TODO come up with other sync value
header := &objFileHeader{
Magic: magic,
Meta: map[string][]byte{
schemaKey: []byte(schema.String()),
codecKey: []byte("null"),
},
Sync: sync,
}
headerWriter := NewSpecificDatumWriter()
headerWriter.SetSchema(objHeaderSchema)
if err = headerWriter.Write(header, encoder); err != nil {
return
}
blockBuf := &bytes.Buffer{}
writer = &DataFileWriter{
output: output,
outputEnc: encoder,
datumWriter: datumWriter,
sync: sync,
blockBuf: blockBuf,
blockEnc: NewBinaryEncoder(blockBuf),
}
return
} | go | func NewDataFileWriter(output io.Writer, schema Schema, datumWriter DatumWriter) (writer *DataFileWriter, err error) {
encoder := NewBinaryEncoder(output)
datumWriter.SetSchema(schema)
sync := []byte("1234567890abcdef") // TODO come up with other sync value
header := &objFileHeader{
Magic: magic,
Meta: map[string][]byte{
schemaKey: []byte(schema.String()),
codecKey: []byte("null"),
},
Sync: sync,
}
headerWriter := NewSpecificDatumWriter()
headerWriter.SetSchema(objHeaderSchema)
if err = headerWriter.Write(header, encoder); err != nil {
return
}
blockBuf := &bytes.Buffer{}
writer = &DataFileWriter{
output: output,
outputEnc: encoder,
datumWriter: datumWriter,
sync: sync,
blockBuf: blockBuf,
blockEnc: NewBinaryEncoder(blockBuf),
}
return
} | [
"func",
"NewDataFileWriter",
"(",
"output",
"io",
".",
"Writer",
",",
"schema",
"Schema",
",",
"datumWriter",
"DatumWriter",
")",
"(",
"writer",
"*",
"DataFileWriter",
",",
"err",
"error",
")",
"{",
"encoder",
":=",
"NewBinaryEncoder",
"(",
"output",
")",
"\n",
"datumWriter",
".",
"SetSchema",
"(",
"schema",
")",
"\n",
"sync",
":=",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
"// TODO come up with other sync value",
"\n\n",
"header",
":=",
"&",
"objFileHeader",
"{",
"Magic",
":",
"magic",
",",
"Meta",
":",
"map",
"[",
"string",
"]",
"[",
"]",
"byte",
"{",
"schemaKey",
":",
"[",
"]",
"byte",
"(",
"schema",
".",
"String",
"(",
")",
")",
",",
"codecKey",
":",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"}",
",",
"Sync",
":",
"sync",
",",
"}",
"\n",
"headerWriter",
":=",
"NewSpecificDatumWriter",
"(",
")",
"\n",
"headerWriter",
".",
"SetSchema",
"(",
"objHeaderSchema",
")",
"\n",
"if",
"err",
"=",
"headerWriter",
".",
"Write",
"(",
"header",
",",
"encoder",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"blockBuf",
":=",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"writer",
"=",
"&",
"DataFileWriter",
"{",
"output",
":",
"output",
",",
"outputEnc",
":",
"encoder",
",",
"datumWriter",
":",
"datumWriter",
",",
"sync",
":",
"sync",
",",
"blockBuf",
":",
"blockBuf",
",",
"blockEnc",
":",
"NewBinaryEncoder",
"(",
"blockBuf",
")",
",",
"}",
"\n\n",
"return",
"\n",
"}"
] | // NewDataFileWriter creates a new DataFileWriter for given output and schema using the given DatumWriter to write the data to that Writer.
// May return an error if writing fails. | [
"NewDataFileWriter",
"creates",
"a",
"new",
"DataFileWriter",
"for",
"given",
"output",
"and",
"schema",
"using",
"the",
"given",
"DatumWriter",
"to",
"write",
"the",
"data",
"to",
"that",
"Writer",
".",
"May",
"return",
"an",
"error",
"if",
"writing",
"fails",
"."
] | 0c8185d9a3ba82aeac98db3313a268a5b6df99b5 | https://github.com/elodina/go-avro/blob/0c8185d9a3ba82aeac98db3313a268a5b6df99b5/data_file.go#L210-L239 |
14,807 | cloudflare/cfssl_trust | info/info.go | WriteCertificateInformation | func WriteCertificateInformation(w io.Writer, db *sql.DB, cert *certdb.Certificate) error {
tx, err := db.Begin()
if err != nil {
fmt.Fprintf(os.Stderr, "[!] %s\n", err)
os.Exit(1)
}
defer certdb.Finalize(&err, tx)
err = writeBasicInformation(w, cert.X509())
if err != nil {
return err
}
err = writeCertificateReleases(w, tx, cert)
if err != nil {
return err
}
return nil
} | go | func WriteCertificateInformation(w io.Writer, db *sql.DB, cert *certdb.Certificate) error {
tx, err := db.Begin()
if err != nil {
fmt.Fprintf(os.Stderr, "[!] %s\n", err)
os.Exit(1)
}
defer certdb.Finalize(&err, tx)
err = writeBasicInformation(w, cert.X509())
if err != nil {
return err
}
err = writeCertificateReleases(w, tx, cert)
if err != nil {
return err
}
return nil
} | [
"func",
"WriteCertificateInformation",
"(",
"w",
"io",
".",
"Writer",
",",
"db",
"*",
"sql",
".",
"DB",
",",
"cert",
"*",
"certdb",
".",
"Certificate",
")",
"error",
"{",
"tx",
",",
"err",
":=",
"db",
".",
"Begin",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\\n",
"\"",
",",
"err",
")",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"}",
"\n",
"defer",
"certdb",
".",
"Finalize",
"(",
"&",
"err",
",",
"tx",
")",
"\n\n",
"err",
"=",
"writeBasicInformation",
"(",
"w",
",",
"cert",
".",
"X509",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"writeCertificateReleases",
"(",
"w",
",",
"tx",
",",
"cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // WriteCertificateInformation pretty prints details about the given certificate
// to the given io.Writer. | [
"WriteCertificateInformation",
"pretty",
"prints",
"details",
"about",
"the",
"given",
"certificate",
"to",
"the",
"given",
"io",
".",
"Writer",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/info/info.go#L54-L73 |
14,808 | cloudflare/cfssl_trust | info/info.go | LoadCertificateMetadata | func LoadCertificateMetadata(tx *sql.Tx, cert *certdb.Certificate) (*CertificateMetadata, error) {
x509Cert := cert.X509()
cm := &CertificateMetadata{
SKI: cert.SKI,
AKI: cert.AKI,
Serial: x509Cert.SerialNumber,
Subject: common.NameToString(x509Cert.Subject),
Issuer: common.NameToString(x509Cert.Issuer),
cert: cert,
}
var err error
cm.Releases, err = cert.Releases(tx)
return cm, err
} | go | func LoadCertificateMetadata(tx *sql.Tx, cert *certdb.Certificate) (*CertificateMetadata, error) {
x509Cert := cert.X509()
cm := &CertificateMetadata{
SKI: cert.SKI,
AKI: cert.AKI,
Serial: x509Cert.SerialNumber,
Subject: common.NameToString(x509Cert.Subject),
Issuer: common.NameToString(x509Cert.Issuer),
cert: cert,
}
var err error
cm.Releases, err = cert.Releases(tx)
return cm, err
} | [
"func",
"LoadCertificateMetadata",
"(",
"tx",
"*",
"sql",
".",
"Tx",
",",
"cert",
"*",
"certdb",
".",
"Certificate",
")",
"(",
"*",
"CertificateMetadata",
",",
"error",
")",
"{",
"x509Cert",
":=",
"cert",
".",
"X509",
"(",
")",
"\n",
"cm",
":=",
"&",
"CertificateMetadata",
"{",
"SKI",
":",
"cert",
".",
"SKI",
",",
"AKI",
":",
"cert",
".",
"AKI",
",",
"Serial",
":",
"x509Cert",
".",
"SerialNumber",
",",
"Subject",
":",
"common",
".",
"NameToString",
"(",
"x509Cert",
".",
"Subject",
")",
",",
"Issuer",
":",
"common",
".",
"NameToString",
"(",
"x509Cert",
".",
"Issuer",
")",
",",
"cert",
":",
"cert",
",",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"cm",
".",
"Releases",
",",
"err",
"=",
"cert",
".",
"Releases",
"(",
"tx",
")",
"\n",
"return",
"cm",
",",
"err",
"\n",
"}"
] | // LoadCertificateMetadata returns the metadata for a given certificate. | [
"LoadCertificateMetadata",
"returns",
"the",
"metadata",
"for",
"a",
"given",
"certificate",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/info/info.go#L87-L101 |
14,809 | cloudflare/cfssl_trust | info/info.go | WriteCertificateMetadata | func WriteCertificateMetadata(w io.Writer, cert *CertificateMetadata) error {
x509Cert := cert.cert.X509()
_, err := fmt.Fprintf(w, `Subject: %s
Issuer: %s
Not Before: %s
Not After: %s
`, (cert.Subject),
(cert.Issuer),
x509Cert.NotBefore.UTC().Format(common.DateFormat),
x509Cert.NotAfter.UTC().Format(common.DateFormat),
)
if err != nil {
return err
}
_, err = fmt.Fprintf(w, "\tReleases:\n")
if err != nil {
return err
}
for _, rel := range cert.Releases {
_, err = fmt.Fprintf(w, "\t\t- %s %s (%s)\n",
rel.Version, rel.Bundle,
time.Unix(rel.ReleasedAt, 0).UTC().Format(common.DateFormat))
if err != nil {
break
}
}
return err
} | go | func WriteCertificateMetadata(w io.Writer, cert *CertificateMetadata) error {
x509Cert := cert.cert.X509()
_, err := fmt.Fprintf(w, `Subject: %s
Issuer: %s
Not Before: %s
Not After: %s
`, (cert.Subject),
(cert.Issuer),
x509Cert.NotBefore.UTC().Format(common.DateFormat),
x509Cert.NotAfter.UTC().Format(common.DateFormat),
)
if err != nil {
return err
}
_, err = fmt.Fprintf(w, "\tReleases:\n")
if err != nil {
return err
}
for _, rel := range cert.Releases {
_, err = fmt.Fprintf(w, "\t\t- %s %s (%s)\n",
rel.Version, rel.Bundle,
time.Unix(rel.ReleasedAt, 0).UTC().Format(common.DateFormat))
if err != nil {
break
}
}
return err
} | [
"func",
"WriteCertificateMetadata",
"(",
"w",
"io",
".",
"Writer",
",",
"cert",
"*",
"CertificateMetadata",
")",
"error",
"{",
"x509Cert",
":=",
"cert",
".",
"cert",
".",
"X509",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"fmt",
".",
"Fprintf",
"(",
"w",
",",
"`Subject: %s\nIssuer: %s\n\tNot Before: %s\n\tNot After: %s\n`",
",",
"(",
"cert",
".",
"Subject",
")",
",",
"(",
"cert",
".",
"Issuer",
")",
",",
"x509Cert",
".",
"NotBefore",
".",
"UTC",
"(",
")",
".",
"Format",
"(",
"common",
".",
"DateFormat",
")",
",",
"x509Cert",
".",
"NotAfter",
".",
"UTC",
"(",
")",
".",
"Format",
"(",
"common",
".",
"DateFormat",
")",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"fmt",
".",
"Fprintf",
"(",
"w",
",",
"\"",
"\\t",
"\\n",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"rel",
":=",
"range",
"cert",
".",
"Releases",
"{",
"_",
",",
"err",
"=",
"fmt",
".",
"Fprintf",
"(",
"w",
",",
"\"",
"\\t",
"\\t",
"\\n",
"\"",
",",
"rel",
".",
"Version",
",",
"rel",
".",
"Bundle",
",",
"time",
".",
"Unix",
"(",
"rel",
".",
"ReleasedAt",
",",
"0",
")",
".",
"UTC",
"(",
")",
".",
"Format",
"(",
"common",
".",
"DateFormat",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"err",
"\n",
"}"
] | // WriteCertificateMetadata pretty prints the certificate metadata to
// the given io.Writer. | [
"WriteCertificateMetadata",
"pretty",
"prints",
"the",
"certificate",
"metadata",
"to",
"the",
"given",
"io",
".",
"Writer",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/info/info.go#L105-L135 |
14,810 | cloudflare/cfssl_trust | model/certdb/bundle.go | CollectRelease | func CollectRelease(bundle, version string, tx *sql.Tx) ([]*Certificate, error) {
rel, err := NewRelease(bundle, version)
if err != nil {
return nil, err
}
err = rel.Select(tx)
if err != nil {
if err == sql.ErrNoRows {
err = errors.New("model/certdb: invalid release " + version)
}
return nil, err
}
var certs []*Certificate
tbl := rel.table()
query := fmt.Sprintf(`
SELECT certificates.ski, aki, certificates.serial, not_before, not_after, raw
FROM certificates
INNER JOIN %ss ON certificates.ski = %ss.ski AND
certificates.serial = %ss.serial AND
%ss.release = ?
ORDER BY certificates.not_before`,
tbl, tbl, tbl, tbl)
rows, err := tx.Query(query, rel.Version)
if err != nil {
return nil, err
}
for rows.Next() {
cert := &Certificate{}
err = rows.Scan(&cert.SKI, &cert.AKI, &cert.Serial, &cert.NotBefore, &cert.NotAfter, &cert.Raw)
if err != nil {
return nil, err
}
cert.cert, err = x509.ParseCertificate(cert.Raw)
if err != nil {
return nil, err
}
certs = append(certs, cert)
}
return certs, nil
} | go | func CollectRelease(bundle, version string, tx *sql.Tx) ([]*Certificate, error) {
rel, err := NewRelease(bundle, version)
if err != nil {
return nil, err
}
err = rel.Select(tx)
if err != nil {
if err == sql.ErrNoRows {
err = errors.New("model/certdb: invalid release " + version)
}
return nil, err
}
var certs []*Certificate
tbl := rel.table()
query := fmt.Sprintf(`
SELECT certificates.ski, aki, certificates.serial, not_before, not_after, raw
FROM certificates
INNER JOIN %ss ON certificates.ski = %ss.ski AND
certificates.serial = %ss.serial AND
%ss.release = ?
ORDER BY certificates.not_before`,
tbl, tbl, tbl, tbl)
rows, err := tx.Query(query, rel.Version)
if err != nil {
return nil, err
}
for rows.Next() {
cert := &Certificate{}
err = rows.Scan(&cert.SKI, &cert.AKI, &cert.Serial, &cert.NotBefore, &cert.NotAfter, &cert.Raw)
if err != nil {
return nil, err
}
cert.cert, err = x509.ParseCertificate(cert.Raw)
if err != nil {
return nil, err
}
certs = append(certs, cert)
}
return certs, nil
} | [
"func",
"CollectRelease",
"(",
"bundle",
",",
"version",
"string",
",",
"tx",
"*",
"sql",
".",
"Tx",
")",
"(",
"[",
"]",
"*",
"Certificate",
",",
"error",
")",
"{",
"rel",
",",
"err",
":=",
"NewRelease",
"(",
"bundle",
",",
"version",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"rel",
".",
"Select",
"(",
"tx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"sql",
".",
"ErrNoRows",
"{",
"err",
"=",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"version",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"certs",
"[",
"]",
"*",
"Certificate",
"\n",
"tbl",
":=",
"rel",
".",
"table",
"(",
")",
"\n",
"query",
":=",
"fmt",
".",
"Sprintf",
"(",
"`\nSELECT certificates.ski, aki, certificates.serial, not_before, not_after, raw\n\tFROM certificates\n\tINNER JOIN %ss ON certificates.ski = %ss.ski AND\n\t\t\t certificates.serial = %ss.serial AND\n\t\t\t %ss.release = ?\n\tORDER BY certificates.not_before`",
",",
"tbl",
",",
"tbl",
",",
"tbl",
",",
"tbl",
")",
"\n",
"rows",
",",
"err",
":=",
"tx",
".",
"Query",
"(",
"query",
",",
"rel",
".",
"Version",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"rows",
".",
"Next",
"(",
")",
"{",
"cert",
":=",
"&",
"Certificate",
"{",
"}",
"\n\n",
"err",
"=",
"rows",
".",
"Scan",
"(",
"&",
"cert",
".",
"SKI",
",",
"&",
"cert",
".",
"AKI",
",",
"&",
"cert",
".",
"Serial",
",",
"&",
"cert",
".",
"NotBefore",
",",
"&",
"cert",
".",
"NotAfter",
",",
"&",
"cert",
".",
"Raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"cert",
".",
"cert",
",",
"err",
"=",
"x509",
".",
"ParseCertificate",
"(",
"cert",
".",
"Raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"certs",
"=",
"append",
"(",
"certs",
",",
"cert",
")",
"\n",
"}",
"\n\n",
"return",
"certs",
",",
"nil",
"\n",
"}"
] | // CollectRelease grabs all the certificates in a release, ordering
// them by the oldest. | [
"CollectRelease",
"grabs",
"all",
"the",
"certificates",
"in",
"a",
"release",
"ordering",
"them",
"by",
"the",
"oldest",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/bundle.go#L12-L58 |
14,811 | cloudflare/cfssl_trust | release/release.go | New | func New() Release {
now := time.Now()
return Release{
Year: now.Year(),
Month: int(now.Month()),
}
} | go | func New() Release {
now := time.Now()
return Release{
Year: now.Year(),
Month: int(now.Month()),
}
} | [
"func",
"New",
"(",
")",
"Release",
"{",
"now",
":=",
"time",
".",
"Now",
"(",
")",
"\n\n",
"return",
"Release",
"{",
"Year",
":",
"now",
".",
"Year",
"(",
")",
",",
"Month",
":",
"int",
"(",
"now",
".",
"Month",
"(",
")",
")",
",",
"}",
"\n",
"}"
] | // New returns a release for the current year and month with a zero
// iteration counter. | [
"New",
"returns",
"a",
"release",
"for",
"the",
"current",
"year",
"and",
"month",
"with",
"a",
"zero",
"iteration",
"counter",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/release/release.go#L14-L21 |
14,812 | cloudflare/cfssl_trust | release/release.go | IncAt | func (r Release) IncAt(now time.Time) (Release, error) {
year := now.Year()
month := int(now.Month())
rel := Release{
Year: r.Year,
Month: r.Month,
Iteration: r.Iteration,
Extra: r.Extra,
}
if r.Year > year {
return rel, errors.New("release: incremented release caused a regression (year)")
}
if r.Year == year && r.Month > month {
return rel, errors.New("release: incremented release caused a regression (month)")
}
if year != rel.Year {
rel.Year = year
rel.Month = month
rel.Iteration = 0
} else if month != rel.Month {
rel.Month = month
rel.Iteration = 0
} else {
rel.Iteration++
}
return rel, nil
} | go | func (r Release) IncAt(now time.Time) (Release, error) {
year := now.Year()
month := int(now.Month())
rel := Release{
Year: r.Year,
Month: r.Month,
Iteration: r.Iteration,
Extra: r.Extra,
}
if r.Year > year {
return rel, errors.New("release: incremented release caused a regression (year)")
}
if r.Year == year && r.Month > month {
return rel, errors.New("release: incremented release caused a regression (month)")
}
if year != rel.Year {
rel.Year = year
rel.Month = month
rel.Iteration = 0
} else if month != rel.Month {
rel.Month = month
rel.Iteration = 0
} else {
rel.Iteration++
}
return rel, nil
} | [
"func",
"(",
"r",
"Release",
")",
"IncAt",
"(",
"now",
"time",
".",
"Time",
")",
"(",
"Release",
",",
"error",
")",
"{",
"year",
":=",
"now",
".",
"Year",
"(",
")",
"\n",
"month",
":=",
"int",
"(",
"now",
".",
"Month",
"(",
")",
")",
"\n\n",
"rel",
":=",
"Release",
"{",
"Year",
":",
"r",
".",
"Year",
",",
"Month",
":",
"r",
".",
"Month",
",",
"Iteration",
":",
"r",
".",
"Iteration",
",",
"Extra",
":",
"r",
".",
"Extra",
",",
"}",
"\n\n",
"if",
"r",
".",
"Year",
">",
"year",
"{",
"return",
"rel",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"Year",
"==",
"year",
"&&",
"r",
".",
"Month",
">",
"month",
"{",
"return",
"rel",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"year",
"!=",
"rel",
".",
"Year",
"{",
"rel",
".",
"Year",
"=",
"year",
"\n",
"rel",
".",
"Month",
"=",
"month",
"\n",
"rel",
".",
"Iteration",
"=",
"0",
"\n",
"}",
"else",
"if",
"month",
"!=",
"rel",
".",
"Month",
"{",
"rel",
".",
"Month",
"=",
"month",
"\n",
"rel",
".",
"Iteration",
"=",
"0",
"\n",
"}",
"else",
"{",
"rel",
".",
"Iteration",
"++",
"\n",
"}",
"\n\n",
"return",
"rel",
",",
"nil",
"\n",
"}"
] | // IncAt increments the release assuming the given timestamp. This is
// useful for verifying increments. | [
"IncAt",
"increments",
"the",
"release",
"assuming",
"the",
"given",
"timestamp",
".",
"This",
"is",
"useful",
"for",
"verifying",
"increments",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/release/release.go#L97-L128 |
14,813 | cloudflare/cfssl_trust | release/release.go | Parse | func Parse(in string) (Release, error) {
var rel Release
parts := strings.Split(in, ".")
if len(parts) != 3 {
return rel, errors.New("release: invalid release " + in)
}
var err error
rel.Year, err = strconv.Atoi(parts[0])
if err != nil {
return rel, err
} else if rel.Year > 2038 || rel.Year < 2000 {
return rel, errors.New("release: " + parts[0] + " is an invalid year (2000 >= year <= 2038)")
}
rel.Month, err = strconv.Atoi(parts[1])
if err != nil {
return rel, err
} else if rel.Month < 1 || rel.Month > 12 {
return rel, errors.New("release: " + parts[1] + " is an invalid month (1 >= month <= 12)")
}
parts = strings.SplitN(parts[2], "-", 2)
rel.Iteration, err = strconv.Atoi(parts[0])
if err != nil {
return rel, err
}
if len(parts) == 2 {
rel.Extra = parts[1]
}
return rel, nil
} | go | func Parse(in string) (Release, error) {
var rel Release
parts := strings.Split(in, ".")
if len(parts) != 3 {
return rel, errors.New("release: invalid release " + in)
}
var err error
rel.Year, err = strconv.Atoi(parts[0])
if err != nil {
return rel, err
} else if rel.Year > 2038 || rel.Year < 2000 {
return rel, errors.New("release: " + parts[0] + " is an invalid year (2000 >= year <= 2038)")
}
rel.Month, err = strconv.Atoi(parts[1])
if err != nil {
return rel, err
} else if rel.Month < 1 || rel.Month > 12 {
return rel, errors.New("release: " + parts[1] + " is an invalid month (1 >= month <= 12)")
}
parts = strings.SplitN(parts[2], "-", 2)
rel.Iteration, err = strconv.Atoi(parts[0])
if err != nil {
return rel, err
}
if len(parts) == 2 {
rel.Extra = parts[1]
}
return rel, nil
} | [
"func",
"Parse",
"(",
"in",
"string",
")",
"(",
"Release",
",",
"error",
")",
"{",
"var",
"rel",
"Release",
"\n",
"parts",
":=",
"strings",
".",
"Split",
"(",
"in",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"!=",
"3",
"{",
"return",
"rel",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"in",
")",
"\n",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"rel",
".",
"Year",
",",
"err",
"=",
"strconv",
".",
"Atoi",
"(",
"parts",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"rel",
",",
"err",
"\n",
"}",
"else",
"if",
"rel",
".",
"Year",
">",
"2038",
"||",
"rel",
".",
"Year",
"<",
"2000",
"{",
"return",
"rel",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"parts",
"[",
"0",
"]",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"rel",
".",
"Month",
",",
"err",
"=",
"strconv",
".",
"Atoi",
"(",
"parts",
"[",
"1",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"rel",
",",
"err",
"\n",
"}",
"else",
"if",
"rel",
".",
"Month",
"<",
"1",
"||",
"rel",
".",
"Month",
">",
"12",
"{",
"return",
"rel",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"parts",
"[",
"1",
"]",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"parts",
"=",
"strings",
".",
"SplitN",
"(",
"parts",
"[",
"2",
"]",
",",
"\"",
"\"",
",",
"2",
")",
"\n",
"rel",
".",
"Iteration",
",",
"err",
"=",
"strconv",
".",
"Atoi",
"(",
"parts",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"rel",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"parts",
")",
"==",
"2",
"{",
"rel",
".",
"Extra",
"=",
"parts",
"[",
"1",
"]",
"\n",
"}",
"\n\n",
"return",
"rel",
",",
"nil",
"\n",
"}"
] | // Parse takes a version string and returns a release structure. | [
"Parse",
"takes",
"a",
"version",
"string",
"and",
"returns",
"a",
"release",
"structure",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/release/release.go#L131-L164 |
14,814 | cloudflare/cfssl_trust | cli/root.go | cleanup | func cleanup(tx *sql.Tx, db *sql.DB, err error) {
if tx != nil {
if err != nil {
err = tx.Rollback()
if err != nil {
fmt.Fprintf(os.Stderr, "[!] error while rolling back transaction: %s\n", err)
os.Exit(1)
}
} else {
err = tx.Commit()
if err != nil {
fmt.Fprintf(os.Stderr, "[!] error while committing transaction: %s\n", err)
os.Exit(1)
}
}
}
if db != nil {
err = db.Close()
if err != nil {
fmt.Fprintf(os.Stderr, "[!] error while closing database: %s\n", err)
os.Exit(1)
}
}
} | go | func cleanup(tx *sql.Tx, db *sql.DB, err error) {
if tx != nil {
if err != nil {
err = tx.Rollback()
if err != nil {
fmt.Fprintf(os.Stderr, "[!] error while rolling back transaction: %s\n", err)
os.Exit(1)
}
} else {
err = tx.Commit()
if err != nil {
fmt.Fprintf(os.Stderr, "[!] error while committing transaction: %s\n", err)
os.Exit(1)
}
}
}
if db != nil {
err = db.Close()
if err != nil {
fmt.Fprintf(os.Stderr, "[!] error while closing database: %s\n", err)
os.Exit(1)
}
}
} | [
"func",
"cleanup",
"(",
"tx",
"*",
"sql",
".",
"Tx",
",",
"db",
"*",
"sql",
".",
"DB",
",",
"err",
"error",
")",
"{",
"if",
"tx",
"!=",
"nil",
"{",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"tx",
".",
"Rollback",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\\n",
"\"",
",",
"err",
")",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"err",
"=",
"tx",
".",
"Commit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\\n",
"\"",
",",
"err",
")",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"db",
"!=",
"nil",
"{",
"err",
"=",
"db",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\\n",
"\"",
",",
"err",
")",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // If err isn't nil, this should rollback the transaction. If err is
// nil, it should commit the transaction. Finally, it should close the
// database. | [
"If",
"err",
"isn",
"t",
"nil",
"this",
"should",
"rollback",
"the",
"transaction",
".",
"If",
"err",
"is",
"nil",
"it",
"should",
"commit",
"the",
"transaction",
".",
"Finally",
"it",
"should",
"close",
"the",
"database",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/cli/root.go#L54-L78 |
14,815 | cloudflare/cfssl_trust | model/certdb/certificate.go | Finalize | func Finalize(err *error, tx *sql.Tx) {
if *err == nil {
*err = tx.Commit()
if *err != nil {
fmt.Fprintf(os.Stderr, "[!] failed to commit transaction: %s\n", *err)
os.Exit(1)
}
} else {
tx.Rollback()
}
} | go | func Finalize(err *error, tx *sql.Tx) {
if *err == nil {
*err = tx.Commit()
if *err != nil {
fmt.Fprintf(os.Stderr, "[!] failed to commit transaction: %s\n", *err)
os.Exit(1)
}
} else {
tx.Rollback()
}
} | [
"func",
"Finalize",
"(",
"err",
"*",
"error",
",",
"tx",
"*",
"sql",
".",
"Tx",
")",
"{",
"if",
"*",
"err",
"==",
"nil",
"{",
"*",
"err",
"=",
"tx",
".",
"Commit",
"(",
")",
"\n",
"if",
"*",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\\n",
"\"",
",",
"*",
"err",
")",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"tx",
".",
"Rollback",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Finalize finishes a transaction, committing it if needed or rolling
// back on error. | [
"Finalize",
"finishes",
"a",
"transaction",
"committing",
"it",
"if",
"needed",
"or",
"rolling",
"back",
"on",
"error",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L20-L30 |
14,816 | cloudflare/cfssl_trust | model/certdb/certificate.go | FindCertificateBySKI | func FindCertificateBySKI(db *sql.DB, ski string) ([]*Certificate, error) {
tx, err := db.Begin()
if err != nil {
return nil, err
}
defer Finalize(&err, tx)
var certificates []*Certificate
rows, err := tx.Query(`
SELECT aki, serial, not_before, not_after, raw
FROM certificates
WHERE ski=?`,
ski)
if err != nil {
return nil, err
}
for rows.Next() {
cert := &Certificate{
SKI: ski,
}
err = rows.Scan(&cert.AKI, &cert.Serial, &cert.NotBefore,
&cert.NotAfter, &cert.Raw)
if err != nil {
return nil, err
}
cert.cert, err = x509.ParseCertificate(cert.Raw)
if err != nil {
return nil, err
}
certificates = append(certificates, cert)
}
return certificates, nil
} | go | func FindCertificateBySKI(db *sql.DB, ski string) ([]*Certificate, error) {
tx, err := db.Begin()
if err != nil {
return nil, err
}
defer Finalize(&err, tx)
var certificates []*Certificate
rows, err := tx.Query(`
SELECT aki, serial, not_before, not_after, raw
FROM certificates
WHERE ski=?`,
ski)
if err != nil {
return nil, err
}
for rows.Next() {
cert := &Certificate{
SKI: ski,
}
err = rows.Scan(&cert.AKI, &cert.Serial, &cert.NotBefore,
&cert.NotAfter, &cert.Raw)
if err != nil {
return nil, err
}
cert.cert, err = x509.ParseCertificate(cert.Raw)
if err != nil {
return nil, err
}
certificates = append(certificates, cert)
}
return certificates, nil
} | [
"func",
"FindCertificateBySKI",
"(",
"db",
"*",
"sql",
".",
"DB",
",",
"ski",
"string",
")",
"(",
"[",
"]",
"*",
"Certificate",
",",
"error",
")",
"{",
"tx",
",",
"err",
":=",
"db",
".",
"Begin",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"Finalize",
"(",
"&",
"err",
",",
"tx",
")",
"\n\n",
"var",
"certificates",
"[",
"]",
"*",
"Certificate",
"\n",
"rows",
",",
"err",
":=",
"tx",
".",
"Query",
"(",
"`\nSELECT aki, serial, not_before, not_after, raw\n\tFROM certificates\n\tWHERE ski=?`",
",",
"ski",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"rows",
".",
"Next",
"(",
")",
"{",
"cert",
":=",
"&",
"Certificate",
"{",
"SKI",
":",
"ski",
",",
"}",
"\n\n",
"err",
"=",
"rows",
".",
"Scan",
"(",
"&",
"cert",
".",
"AKI",
",",
"&",
"cert",
".",
"Serial",
",",
"&",
"cert",
".",
"NotBefore",
",",
"&",
"cert",
".",
"NotAfter",
",",
"&",
"cert",
".",
"Raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"cert",
".",
"cert",
",",
"err",
"=",
"x509",
".",
"ParseCertificate",
"(",
"cert",
".",
"Raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"certificates",
"=",
"append",
"(",
"certificates",
",",
"cert",
")",
"\n",
"}",
"\n\n",
"return",
"certificates",
",",
"nil",
"\n",
"}"
] | // FindCertificateBySKI returns all the certificates with the given
// SKI. | [
"FindCertificateBySKI",
"returns",
"all",
"the",
"certificates",
"with",
"the",
"given",
"SKI",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L34-L71 |
14,817 | cloudflare/cfssl_trust | model/certdb/certificate.go | AllCertificates | func AllCertificates(tx *sql.Tx) ([]*Certificate, error) {
rows, err := tx.Query("SELECT * FROM certificates")
if err != nil {
return nil, err
}
var certificates []*Certificate
for rows.Next() {
cert := &Certificate{}
err = rows.Scan(&cert.SKI, &cert.AKI, &cert.Serial, &cert.NotBefore,
&cert.NotAfter, &cert.Raw)
if err != nil {
return nil, err
}
cert.cert, err = x509.ParseCertificate(cert.Raw)
if err != nil {
return nil, err
}
certificates = append(certificates, cert)
}
return certificates, err
} | go | func AllCertificates(tx *sql.Tx) ([]*Certificate, error) {
rows, err := tx.Query("SELECT * FROM certificates")
if err != nil {
return nil, err
}
var certificates []*Certificate
for rows.Next() {
cert := &Certificate{}
err = rows.Scan(&cert.SKI, &cert.AKI, &cert.Serial, &cert.NotBefore,
&cert.NotAfter, &cert.Raw)
if err != nil {
return nil, err
}
cert.cert, err = x509.ParseCertificate(cert.Raw)
if err != nil {
return nil, err
}
certificates = append(certificates, cert)
}
return certificates, err
} | [
"func",
"AllCertificates",
"(",
"tx",
"*",
"sql",
".",
"Tx",
")",
"(",
"[",
"]",
"*",
"Certificate",
",",
"error",
")",
"{",
"rows",
",",
"err",
":=",
"tx",
".",
"Query",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"certificates",
"[",
"]",
"*",
"Certificate",
"\n",
"for",
"rows",
".",
"Next",
"(",
")",
"{",
"cert",
":=",
"&",
"Certificate",
"{",
"}",
"\n",
"err",
"=",
"rows",
".",
"Scan",
"(",
"&",
"cert",
".",
"SKI",
",",
"&",
"cert",
".",
"AKI",
",",
"&",
"cert",
".",
"Serial",
",",
"&",
"cert",
".",
"NotBefore",
",",
"&",
"cert",
".",
"NotAfter",
",",
"&",
"cert",
".",
"Raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"cert",
".",
"cert",
",",
"err",
"=",
"x509",
".",
"ParseCertificate",
"(",
"cert",
".",
"Raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"certificates",
"=",
"append",
"(",
"certificates",
",",
"cert",
")",
"\n",
"}",
"\n\n",
"return",
"certificates",
",",
"err",
"\n",
"}"
] | // AllCertificates loads all the certificates in the database. | [
"AllCertificates",
"loads",
"all",
"the",
"certificates",
"in",
"the",
"database",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L74-L98 |
14,818 | cloudflare/cfssl_trust | model/certdb/certificate.go | Ensure | func Ensure(table Table, tx *sql.Tx) (bool, error) {
var inserted bool
err := table.Select(tx)
if err == sql.ErrNoRows {
err = table.Insert(tx)
inserted = true
}
return inserted, err
} | go | func Ensure(table Table, tx *sql.Tx) (bool, error) {
var inserted bool
err := table.Select(tx)
if err == sql.ErrNoRows {
err = table.Insert(tx)
inserted = true
}
return inserted, err
} | [
"func",
"Ensure",
"(",
"table",
"Table",
",",
"tx",
"*",
"sql",
".",
"Tx",
")",
"(",
"bool",
",",
"error",
")",
"{",
"var",
"inserted",
"bool",
"\n",
"err",
":=",
"table",
".",
"Select",
"(",
"tx",
")",
"\n",
"if",
"err",
"==",
"sql",
".",
"ErrNoRows",
"{",
"err",
"=",
"table",
".",
"Insert",
"(",
"tx",
")",
"\n",
"inserted",
"=",
"true",
"\n",
"}",
"\n",
"return",
"inserted",
",",
"err",
"\n",
"}"
] | // Ensure ensures the value is present in the database. It calls
// Select, and if no rows are returned, it calls Insert. The boolean
// will be true if the value was inserted. This value is meaningless
// if err is non-nil. | [
"Ensure",
"ensures",
"the",
"value",
"is",
"present",
"in",
"the",
"database",
".",
"It",
"calls",
"Select",
"and",
"if",
"no",
"rows",
"are",
"returned",
"it",
"calls",
"Insert",
".",
"The",
"boolean",
"will",
"be",
"true",
"if",
"the",
"value",
"was",
"inserted",
".",
"This",
"value",
"is",
"meaningless",
"if",
"err",
"is",
"non",
"-",
"nil",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L125-L133 |
14,819 | cloudflare/cfssl_trust | model/certdb/certificate.go | Insert | func (cert *Certificate) Insert(tx *sql.Tx) error {
_, err := tx.Exec(`INSERT INTO certificates (ski, aki, serial, not_before, not_after, raw) values (?, ?, ?, ?, ?, ?)`, cert.SKI, cert.AKI, cert.Serial, cert.NotBefore, cert.NotAfter, cert.Raw)
return err
} | go | func (cert *Certificate) Insert(tx *sql.Tx) error {
_, err := tx.Exec(`INSERT INTO certificates (ski, aki, serial, not_before, not_after, raw) values (?, ?, ?, ?, ?, ?)`, cert.SKI, cert.AKI, cert.Serial, cert.NotBefore, cert.NotAfter, cert.Raw)
return err
} | [
"func",
"(",
"cert",
"*",
"Certificate",
")",
"Insert",
"(",
"tx",
"*",
"sql",
".",
"Tx",
")",
"error",
"{",
"_",
",",
"err",
":=",
"tx",
".",
"Exec",
"(",
"`INSERT INTO certificates (ski, aki, serial, not_before, not_after, raw) values (?, ?, ?, ?, ?, ?)`",
",",
"cert",
".",
"SKI",
",",
"cert",
".",
"AKI",
",",
"cert",
".",
"Serial",
",",
"cert",
".",
"NotBefore",
",",
"cert",
".",
"NotAfter",
",",
"cert",
".",
"Raw",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Insert stores the Certificate in the database. | [
"Insert",
"stores",
"the",
"Certificate",
"in",
"the",
"database",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L147-L150 |
14,820 | cloudflare/cfssl_trust | model/certdb/certificate.go | Select | func (cert *Certificate) Select(tx *sql.Tx) error {
row := tx.QueryRow(`SELECT aki, not_before, not_after, raw FROM certificates WHERE ski=? and serial=?`, cert.SKI, cert.Serial)
err := row.Scan(&cert.AKI, &cert.NotBefore, &cert.NotAfter, &cert.Raw)
if err != nil {
return err
}
cert.cert, err = x509.ParseCertificate(cert.Raw)
return err
} | go | func (cert *Certificate) Select(tx *sql.Tx) error {
row := tx.QueryRow(`SELECT aki, not_before, not_after, raw FROM certificates WHERE ski=? and serial=?`, cert.SKI, cert.Serial)
err := row.Scan(&cert.AKI, &cert.NotBefore, &cert.NotAfter, &cert.Raw)
if err != nil {
return err
}
cert.cert, err = x509.ParseCertificate(cert.Raw)
return err
} | [
"func",
"(",
"cert",
"*",
"Certificate",
")",
"Select",
"(",
"tx",
"*",
"sql",
".",
"Tx",
")",
"error",
"{",
"row",
":=",
"tx",
".",
"QueryRow",
"(",
"`SELECT aki, not_before, not_after, raw FROM certificates WHERE ski=? and serial=?`",
",",
"cert",
".",
"SKI",
",",
"cert",
".",
"Serial",
")",
"\n",
"err",
":=",
"row",
".",
"Scan",
"(",
"&",
"cert",
".",
"AKI",
",",
"&",
"cert",
".",
"NotBefore",
",",
"&",
"cert",
".",
"NotAfter",
",",
"&",
"cert",
".",
"Raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"cert",
".",
"cert",
",",
"err",
"=",
"x509",
".",
"ParseCertificate",
"(",
"cert",
".",
"Raw",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Select requires the SKI and Serial fields to be filled in. | [
"Select",
"requires",
"the",
"SKI",
"and",
"Serial",
"fields",
"to",
"be",
"filled",
"in",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L153-L162 |
14,821 | cloudflare/cfssl_trust | model/certdb/certificate.go | Releases | func (cert *Certificate) Releases(tx *sql.Tx) ([]*Release, error) {
var releases []*Release
rows, err := tx.Query("SELECT release FROM roots WHERE ski=? AND serial=?", cert.SKI, cert.Serial)
if err != nil {
return nil, err
}
for rows.Next() {
rel := &Release{
Bundle: "ca",
}
err = rows.Scan(&rel.Version)
if err != nil {
return nil, err
}
releases = append(releases, rel)
}
rows.Close()
rows, err = tx.Query("SELECT release FROM intermediates WHERE ski=? AND serial=?", cert.SKI, cert.Serial)
if err != nil {
return nil, err
}
for rows.Next() {
rel := &Release{
Bundle: "int",
}
err = rows.Scan(&rel.Version)
if err != nil {
return nil, err
}
releases = append(releases, rel)
}
for _, rel := range releases {
err = rel.Select(tx)
if err != nil {
return nil, err
}
}
return releases, nil
} | go | func (cert *Certificate) Releases(tx *sql.Tx) ([]*Release, error) {
var releases []*Release
rows, err := tx.Query("SELECT release FROM roots WHERE ski=? AND serial=?", cert.SKI, cert.Serial)
if err != nil {
return nil, err
}
for rows.Next() {
rel := &Release{
Bundle: "ca",
}
err = rows.Scan(&rel.Version)
if err != nil {
return nil, err
}
releases = append(releases, rel)
}
rows.Close()
rows, err = tx.Query("SELECT release FROM intermediates WHERE ski=? AND serial=?", cert.SKI, cert.Serial)
if err != nil {
return nil, err
}
for rows.Next() {
rel := &Release{
Bundle: "int",
}
err = rows.Scan(&rel.Version)
if err != nil {
return nil, err
}
releases = append(releases, rel)
}
for _, rel := range releases {
err = rel.Select(tx)
if err != nil {
return nil, err
}
}
return releases, nil
} | [
"func",
"(",
"cert",
"*",
"Certificate",
")",
"Releases",
"(",
"tx",
"*",
"sql",
".",
"Tx",
")",
"(",
"[",
"]",
"*",
"Release",
",",
"error",
")",
"{",
"var",
"releases",
"[",
"]",
"*",
"Release",
"\n\n",
"rows",
",",
"err",
":=",
"tx",
".",
"Query",
"(",
"\"",
"\"",
",",
"cert",
".",
"SKI",
",",
"cert",
".",
"Serial",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"rows",
".",
"Next",
"(",
")",
"{",
"rel",
":=",
"&",
"Release",
"{",
"Bundle",
":",
"\"",
"\"",
",",
"}",
"\n\n",
"err",
"=",
"rows",
".",
"Scan",
"(",
"&",
"rel",
".",
"Version",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"releases",
"=",
"append",
"(",
"releases",
",",
"rel",
")",
"\n",
"}",
"\n",
"rows",
".",
"Close",
"(",
")",
"\n\n",
"rows",
",",
"err",
"=",
"tx",
".",
"Query",
"(",
"\"",
"\"",
",",
"cert",
".",
"SKI",
",",
"cert",
".",
"Serial",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"rows",
".",
"Next",
"(",
")",
"{",
"rel",
":=",
"&",
"Release",
"{",
"Bundle",
":",
"\"",
"\"",
",",
"}",
"\n\n",
"err",
"=",
"rows",
".",
"Scan",
"(",
"&",
"rel",
".",
"Version",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"releases",
"=",
"append",
"(",
"releases",
",",
"rel",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"rel",
":=",
"range",
"releases",
"{",
"err",
"=",
"rel",
".",
"Select",
"(",
"tx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"releases",
",",
"nil",
"\n",
"}"
] | // Releases looks up all the releases for a certificate. | [
"Releases",
"looks",
"up",
"all",
"the",
"releases",
"for",
"a",
"certificate",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L165-L213 |
14,822 | cloudflare/cfssl_trust | model/certdb/certificate.go | Revoked | func (cert *Certificate) Revoked(tx *sql.Tx, when int64) (bool, error) {
if err := cert.Select(tx); err != nil {
return true, err
}
var count int
row := tx.QueryRow(`SELECT count(*) FROM revocations WHERE ski=? AND revoked_at <= ?`, cert.SKI, when)
err := row.Scan(&count)
if err != nil {
return true, err
}
return count > 0, nil
} | go | func (cert *Certificate) Revoked(tx *sql.Tx, when int64) (bool, error) {
if err := cert.Select(tx); err != nil {
return true, err
}
var count int
row := tx.QueryRow(`SELECT count(*) FROM revocations WHERE ski=? AND revoked_at <= ?`, cert.SKI, when)
err := row.Scan(&count)
if err != nil {
return true, err
}
return count > 0, nil
} | [
"func",
"(",
"cert",
"*",
"Certificate",
")",
"Revoked",
"(",
"tx",
"*",
"sql",
".",
"Tx",
",",
"when",
"int64",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"err",
":=",
"cert",
".",
"Select",
"(",
"tx",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"true",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"count",
"int",
"\n",
"row",
":=",
"tx",
".",
"QueryRow",
"(",
"`SELECT count(*) FROM revocations WHERE ski=? AND revoked_at <= ?`",
",",
"cert",
".",
"SKI",
",",
"when",
")",
"\n",
"err",
":=",
"row",
".",
"Scan",
"(",
"&",
"count",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"true",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"count",
">",
"0",
",",
"nil",
"\n",
"}"
] | // Revoked returns true if the certificate was revoked before the
// timestamp passed in. | [
"Revoked",
"returns",
"true",
"if",
"the",
"certificate",
"was",
"revoked",
"before",
"the",
"timestamp",
"passed",
"in",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L217-L230 |
14,823 | cloudflare/cfssl_trust | model/certdb/certificate.go | Revoke | func (cert *Certificate) Revoke(tx *sql.Tx, mechanism, reason string, when int64) error {
if err := cert.Select(tx); err != nil {
return err
}
rev := &Revocation{
SKI: cert.SKI,
RevokedAt: when,
Mechanism: mechanism,
Reason: reason,
}
// We ignore the inserted value because if it returns false, that means
// the certificate has already been revoked.
_, err := Ensure(rev, tx)
return err
} | go | func (cert *Certificate) Revoke(tx *sql.Tx, mechanism, reason string, when int64) error {
if err := cert.Select(tx); err != nil {
return err
}
rev := &Revocation{
SKI: cert.SKI,
RevokedAt: when,
Mechanism: mechanism,
Reason: reason,
}
// We ignore the inserted value because if it returns false, that means
// the certificate has already been revoked.
_, err := Ensure(rev, tx)
return err
} | [
"func",
"(",
"cert",
"*",
"Certificate",
")",
"Revoke",
"(",
"tx",
"*",
"sql",
".",
"Tx",
",",
"mechanism",
",",
"reason",
"string",
",",
"when",
"int64",
")",
"error",
"{",
"if",
"err",
":=",
"cert",
".",
"Select",
"(",
"tx",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"rev",
":=",
"&",
"Revocation",
"{",
"SKI",
":",
"cert",
".",
"SKI",
",",
"RevokedAt",
":",
"when",
",",
"Mechanism",
":",
"mechanism",
",",
"Reason",
":",
"reason",
",",
"}",
"\n\n",
"// We ignore the inserted value because if it returns false, that means",
"// the certificate has already been revoked.",
"_",
",",
"err",
":=",
"Ensure",
"(",
"rev",
",",
"tx",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Revoke marks the certificate as revoked. | [
"Revoke",
"marks",
"the",
"certificate",
"as",
"revoked",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L233-L249 |
14,824 | cloudflare/cfssl_trust | model/certdb/certificate.go | Insert | func (aia *AIA) Insert(tx *sql.Tx) error {
_, err := tx.Exec(`INSERT INTO aia (ski, url) values (?, ?)`, aia.SKI, aia.URL)
return err
} | go | func (aia *AIA) Insert(tx *sql.Tx) error {
_, err := tx.Exec(`INSERT INTO aia (ski, url) values (?, ?)`, aia.SKI, aia.URL)
return err
} | [
"func",
"(",
"aia",
"*",
"AIA",
")",
"Insert",
"(",
"tx",
"*",
"sql",
".",
"Tx",
")",
"error",
"{",
"_",
",",
"err",
":=",
"tx",
".",
"Exec",
"(",
"`INSERT INTO aia (ski, url) values (?, ?)`",
",",
"aia",
".",
"SKI",
",",
"aia",
".",
"URL",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Insert stores the release in the database. | [
"Insert",
"stores",
"the",
"release",
"in",
"the",
"database",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L299-L302 |
14,825 | cloudflare/cfssl_trust | model/certdb/certificate.go | Select | func (aia *AIA) Select(tx *sql.Tx) error {
row := tx.QueryRow(`SELECT url FROM aia WHERE ski=?`, aia.SKI)
err := row.Scan(&aia.URL)
if err != nil {
return err
}
return nil
} | go | func (aia *AIA) Select(tx *sql.Tx) error {
row := tx.QueryRow(`SELECT url FROM aia WHERE ski=?`, aia.SKI)
err := row.Scan(&aia.URL)
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"aia",
"*",
"AIA",
")",
"Select",
"(",
"tx",
"*",
"sql",
".",
"Tx",
")",
"error",
"{",
"row",
":=",
"tx",
".",
"QueryRow",
"(",
"`SELECT url FROM aia WHERE ski=?`",
",",
"aia",
".",
"SKI",
")",
"\n",
"err",
":=",
"row",
".",
"Scan",
"(",
"&",
"aia",
".",
"URL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Select requires the SKI field to be filled in. | [
"Select",
"requires",
"the",
"SKI",
"field",
"to",
"be",
"filled",
"in",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L305-L313 |
14,826 | cloudflare/cfssl_trust | model/certdb/certificate.go | NewAIA | func NewAIA(cert *Certificate) *AIA {
if len(cert.cert.IssuingCertificateURL) == 0 {
return nil
}
// Arbitrary choice: store the first HTTP URL. We can always
// look up the other URLs later and replace this one if
// need be.
return &AIA{
SKI: cert.AKI,
URL: cert.cert.IssuingCertificateURL[0],
}
} | go | func NewAIA(cert *Certificate) *AIA {
if len(cert.cert.IssuingCertificateURL) == 0 {
return nil
}
// Arbitrary choice: store the first HTTP URL. We can always
// look up the other URLs later and replace this one if
// need be.
return &AIA{
SKI: cert.AKI,
URL: cert.cert.IssuingCertificateURL[0],
}
} | [
"func",
"NewAIA",
"(",
"cert",
"*",
"Certificate",
")",
"*",
"AIA",
"{",
"if",
"len",
"(",
"cert",
".",
"cert",
".",
"IssuingCertificateURL",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Arbitrary choice: store the first HTTP URL. We can always",
"// look up the other URLs later and replace this one if",
"// need be.",
"return",
"&",
"AIA",
"{",
"SKI",
":",
"cert",
".",
"AKI",
",",
"URL",
":",
"cert",
".",
"cert",
".",
"IssuingCertificateURL",
"[",
"0",
"]",
",",
"}",
"\n",
"}"
] | // NewAIA populates an AIA structure from a Certificate. | [
"NewAIA",
"populates",
"an",
"AIA",
"structure",
"from",
"a",
"Certificate",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L316-L328 |
14,827 | cloudflare/cfssl_trust | model/certdb/certificate.go | NewRelease | func NewRelease(bundle, version string) (*Release, error) {
r := &Release{
Bundle: bundle,
Version: version,
ReleasedAt: time.Now().Unix(),
}
if !r.validBundle() {
return nil, r.errInvalidBundle()
}
return r, nil
} | go | func NewRelease(bundle, version string) (*Release, error) {
r := &Release{
Bundle: bundle,
Version: version,
ReleasedAt: time.Now().Unix(),
}
if !r.validBundle() {
return nil, r.errInvalidBundle()
}
return r, nil
} | [
"func",
"NewRelease",
"(",
"bundle",
",",
"version",
"string",
")",
"(",
"*",
"Release",
",",
"error",
")",
"{",
"r",
":=",
"&",
"Release",
"{",
"Bundle",
":",
"bundle",
",",
"Version",
":",
"version",
",",
"ReleasedAt",
":",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
",",
"}",
"\n\n",
"if",
"!",
"r",
".",
"validBundle",
"(",
")",
"{",
"return",
"nil",
",",
"r",
".",
"errInvalidBundle",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"r",
",",
"nil",
"\n",
"}"
] | // NewRelease verifies the bundle is valid, and creates a new Release
// with the current time stamp. | [
"NewRelease",
"verifies",
"the",
"bundle",
"is",
"valid",
"and",
"creates",
"a",
"new",
"Release",
"with",
"the",
"current",
"time",
"stamp",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L374-L386 |
14,828 | cloudflare/cfssl_trust | model/certdb/certificate.go | Insert | func (r *Release) Insert(tx *sql.Tx) error {
if !r.validBundle() {
return r.errInvalidBundle()
}
query := fmt.Sprintf("INSERT INTO %s_releases (version, released_at) VALUES (?, ?)",
r.table())
_, err := tx.Exec(query, r.Version, r.ReleasedAt)
return err
} | go | func (r *Release) Insert(tx *sql.Tx) error {
if !r.validBundle() {
return r.errInvalidBundle()
}
query := fmt.Sprintf("INSERT INTO %s_releases (version, released_at) VALUES (?, ?)",
r.table())
_, err := tx.Exec(query, r.Version, r.ReleasedAt)
return err
} | [
"func",
"(",
"r",
"*",
"Release",
")",
"Insert",
"(",
"tx",
"*",
"sql",
".",
"Tx",
")",
"error",
"{",
"if",
"!",
"r",
".",
"validBundle",
"(",
")",
"{",
"return",
"r",
".",
"errInvalidBundle",
"(",
")",
"\n",
"}",
"\n\n",
"query",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"r",
".",
"table",
"(",
")",
")",
"\n",
"_",
",",
"err",
":=",
"tx",
".",
"Exec",
"(",
"query",
",",
"r",
".",
"Version",
",",
"r",
".",
"ReleasedAt",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Insert stores the Release in the database. | [
"Insert",
"stores",
"the",
"Release",
"in",
"the",
"database",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L389-L398 |
14,829 | cloudflare/cfssl_trust | model/certdb/certificate.go | Select | func (r *Release) Select(tx *sql.Tx) error {
if !r.validBundle() {
return r.errInvalidBundle()
}
query := fmt.Sprintf("SELECT released_at FROM %s_releases WHERE version=?", r.table())
row := tx.QueryRow(query, r.Version)
return row.Scan(&r.ReleasedAt)
} | go | func (r *Release) Select(tx *sql.Tx) error {
if !r.validBundle() {
return r.errInvalidBundle()
}
query := fmt.Sprintf("SELECT released_at FROM %s_releases WHERE version=?", r.table())
row := tx.QueryRow(query, r.Version)
return row.Scan(&r.ReleasedAt)
} | [
"func",
"(",
"r",
"*",
"Release",
")",
"Select",
"(",
"tx",
"*",
"sql",
".",
"Tx",
")",
"error",
"{",
"if",
"!",
"r",
".",
"validBundle",
"(",
")",
"{",
"return",
"r",
".",
"errInvalidBundle",
"(",
")",
"\n",
"}",
"\n\n",
"query",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"r",
".",
"table",
"(",
")",
")",
"\n",
"row",
":=",
"tx",
".",
"QueryRow",
"(",
"query",
",",
"r",
".",
"Version",
")",
"\n",
"return",
"row",
".",
"Scan",
"(",
"&",
"r",
".",
"ReleasedAt",
")",
"\n",
"}"
] | // Select requires the Version field to have been populated. | [
"Select",
"requires",
"the",
"Version",
"field",
"to",
"have",
"been",
"populated",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L401-L409 |
14,830 | cloudflare/cfssl_trust | model/certdb/certificate.go | Count | func (r *Release) Count(db *sql.DB) (int, error) {
tx, err := db.Begin()
if err != nil {
return 0, err
}
defer tx.Rollback()
err = r.Select(tx)
if err != nil {
if err == sql.ErrNoRows {
err = errors.New("model/certdb: release doesn't exist")
}
return 0, err
}
var count int
q := fmt.Sprintf("SELECT count(*) FROM %ss WHERE release = ?", r.table())
row := tx.QueryRow(q, r.Version)
err = row.Scan(&count)
if err == nil {
err = tx.Commit()
}
return count, err
} | go | func (r *Release) Count(db *sql.DB) (int, error) {
tx, err := db.Begin()
if err != nil {
return 0, err
}
defer tx.Rollback()
err = r.Select(tx)
if err != nil {
if err == sql.ErrNoRows {
err = errors.New("model/certdb: release doesn't exist")
}
return 0, err
}
var count int
q := fmt.Sprintf("SELECT count(*) FROM %ss WHERE release = ?", r.table())
row := tx.QueryRow(q, r.Version)
err = row.Scan(&count)
if err == nil {
err = tx.Commit()
}
return count, err
} | [
"func",
"(",
"r",
"*",
"Release",
")",
"Count",
"(",
"db",
"*",
"sql",
".",
"DB",
")",
"(",
"int",
",",
"error",
")",
"{",
"tx",
",",
"err",
":=",
"db",
".",
"Begin",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"defer",
"tx",
".",
"Rollback",
"(",
")",
"\n\n",
"err",
"=",
"r",
".",
"Select",
"(",
"tx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"sql",
".",
"ErrNoRows",
"{",
"err",
"=",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"count",
"int",
"\n",
"q",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"r",
".",
"table",
"(",
")",
")",
"\n",
"row",
":=",
"tx",
".",
"QueryRow",
"(",
"q",
",",
"r",
".",
"Version",
")",
"\n",
"err",
"=",
"row",
".",
"Scan",
"(",
"&",
"count",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"tx",
".",
"Commit",
"(",
")",
"\n",
"}",
"\n",
"return",
"count",
",",
"err",
"\n",
"}"
] | // Count requires the Release to be Selectable, and will return the
// number of certificates in the release. | [
"Count",
"requires",
"the",
"Release",
"to",
"be",
"Selectable",
"and",
"will",
"return",
"the",
"number",
"of",
"certificates",
"in",
"the",
"release",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L413-L436 |
14,831 | cloudflare/cfssl_trust | model/certdb/certificate.go | Previous | func (r *Release) Previous(db *sql.DB) (*Release, error) {
tx, err := db.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback()
var prev = &Release{Bundle: r.Bundle}
query := fmt.Sprintf(`SELECT version, released_at FROM %s_releases WHERE released_at < ? ORDER BY released_at DESC LIMIT 1`, r.table())
row := tx.QueryRow(query, r.ReleasedAt)
err = row.Scan(&prev.Version, &prev.ReleasedAt)
if err == nil {
err = tx.Commit()
}
return prev, err
} | go | func (r *Release) Previous(db *sql.DB) (*Release, error) {
tx, err := db.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback()
var prev = &Release{Bundle: r.Bundle}
query := fmt.Sprintf(`SELECT version, released_at FROM %s_releases WHERE released_at < ? ORDER BY released_at DESC LIMIT 1`, r.table())
row := tx.QueryRow(query, r.ReleasedAt)
err = row.Scan(&prev.Version, &prev.ReleasedAt)
if err == nil {
err = tx.Commit()
}
return prev, err
} | [
"func",
"(",
"r",
"*",
"Release",
")",
"Previous",
"(",
"db",
"*",
"sql",
".",
"DB",
")",
"(",
"*",
"Release",
",",
"error",
")",
"{",
"tx",
",",
"err",
":=",
"db",
".",
"Begin",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"tx",
".",
"Rollback",
"(",
")",
"\n\n",
"var",
"prev",
"=",
"&",
"Release",
"{",
"Bundle",
":",
"r",
".",
"Bundle",
"}",
"\n",
"query",
":=",
"fmt",
".",
"Sprintf",
"(",
"`SELECT version, released_at FROM %s_releases WHERE released_at < ? ORDER BY released_at DESC LIMIT 1`",
",",
"r",
".",
"table",
"(",
")",
")",
"\n",
"row",
":=",
"tx",
".",
"QueryRow",
"(",
"query",
",",
"r",
".",
"ReleasedAt",
")",
"\n",
"err",
"=",
"row",
".",
"Scan",
"(",
"&",
"prev",
".",
"Version",
",",
"&",
"prev",
".",
"ReleasedAt",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"tx",
".",
"Commit",
"(",
")",
"\n",
"}",
"\n",
"return",
"prev",
",",
"err",
"\n",
"}"
] | // Previous returns the previous release. The Release must fully filled out. | [
"Previous",
"returns",
"the",
"previous",
"release",
".",
"The",
"Release",
"must",
"fully",
"filled",
"out",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L439-L454 |
14,832 | cloudflare/cfssl_trust | model/certdb/certificate.go | AllReleases | func AllReleases(db *sql.DB, bundle string) ([]*Release, error) {
if !validBundle(bundle) {
return nil, errors.New("model/certdb: invalid bundle " + bundle)
}
tx, err := db.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback() // nop if commit is called.
tbl := tableForBundle(bundle)
var releases []*Release
rows, err := tx.Query(fmt.Sprintf(`SELECT version,released_at FROM %s_releases ORDER BY released_at DESC`, tbl))
if err != nil {
return nil, err
}
for rows.Next() {
release := &Release{Bundle: bundle}
err = rows.Scan(&release.Version, &release.ReleasedAt)
if err != nil {
break
}
releases = append(releases, release)
}
if err == nil {
err = tx.Commit()
}
return releases, err
} | go | func AllReleases(db *sql.DB, bundle string) ([]*Release, error) {
if !validBundle(bundle) {
return nil, errors.New("model/certdb: invalid bundle " + bundle)
}
tx, err := db.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback() // nop if commit is called.
tbl := tableForBundle(bundle)
var releases []*Release
rows, err := tx.Query(fmt.Sprintf(`SELECT version,released_at FROM %s_releases ORDER BY released_at DESC`, tbl))
if err != nil {
return nil, err
}
for rows.Next() {
release := &Release{Bundle: bundle}
err = rows.Scan(&release.Version, &release.ReleasedAt)
if err != nil {
break
}
releases = append(releases, release)
}
if err == nil {
err = tx.Commit()
}
return releases, err
} | [
"func",
"AllReleases",
"(",
"db",
"*",
"sql",
".",
"DB",
",",
"bundle",
"string",
")",
"(",
"[",
"]",
"*",
"Release",
",",
"error",
")",
"{",
"if",
"!",
"validBundle",
"(",
"bundle",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"bundle",
")",
"\n",
"}",
"\n\n",
"tx",
",",
"err",
":=",
"db",
".",
"Begin",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"tx",
".",
"Rollback",
"(",
")",
"// nop if commit is called.",
"\n\n",
"tbl",
":=",
"tableForBundle",
"(",
"bundle",
")",
"\n",
"var",
"releases",
"[",
"]",
"*",
"Release",
"\n\n",
"rows",
",",
"err",
":=",
"tx",
".",
"Query",
"(",
"fmt",
".",
"Sprintf",
"(",
"`SELECT version,released_at FROM %s_releases ORDER BY released_at DESC`",
",",
"tbl",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"rows",
".",
"Next",
"(",
")",
"{",
"release",
":=",
"&",
"Release",
"{",
"Bundle",
":",
"bundle",
"}",
"\n",
"err",
"=",
"rows",
".",
"Scan",
"(",
"&",
"release",
".",
"Version",
",",
"&",
"release",
".",
"ReleasedAt",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"releases",
"=",
"append",
"(",
"releases",
",",
"release",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"tx",
".",
"Commit",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"releases",
",",
"err",
"\n",
"}"
] | // AllReleases returns the list of all releases, sorted in reverse chronological
// order. | [
"AllReleases",
"returns",
"the",
"list",
"of",
"all",
"releases",
"sorted",
"in",
"reverse",
"chronological",
"order",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L458-L491 |
14,833 | cloudflare/cfssl_trust | model/certdb/certificate.go | FetchRelease | func FetchRelease(db *sql.DB, bundle, version string) (*Release, error) {
rel, err := NewRelease(bundle, version)
if err != nil {
return nil, err
}
tx, err := db.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback() // nop if commit is called.
err = rel.Select(tx)
if err != nil {
return nil, err
}
err = tx.Commit()
if err != nil {
return nil, err
}
return rel, nil
} | go | func FetchRelease(db *sql.DB, bundle, version string) (*Release, error) {
rel, err := NewRelease(bundle, version)
if err != nil {
return nil, err
}
tx, err := db.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback() // nop if commit is called.
err = rel.Select(tx)
if err != nil {
return nil, err
}
err = tx.Commit()
if err != nil {
return nil, err
}
return rel, nil
} | [
"func",
"FetchRelease",
"(",
"db",
"*",
"sql",
".",
"DB",
",",
"bundle",
",",
"version",
"string",
")",
"(",
"*",
"Release",
",",
"error",
")",
"{",
"rel",
",",
"err",
":=",
"NewRelease",
"(",
"bundle",
",",
"version",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"tx",
",",
"err",
":=",
"db",
".",
"Begin",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"tx",
".",
"Rollback",
"(",
")",
"// nop if commit is called.",
"\n\n",
"err",
"=",
"rel",
".",
"Select",
"(",
"tx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"tx",
".",
"Commit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"rel",
",",
"nil",
"\n",
"}"
] | // FetchRelease looks for the specified release. It does its own
// transaction to match the style of the other release fetching
// functions. | [
"FetchRelease",
"looks",
"for",
"the",
"specified",
"release",
".",
"It",
"does",
"its",
"own",
"transaction",
"to",
"match",
"the",
"style",
"of",
"the",
"other",
"release",
"fetching",
"functions",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L521-L544 |
14,834 | cloudflare/cfssl_trust | model/certdb/certificate.go | NewCertificateRelease | func NewCertificateRelease(c *Certificate, r *Release) *CertificateRelease {
return &CertificateRelease{
Certificate: c,
Release: r,
}
} | go | func NewCertificateRelease(c *Certificate, r *Release) *CertificateRelease {
return &CertificateRelease{
Certificate: c,
Release: r,
}
} | [
"func",
"NewCertificateRelease",
"(",
"c",
"*",
"Certificate",
",",
"r",
"*",
"Release",
")",
"*",
"CertificateRelease",
"{",
"return",
"&",
"CertificateRelease",
"{",
"Certificate",
":",
"c",
",",
"Release",
":",
"r",
",",
"}",
"\n",
"}"
] | // NewCertificateRelease is a convenience function for building a
// CertificateRelease structure. | [
"NewCertificateRelease",
"is",
"a",
"convenience",
"function",
"for",
"building",
"a",
"CertificateRelease",
"structure",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L555-L560 |
14,835 | cloudflare/cfssl_trust | model/certdb/certificate.go | Select | func (cr *CertificateRelease) Select(tx *sql.Tx) error {
var count int
query := fmt.Sprintf("SELECT count(*) FROM %ss WHERE ski=? AND serial=? AND release=?", cr.Release.table())
row := tx.QueryRow(query, cr.Certificate.SKI, cr.Certificate.Serial, cr.Release.Version)
err := row.Scan(&count)
if err == nil && count == 0 {
return sql.ErrNoRows
}
return err
} | go | func (cr *CertificateRelease) Select(tx *sql.Tx) error {
var count int
query := fmt.Sprintf("SELECT count(*) FROM %ss WHERE ski=? AND serial=? AND release=?", cr.Release.table())
row := tx.QueryRow(query, cr.Certificate.SKI, cr.Certificate.Serial, cr.Release.Version)
err := row.Scan(&count)
if err == nil && count == 0 {
return sql.ErrNoRows
}
return err
} | [
"func",
"(",
"cr",
"*",
"CertificateRelease",
")",
"Select",
"(",
"tx",
"*",
"sql",
".",
"Tx",
")",
"error",
"{",
"var",
"count",
"int",
"\n",
"query",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cr",
".",
"Release",
".",
"table",
"(",
")",
")",
"\n",
"row",
":=",
"tx",
".",
"QueryRow",
"(",
"query",
",",
"cr",
".",
"Certificate",
".",
"SKI",
",",
"cr",
".",
"Certificate",
".",
"Serial",
",",
"cr",
".",
"Release",
".",
"Version",
")",
"\n",
"err",
":=",
"row",
".",
"Scan",
"(",
"&",
"count",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"count",
"==",
"0",
"{",
"return",
"sql",
".",
"ErrNoRows",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // Select requires the Certificate field to have the SKI and Serial
// filled in, and the Release field to have the Version field filled
// in. | [
"Select",
"requires",
"the",
"Certificate",
"field",
"to",
"have",
"the",
"SKI",
"and",
"Serial",
"filled",
"in",
"and",
"the",
"Release",
"field",
"to",
"have",
"the",
"Version",
"field",
"filled",
"in",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L575-L584 |
14,836 | cloudflare/cfssl_trust | model/certdb/certificate.go | Select | func (rev *Revocation) Select(tx *sql.Tx) error {
row := tx.QueryRow(`SELECT revoked_at, mechanism, reason FROM revocations WHERE ski=?`, rev.SKI)
err := row.Scan(&rev.RevokedAt, &rev.Mechanism, &rev.Reason)
if err != nil {
return err
}
return nil
} | go | func (rev *Revocation) Select(tx *sql.Tx) error {
row := tx.QueryRow(`SELECT revoked_at, mechanism, reason FROM revocations WHERE ski=?`, rev.SKI)
err := row.Scan(&rev.RevokedAt, &rev.Mechanism, &rev.Reason)
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"rev",
"*",
"Revocation",
")",
"Select",
"(",
"tx",
"*",
"sql",
".",
"Tx",
")",
"error",
"{",
"row",
":=",
"tx",
".",
"QueryRow",
"(",
"`SELECT revoked_at, mechanism, reason FROM revocations WHERE ski=?`",
",",
"rev",
".",
"SKI",
")",
"\n",
"err",
":=",
"row",
".",
"Scan",
"(",
"&",
"rev",
".",
"RevokedAt",
",",
"&",
"rev",
".",
"Mechanism",
",",
"&",
"rev",
".",
"Reason",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Select requires the SKI field to be filled in. Note that only one
// revocation per SKI should exist. | [
"Select",
"requires",
"the",
"SKI",
"field",
"to",
"be",
"filled",
"in",
".",
"Note",
"that",
"only",
"one",
"revocation",
"per",
"SKI",
"should",
"exist",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L596-L604 |
14,837 | cloudflare/cfssl_trust | model/certdb/certificate.go | Insert | func (rev *Revocation) Insert(tx *sql.Tx) error {
_, err := tx.Exec(`INSERT INTO revocations (ski, revoked_at, mechanism, reason) VALUES (?, ?, ?, ?)`, rev.SKI, rev.RevokedAt, rev.Mechanism, rev.Reason)
return err
} | go | func (rev *Revocation) Insert(tx *sql.Tx) error {
_, err := tx.Exec(`INSERT INTO revocations (ski, revoked_at, mechanism, reason) VALUES (?, ?, ?, ?)`, rev.SKI, rev.RevokedAt, rev.Mechanism, rev.Reason)
return err
} | [
"func",
"(",
"rev",
"*",
"Revocation",
")",
"Insert",
"(",
"tx",
"*",
"sql",
".",
"Tx",
")",
"error",
"{",
"_",
",",
"err",
":=",
"tx",
".",
"Exec",
"(",
"`INSERT INTO revocations (ski, revoked_at, mechanism, reason) VALUES (?, ?, ?, ?)`",
",",
"rev",
".",
"SKI",
",",
"rev",
".",
"RevokedAt",
",",
"rev",
".",
"Mechanism",
",",
"rev",
".",
"Reason",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Insert adds the revocation to the database if no revocation exists
// yet. | [
"Insert",
"adds",
"the",
"revocation",
"to",
"the",
"database",
"if",
"no",
"revocation",
"exists",
"yet",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/model/certdb/certificate.go#L608-L611 |
14,838 | cloudflare/cfssl_trust | config/config.go | GoPath | func GoPath() string {
if path := os.Getenv("GOPATH"); path != "" {
return path
}
// https://github.com/golang/go/issues/17262
return filepath.Join(os.Getenv("HOME"), "go")
} | go | func GoPath() string {
if path := os.Getenv("GOPATH"); path != "" {
return path
}
// https://github.com/golang/go/issues/17262
return filepath.Join(os.Getenv("HOME"), "go")
} | [
"func",
"GoPath",
"(",
")",
"string",
"{",
"if",
"path",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
";",
"path",
"!=",
"\"",
"\"",
"{",
"return",
"path",
"\n",
"}",
"\n",
"// https://github.com/golang/go/issues/17262",
"return",
"filepath",
".",
"Join",
"(",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // GoPath returns the current GOPATH. | [
"GoPath",
"returns",
"the",
"current",
"GOPATH",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/config/config.go#L11-L17 |
14,839 | cloudflare/cfssl_trust | info/search.go | filterCertificates | func filterCertificates(certs []*CertificateMetadata, filters []CertificateFilter) []*CertificateMetadata {
filtered := certs
for _, f := range filters {
filtered = filter(filtered, f)
}
return filtered
} | go | func filterCertificates(certs []*CertificateMetadata, filters []CertificateFilter) []*CertificateMetadata {
filtered := certs
for _, f := range filters {
filtered = filter(filtered, f)
}
return filtered
} | [
"func",
"filterCertificates",
"(",
"certs",
"[",
"]",
"*",
"CertificateMetadata",
",",
"filters",
"[",
"]",
"CertificateFilter",
")",
"[",
"]",
"*",
"CertificateMetadata",
"{",
"filtered",
":=",
"certs",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"filters",
"{",
"filtered",
"=",
"filter",
"(",
"filtered",
",",
"f",
")",
"\n",
"}",
"\n",
"return",
"filtered",
"\n",
"}"
] | // filterCertificates applies the filters to the list of certificates,
// returning only those certificates that match all the filters. | [
"filterCertificates",
"applies",
"the",
"filters",
"to",
"the",
"list",
"of",
"certificates",
"returning",
"only",
"those",
"certificates",
"that",
"match",
"all",
"the",
"filters",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/info/search.go#L28-L34 |
14,840 | cloudflare/cfssl_trust | info/search.go | FilterBySKI | func FilterBySKI(ski string) (CertificateFilter, error) {
skiFilter, err := regexp.Compile(ski)
if err != nil {
return nil, err
}
return func(cm *CertificateMetadata) bool {
return skiFilter.MatchString(cm.SKI)
}, nil
} | go | func FilterBySKI(ski string) (CertificateFilter, error) {
skiFilter, err := regexp.Compile(ski)
if err != nil {
return nil, err
}
return func(cm *CertificateMetadata) bool {
return skiFilter.MatchString(cm.SKI)
}, nil
} | [
"func",
"FilterBySKI",
"(",
"ski",
"string",
")",
"(",
"CertificateFilter",
",",
"error",
")",
"{",
"skiFilter",
",",
"err",
":=",
"regexp",
".",
"Compile",
"(",
"ski",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"func",
"(",
"cm",
"*",
"CertificateMetadata",
")",
"bool",
"{",
"return",
"skiFilter",
".",
"MatchString",
"(",
"cm",
".",
"SKI",
")",
"\n",
"}",
",",
"nil",
"\n",
"}"
] | // FilterBySKI is a CertificateFilter that returns true if the SKI in
// a certificate matches the regular expression passed in. | [
"FilterBySKI",
"is",
"a",
"CertificateFilter",
"that",
"returns",
"true",
"if",
"the",
"SKI",
"in",
"a",
"certificate",
"matches",
"the",
"regular",
"expression",
"passed",
"in",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/info/search.go#L38-L47 |
14,841 | cloudflare/cfssl_trust | info/search.go | FilterByAKI | func FilterByAKI(aki string) (CertificateFilter, error) {
akiFilter, err := regexp.Compile(aki)
if err != nil {
return nil, err
}
return func(cm *CertificateMetadata) bool {
return akiFilter.MatchString(cm.AKI)
}, nil
} | go | func FilterByAKI(aki string) (CertificateFilter, error) {
akiFilter, err := regexp.Compile(aki)
if err != nil {
return nil, err
}
return func(cm *CertificateMetadata) bool {
return akiFilter.MatchString(cm.AKI)
}, nil
} | [
"func",
"FilterByAKI",
"(",
"aki",
"string",
")",
"(",
"CertificateFilter",
",",
"error",
")",
"{",
"akiFilter",
",",
"err",
":=",
"regexp",
".",
"Compile",
"(",
"aki",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"func",
"(",
"cm",
"*",
"CertificateMetadata",
")",
"bool",
"{",
"return",
"akiFilter",
".",
"MatchString",
"(",
"cm",
".",
"AKI",
")",
"\n",
"}",
",",
"nil",
"\n",
"}"
] | // FilterByAKI is a CertificateFilter that returns true if the AKI in
// a certificate matches the regular expression passed in. | [
"FilterByAKI",
"is",
"a",
"CertificateFilter",
"that",
"returns",
"true",
"if",
"the",
"AKI",
"in",
"a",
"certificate",
"matches",
"the",
"regular",
"expression",
"passed",
"in",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/info/search.go#L51-L60 |
14,842 | cloudflare/cfssl_trust | info/search.go | FilterBySubject | func FilterBySubject(subj string) (CertificateFilter, error) {
subjFilter, err := regexp.Compile(subj)
if err != nil {
return nil, err
}
return func(cm *CertificateMetadata) bool {
return subjFilter.MatchString(cm.Subject)
}, nil
} | go | func FilterBySubject(subj string) (CertificateFilter, error) {
subjFilter, err := regexp.Compile(subj)
if err != nil {
return nil, err
}
return func(cm *CertificateMetadata) bool {
return subjFilter.MatchString(cm.Subject)
}, nil
} | [
"func",
"FilterBySubject",
"(",
"subj",
"string",
")",
"(",
"CertificateFilter",
",",
"error",
")",
"{",
"subjFilter",
",",
"err",
":=",
"regexp",
".",
"Compile",
"(",
"subj",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"func",
"(",
"cm",
"*",
"CertificateMetadata",
")",
"bool",
"{",
"return",
"subjFilter",
".",
"MatchString",
"(",
"cm",
".",
"Subject",
")",
"\n",
"}",
",",
"nil",
"\n",
"}"
] | // FilterBySubject is a CertificateFilter that returns true if the
// Subject in a certificate matches the regular expression passed in. | [
"FilterBySubject",
"is",
"a",
"CertificateFilter",
"that",
"returns",
"true",
"if",
"the",
"Subject",
"in",
"a",
"certificate",
"matches",
"the",
"regular",
"expression",
"passed",
"in",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/info/search.go#L64-L73 |
14,843 | cloudflare/cfssl_trust | info/search.go | FilterByIssuer | func FilterByIssuer(iss string) (CertificateFilter, error) {
issFilter, err := regexp.Compile(iss)
if err != nil {
return nil, err
}
return func(cm *CertificateMetadata) bool {
return issFilter.MatchString(cm.Issuer)
}, nil
} | go | func FilterByIssuer(iss string) (CertificateFilter, error) {
issFilter, err := regexp.Compile(iss)
if err != nil {
return nil, err
}
return func(cm *CertificateMetadata) bool {
return issFilter.MatchString(cm.Issuer)
}, nil
} | [
"func",
"FilterByIssuer",
"(",
"iss",
"string",
")",
"(",
"CertificateFilter",
",",
"error",
")",
"{",
"issFilter",
",",
"err",
":=",
"regexp",
".",
"Compile",
"(",
"iss",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"func",
"(",
"cm",
"*",
"CertificateMetadata",
")",
"bool",
"{",
"return",
"issFilter",
".",
"MatchString",
"(",
"cm",
".",
"Issuer",
")",
"\n",
"}",
",",
"nil",
"\n",
"}"
] | // FilterByIssuer is a CertificateFilter that returns true if the
// Issuer in a certificate matches the regular expression passed in. | [
"FilterByIssuer",
"is",
"a",
"CertificateFilter",
"that",
"returns",
"true",
"if",
"the",
"Issuer",
"in",
"a",
"certificate",
"matches",
"the",
"regular",
"expression",
"passed",
"in",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/info/search.go#L77-L86 |
14,844 | cloudflare/cfssl_trust | info/search.go | FilterByRelease | func FilterByRelease(version string) (CertificateFilter, error) {
verFilter, err := regexp.Compile(version)
if err != nil {
return nil, err
}
return func(cm *CertificateMetadata) bool {
for _, rel := range cm.Releases {
if verFilter.MatchString(rel.Version) {
return true
}
}
return false
}, nil
} | go | func FilterByRelease(version string) (CertificateFilter, error) {
verFilter, err := regexp.Compile(version)
if err != nil {
return nil, err
}
return func(cm *CertificateMetadata) bool {
for _, rel := range cm.Releases {
if verFilter.MatchString(rel.Version) {
return true
}
}
return false
}, nil
} | [
"func",
"FilterByRelease",
"(",
"version",
"string",
")",
"(",
"CertificateFilter",
",",
"error",
")",
"{",
"verFilter",
",",
"err",
":=",
"regexp",
".",
"Compile",
"(",
"version",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"func",
"(",
"cm",
"*",
"CertificateMetadata",
")",
"bool",
"{",
"for",
"_",
",",
"rel",
":=",
"range",
"cm",
".",
"Releases",
"{",
"if",
"verFilter",
".",
"MatchString",
"(",
"rel",
".",
"Version",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
",",
"nil",
"\n",
"}"
] | // FilterByRelease is a CertificateFilter that returns true if the
// release version matches the regular expression passed in. | [
"FilterByRelease",
"is",
"a",
"CertificateFilter",
"that",
"returns",
"true",
"if",
"the",
"release",
"version",
"matches",
"the",
"regular",
"expression",
"passed",
"in",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/info/search.go#L90-L104 |
14,845 | cloudflare/cfssl_trust | info/search.go | FilterByBundle | func FilterByBundle(bundle string) (CertificateFilter, error) {
bundleFilter, err := regexp.Compile(bundle)
if err != nil {
return nil, err
}
return func(cm *CertificateMetadata) bool {
for _, rel := range cm.Releases {
if bundleFilter.MatchString(rel.Bundle) {
return true
}
}
return false
}, nil
} | go | func FilterByBundle(bundle string) (CertificateFilter, error) {
bundleFilter, err := regexp.Compile(bundle)
if err != nil {
return nil, err
}
return func(cm *CertificateMetadata) bool {
for _, rel := range cm.Releases {
if bundleFilter.MatchString(rel.Bundle) {
return true
}
}
return false
}, nil
} | [
"func",
"FilterByBundle",
"(",
"bundle",
"string",
")",
"(",
"CertificateFilter",
",",
"error",
")",
"{",
"bundleFilter",
",",
"err",
":=",
"regexp",
".",
"Compile",
"(",
"bundle",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"func",
"(",
"cm",
"*",
"CertificateMetadata",
")",
"bool",
"{",
"for",
"_",
",",
"rel",
":=",
"range",
"cm",
".",
"Releases",
"{",
"if",
"bundleFilter",
".",
"MatchString",
"(",
"rel",
".",
"Bundle",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
",",
"nil",
"\n",
"}"
] | // FilterByBundle is a CertificateFilter that returns true if the
// release bundle matches the regular expression passed in. | [
"FilterByBundle",
"is",
"a",
"CertificateFilter",
"that",
"returns",
"true",
"if",
"the",
"release",
"bundle",
"matches",
"the",
"regular",
"expression",
"passed",
"in",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/info/search.go#L108-L122 |
14,846 | cloudflare/cfssl_trust | info/search.go | Query | func Query(db *sql.DB, terms []string) ([]*CertificateMetadata, error) {
tx, err := db.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback()
certs, err := certdb.AllCertificates(tx)
if err != nil {
return nil, err
}
results := make([]*CertificateMetadata, len(certs))
for i := range certs {
results[i], err = LoadCertificateMetadata(tx, certs[i])
if err != nil {
return nil, err
}
}
filters := make([]CertificateFilter, 0, len(terms))
for _, term := range terms {
f, err := ParseQuery(term)
if err != nil {
return nil, err
}
filters = append(filters, f)
}
err = tx.Commit()
return filterCertificates(results, filters), err
} | go | func Query(db *sql.DB, terms []string) ([]*CertificateMetadata, error) {
tx, err := db.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback()
certs, err := certdb.AllCertificates(tx)
if err != nil {
return nil, err
}
results := make([]*CertificateMetadata, len(certs))
for i := range certs {
results[i], err = LoadCertificateMetadata(tx, certs[i])
if err != nil {
return nil, err
}
}
filters := make([]CertificateFilter, 0, len(terms))
for _, term := range terms {
f, err := ParseQuery(term)
if err != nil {
return nil, err
}
filters = append(filters, f)
}
err = tx.Commit()
return filterCertificates(results, filters), err
} | [
"func",
"Query",
"(",
"db",
"*",
"sql",
".",
"DB",
",",
"terms",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"*",
"CertificateMetadata",
",",
"error",
")",
"{",
"tx",
",",
"err",
":=",
"db",
".",
"Begin",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"tx",
".",
"Rollback",
"(",
")",
"\n\n",
"certs",
",",
"err",
":=",
"certdb",
".",
"AllCertificates",
"(",
"tx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"results",
":=",
"make",
"(",
"[",
"]",
"*",
"CertificateMetadata",
",",
"len",
"(",
"certs",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"certs",
"{",
"results",
"[",
"i",
"]",
",",
"err",
"=",
"LoadCertificateMetadata",
"(",
"tx",
",",
"certs",
"[",
"i",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"filters",
":=",
"make",
"(",
"[",
"]",
"CertificateFilter",
",",
"0",
",",
"len",
"(",
"terms",
")",
")",
"\n",
"for",
"_",
",",
"term",
":=",
"range",
"terms",
"{",
"f",
",",
"err",
":=",
"ParseQuery",
"(",
"term",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"filters",
"=",
"append",
"(",
"filters",
",",
"f",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"tx",
".",
"Commit",
"(",
")",
"\n",
"return",
"filterCertificates",
"(",
"results",
",",
"filters",
")",
",",
"err",
"\n",
"}"
] | // Query searches the database for all certificates matching the search terms. | [
"Query",
"searches",
"the",
"database",
"for",
"all",
"certificates",
"matching",
"the",
"search",
"terms",
"."
] | d6196c3eaf941c8269bf4f41882426440401299b | https://github.com/cloudflare/cfssl_trust/blob/d6196c3eaf941c8269bf4f41882426440401299b/info/search.go#L152-L184 |
14,847 | paulbellamy/ratecounter | counter.go | Incr | func (c *Counter) Incr(val int64) {
atomic.AddInt64((*int64)(c), val)
} | go | func (c *Counter) Incr(val int64) {
atomic.AddInt64((*int64)(c), val)
} | [
"func",
"(",
"c",
"*",
"Counter",
")",
"Incr",
"(",
"val",
"int64",
")",
"{",
"atomic",
".",
"AddInt64",
"(",
"(",
"*",
"int64",
")",
"(",
"c",
")",
",",
"val",
")",
"\n",
"}"
] | // Incr method increments the counter by some value | [
"Incr",
"method",
"increments",
"the",
"counter",
"by",
"some",
"value"
] | a803f0e4f07116687bb30965e8f7d0c32981b63c | https://github.com/paulbellamy/ratecounter/blob/a803f0e4f07116687bb30965e8f7d0c32981b63c/counter.go#L9-L11 |
14,848 | paulbellamy/ratecounter | avgratecounter.go | NewAvgRateCounter | func NewAvgRateCounter(intrvl time.Duration) *AvgRateCounter {
return &AvgRateCounter{
hits: NewRateCounter(intrvl),
counter: NewRateCounter(intrvl),
interval: intrvl,
}
} | go | func NewAvgRateCounter(intrvl time.Duration) *AvgRateCounter {
return &AvgRateCounter{
hits: NewRateCounter(intrvl),
counter: NewRateCounter(intrvl),
interval: intrvl,
}
} | [
"func",
"NewAvgRateCounter",
"(",
"intrvl",
"time",
".",
"Duration",
")",
"*",
"AvgRateCounter",
"{",
"return",
"&",
"AvgRateCounter",
"{",
"hits",
":",
"NewRateCounter",
"(",
"intrvl",
")",
",",
"counter",
":",
"NewRateCounter",
"(",
"intrvl",
")",
",",
"interval",
":",
"intrvl",
",",
"}",
"\n",
"}"
] | // NewAvgRateCounter constructs a new AvgRateCounter, for the interval provided | [
"NewAvgRateCounter",
"constructs",
"a",
"new",
"AvgRateCounter",
"for",
"the",
"interval",
"provided"
] | a803f0e4f07116687bb30965e8f7d0c32981b63c | https://github.com/paulbellamy/ratecounter/blob/a803f0e4f07116687bb30965e8f7d0c32981b63c/avgratecounter.go#L17-L23 |
14,849 | paulbellamy/ratecounter | avgratecounter.go | WithResolution | func (a *AvgRateCounter) WithResolution(resolution int) *AvgRateCounter {
if resolution < 1 {
panic("AvgRateCounter resolution cannot be less than 1")
}
a.hits = a.hits.WithResolution(resolution)
a.counter = a.counter.WithResolution(resolution)
return a
} | go | func (a *AvgRateCounter) WithResolution(resolution int) *AvgRateCounter {
if resolution < 1 {
panic("AvgRateCounter resolution cannot be less than 1")
}
a.hits = a.hits.WithResolution(resolution)
a.counter = a.counter.WithResolution(resolution)
return a
} | [
"func",
"(",
"a",
"*",
"AvgRateCounter",
")",
"WithResolution",
"(",
"resolution",
"int",
")",
"*",
"AvgRateCounter",
"{",
"if",
"resolution",
"<",
"1",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"a",
".",
"hits",
"=",
"a",
".",
"hits",
".",
"WithResolution",
"(",
"resolution",
")",
"\n",
"a",
".",
"counter",
"=",
"a",
".",
"counter",
".",
"WithResolution",
"(",
"resolution",
")",
"\n\n",
"return",
"a",
"\n",
"}"
] | // WithResolution determines the minimum resolution of this counter | [
"WithResolution",
"determines",
"the",
"minimum",
"resolution",
"of",
"this",
"counter"
] | a803f0e4f07116687bb30965e8f7d0c32981b63c | https://github.com/paulbellamy/ratecounter/blob/a803f0e4f07116687bb30965e8f7d0c32981b63c/avgratecounter.go#L26-L35 |
14,850 | paulbellamy/ratecounter | avgratecounter.go | Incr | func (a *AvgRateCounter) Incr(val int64) {
a.hits.Incr(1)
a.counter.Incr(val)
} | go | func (a *AvgRateCounter) Incr(val int64) {
a.hits.Incr(1)
a.counter.Incr(val)
} | [
"func",
"(",
"a",
"*",
"AvgRateCounter",
")",
"Incr",
"(",
"val",
"int64",
")",
"{",
"a",
".",
"hits",
".",
"Incr",
"(",
"1",
")",
"\n",
"a",
".",
"counter",
".",
"Incr",
"(",
"val",
")",
"\n",
"}"
] | // Incr Adds an event into the AvgRateCounter | [
"Incr",
"Adds",
"an",
"event",
"into",
"the",
"AvgRateCounter"
] | a803f0e4f07116687bb30965e8f7d0c32981b63c | https://github.com/paulbellamy/ratecounter/blob/a803f0e4f07116687bb30965e8f7d0c32981b63c/avgratecounter.go#L38-L41 |
14,851 | paulbellamy/ratecounter | avgratecounter.go | Rate | func (a *AvgRateCounter) Rate() float64 {
hits, value := a.hits.Rate(), a.counter.Rate()
if hits == 0 {
return 0 // Avoid division by zero
}
return float64(value) / float64(hits)
} | go | func (a *AvgRateCounter) Rate() float64 {
hits, value := a.hits.Rate(), a.counter.Rate()
if hits == 0 {
return 0 // Avoid division by zero
}
return float64(value) / float64(hits)
} | [
"func",
"(",
"a",
"*",
"AvgRateCounter",
")",
"Rate",
"(",
")",
"float64",
"{",
"hits",
",",
"value",
":=",
"a",
".",
"hits",
".",
"Rate",
"(",
")",
",",
"a",
".",
"counter",
".",
"Rate",
"(",
")",
"\n\n",
"if",
"hits",
"==",
"0",
"{",
"return",
"0",
"// Avoid division by zero",
"\n",
"}",
"\n\n",
"return",
"float64",
"(",
"value",
")",
"/",
"float64",
"(",
"hits",
")",
"\n",
"}"
] | // Rate Returns the current ratio between the events count and its values during the last interval | [
"Rate",
"Returns",
"the",
"current",
"ratio",
"between",
"the",
"events",
"count",
"and",
"its",
"values",
"during",
"the",
"last",
"interval"
] | a803f0e4f07116687bb30965e8f7d0c32981b63c | https://github.com/paulbellamy/ratecounter/blob/a803f0e4f07116687bb30965e8f7d0c32981b63c/avgratecounter.go#L44-L52 |
14,852 | paulbellamy/ratecounter | ratecounter.go | NewRateCounter | func NewRateCounter(intrvl time.Duration) *RateCounter {
ratecounter := &RateCounter{
interval: intrvl,
running: 0,
}
return ratecounter.WithResolution(20)
} | go | func NewRateCounter(intrvl time.Duration) *RateCounter {
ratecounter := &RateCounter{
interval: intrvl,
running: 0,
}
return ratecounter.WithResolution(20)
} | [
"func",
"NewRateCounter",
"(",
"intrvl",
"time",
".",
"Duration",
")",
"*",
"RateCounter",
"{",
"ratecounter",
":=",
"&",
"RateCounter",
"{",
"interval",
":",
"intrvl",
",",
"running",
":",
"0",
",",
"}",
"\n\n",
"return",
"ratecounter",
".",
"WithResolution",
"(",
"20",
")",
"\n",
"}"
] | // NewRateCounter Constructs a new RateCounter, for the interval provided | [
"NewRateCounter",
"Constructs",
"a",
"new",
"RateCounter",
"for",
"the",
"interval",
"provided"
] | a803f0e4f07116687bb30965e8f7d0c32981b63c | https://github.com/paulbellamy/ratecounter/blob/a803f0e4f07116687bb30965e8f7d0c32981b63c/ratecounter.go#L21-L28 |
14,853 | paulbellamy/ratecounter | ratecounter.go | WithResolution | func (r *RateCounter) WithResolution(resolution int) *RateCounter {
if resolution < 1 {
panic("RateCounter resolution cannot be less than 1")
}
r.resolution = resolution
r.partials = make([]Counter, resolution)
r.current = 0
return r
} | go | func (r *RateCounter) WithResolution(resolution int) *RateCounter {
if resolution < 1 {
panic("RateCounter resolution cannot be less than 1")
}
r.resolution = resolution
r.partials = make([]Counter, resolution)
r.current = 0
return r
} | [
"func",
"(",
"r",
"*",
"RateCounter",
")",
"WithResolution",
"(",
"resolution",
"int",
")",
"*",
"RateCounter",
"{",
"if",
"resolution",
"<",
"1",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"r",
".",
"resolution",
"=",
"resolution",
"\n",
"r",
".",
"partials",
"=",
"make",
"(",
"[",
"]",
"Counter",
",",
"resolution",
")",
"\n",
"r",
".",
"current",
"=",
"0",
"\n\n",
"return",
"r",
"\n",
"}"
] | // WithResolution determines the minimum resolution of this counter, default is 20 | [
"WithResolution",
"determines",
"the",
"minimum",
"resolution",
"of",
"this",
"counter",
"default",
"is",
"20"
] | a803f0e4f07116687bb30965e8f7d0c32981b63c | https://github.com/paulbellamy/ratecounter/blob/a803f0e4f07116687bb30965e8f7d0c32981b63c/ratecounter.go#L31-L41 |
14,854 | paulbellamy/ratecounter | ratecounter.go | Incr | func (r *RateCounter) Incr(val int64) {
r.counter.Incr(val)
r.partials[atomic.LoadInt32(&r.current)].Incr(val)
r.run()
} | go | func (r *RateCounter) Incr(val int64) {
r.counter.Incr(val)
r.partials[atomic.LoadInt32(&r.current)].Incr(val)
r.run()
} | [
"func",
"(",
"r",
"*",
"RateCounter",
")",
"Incr",
"(",
"val",
"int64",
")",
"{",
"r",
".",
"counter",
".",
"Incr",
"(",
"val",
")",
"\n",
"r",
".",
"partials",
"[",
"atomic",
".",
"LoadInt32",
"(",
"&",
"r",
".",
"current",
")",
"]",
".",
"Incr",
"(",
"val",
")",
"\n",
"r",
".",
"run",
"(",
")",
"\n",
"}"
] | // Incr Add an event into the RateCounter | [
"Incr",
"Add",
"an",
"event",
"into",
"the",
"RateCounter"
] | a803f0e4f07116687bb30965e8f7d0c32981b63c | https://github.com/paulbellamy/ratecounter/blob/a803f0e4f07116687bb30965e8f7d0c32981b63c/ratecounter.go#L68-L72 |
14,855 | azer/logger | runtime.go | Hook | func Hook(writer OutputWriter) {
writer.Init()
runtime.Writers = append(runtime.Writers, writer)
} | go | func Hook(writer OutputWriter) {
writer.Init()
runtime.Writers = append(runtime.Writers, writer)
} | [
"func",
"Hook",
"(",
"writer",
"OutputWriter",
")",
"{",
"writer",
".",
"Init",
"(",
")",
"\n",
"runtime",
".",
"Writers",
"=",
"append",
"(",
"runtime",
".",
"Writers",
",",
"writer",
")",
"\n",
"}"
] | // Add a new writer | [
"Add",
"a",
"new",
"writer"
] | 3735dd63006daf526f2bb390a7f9e68077eddde8 | https://github.com/azer/logger/blob/3735dd63006daf526f2bb390a7f9e68077eddde8/runtime.go#L56-L59 |
14,856 | azer/logger | logger.go | Info | func (l *Logger) Info(msg string, v ...interface{}) {
l.Log("INFO", msg, v)
} | go | func (l *Logger) Info(msg string, v ...interface{}) {
l.Log("INFO", msg, v)
} | [
"func",
"(",
"l",
"*",
"Logger",
")",
"Info",
"(",
"msg",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"Log",
"(",
"\"",
"\"",
",",
"msg",
",",
"v",
")",
"\n",
"}"
] | // Info prints log information to the screen that is informational in nature. | [
"Info",
"prints",
"log",
"information",
"to",
"the",
"screen",
"that",
"is",
"informational",
"in",
"nature",
"."
] | 3735dd63006daf526f2bb390a7f9e68077eddde8 | https://github.com/azer/logger/blob/3735dd63006daf526f2bb390a7f9e68077eddde8/logger.go#L34-L36 |
14,857 | azer/logger | logger.go | Timer | func (l *Logger) Timer() *Log {
return &Log{
Package: l.Name,
Level: "TIMER",
Time: Now(),
}
} | go | func (l *Logger) Timer() *Log {
return &Log{
Package: l.Name,
Level: "TIMER",
Time: Now(),
}
} | [
"func",
"(",
"l",
"*",
"Logger",
")",
"Timer",
"(",
")",
"*",
"Log",
"{",
"return",
"&",
"Log",
"{",
"Package",
":",
"l",
".",
"Name",
",",
"Level",
":",
"\"",
"\"",
",",
"Time",
":",
"Now",
"(",
")",
",",
"}",
"\n",
"}"
] | // Timer returns a timer sub-logger. | [
"Timer",
"returns",
"a",
"timer",
"sub",
"-",
"logger",
"."
] | 3735dd63006daf526f2bb390a7f9e68077eddde8 | https://github.com/azer/logger/blob/3735dd63006daf526f2bb390a7f9e68077eddde8/logger.go#L44-L50 |
14,858 | azer/logger | log.go | SplitAttrs | func SplitAttrs(v []interface{}) ([]interface{}, *Attrs) {
if len(v) == 0 {
return v, nil
}
attrs, ok := v[len(v)-1].(Attrs)
if !ok {
return v, nil
}
v = v[:len(v)-1]
return v, &attrs
} | go | func SplitAttrs(v []interface{}) ([]interface{}, *Attrs) {
if len(v) == 0 {
return v, nil
}
attrs, ok := v[len(v)-1].(Attrs)
if !ok {
return v, nil
}
v = v[:len(v)-1]
return v, &attrs
} | [
"func",
"SplitAttrs",
"(",
"v",
"[",
"]",
"interface",
"{",
"}",
")",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"*",
"Attrs",
")",
"{",
"if",
"len",
"(",
"v",
")",
"==",
"0",
"{",
"return",
"v",
",",
"nil",
"\n",
"}",
"\n\n",
"attrs",
",",
"ok",
":=",
"v",
"[",
"len",
"(",
"v",
")",
"-",
"1",
"]",
".",
"(",
"Attrs",
")",
"\n\n",
"if",
"!",
"ok",
"{",
"return",
"v",
",",
"nil",
"\n",
"}",
"\n\n",
"v",
"=",
"v",
"[",
":",
"len",
"(",
"v",
")",
"-",
"1",
"]",
"\n",
"return",
"v",
",",
"&",
"attrs",
"\n",
"}"
] | // SplitAttrs checks if the last item passed in v is an Attrs instance,
// if so it returns it separately. If not, v is returned as-is with a nil Attrs. | [
"SplitAttrs",
"checks",
"if",
"the",
"last",
"item",
"passed",
"in",
"v",
"is",
"an",
"Attrs",
"instance",
"if",
"so",
"it",
"returns",
"it",
"separately",
".",
"If",
"not",
"v",
"is",
"returned",
"as",
"-",
"is",
"with",
"a",
"nil",
"Attrs",
"."
] | 3735dd63006daf526f2bb390a7f9e68077eddde8 | https://github.com/azer/logger/blob/3735dd63006daf526f2bb390a7f9e68077eddde8/log.go#L34-L47 |
14,859 | temoto/robotstxt | scanner.go | nextChar | func (s *byteScanner) nextChar() error {
//println("--- nextChar(). Offset / len(s.buf): ", s.pos.Offset, len(s.buf))
if s.pos.Offset >= len(s.buf) {
s.ch = -1
return io.EOF
}
s.pos.Column++
if s.ch == '\n' {
s.pos.Line++
s.pos.Column = 1
}
r, w := rune(s.buf[s.pos.Offset]), 1
if r >= 0x80 {
r, w = utf8.DecodeRune(s.buf[s.pos.Offset:])
if r == utf8.RuneError && w == 1 {
s.error(s.pos, "illegal UTF-8 encoding")
}
}
s.pos.Column++
s.pos.Offset += w
s.ch = r
return nil
} | go | func (s *byteScanner) nextChar() error {
//println("--- nextChar(). Offset / len(s.buf): ", s.pos.Offset, len(s.buf))
if s.pos.Offset >= len(s.buf) {
s.ch = -1
return io.EOF
}
s.pos.Column++
if s.ch == '\n' {
s.pos.Line++
s.pos.Column = 1
}
r, w := rune(s.buf[s.pos.Offset]), 1
if r >= 0x80 {
r, w = utf8.DecodeRune(s.buf[s.pos.Offset:])
if r == utf8.RuneError && w == 1 {
s.error(s.pos, "illegal UTF-8 encoding")
}
}
s.pos.Column++
s.pos.Offset += w
s.ch = r
return nil
} | [
"func",
"(",
"s",
"*",
"byteScanner",
")",
"nextChar",
"(",
")",
"error",
"{",
"//println(\"--- nextChar(). Offset / len(s.buf): \", s.pos.Offset, len(s.buf))",
"if",
"s",
".",
"pos",
".",
"Offset",
">=",
"len",
"(",
"s",
".",
"buf",
")",
"{",
"s",
".",
"ch",
"=",
"-",
"1",
"\n",
"return",
"io",
".",
"EOF",
"\n",
"}",
"\n",
"s",
".",
"pos",
".",
"Column",
"++",
"\n",
"if",
"s",
".",
"ch",
"==",
"'\\n'",
"{",
"s",
".",
"pos",
".",
"Line",
"++",
"\n",
"s",
".",
"pos",
".",
"Column",
"=",
"1",
"\n",
"}",
"\n",
"r",
",",
"w",
":=",
"rune",
"(",
"s",
".",
"buf",
"[",
"s",
".",
"pos",
".",
"Offset",
"]",
")",
",",
"1",
"\n",
"if",
"r",
">=",
"0x80",
"{",
"r",
",",
"w",
"=",
"utf8",
".",
"DecodeRune",
"(",
"s",
".",
"buf",
"[",
"s",
".",
"pos",
".",
"Offset",
":",
"]",
")",
"\n",
"if",
"r",
"==",
"utf8",
".",
"RuneError",
"&&",
"w",
"==",
"1",
"{",
"s",
".",
"error",
"(",
"s",
".",
"pos",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"s",
".",
"pos",
".",
"Column",
"++",
"\n",
"s",
".",
"pos",
".",
"Offset",
"+=",
"w",
"\n",
"s",
".",
"ch",
"=",
"r",
"\n",
"return",
"nil",
"\n",
"}"
] | // Reads next Unicode char. | [
"Reads",
"next",
"Unicode",
"char",
"."
] | 97ee4a9ee6ea01ed0bbf0325dd789f74cac6cb94 | https://github.com/temoto/robotstxt/blob/97ee4a9ee6ea01ed0bbf0325dd789f74cac6cb94/scanner.go#L182-L205 |
14,860 | segmentio/fasthash | fasthash32.go | HashString32 | func HashString32(f func() hash.Hash32) func(string) uint32 {
return func(s string) uint32 {
h := f()
h.Write([]byte(s))
return h.Sum32()
}
} | go | func HashString32(f func() hash.Hash32) func(string) uint32 {
return func(s string) uint32 {
h := f()
h.Write([]byte(s))
return h.Sum32()
}
} | [
"func",
"HashString32",
"(",
"f",
"func",
"(",
")",
"hash",
".",
"Hash32",
")",
"func",
"(",
"string",
")",
"uint32",
"{",
"return",
"func",
"(",
"s",
"string",
")",
"uint32",
"{",
"h",
":=",
"f",
"(",
")",
"\n",
"h",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"s",
")",
")",
"\n",
"return",
"h",
".",
"Sum32",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // HashString32 makes a hashing function from the hashing algorithm returned by f. | [
"HashString32",
"makes",
"a",
"hashing",
"function",
"from",
"the",
"hashing",
"algorithm",
"returned",
"by",
"f",
"."
] | a72b379d632eab4b49e4f4b2c765cfebf0a74796 | https://github.com/segmentio/fasthash/blob/a72b379d632eab4b49e4f4b2c765cfebf0a74796/fasthash32.go#L9-L15 |
14,861 | segmentio/fasthash | fasthash32.go | HashUint32 | func HashUint32(f func() hash.Hash32) func(uint32) uint32 {
return func(u uint32) uint32 {
b := [4]byte{}
binary.BigEndian.PutUint32(b[:], u)
h := f()
h.Write(b[:])
return h.Sum32()
}
} | go | func HashUint32(f func() hash.Hash32) func(uint32) uint32 {
return func(u uint32) uint32 {
b := [4]byte{}
binary.BigEndian.PutUint32(b[:], u)
h := f()
h.Write(b[:])
return h.Sum32()
}
} | [
"func",
"HashUint32",
"(",
"f",
"func",
"(",
")",
"hash",
".",
"Hash32",
")",
"func",
"(",
"uint32",
")",
"uint32",
"{",
"return",
"func",
"(",
"u",
"uint32",
")",
"uint32",
"{",
"b",
":=",
"[",
"4",
"]",
"byte",
"{",
"}",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint32",
"(",
"b",
"[",
":",
"]",
",",
"u",
")",
"\n",
"h",
":=",
"f",
"(",
")",
"\n",
"h",
".",
"Write",
"(",
"b",
"[",
":",
"]",
")",
"\n",
"return",
"h",
".",
"Sum32",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // HashUint32 makes a hashing function from the hashing algorithm return by f. | [
"HashUint32",
"makes",
"a",
"hashing",
"function",
"from",
"the",
"hashing",
"algorithm",
"return",
"by",
"f",
"."
] | a72b379d632eab4b49e4f4b2c765cfebf0a74796 | https://github.com/segmentio/fasthash/blob/a72b379d632eab4b49e4f4b2c765cfebf0a74796/fasthash32.go#L18-L26 |
14,862 | segmentio/fasthash | fnv1a/hash32.go | AddString32 | func AddString32(h uint32, s string) uint32 {
i := 0
n := (len(s) / 8) * 8
for i != n {
h = (h ^ uint32(s[i])) * prime32
h = (h ^ uint32(s[i+1])) * prime32
h = (h ^ uint32(s[i+2])) * prime32
h = (h ^ uint32(s[i+3])) * prime32
h = (h ^ uint32(s[i+4])) * prime32
h = (h ^ uint32(s[i+5])) * prime32
h = (h ^ uint32(s[i+6])) * prime32
h = (h ^ uint32(s[i+7])) * prime32
i += 8
}
for _, c := range s[i:] {
h = (h ^ uint32(c)) * prime32
}
return h
} | go | func AddString32(h uint32, s string) uint32 {
i := 0
n := (len(s) / 8) * 8
for i != n {
h = (h ^ uint32(s[i])) * prime32
h = (h ^ uint32(s[i+1])) * prime32
h = (h ^ uint32(s[i+2])) * prime32
h = (h ^ uint32(s[i+3])) * prime32
h = (h ^ uint32(s[i+4])) * prime32
h = (h ^ uint32(s[i+5])) * prime32
h = (h ^ uint32(s[i+6])) * prime32
h = (h ^ uint32(s[i+7])) * prime32
i += 8
}
for _, c := range s[i:] {
h = (h ^ uint32(c)) * prime32
}
return h
} | [
"func",
"AddString32",
"(",
"h",
"uint32",
",",
"s",
"string",
")",
"uint32",
"{",
"i",
":=",
"0",
"\n",
"n",
":=",
"(",
"len",
"(",
"s",
")",
"/",
"8",
")",
"*",
"8",
"\n\n",
"for",
"i",
"!=",
"n",
"{",
"h",
"=",
"(",
"h",
"^",
"uint32",
"(",
"s",
"[",
"i",
"]",
")",
")",
"*",
"prime32",
"\n",
"h",
"=",
"(",
"h",
"^",
"uint32",
"(",
"s",
"[",
"i",
"+",
"1",
"]",
")",
")",
"*",
"prime32",
"\n",
"h",
"=",
"(",
"h",
"^",
"uint32",
"(",
"s",
"[",
"i",
"+",
"2",
"]",
")",
")",
"*",
"prime32",
"\n",
"h",
"=",
"(",
"h",
"^",
"uint32",
"(",
"s",
"[",
"i",
"+",
"3",
"]",
")",
")",
"*",
"prime32",
"\n",
"h",
"=",
"(",
"h",
"^",
"uint32",
"(",
"s",
"[",
"i",
"+",
"4",
"]",
")",
")",
"*",
"prime32",
"\n",
"h",
"=",
"(",
"h",
"^",
"uint32",
"(",
"s",
"[",
"i",
"+",
"5",
"]",
")",
")",
"*",
"prime32",
"\n",
"h",
"=",
"(",
"h",
"^",
"uint32",
"(",
"s",
"[",
"i",
"+",
"6",
"]",
")",
")",
"*",
"prime32",
"\n",
"h",
"=",
"(",
"h",
"^",
"uint32",
"(",
"s",
"[",
"i",
"+",
"7",
"]",
")",
")",
"*",
"prime32",
"\n",
"i",
"+=",
"8",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"c",
":=",
"range",
"s",
"[",
"i",
":",
"]",
"{",
"h",
"=",
"(",
"h",
"^",
"uint32",
"(",
"c",
")",
")",
"*",
"prime32",
"\n",
"}",
"\n\n",
"return",
"h",
"\n",
"}"
] | // AddString32 adds the hash of s to the precomputed hash value h. | [
"AddString32",
"adds",
"the",
"hash",
"of",
"s",
"to",
"the",
"precomputed",
"hash",
"value",
"h",
"."
] | a72b379d632eab4b49e4f4b2c765cfebf0a74796 | https://github.com/segmentio/fasthash/blob/a72b379d632eab4b49e4f4b2c765cfebf0a74796/fnv1a/hash32.go#L23-L44 |
14,863 | segmentio/fasthash | fnv1a/hash32.go | AddUint32 | func AddUint32(h, u uint32) uint32 {
h = (h ^ ((u >> 24) & 0xFF)) * prime32
h = (h ^ ((u >> 16) & 0xFF)) * prime32
h = (h ^ ((u >> 8) & 0xFF)) * prime32
h = (h ^ ((u >> 0) & 0xFF)) * prime32
return h
} | go | func AddUint32(h, u uint32) uint32 {
h = (h ^ ((u >> 24) & 0xFF)) * prime32
h = (h ^ ((u >> 16) & 0xFF)) * prime32
h = (h ^ ((u >> 8) & 0xFF)) * prime32
h = (h ^ ((u >> 0) & 0xFF)) * prime32
return h
} | [
"func",
"AddUint32",
"(",
"h",
",",
"u",
"uint32",
")",
"uint32",
"{",
"h",
"=",
"(",
"h",
"^",
"(",
"(",
"u",
">>",
"24",
")",
"&",
"0xFF",
")",
")",
"*",
"prime32",
"\n",
"h",
"=",
"(",
"h",
"^",
"(",
"(",
"u",
">>",
"16",
")",
"&",
"0xFF",
")",
")",
"*",
"prime32",
"\n",
"h",
"=",
"(",
"h",
"^",
"(",
"(",
"u",
">>",
"8",
")",
"&",
"0xFF",
")",
")",
"*",
"prime32",
"\n",
"h",
"=",
"(",
"h",
"^",
"(",
"(",
"u",
">>",
"0",
")",
"&",
"0xFF",
")",
")",
"*",
"prime32",
"\n",
"return",
"h",
"\n",
"}"
] | // AddUint32 adds the hash value of the 8 bytes of u to h. | [
"AddUint32",
"adds",
"the",
"hash",
"value",
"of",
"the",
"8",
"bytes",
"of",
"u",
"to",
"h",
"."
] | a72b379d632eab4b49e4f4b2c765cfebf0a74796 | https://github.com/segmentio/fasthash/blob/a72b379d632eab4b49e4f4b2c765cfebf0a74796/fnv1a/hash32.go#L47-L53 |
14,864 | segmentio/fasthash | fasthash.go | HashString64 | func HashString64(f func() hash.Hash64) func(string) uint64 {
return func(s string) uint64 {
h := f()
h.Write([]byte(s))
return h.Sum64()
}
} | go | func HashString64(f func() hash.Hash64) func(string) uint64 {
return func(s string) uint64 {
h := f()
h.Write([]byte(s))
return h.Sum64()
}
} | [
"func",
"HashString64",
"(",
"f",
"func",
"(",
")",
"hash",
".",
"Hash64",
")",
"func",
"(",
"string",
")",
"uint64",
"{",
"return",
"func",
"(",
"s",
"string",
")",
"uint64",
"{",
"h",
":=",
"f",
"(",
")",
"\n",
"h",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"s",
")",
")",
"\n",
"return",
"h",
".",
"Sum64",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // HashString64 makes a hashing function from the hashing algorithm returned by f. | [
"HashString64",
"makes",
"a",
"hashing",
"function",
"from",
"the",
"hashing",
"algorithm",
"returned",
"by",
"f",
"."
] | a72b379d632eab4b49e4f4b2c765cfebf0a74796 | https://github.com/segmentio/fasthash/blob/a72b379d632eab4b49e4f4b2c765cfebf0a74796/fasthash.go#L9-L15 |
14,865 | segmentio/fasthash | fasthash.go | HashUint64 | func HashUint64(f func() hash.Hash64) func(uint64) uint64 {
return func(u uint64) uint64 {
b := [8]byte{}
binary.BigEndian.PutUint64(b[:], u)
h := f()
h.Write(b[:])
return h.Sum64()
}
} | go | func HashUint64(f func() hash.Hash64) func(uint64) uint64 {
return func(u uint64) uint64 {
b := [8]byte{}
binary.BigEndian.PutUint64(b[:], u)
h := f()
h.Write(b[:])
return h.Sum64()
}
} | [
"func",
"HashUint64",
"(",
"f",
"func",
"(",
")",
"hash",
".",
"Hash64",
")",
"func",
"(",
"uint64",
")",
"uint64",
"{",
"return",
"func",
"(",
"u",
"uint64",
")",
"uint64",
"{",
"b",
":=",
"[",
"8",
"]",
"byte",
"{",
"}",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint64",
"(",
"b",
"[",
":",
"]",
",",
"u",
")",
"\n",
"h",
":=",
"f",
"(",
")",
"\n",
"h",
".",
"Write",
"(",
"b",
"[",
":",
"]",
")",
"\n",
"return",
"h",
".",
"Sum64",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // HashUint64 makes a hashing function from the hashing algorithm return by f. | [
"HashUint64",
"makes",
"a",
"hashing",
"function",
"from",
"the",
"hashing",
"algorithm",
"return",
"by",
"f",
"."
] | a72b379d632eab4b49e4f4b2c765cfebf0a74796 | https://github.com/segmentio/fasthash/blob/a72b379d632eab4b49e4f4b2c765cfebf0a74796/fasthash.go#L18-L26 |
14,866 | gauntface/web-push-go | webpush/push.go | headerField | func headerField(headerType string, value []byte) string {
return fmt.Sprintf(`%s=%s`, headerType, base64.URLEncoding.EncodeToString(value))
} | go | func headerField(headerType string, value []byte) string {
return fmt.Sprintf(`%s=%s`, headerType, base64.URLEncoding.EncodeToString(value))
} | [
"func",
"headerField",
"(",
"headerType",
"string",
",",
"value",
"[",
"]",
"byte",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"`%s=%s`",
",",
"headerType",
",",
"base64",
".",
"URLEncoding",
".",
"EncodeToString",
"(",
"value",
")",
")",
"\n",
"}"
] | // A helper for creating the value part of the HTTP encryption headers | [
"A",
"helper",
"for",
"creating",
"the",
"value",
"part",
"of",
"the",
"HTTP",
"encryption",
"headers"
] | 450e1dc947e62d3deca2694c8d06068be8e05a0c | https://github.com/gauntface/web-push-go/blob/450e1dc947e62d3deca2694c8d06068be8e05a0c/webpush/push.go#L91-L93 |
14,867 | gauntface/web-push-go | webpush/encrypt.go | SubscriptionFromJSON | func SubscriptionFromJSON(b []byte) (*Subscription, error) {
var sub struct {
Endpoint string
Keys struct {
P256dh string
Auth string
}
}
if err := json.Unmarshal(b, &sub); err != nil {
return nil, err
}
b64 := base64.URLEncoding.WithPadding(base64.NoPadding)
// Chrome < 52 incorrectly adds padding when Base64 encoding the values, so
// we need to strip that out
key, err := b64.DecodeString(strings.TrimRight(sub.Keys.P256dh, "="))
if err != nil {
return nil, err
}
auth, err := b64.DecodeString(strings.TrimRight(sub.Keys.Auth, "="))
if err != nil {
return nil, err
}
return &Subscription{sub.Endpoint, key, auth}, nil
} | go | func SubscriptionFromJSON(b []byte) (*Subscription, error) {
var sub struct {
Endpoint string
Keys struct {
P256dh string
Auth string
}
}
if err := json.Unmarshal(b, &sub); err != nil {
return nil, err
}
b64 := base64.URLEncoding.WithPadding(base64.NoPadding)
// Chrome < 52 incorrectly adds padding when Base64 encoding the values, so
// we need to strip that out
key, err := b64.DecodeString(strings.TrimRight(sub.Keys.P256dh, "="))
if err != nil {
return nil, err
}
auth, err := b64.DecodeString(strings.TrimRight(sub.Keys.Auth, "="))
if err != nil {
return nil, err
}
return &Subscription{sub.Endpoint, key, auth}, nil
} | [
"func",
"SubscriptionFromJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"*",
"Subscription",
",",
"error",
")",
"{",
"var",
"sub",
"struct",
"{",
"Endpoint",
"string",
"\n",
"Keys",
"struct",
"{",
"P256dh",
"string",
"\n",
"Auth",
"string",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"sub",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"b64",
":=",
"base64",
".",
"URLEncoding",
".",
"WithPadding",
"(",
"base64",
".",
"NoPadding",
")",
"\n\n",
"// Chrome < 52 incorrectly adds padding when Base64 encoding the values, so",
"// we need to strip that out",
"key",
",",
"err",
":=",
"b64",
".",
"DecodeString",
"(",
"strings",
".",
"TrimRight",
"(",
"sub",
".",
"Keys",
".",
"P256dh",
",",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"auth",
",",
"err",
":=",
"b64",
".",
"DecodeString",
"(",
"strings",
".",
"TrimRight",
"(",
"sub",
".",
"Keys",
".",
"Auth",
",",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"Subscription",
"{",
"sub",
".",
"Endpoint",
",",
"key",
",",
"auth",
"}",
",",
"nil",
"\n",
"}"
] | // SubscriptionFromJSON is a convenience function that takes a JSON encoded
// PushSubscription object acquired from the browser and returns a pointer to a
// Subscription | [
"SubscriptionFromJSON",
"is",
"a",
"convenience",
"function",
"that",
"takes",
"a",
"JSON",
"encoded",
"PushSubscription",
"object",
"acquired",
"from",
"the",
"browser",
"and",
"returns",
"a",
"pointer",
"to",
"a",
"Subscription"
] | 450e1dc947e62d3deca2694c8d06068be8e05a0c | https://github.com/gauntface/web-push-go/blob/450e1dc947e62d3deca2694c8d06068be8e05a0c/webpush/encrypt.go#L134-L161 |
14,868 | gauntface/web-push-go | webpush/encrypt.go | sharedSecret | func sharedSecret(curve elliptic.Curve, pub, priv []byte) ([]byte, error) {
publicX, publicY := elliptic.Unmarshal(curve, pub)
if publicX == nil {
return nil, errors.New("Couldn't unmarshal public key. Not a valid point on the curve")
}
x, _ := curve.ScalarMult(publicX, publicY, priv)
return x.Bytes(), nil
} | go | func sharedSecret(curve elliptic.Curve, pub, priv []byte) ([]byte, error) {
publicX, publicY := elliptic.Unmarshal(curve, pub)
if publicX == nil {
return nil, errors.New("Couldn't unmarshal public key. Not a valid point on the curve")
}
x, _ := curve.ScalarMult(publicX, publicY, priv)
return x.Bytes(), nil
} | [
"func",
"sharedSecret",
"(",
"curve",
"elliptic",
".",
"Curve",
",",
"pub",
",",
"priv",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"publicX",
",",
"publicY",
":=",
"elliptic",
".",
"Unmarshal",
"(",
"curve",
",",
"pub",
")",
"\n",
"if",
"publicX",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"x",
",",
"_",
":=",
"curve",
".",
"ScalarMult",
"(",
"publicX",
",",
"publicY",
",",
"priv",
")",
"\n",
"return",
"x",
".",
"Bytes",
"(",
")",
",",
"nil",
"\n",
"}"
] | // Given the coordinates of a party A's public key and the bytes of party B's
// private key, compute a shared secret. | [
"Given",
"the",
"coordinates",
"of",
"a",
"party",
"A",
"s",
"public",
"key",
"and",
"the",
"bytes",
"of",
"party",
"B",
"s",
"private",
"key",
"compute",
"a",
"shared",
"secret",
"."
] | 450e1dc947e62d3deca2694c8d06068be8e05a0c | https://github.com/gauntface/web-push-go/blob/450e1dc947e62d3deca2694c8d06068be8e05a0c/webpush/encrypt.go#L400-L407 |
14,869 | tj/go-dropbox | users.go | GetAccount | func (c *Users) GetAccount(in *GetAccountInput) (out *GetAccountOutput, err error) {
body, err := c.call("/users/get_account", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Users) GetAccount(in *GetAccountInput) (out *GetAccountOutput, err error) {
body, err := c.call("/users/get_account", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Users",
")",
"GetAccount",
"(",
"in",
"*",
"GetAccountInput",
")",
"(",
"out",
"*",
"GetAccountOutput",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"\"",
"\"",
",",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // GetAccount returns information about a user's account. | [
"GetAccount",
"returns",
"information",
"about",
"a",
"user",
"s",
"account",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/users.go#L38-L47 |
14,870 | tj/go-dropbox | users.go | GetCurrentAccount | func (c *Users) GetCurrentAccount() (out *GetCurrentAccountOutput, err error) {
body, err := c.call("/users/get_current_account", nil)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Users) GetCurrentAccount() (out *GetCurrentAccountOutput, err error) {
body, err := c.call("/users/get_current_account", nil)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Users",
")",
"GetCurrentAccount",
"(",
")",
"(",
"out",
"*",
"GetCurrentAccountOutput",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"\"",
"\"",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // GetCurrentAccount returns information about the current user's account. | [
"GetCurrentAccount",
"returns",
"information",
"about",
"the",
"current",
"user",
"s",
"account",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/users.go#L69-L78 |
14,871 | tj/go-dropbox | users.go | GetSpaceUsage | func (c *Users) GetSpaceUsage() (out *GetSpaceUsageOutput, err error) {
body, err := c.call("/users/get_space_usage", nil)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Users) GetSpaceUsage() (out *GetSpaceUsageOutput, err error) {
body, err := c.call("/users/get_space_usage", nil)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Users",
")",
"GetSpaceUsage",
"(",
")",
"(",
"out",
"*",
"GetSpaceUsageOutput",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"\"",
"\"",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // GetSpaceUsage returns space usage information for the current user's account. | [
"GetSpaceUsage",
"returns",
"space",
"usage",
"information",
"for",
"the",
"current",
"user",
"s",
"account",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/users.go#L90-L99 |
14,872 | tj/go-dropbox | sharing.go | CreateSharedLink | func (c *Sharing) CreateSharedLink(in *CreateSharedLinkInput) (out *CreateSharedLinkOutput, err error) {
body, err := c.call("/sharing/create_shared_link_with_settings", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Sharing) CreateSharedLink(in *CreateSharedLinkInput) (out *CreateSharedLinkOutput, err error) {
body, err := c.call("/sharing/create_shared_link_with_settings", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Sharing",
")",
"CreateSharedLink",
"(",
"in",
"*",
"CreateSharedLinkInput",
")",
"(",
"out",
"*",
"CreateSharedLinkOutput",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"\"",
"\"",
",",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // CreateSharedLink returns a shared link. | [
"CreateSharedLink",
"returns",
"a",
"shared",
"link",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/sharing.go#L50-L59 |
14,873 | tj/go-dropbox | sharing.go | ListSharedLinks | func (c *Sharing) ListSharedLinks(in *ListShareLinksInput) (out *ListShareLinksOutput, err error) {
endpoint := "/sharing/list_shared_links"
body, err := c.call(endpoint, in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Sharing) ListSharedLinks(in *ListShareLinksInput) (out *ListShareLinksOutput, err error) {
endpoint := "/sharing/list_shared_links"
body, err := c.call(endpoint, in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Sharing",
")",
"ListSharedLinks",
"(",
"in",
"*",
"ListShareLinksInput",
")",
"(",
"out",
"*",
"ListShareLinksOutput",
",",
"err",
"error",
")",
"{",
"endpoint",
":=",
"\"",
"\"",
"\n",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"endpoint",
",",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // ListSharedLinks gets shared links of input. | [
"ListSharedLinks",
"gets",
"shared",
"links",
"of",
"input",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/sharing.go#L82-L92 |
14,874 | tj/go-dropbox | sharing.go | ListSharedFolders | func (c *Sharing) ListSharedFolders(in *ListSharedFolderInput) (out *ListSharedFolderOutput, err error) {
body, err := c.call("/sharing/list_folders", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Sharing) ListSharedFolders(in *ListSharedFolderInput) (out *ListSharedFolderOutput, err error) {
body, err := c.call("/sharing/list_folders", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Sharing",
")",
"ListSharedFolders",
"(",
"in",
"*",
"ListSharedFolderInput",
")",
"(",
"out",
"*",
"ListSharedFolderOutput",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"\"",
"\"",
",",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // ListSharedFolders returns the list of all shared folders the current user has access to. | [
"ListSharedFolders",
"returns",
"the",
"list",
"of",
"all",
"shared",
"folders",
"the",
"current",
"user",
"has",
"access",
"to",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/sharing.go#L112-L121 |
14,875 | tj/go-dropbox | sharing.go | ListSharedFoldersContinue | func (c *Sharing) ListSharedFoldersContinue(in *ListSharedFolderContinueInput) (out *ListSharedFolderOutput, err error) {
body, err := c.call("/sharing/list_folders/continue", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Sharing) ListSharedFoldersContinue(in *ListSharedFolderContinueInput) (out *ListSharedFolderOutput, err error) {
body, err := c.call("/sharing/list_folders/continue", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Sharing",
")",
"ListSharedFoldersContinue",
"(",
"in",
"*",
"ListSharedFolderContinueInput",
")",
"(",
"out",
"*",
"ListSharedFolderOutput",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"\"",
"\"",
",",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // ListSharedFoldersContinue returns the list of all shared folders the current user has access to. | [
"ListSharedFoldersContinue",
"returns",
"the",
"list",
"of",
"all",
"shared",
"folders",
"the",
"current",
"user",
"has",
"access",
"to",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/sharing.go#L129-L138 |
14,876 | tj/go-dropbox | client.go | call | func (c *Client) call(path string, in interface{}) (io.ReadCloser, error) {
url := "https://api.dropboxapi.com/2" + path
body, err := json.Marshal(in)
if err != nil {
return nil, err
}
req, err := http.NewRequest("POST", url, bytes.NewReader(body))
if err != nil {
return nil, err
}
req.Header.Set("Authorization", "Bearer "+c.AccessToken)
req.Header.Set("Content-Type", "application/json")
r, _, err := c.do(req)
return r, err
} | go | func (c *Client) call(path string, in interface{}) (io.ReadCloser, error) {
url := "https://api.dropboxapi.com/2" + path
body, err := json.Marshal(in)
if err != nil {
return nil, err
}
req, err := http.NewRequest("POST", url, bytes.NewReader(body))
if err != nil {
return nil, err
}
req.Header.Set("Authorization", "Bearer "+c.AccessToken)
req.Header.Set("Content-Type", "application/json")
r, _, err := c.do(req)
return r, err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"call",
"(",
"path",
"string",
",",
"in",
"interface",
"{",
"}",
")",
"(",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"url",
":=",
"\"",
"\"",
"+",
"path",
"\n\n",
"body",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"url",
",",
"bytes",
".",
"NewReader",
"(",
"body",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"c",
".",
"AccessToken",
")",
"\n",
"req",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"r",
",",
"_",
",",
"err",
":=",
"c",
".",
"do",
"(",
"req",
")",
"\n",
"return",
"r",
",",
"err",
"\n",
"}"
] | // call rpc style endpoint. | [
"call",
"rpc",
"style",
"endpoint",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/client.go#L31-L48 |
14,877 | tj/go-dropbox | client.go | download | func (c *Client) download(path string, in interface{}, r io.Reader) (io.ReadCloser, int64, error) {
url := "https://content.dropboxapi.com/2" + path
body, err := json.Marshal(in)
if err != nil {
return nil, 0, err
}
req, err := http.NewRequest("POST", url, r)
if err != nil {
return nil, 0, err
}
req.Header.Set("Authorization", "Bearer "+c.AccessToken)
req.Header.Set("Dropbox-API-Arg", string(body))
if r != nil {
req.Header.Set("Content-Type", "application/octet-stream")
}
return c.do(req)
} | go | func (c *Client) download(path string, in interface{}, r io.Reader) (io.ReadCloser, int64, error) {
url := "https://content.dropboxapi.com/2" + path
body, err := json.Marshal(in)
if err != nil {
return nil, 0, err
}
req, err := http.NewRequest("POST", url, r)
if err != nil {
return nil, 0, err
}
req.Header.Set("Authorization", "Bearer "+c.AccessToken)
req.Header.Set("Dropbox-API-Arg", string(body))
if r != nil {
req.Header.Set("Content-Type", "application/octet-stream")
}
return c.do(req)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"download",
"(",
"path",
"string",
",",
"in",
"interface",
"{",
"}",
",",
"r",
"io",
".",
"Reader",
")",
"(",
"io",
".",
"ReadCloser",
",",
"int64",
",",
"error",
")",
"{",
"url",
":=",
"\"",
"\"",
"+",
"path",
"\n\n",
"body",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"url",
",",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"err",
"\n",
"}",
"\n",
"req",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"c",
".",
"AccessToken",
")",
"\n",
"req",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"string",
"(",
"body",
")",
")",
"\n\n",
"if",
"r",
"!=",
"nil",
"{",
"req",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"c",
".",
"do",
"(",
"req",
")",
"\n",
"}"
] | // download style endpoint. | [
"download",
"style",
"endpoint",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/client.go#L51-L71 |
14,878 | tj/go-dropbox | client.go | do | func (c *Client) do(req *http.Request) (io.ReadCloser, int64, error) {
res, err := c.HTTPClient.Do(req)
if err != nil {
return nil, 0, err
}
if res.StatusCode < 400 {
return res.Body, res.ContentLength, err
}
defer res.Body.Close()
e := &Error{
Status: http.StatusText(res.StatusCode),
StatusCode: res.StatusCode,
}
kind := res.Header.Get("Content-Type")
if strings.Contains(kind, "text/plain") {
if b, err := ioutil.ReadAll(res.Body); err == nil {
e.Summary = string(b)
return nil, 0, e
}
return nil, 0, err
}
if err := json.NewDecoder(res.Body).Decode(e); err != nil {
return nil, 0, err
}
return nil, 0, e
} | go | func (c *Client) do(req *http.Request) (io.ReadCloser, int64, error) {
res, err := c.HTTPClient.Do(req)
if err != nil {
return nil, 0, err
}
if res.StatusCode < 400 {
return res.Body, res.ContentLength, err
}
defer res.Body.Close()
e := &Error{
Status: http.StatusText(res.StatusCode),
StatusCode: res.StatusCode,
}
kind := res.Header.Get("Content-Type")
if strings.Contains(kind, "text/plain") {
if b, err := ioutil.ReadAll(res.Body); err == nil {
e.Summary = string(b)
return nil, 0, e
}
return nil, 0, err
}
if err := json.NewDecoder(res.Body).Decode(e); err != nil {
return nil, 0, err
}
return nil, 0, e
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"do",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"io",
".",
"ReadCloser",
",",
"int64",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"c",
".",
"HTTPClient",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"res",
".",
"StatusCode",
"<",
"400",
"{",
"return",
"res",
".",
"Body",
",",
"res",
".",
"ContentLength",
",",
"err",
"\n",
"}",
"\n\n",
"defer",
"res",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"e",
":=",
"&",
"Error",
"{",
"Status",
":",
"http",
".",
"StatusText",
"(",
"res",
".",
"StatusCode",
")",
",",
"StatusCode",
":",
"res",
".",
"StatusCode",
",",
"}",
"\n\n",
"kind",
":=",
"res",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n\n",
"if",
"strings",
".",
"Contains",
"(",
"kind",
",",
"\"",
"\"",
")",
"{",
"if",
"b",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"res",
".",
"Body",
")",
";",
"err",
"==",
"nil",
"{",
"e",
".",
"Summary",
"=",
"string",
"(",
"b",
")",
"\n",
"return",
"nil",
",",
"0",
",",
"e",
"\n",
"}",
"\n",
"return",
"nil",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"res",
".",
"Body",
")",
".",
"Decode",
"(",
"e",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"0",
",",
"e",
"\n",
"}"
] | // perform the request. | [
"perform",
"the",
"request",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/client.go#L74-L106 |
14,879 | tj/go-dropbox | config.go | NewConfig | func NewConfig(accessToken string) *Config {
return &Config{
HTTPClient: http.DefaultClient,
AccessToken: accessToken,
}
} | go | func NewConfig(accessToken string) *Config {
return &Config{
HTTPClient: http.DefaultClient,
AccessToken: accessToken,
}
} | [
"func",
"NewConfig",
"(",
"accessToken",
"string",
")",
"*",
"Config",
"{",
"return",
"&",
"Config",
"{",
"HTTPClient",
":",
"http",
".",
"DefaultClient",
",",
"AccessToken",
":",
"accessToken",
",",
"}",
"\n",
"}"
] | // NewConfig with the given access token. | [
"NewConfig",
"with",
"the",
"given",
"access",
"token",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/config.go#L14-L19 |
14,880 | tj/go-dropbox | files.go | GetMetadata | func (c *Files) GetMetadata(in *GetMetadataInput) (out *GetMetadataOutput, err error) {
body, err := c.call("/files/get_metadata", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Files) GetMetadata(in *GetMetadataInput) (out *GetMetadataOutput, err error) {
body, err := c.call("/files/get_metadata", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Files",
")",
"GetMetadata",
"(",
"in",
"*",
"GetMetadataInput",
")",
"(",
"out",
"*",
"GetMetadataOutput",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"\"",
"\"",
",",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // GetMetadata returns the metadata for a file or folder. | [
"GetMetadata",
"returns",
"the",
"metadata",
"for",
"a",
"file",
"or",
"folder",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/files.go#L109-L118 |
14,881 | tj/go-dropbox | files.go | CreateFolder | func (c *Files) CreateFolder(in *CreateFolderInput) (out *CreateFolderOutput, err error) {
body, err := c.call("/files/create_folder", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Files) CreateFolder(in *CreateFolderInput) (out *CreateFolderOutput, err error) {
body, err := c.call("/files/create_folder", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Files",
")",
"CreateFolder",
"(",
"in",
"*",
"CreateFolderInput",
")",
"(",
"out",
"*",
"CreateFolderOutput",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"\"",
"\"",
",",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // CreateFolder creates a folder. | [
"CreateFolder",
"creates",
"a",
"folder",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/files.go#L133-L142 |
14,882 | tj/go-dropbox | files.go | Delete | func (c *Files) Delete(in *DeleteInput) (out *DeleteOutput, err error) {
body, err := c.call("/files/delete", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Files) Delete(in *DeleteInput) (out *DeleteOutput, err error) {
body, err := c.call("/files/delete", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Files",
")",
"Delete",
"(",
"in",
"*",
"DeleteInput",
")",
"(",
"out",
"*",
"DeleteOutput",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"\"",
"\"",
",",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // Delete a file or folder and its contents. | [
"Delete",
"a",
"file",
"or",
"folder",
"and",
"its",
"contents",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/files.go#L155-L164 |
14,883 | tj/go-dropbox | files.go | PermanentlyDelete | func (c *Files) PermanentlyDelete(in *PermanentlyDeleteInput) (err error) {
body, err := c.call("/files/delete", in)
if err != nil {
return
}
defer body.Close()
return
} | go | func (c *Files) PermanentlyDelete(in *PermanentlyDeleteInput) (err error) {
body, err := c.call("/files/delete", in)
if err != nil {
return
}
defer body.Close()
return
} | [
"func",
"(",
"c",
"*",
"Files",
")",
"PermanentlyDelete",
"(",
"in",
"*",
"PermanentlyDeleteInput",
")",
"(",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"\"",
"\"",
",",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"return",
"\n",
"}"
] | // PermanentlyDelete a file or folder and its contents. | [
"PermanentlyDelete",
"a",
"file",
"or",
"folder",
"and",
"its",
"contents",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/files.go#L172-L180 |
14,884 | tj/go-dropbox | files.go | Copy | func (c *Files) Copy(in *CopyInput) (out *CopyOutput, err error) {
body, err := c.call("/files/copy", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Files) Copy(in *CopyInput) (out *CopyOutput, err error) {
body, err := c.call("/files/copy", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Files",
")",
"Copy",
"(",
"in",
"*",
"CopyInput",
")",
"(",
"out",
"*",
"CopyOutput",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"\"",
"\"",
",",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // Copy a file or folder to a different location. | [
"Copy",
"a",
"file",
"or",
"folder",
"to",
"a",
"different",
"location",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/files.go#L194-L203 |
14,885 | tj/go-dropbox | files.go | Move | func (c *Files) Move(in *MoveInput) (out *MoveOutput, err error) {
body, err := c.call("/files/move", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Files) Move(in *MoveInput) (out *MoveOutput, err error) {
body, err := c.call("/files/move", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Files",
")",
"Move",
"(",
"in",
"*",
"MoveInput",
")",
"(",
"out",
"*",
"MoveOutput",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"\"",
"\"",
",",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // Move a file or folder to a different location. | [
"Move",
"a",
"file",
"or",
"folder",
"to",
"a",
"different",
"location",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/files.go#L217-L226 |
14,886 | tj/go-dropbox | files.go | Restore | func (c *Files) Restore(in *RestoreInput) (out *RestoreOutput, err error) {
body, err := c.call("/files/restore", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Files) Restore(in *RestoreInput) (out *RestoreOutput, err error) {
body, err := c.call("/files/restore", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Files",
")",
"Restore",
"(",
"in",
"*",
"RestoreInput",
")",
"(",
"out",
"*",
"RestoreOutput",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"\"",
"\"",
",",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // Restore a file to a specific revision. | [
"Restore",
"a",
"file",
"to",
"a",
"specific",
"revision",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/files.go#L240-L249 |
14,887 | tj/go-dropbox | files.go | ListFolder | func (c *Files) ListFolder(in *ListFolderInput) (out *ListFolderOutput, err error) {
in.Path = normalizePath(in.Path)
body, err := c.call("/files/list_folder", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Files) ListFolder(in *ListFolderInput) (out *ListFolderOutput, err error) {
in.Path = normalizePath(in.Path)
body, err := c.call("/files/list_folder", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Files",
")",
"ListFolder",
"(",
"in",
"*",
"ListFolderInput",
")",
"(",
"out",
"*",
"ListFolderOutput",
",",
"err",
"error",
")",
"{",
"in",
".",
"Path",
"=",
"normalizePath",
"(",
"in",
".",
"Path",
")",
"\n\n",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"\"",
"\"",
",",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // ListFolder returns the metadata for a file or folder. | [
"ListFolder",
"returns",
"the",
"metadata",
"for",
"a",
"file",
"or",
"folder",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/files.go#L267-L278 |
14,888 | tj/go-dropbox | files.go | ListFolderContinue | func (c *Files) ListFolderContinue(in *ListFolderContinueInput) (out *ListFolderOutput, err error) {
body, err := c.call("/files/list_folder/continue", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Files) ListFolderContinue(in *ListFolderContinueInput) (out *ListFolderOutput, err error) {
body, err := c.call("/files/list_folder/continue", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Files",
")",
"ListFolderContinue",
"(",
"in",
"*",
"ListFolderContinueInput",
")",
"(",
"out",
"*",
"ListFolderOutput",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"\"",
"\"",
",",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // ListFolderContinue pagenates using the cursor from ListFolder. | [
"ListFolderContinue",
"pagenates",
"using",
"the",
"cursor",
"from",
"ListFolder",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/files.go#L286-L295 |
14,889 | tj/go-dropbox | files.go | Search | func (c *Files) Search(in *SearchInput) (out *SearchOutput, err error) {
in.Path = normalizePath(in.Path)
if in.Mode == "" {
in.Mode = SearchModeFilename
}
body, err := c.call("/files/search", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Files) Search(in *SearchInput) (out *SearchOutput, err error) {
in.Path = normalizePath(in.Path)
if in.Mode == "" {
in.Mode = SearchModeFilename
}
body, err := c.call("/files/search", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Files",
")",
"Search",
"(",
"in",
"*",
"SearchInput",
")",
"(",
"out",
"*",
"SearchOutput",
",",
"err",
"error",
")",
"{",
"in",
".",
"Path",
"=",
"normalizePath",
"(",
"in",
".",
"Path",
")",
"\n\n",
"if",
"in",
".",
"Mode",
"==",
"\"",
"\"",
"{",
"in",
".",
"Mode",
"=",
"SearchModeFilename",
"\n",
"}",
"\n\n",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"\"",
"\"",
",",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // Search for files and folders. | [
"Search",
"for",
"files",
"and",
"folders",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/files.go#L342-L357 |
14,890 | tj/go-dropbox | files.go | Upload | func (c *Files) Upload(in *UploadInput) (out *UploadOutput, err error) {
body, _, err := c.download("/files/upload", in, in.Reader)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Files) Upload(in *UploadInput) (out *UploadOutput, err error) {
body, _, err := c.download("/files/upload", in, in.Reader)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Files",
")",
"Upload",
"(",
"in",
"*",
"UploadInput",
")",
"(",
"out",
"*",
"UploadOutput",
",",
"err",
"error",
")",
"{",
"body",
",",
"_",
",",
"err",
":=",
"c",
".",
"download",
"(",
"\"",
"\"",
",",
"in",
",",
"in",
".",
"Reader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // Upload a file smaller than 150MB. | [
"Upload",
"a",
"file",
"smaller",
"than",
"150MB",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/files.go#L375-L384 |
14,891 | tj/go-dropbox | files.go | Download | func (c *Files) Download(in *DownloadInput) (out *DownloadOutput, err error) {
body, l, err := c.download("/files/download", in, nil)
if err != nil {
return
}
out = &DownloadOutput{body, l}
return
} | go | func (c *Files) Download(in *DownloadInput) (out *DownloadOutput, err error) {
body, l, err := c.download("/files/download", in, nil)
if err != nil {
return
}
out = &DownloadOutput{body, l}
return
} | [
"func",
"(",
"c",
"*",
"Files",
")",
"Download",
"(",
"in",
"*",
"DownloadInput",
")",
"(",
"out",
"*",
"DownloadOutput",
",",
"err",
"error",
")",
"{",
"body",
",",
"l",
",",
"err",
":=",
"c",
".",
"download",
"(",
"\"",
"\"",
",",
"in",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"out",
"=",
"&",
"DownloadOutput",
"{",
"body",
",",
"l",
"}",
"\n",
"return",
"\n",
"}"
] | // Download a file. | [
"Download",
"a",
"file",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/files.go#L398-L406 |
14,892 | tj/go-dropbox | files.go | ListRevisions | func (c *Files) ListRevisions(in *ListRevisionsInput) (out *ListRevisionsOutput, err error) {
body, err := c.call("/files/list_revisions", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | go | func (c *Files) ListRevisions(in *ListRevisionsInput) (out *ListRevisionsOutput, err error) {
body, err := c.call("/files/list_revisions", in)
if err != nil {
return
}
defer body.Close()
err = json.NewDecoder(body).Decode(&out)
return
} | [
"func",
"(",
"c",
"*",
"Files",
")",
"ListRevisions",
"(",
"in",
"*",
"ListRevisionsInput",
")",
"(",
"out",
"*",
"ListRevisionsOutput",
",",
"err",
"error",
")",
"{",
"body",
",",
"err",
":=",
"c",
".",
"call",
"(",
"\"",
"\"",
",",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"body",
")",
".",
"Decode",
"(",
"&",
"out",
")",
"\n",
"return",
"\n",
"}"
] | // ListRevisions gets the revisions of the specified file. | [
"ListRevisions",
"gets",
"the",
"revisions",
"of",
"the",
"specified",
"file",
"."
] | 42dd2be3662d084396bbc756e04116fb30ba7ced | https://github.com/tj/go-dropbox/blob/42dd2be3662d084396bbc756e04116fb30ba7ced/files.go#L496-L505 |
14,893 | gojek/valkyrie | multierror.go | Push | func (m *MultiError) Push(errString string) {
m.mutex.Lock()
defer m.mutex.Unlock()
m.errs = append(m.errs, errors.New(errString))
} | go | func (m *MultiError) Push(errString string) {
m.mutex.Lock()
defer m.mutex.Unlock()
m.errs = append(m.errs, errors.New(errString))
} | [
"func",
"(",
"m",
"*",
"MultiError",
")",
"Push",
"(",
"errString",
"string",
")",
"{",
"m",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"m",
".",
"errs",
"=",
"append",
"(",
"m",
".",
"errs",
",",
"errors",
".",
"New",
"(",
"errString",
")",
")",
"\n",
"}"
] | // Push adds an error to MultiError. | [
"Push",
"adds",
"an",
"error",
"to",
"MultiError",
"."
] | 8f62c1e7ba45ff2cfcd96ce3b39169b3e9af1dc5 | https://github.com/gojek/valkyrie/blob/8f62c1e7ba45ff2cfcd96ce3b39169b3e9af1dc5/multierror.go#L17-L21 |
14,894 | gojek/valkyrie | multierror.go | HasError | func (m *MultiError) HasError() error {
m.mutex.Lock()
defer m.mutex.Unlock()
if len(m.errs) == 0 {
return nil
}
return m
} | go | func (m *MultiError) HasError() error {
m.mutex.Lock()
defer m.mutex.Unlock()
if len(m.errs) == 0 {
return nil
}
return m
} | [
"func",
"(",
"m",
"*",
"MultiError",
")",
"HasError",
"(",
")",
"error",
"{",
"m",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"if",
"len",
"(",
"m",
".",
"errs",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"m",
"\n",
"}"
] | // HasError checks if MultiError has any error. | [
"HasError",
"checks",
"if",
"MultiError",
"has",
"any",
"error",
"."
] | 8f62c1e7ba45ff2cfcd96ce3b39169b3e9af1dc5 | https://github.com/gojek/valkyrie/blob/8f62c1e7ba45ff2cfcd96ce3b39169b3e9af1dc5/multierror.go#L24-L32 |
14,895 | kr/text | wrap.go | WrapBytes | func WrapBytes(b []byte, lim int) []byte {
words := bytes.Split(bytes.Replace(bytes.TrimSpace(b), nl, sp, -1), sp)
var lines [][]byte
for _, line := range WrapWords(words, 1, lim, defaultPenalty) {
lines = append(lines, bytes.Join(line, sp))
}
return bytes.Join(lines, nl)
} | go | func WrapBytes(b []byte, lim int) []byte {
words := bytes.Split(bytes.Replace(bytes.TrimSpace(b), nl, sp, -1), sp)
var lines [][]byte
for _, line := range WrapWords(words, 1, lim, defaultPenalty) {
lines = append(lines, bytes.Join(line, sp))
}
return bytes.Join(lines, nl)
} | [
"func",
"WrapBytes",
"(",
"b",
"[",
"]",
"byte",
",",
"lim",
"int",
")",
"[",
"]",
"byte",
"{",
"words",
":=",
"bytes",
".",
"Split",
"(",
"bytes",
".",
"Replace",
"(",
"bytes",
".",
"TrimSpace",
"(",
"b",
")",
",",
"nl",
",",
"sp",
",",
"-",
"1",
")",
",",
"sp",
")",
"\n",
"var",
"lines",
"[",
"]",
"[",
"]",
"byte",
"\n",
"for",
"_",
",",
"line",
":=",
"range",
"WrapWords",
"(",
"words",
",",
"1",
",",
"lim",
",",
"defaultPenalty",
")",
"{",
"lines",
"=",
"append",
"(",
"lines",
",",
"bytes",
".",
"Join",
"(",
"line",
",",
"sp",
")",
")",
"\n",
"}",
"\n",
"return",
"bytes",
".",
"Join",
"(",
"lines",
",",
"nl",
")",
"\n",
"}"
] | // WrapBytes wraps b into a paragraph of lines of length lim, with minimal
// raggedness. | [
"WrapBytes",
"wraps",
"b",
"into",
"a",
"paragraph",
"of",
"lines",
"of",
"length",
"lim",
"with",
"minimal",
"raggedness",
"."
] | e2ffdb16a802fe2bb95e2e35ff34f0e53aeef34f | https://github.com/kr/text/blob/e2ffdb16a802fe2bb95e2e35ff34f0e53aeef34f/wrap.go#L23-L30 |
14,896 | kr/text | colwriter/column.go | NewWriter | func NewWriter(w io.Writer, width int, flag uint) *Writer {
return &Writer{
w: w,
width: width,
flag: flag,
}
} | go | func NewWriter(w io.Writer, width int, flag uint) *Writer {
return &Writer{
w: w,
width: width,
flag: flag,
}
} | [
"func",
"NewWriter",
"(",
"w",
"io",
".",
"Writer",
",",
"width",
"int",
",",
"flag",
"uint",
")",
"*",
"Writer",
"{",
"return",
"&",
"Writer",
"{",
"w",
":",
"w",
",",
"width",
":",
"width",
",",
"flag",
":",
"flag",
",",
"}",
"\n",
"}"
] | // NewWriter allocates and initializes a new Writer writing to w.
// Parameter width controls the total number of characters on each line
// across all columns. | [
"NewWriter",
"allocates",
"and",
"initializes",
"a",
"new",
"Writer",
"writing",
"to",
"w",
".",
"Parameter",
"width",
"controls",
"the",
"total",
"number",
"of",
"characters",
"on",
"each",
"line",
"across",
"all",
"columns",
"."
] | e2ffdb16a802fe2bb95e2e35ff34f0e53aeef34f | https://github.com/kr/text/blob/e2ffdb16a802fe2bb95e2e35ff34f0e53aeef34f/colwriter/column.go#L42-L48 |
14,897 | kr/text | colwriter/column.go | Write | func (w *Writer) Write(p []byte) (n int, err error) {
var linelen int
var lastWasColon bool
for i, c := range p {
w.buf = append(w.buf, c)
linelen++
if c == '\t' {
w.buf[len(w.buf)-1] = ' '
for linelen%tab != 0 {
w.buf = append(w.buf, ' ')
linelen++
}
}
if w.flag&BreakOnColon != 0 && c == ':' {
lastWasColon = true
} else if lastWasColon {
if c == '\n' {
pos := bytes.LastIndex(w.buf[:len(w.buf)-1], []byte{'\n'})
if pos < 0 {
pos = 0
}
line := w.buf[pos:]
w.buf = w.buf[:pos]
if err = w.columnate(); err != nil {
if len(line) < i {
return i - len(line), err
}
return 0, err
}
if n, err := w.w.Write(line); err != nil {
if r := len(line) - n; r < i {
return i - r, err
}
return 0, err
}
}
lastWasColon = false
}
if c == '\n' {
linelen = 0
}
}
return len(p), nil
} | go | func (w *Writer) Write(p []byte) (n int, err error) {
var linelen int
var lastWasColon bool
for i, c := range p {
w.buf = append(w.buf, c)
linelen++
if c == '\t' {
w.buf[len(w.buf)-1] = ' '
for linelen%tab != 0 {
w.buf = append(w.buf, ' ')
linelen++
}
}
if w.flag&BreakOnColon != 0 && c == ':' {
lastWasColon = true
} else if lastWasColon {
if c == '\n' {
pos := bytes.LastIndex(w.buf[:len(w.buf)-1], []byte{'\n'})
if pos < 0 {
pos = 0
}
line := w.buf[pos:]
w.buf = w.buf[:pos]
if err = w.columnate(); err != nil {
if len(line) < i {
return i - len(line), err
}
return 0, err
}
if n, err := w.w.Write(line); err != nil {
if r := len(line) - n; r < i {
return i - r, err
}
return 0, err
}
}
lastWasColon = false
}
if c == '\n' {
linelen = 0
}
}
return len(p), nil
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"Write",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"var",
"linelen",
"int",
"\n",
"var",
"lastWasColon",
"bool",
"\n",
"for",
"i",
",",
"c",
":=",
"range",
"p",
"{",
"w",
".",
"buf",
"=",
"append",
"(",
"w",
".",
"buf",
",",
"c",
")",
"\n",
"linelen",
"++",
"\n",
"if",
"c",
"==",
"'\\t'",
"{",
"w",
".",
"buf",
"[",
"len",
"(",
"w",
".",
"buf",
")",
"-",
"1",
"]",
"=",
"' '",
"\n",
"for",
"linelen",
"%",
"tab",
"!=",
"0",
"{",
"w",
".",
"buf",
"=",
"append",
"(",
"w",
".",
"buf",
",",
"' '",
")",
"\n",
"linelen",
"++",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"w",
".",
"flag",
"&",
"BreakOnColon",
"!=",
"0",
"&&",
"c",
"==",
"':'",
"{",
"lastWasColon",
"=",
"true",
"\n",
"}",
"else",
"if",
"lastWasColon",
"{",
"if",
"c",
"==",
"'\\n'",
"{",
"pos",
":=",
"bytes",
".",
"LastIndex",
"(",
"w",
".",
"buf",
"[",
":",
"len",
"(",
"w",
".",
"buf",
")",
"-",
"1",
"]",
",",
"[",
"]",
"byte",
"{",
"'\\n'",
"}",
")",
"\n",
"if",
"pos",
"<",
"0",
"{",
"pos",
"=",
"0",
"\n",
"}",
"\n",
"line",
":=",
"w",
".",
"buf",
"[",
"pos",
":",
"]",
"\n",
"w",
".",
"buf",
"=",
"w",
".",
"buf",
"[",
":",
"pos",
"]",
"\n",
"if",
"err",
"=",
"w",
".",
"columnate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"len",
"(",
"line",
")",
"<",
"i",
"{",
"return",
"i",
"-",
"len",
"(",
"line",
")",
",",
"err",
"\n",
"}",
"\n",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"if",
"n",
",",
"err",
":=",
"w",
".",
"w",
".",
"Write",
"(",
"line",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"r",
":=",
"len",
"(",
"line",
")",
"-",
"n",
";",
"r",
"<",
"i",
"{",
"return",
"i",
"-",
"r",
",",
"err",
"\n",
"}",
"\n",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"lastWasColon",
"=",
"false",
"\n",
"}",
"\n",
"if",
"c",
"==",
"'\\n'",
"{",
"linelen",
"=",
"0",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"len",
"(",
"p",
")",
",",
"nil",
"\n",
"}"
] | // Write writes p to the writer w. The only errors returned are ones
// encountered while writing to the underlying output stream. | [
"Write",
"writes",
"p",
"to",
"the",
"writer",
"w",
".",
"The",
"only",
"errors",
"returned",
"are",
"ones",
"encountered",
"while",
"writing",
"to",
"the",
"underlying",
"output",
"stream",
"."
] | e2ffdb16a802fe2bb95e2e35ff34f0e53aeef34f | https://github.com/kr/text/blob/e2ffdb16a802fe2bb95e2e35ff34f0e53aeef34f/colwriter/column.go#L52-L95 |
14,898 | kr/text | indent.go | NewIndentWriter | func NewIndentWriter(w io.Writer, pre ...[]byte) io.Writer {
return &indentWriter{
w: w,
pre: pre,
bol: true,
}
} | go | func NewIndentWriter(w io.Writer, pre ...[]byte) io.Writer {
return &indentWriter{
w: w,
pre: pre,
bol: true,
}
} | [
"func",
"NewIndentWriter",
"(",
"w",
"io",
".",
"Writer",
",",
"pre",
"...",
"[",
"]",
"byte",
")",
"io",
".",
"Writer",
"{",
"return",
"&",
"indentWriter",
"{",
"w",
":",
"w",
",",
"pre",
":",
"pre",
",",
"bol",
":",
"true",
",",
"}",
"\n",
"}"
] | // NewIndentWriter makes a new write filter that indents the input
// lines. Each line is prefixed in order with the corresponding
// element of pre. If there are more lines than elements, the last
// element of pre is repeated for each subsequent line. | [
"NewIndentWriter",
"makes",
"a",
"new",
"write",
"filter",
"that",
"indents",
"the",
"input",
"lines",
".",
"Each",
"line",
"is",
"prefixed",
"in",
"order",
"with",
"the",
"corresponding",
"element",
"of",
"pre",
".",
"If",
"there",
"are",
"more",
"lines",
"than",
"elements",
"the",
"last",
"element",
"of",
"pre",
"is",
"repeated",
"for",
"each",
"subsequent",
"line",
"."
] | e2ffdb16a802fe2bb95e2e35ff34f0e53aeef34f | https://github.com/kr/text/blob/e2ffdb16a802fe2bb95e2e35ff34f0e53aeef34f/indent.go#L41-L47 |
14,899 | kr/text | indent.go | Write | func (w *indentWriter) Write(p []byte) (n int, err error) {
for _, c := range p {
if w.bol {
var i int
i, err = w.w.Write(w.pre[w.sel][w.off:])
w.off += i
if err != nil {
return n, err
}
}
_, err = w.w.Write([]byte{c})
if err != nil {
return n, err
}
n++
w.bol = c == '\n'
if w.bol {
w.off = 0
if w.sel < len(w.pre)-1 {
w.sel++
}
}
}
return n, nil
} | go | func (w *indentWriter) Write(p []byte) (n int, err error) {
for _, c := range p {
if w.bol {
var i int
i, err = w.w.Write(w.pre[w.sel][w.off:])
w.off += i
if err != nil {
return n, err
}
}
_, err = w.w.Write([]byte{c})
if err != nil {
return n, err
}
n++
w.bol = c == '\n'
if w.bol {
w.off = 0
if w.sel < len(w.pre)-1 {
w.sel++
}
}
}
return n, nil
} | [
"func",
"(",
"w",
"*",
"indentWriter",
")",
"Write",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"for",
"_",
",",
"c",
":=",
"range",
"p",
"{",
"if",
"w",
".",
"bol",
"{",
"var",
"i",
"int",
"\n",
"i",
",",
"err",
"=",
"w",
".",
"w",
".",
"Write",
"(",
"w",
".",
"pre",
"[",
"w",
".",
"sel",
"]",
"[",
"w",
".",
"off",
":",
"]",
")",
"\n",
"w",
".",
"off",
"+=",
"i",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"n",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"w",
".",
"w",
".",
"Write",
"(",
"[",
"]",
"byte",
"{",
"c",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"n",
",",
"err",
"\n",
"}",
"\n",
"n",
"++",
"\n",
"w",
".",
"bol",
"=",
"c",
"==",
"'\\n'",
"\n",
"if",
"w",
".",
"bol",
"{",
"w",
".",
"off",
"=",
"0",
"\n",
"if",
"w",
".",
"sel",
"<",
"len",
"(",
"w",
".",
"pre",
")",
"-",
"1",
"{",
"w",
".",
"sel",
"++",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"n",
",",
"nil",
"\n",
"}"
] | // The only errors returned are from the underlying indentWriter. | [
"The",
"only",
"errors",
"returned",
"are",
"from",
"the",
"underlying",
"indentWriter",
"."
] | e2ffdb16a802fe2bb95e2e35ff34f0e53aeef34f | https://github.com/kr/text/blob/e2ffdb16a802fe2bb95e2e35ff34f0e53aeef34f/indent.go#L50-L74 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.