_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q174300 | SetBg | validation | func (i *IrcText) SetBg(c int) *IrcText {
i.bgColor = c
return i
} | go | {
"resource": ""
} |
q174301 | HandlerBuilder | validation | func HandlerBuilder(i interface{}) (scaffold.Handler, error) {
switch i.(type) {
case Handler:
return build(i.(Handler)), nil
case func(context.Context, http.ResponseWriter, *http.Request) error:
return build(HandlerFunc(i.(func(context.Context, http.ResponseWriter, *http.Request) error))), nil
}
return nil, ... | go | {
"resource": ""
} |
q174302 | LoggerWithPrefix | validation | func LoggerWithPrefix(prefix string) func(ctx *neptulon.ReqCtx) error {
if prefix != "" {
prefix = prefix + ": "
}
return func(ctx *neptulon.ReqCtx) error {
var v interface{}
ctx.Params(&v)
err := ctx.Next()
var res interface{}
if res = ctx.Session.Get(CustResLogDataKey); res == nil {
res = ctx.Res... | go | {
"resource": ""
} |
q174303 | NewEncoder | validation | func NewEncoder(defaultEncoding Encoding, encodings ...Encoding) *Encoder {
m := make(map[Encoding]*mimeInfo)
for _, e := range append(encodings, defaultEncoding) {
info := parseMimeInfo(e.Mime())
m[e] = info
}
return &Encoder{
defaultEncoding: defaultEncoding,
encodings: m,
}
} | go | {
"resource": ""
} |
q174304 | Parser | validation | func (e *Encoder) Parser(r *http.Request) Parser {
contentType := r.Header.Get("Content-Type")
info := parseMimeInfo(contentType)
if info != nil {
for encoding, i := range e.encodings {
if i.equals(info) {
return encoding
}
}
}
return e.defaultEncoding
} | go | {
"resource": ""
} |
q174305 | Responder | validation | func (e *Encoder) Responder(r *http.Request) Responder {
accept := r.Header.Get("Accept")
infoList := parseAcceptHeader(accept)
for _, info := range infoList {
for encoding, i := range e.encodings {
if i.equals(info) {
return encoding
}
}
}
return e.Parser(r).(Responder)
} | go | {
"resource": ""
} |
q174306 | NewErrorStatus | validation | func NewErrorStatus(status int, err string) error {
return &errStatus{
error: errors.New(err),
status: status,
}
} | go | {
"resource": ""
} |
q174307 | ConvertErrorStatus | validation | func ConvertErrorStatus(status int, err error) error {
return &errStatus{
error: err,
status: status,
}
} | go | {
"resource": ""
} |
q174308 | Read | validation | func (f FileEntry) Read(p []byte) (n int, err error) {
file := f.pbo.file
offset, err := file.Seek(0, os.SEEK_CUR)
if offset >= f.dataOffset+int64(f.DataBlockSize) {
return 0, io.EOF
}
// If the offset in the file we're in + length of the buffer is greater than the end of the file,
// then instead read in fil... | go | {
"resource": ""
} |
q174309 | EntrySize | validation | func (f HeaderExtension) EntrySize() int {
// Length of the name includes a null terminator
// the 4 * 5 is 4 bytes (uint32) for the 5 fields
baseSize := f.FileEntry.EntrySize()
for key, val := range f.ExtendedFields {
// + 2 for the null terminator for each key/val
baseSize += len(key) + len(val) + 2
}
// ... | go | {
"resource": ""
} |
q174310 | NewLager | validation | func NewLager(log *logger) Logger {
var minLagerLogLevel lager.LogLevel
switch log.LogLevel {
case DEBUG:
minLagerLogLevel = lager.DEBUG
case INFO:
minLagerLogLevel = lager.INFO
case ERROR:
minLagerLogLevel = lager.ERROR
case FATAL:
minLagerLogLevel = lager.FATAL
default:
panic(fmt.Errorf("unknown log ... | go | {
"resource": ""
} |
q174311 | URLParts | validation | func URLParts(ctx context.Context, r *http.Request) (context.Context, []string) {
if ctx == nil {
ctx = context.Background()
}
if parts, ok := ctx.Value("scaffold_url_parts").([]string); ok {
return ctx, parts
}
parts := pathSplit(r.URL.Path)
ctx = context.WithValue(ctx, "scaffold_url_parts", parts)
retur... | go | {
"resource": ""
} |
q174312 | URLPart | validation | func URLPart(ctx context.Context, r *http.Request, i int) (context.Context, string, bool) {
ctx, parts := URLParts(ctx, r)
if len(parts) > i && i >= 0 {
return ctx, parts[i], true
}
return ctx, "", false
} | go | {
"resource": ""
} |
q174313 | StoreParam | validation | func StoreParam(ctx context.Context, name string, value string) context.Context {
n := paramName(name)
return context.WithValue(ctx, n, Param(value))
} | go | {
"resource": ""
} |
q174314 | GetParam | validation | func GetParam(ctx context.Context, name string) Param {
n := paramName(name)
if p, ok := ctx.Value(n).(Param); ok {
return p
}
return ""
} | go | {
"resource": ""
} |
q174315 | Int32 | validation | func (p Param) Int32() (int32, error) {
i, err := strconv.ParseInt(string(p), 10, 32)
return int32(i), err
} | go | {
"resource": ""
} |
q174316 | UInt | validation | func (p Param) UInt() (uint, error) {
i, err := strconv.ParseUint(string(p), 10, strconv.IntSize)
return uint(i), err
} | go | {
"resource": ""
} |
q174317 | UInt32 | validation | func (p Param) UInt32() (uint32, error) {
i, err := strconv.ParseUint(string(p), 10, 32)
return uint32(i), err
} | go | {
"resource": ""
} |
q174318 | Float32 | validation | func (p Param) Float32() (float32, error) {
f, err := strconv.ParseFloat(string(p), 32)
return float32(f), err
} | go | {
"resource": ""
} |
q174319 | UploadFile | validation | func (s *RemoteOperations) UploadFile(lfile io.Reader) (err error) {
var rfile io.WriteCloser
if rfile, err = s.GetRemoteFile(); err == nil {
defer rfile.Close()
_, err = io.Copy(rfile, lfile)
}
return
} | go | {
"resource": ""
} |
q174320 | RemoveRemoteFile | validation | func (s *RemoteOperations) RemoveRemoteFile() (err error) {
var sftpclient SFTPClient
sftpclient, err = s.getClient()
if err == nil {
err = SafeRemoveSSH(sftpclient, s.remotePath)
}
return
} | go | {
"resource": ""
} |
q174321 | GetRemoteFile | validation | func (s *RemoteOperations) GetRemoteFile() (rfile io.WriteCloser, err error) {
var sftpclient SFTPClient
sftpclient, err = s.getClient()
if err == nil {
rfile, err = SafeCreateSSH(sftpclient, s.remotePath)
}
return
} | go | {
"resource": ""
} |
q174322 | NewConn | validation | func NewConn() (*Conn, error) {
id, err := shortid.UUID()
if err != nil {
return nil, err
}
c := &Conn{
ID: id,
Session: cmap.New(),
resRoutes: cmap.New(),
deadline: time.Second * time.Duration(300),
disconnHandler: func(c *Conn) {},
}
c.connected.Store(false)
return c,... | go | {
"resource": ""
} |
q174323 | RemoteAddr | validation | func (c *Conn) RemoteAddr() net.Addr {
ws := c.ws.Load().(*websocket.Conn)
if ws == nil {
return nil
}
return ws.RemoteAddr()
} | go | {
"resource": ""
} |
q174324 | SendRequest | validation | func (c *Conn) SendRequest(method string, params interface{}, resHandler func(res *ResCtx) error) (reqID string, err error) {
id, err := shortid.UUID()
if err != nil {
return "", err
}
req := request{ID: id, Method: method, Params: params}
if err = c.send(req); err != nil {
return "", err
}
c.resRoutes.Set... | go | {
"resource": ""
} |
q174325 | SendRequestArr | validation | func (c *Conn) SendRequestArr(method string, resHandler func(res *ResCtx) error, params ...interface{}) (reqID string, err error) {
return c.SendRequest(method, params, resHandler)
} | go | {
"resource": ""
} |
q174326 | Close | validation | func (c *Conn) Close() error {
c.connected.Store(false)
ws := c.ws.Load().(*websocket.Conn)
if ws != nil {
ws.Close()
}
return nil
} | go | {
"resource": ""
} |
q174327 | sendResponse | validation | func (c *Conn) sendResponse(id string, result interface{}, err *ResError) error {
return c.send(response{ID: id, Result: result, Error: err})
} | go | {
"resource": ""
} |
q174328 | send | validation | func (c *Conn) send(msg interface{}) error {
if !c.connected.Load().(bool) {
return errors.New("use of closed connection")
}
return websocket.JSON.Send(c.ws.Load().(*websocket.Conn), msg)
} | go | {
"resource": ""
} |
q174329 | receive | validation | func (c *Conn) receive(msg *message) error {
if !c.connected.Load().(bool) {
return errors.New("use of closed connection")
}
return websocket.JSON.Receive(c.ws.Load().(*websocket.Conn), &msg)
} | go | {
"resource": ""
} |
q174330 | setConn | validation | func (c *Conn) setConn(ws *websocket.Conn) error {
c.ws.Store(ws)
c.connected.Store(true)
if err := ws.SetDeadline(time.Now().Add(c.deadline)); err != nil {
return fmt.Errorf("conn: error while setting websocket connection deadline: %v", err)
}
return nil
} | go | {
"resource": ""
} |
q174331 | startReceive | validation | func (c *Conn) startReceive() {
recvCounter.Add(1)
defer func() {
c.Close()
c.disconnHandler(c)
recvCounter.Add(-1)
}()
for {
var m message
err := c.receive(&m)
if err != nil {
// if we closed the connection
if !c.connected.Load().(bool) {
log.Printf("conn: closed %v: %v", c.ID, c.RemoteAddr(... | go | {
"resource": ""
} |
q174332 | NewPbo | validation | func NewPbo(path string) (*Pbo, error) {
file, err := os.Open(path)
if err != nil {
return nil, err
}
pbo := Pbo{
file: file,
}
// Create a new buffered reader
reader := bufio.NewReader(file)
for {
entry := readEntry(reader)
if entry.Flag == ProductEntry {
extension := HeaderExtension{
FileEnt... | go | {
"resource": ""
} |
q174333 | NewReadWriteCloser | validation | func NewReadWriteCloser(readErr, writeErr, closeErr error) *MockReadWriteCloser {
return &MockReadWriteCloser{
ReadErr: readErr,
WriteErr: writeErr,
CloseErr: closeErr,
}
} | go | {
"resource": ""
} |
q174334 | Read | validation | func (r *MockReadWriteCloser) Read(p []byte) (n int, err error) {
if err = r.ReadErr; err == nil {
r.BytesRead = p
n = len(p)
}
return
} | go | {
"resource": ""
} |
q174335 | Write | validation | func (r *MockReadWriteCloser) Write(p []byte) (n int, err error) {
if err = r.WriteErr; err != nil {
r.BytesWritten = p
n = len(p)
}
return
} | go | {
"resource": ""
} |
q174336 | SafeRemoveSSH | validation | func SafeRemoveSSH(client SFTPClient, filePath string) (err error) {
ssh := sshClientBucket{
client: client,
}
lo.G.Debug("Preparing to remove %s", filePath)
if !ssh.exists(filePath) {
lo.G.Debug("Removing %s", filePath)
err = client.Remove(filePath)
}
return
} | go | {
"resource": ""
} |
q174337 | SafeCreateSSH | validation | func SafeCreateSSH(client SFTPClient, name ...string) (file *sftp.File, err error) {
ssh := sshClientBucket{
client: client,
}
fpath := path.Join(name...)
basepath := filepath.Dir(fpath)
if err = ssh.remoteSafeMkdirAll(basepath); err == nil {
file, err = client.Create(fpath)
}
return
} | go | {
"resource": ""
} |
q174338 | SafeCreate | validation | func SafeCreate(name ...string) (file *os.File, err error) {
p, e := ensurePath(path.Join(name...))
if e != nil {
return nil, e
}
return os.Create(p)
} | go | {
"resource": ""
} |
q174339 | HMAC | validation | func HMAC(password string) func(ctx *neptulon.ReqCtx) error {
pass := []byte(password)
return func(ctx *neptulon.ReqCtx) error {
// if user is already authenticated
if _, ok := ctx.Conn.Session.GetOk("userid"); ok {
return ctx.Next()
}
// if user is not authenticated.. check the JWT token
var t token
... | go | {
"resource": ""
} |
q174340 | Scaffold | validation | func Scaffold(d Dispatcher, platform Platform) Handler {
router := New(d)
platform.Routes(router)
return router.dispatcher
} | go | {
"resource": ""
} |
q174341 | Route | validation | func (r *Router) Route(pattern string) *Router {
c := r.pattern(pattern)
return r.clone(c)
} | go | {
"resource": ""
} |
q174342 | Group | validation | func (r *Router) Group(pattern string, group func(*Router)) {
c := r.pattern(pattern)
group(r.clone(c))
} | go | {
"resource": ""
} |
q174343 | Platform | validation | func (r *Router) Platform(pattern string, platform Platform) {
c := r.pattern(pattern)
platform.Routes(r.clone(c))
} | go | {
"resource": ""
} |
q174344 | Handle | validation | func (r *Router) Handle(pattern string, handlers ...interface{}) *Router {
c := r.pattern(pattern)
clone := r.clone(c)
clone.handle(handlers)
return clone
} | go | {
"resource": ""
} |
q174345 | Options | validation | func (r *Router) Options(pattern string, handlers ...interface{}) *Router {
c := r.pattern(pattern)
c.Method = "OPTIONS"
clone := r.clone(c)
clone.handle(handlers)
return clone
} | go | {
"resource": ""
} |
q174346 | Use | validation | func (r *Router) Use(middleware ...interface{}) {
r.dispatcher.Middleware(r.route, r.buildMiddlewares(middleware)...)
} | go | {
"resource": ""
} |
q174347 | NotFound | validation | func (r *Router) NotFound(i interface{}) {
handler := r.buildHandler(i)
r.dispatcher.NotFoundHandler(r.route, handler)
} | go | {
"resource": ""
} |
q174348 | AddHandlerBuilder | validation | func (r *Router) AddHandlerBuilder(builder func(interface{}) (Handler, error)) {
r.builders = append(r.builders, &builder)
} | go | {
"resource": ""
} |
q174349 | ServeErrorPage | validation | func (e ErrorHandlerFunc) ServeErrorPage(ctx context.Context, w http.ResponseWriter, r *http.Request, status int, err error) {
e(ctx, w, r, status, err)
} | go | {
"resource": ""
} |
q174350 | GetErrorHandler | validation | func GetErrorHandler(ctx context.Context, status int) ErrorHandler {
key := fmt.Sprintf("error_handler_%d", status)
if h, ok := ctx.Value(key).(ErrorHandler); ok {
return h
}
key = fmt.Sprintf("error_handler_%d", AllStatusCodes)
if h, ok := ctx.Value(key).(ErrorHandler); ok {
return h
}
return DefaultError... | go | {
"resource": ""
} |
q174351 | SetErrorHandler | validation | func SetErrorHandler(status int, handler ErrorHandler) scaffold.Middleware {
return scaffold.Middleware(func(next scaffold.Handler) scaffold.Handler {
return scaffold.HandlerFunc(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
key := fmt.Sprintf("error_handler_%d", status)
ctx = context.Wit... | go | {
"resource": ""
} |
q174352 | SetErrorHandlerFunc | validation | func SetErrorHandlerFunc(status int, handler func(ctx context.Context, w http.ResponseWriter, r *http.Request, status int, err error)) scaffold.Middleware {
return SetErrorHandler(status, ErrorHandlerFunc(handler))
} | go | {
"resource": ""
} |
q174353 | Echo | validation | func Echo(ctx *neptulon.ReqCtx) error {
// unmarshall incoming message into response directly
if err := ctx.Params(&ctx.Res); err != nil {
return err
}
return ctx.Next()
} | go | {
"resource": ""
} |
q174354 | UnmarshalBinary | validation | func (c *ConfigArg) UnmarshalBinary(b []byte) error {
// Must contain minimum length for argument
if len(b) < configArgLen {
return io.ErrUnexpectedEOF
}
// Retrieve basic data
c.BufferCount = binary.BigEndian.Uint16(b[0:2])
c.FirmwareVersion = binary.BigEndian.Uint16(b[2:4])
c.SectorCount = b[4]
// Version... | go | {
"resource": ""
} |
q174355 | ataIdentify | validation | func ataIdentify(r *ATAArg, rs io.ReadSeeker) (*ATAArg, error) {
// Only ATA device identify allowed here
if r.CmdStatus != ATACmdStatusIdentify {
return nil, errATAAbort
}
// Request must be for 1 sector (512 bytes)
if r.SectorCount != 1 {
return nil, errATAAbort
}
// If rs is an Identifier, request its i... | go | {
"resource": ""
} |
q174356 | ataRead | validation | func ataRead(r *ATAArg, rs io.ReadSeeker) (*ATAArg, error) {
// Only ATA reads allowed here
if r.CmdStatus != ATACmdStatusRead28Bit && r.CmdStatus != ATACmdStatusRead48Bit {
return nil, errATAAbort
}
// Read must not be flagged as a write
if r.FlagWrite {
return nil, errATAAbort
}
// Convert LBA to byte of... | go | {
"resource": ""
} |
q174357 | ataWrite | validation | func ataWrite(r *ATAArg, rs io.ReadSeeker) (*ATAArg, error) {
// Only ATA writes allowed here
if r.CmdStatus != ATACmdStatusWrite28Bit && r.CmdStatus != ATACmdStatusWrite48Bit {
return nil, errATAAbort
}
// Write must be flagged as a write
if !r.FlagWrite {
return nil, errATAAbort
}
// Verify that request ... | go | {
"resource": ""
} |
q174358 | calculateLBA | validation | func calculateLBA(rlba [6]uint8, is48Bit bool) int64 {
// Pad two bytes at the end to parse as uint64
b := []byte{
rlba[0],
rlba[1],
rlba[2],
rlba[3],
rlba[4],
rlba[5],
0,
0,
}
lba := binary.LittleEndian.Uint64(b)
// Mask off high bits to limit size to either 48 bit or 28 bit,
// depending on is4... | go | {
"resource": ""
} |
q174359 | MarshalBinary | validation | func (r *ReserveReleaseArg) MarshalBinary() ([]byte, error) {
// Must indicate correct number of hardware addresses
if int(r.NMACs) != len(r.MACs) {
return nil, ErrorBadArgumentParameter
}
// Allocate byte slice for argument and hardware addresses
b := make([]byte, reserveReleaseArgLen+(r.NMACs*6))
b[0] = uin... | go | {
"resource": ""
} |
q174360 | UnmarshalBinary | validation | func (r *ReserveReleaseArg) UnmarshalBinary(b []byte) error {
// Must contain minimum length for argument
if len(b) < reserveReleaseArgLen {
return io.ErrUnexpectedEOF
}
r.Command = ReserveReleaseCommand(b[0])
r.NMACs = b[1]
// Must have exact number of bytes for hardware addresses with
// this count
if len... | go | {
"resource": ""
} |
q174361 | MarshalBinary | validation | func (a *ATAArg) MarshalBinary() ([]byte, error) {
// Allocate correct number of bytes for argument and data
b := make([]byte, ataArgLen+len(a.Data))
// Add bit flags at appropriate positions
//
// 0101 0011
// | | ||
// | | |+-- write flag
// | | +--- asynchronous flag
// | +------- device/head reg... | go | {
"resource": ""
} |
q174362 | New | validation | func New(db *sql.DB, tables Tables) Fixture {
fixture := Fixture{db: db, Tables: tables}
return fixture
} | go | {
"resource": ""
} |
q174363 | FromYAML | validation | func FromYAML(db *sql.DB, yamlIn []byte) (Fixture, error) {
var tables Tables
err := yaml.Unmarshal(yamlIn, &tables)
return New(db, tables), err
} | go | {
"resource": ""
} |
q174364 | FromJSON | validation | func FromJSON(db *sql.DB, jsonIn []byte) (Fixture, error) {
var tables Tables
err := json.Unmarshal(jsonIn, &tables)
return New(db, tables), err
} | go | {
"resource": ""
} |
q174365 | MarshalBinary | validation | func (d *Directive) MarshalBinary() ([]byte, error) {
// Ethernet hardware addresses must be 6 bytes in length
if len(d.MAC) != 6 {
return nil, ErrorBadArgumentParameter
}
// Allocate fixed-length byte structure
b := make([]byte, directiveLen)
// 1 byte reserved
// Add command copy hardware address into Dir... | go | {
"resource": ""
} |
q174366 | MarshalBinary | validation | func (m *MACMaskArg) MarshalBinary() ([]byte, error) {
// Must indicate correct number of directives
if int(m.DirCount) != len(m.Directives) {
return nil, ErrorBadArgumentParameter
}
// Allocate byte slice for argument and all directives
b := make([]byte, macMaskArgLen+(directiveLen*m.DirCount))
// 1 byte res... | go | {
"resource": ""
} |
q174367 | NewSendToLogger | validation | func NewSendToLogger(logger *golog.Logger) LogBackend {
if logger == nil {
return &SendToLogger{
Logger: golog.New(os.Stderr, "", golog.LstdFlags),
}
}
return &SendToLogger{
Logger: logger,
}
} | go | {
"resource": ""
} |
q174368 | NewMulti | validation | func NewMulti(vals ...interface{}) LogBackend {
if len(vals)%2 != 0 {
Fail(e.New("parameters must be in pair of LogBackend and Formatter"))
return nil
}
l := len(vals) / 2
mp := make([]LogBackend, 0, l)
for i := 0; i < len(vals); i += 2 {
bak, ok := vals[i].(LogBackend)
if !ok {
Fail(e.New("not a LogBac... | go | {
"resource": ""
} |
q174369 | OuterLog | validation | func (mp *MultiLog) OuterLog(level Level, tags ...string) io.Writer {
if mp.chouter != nil {
return &outer{
ch: mp.chouter,
buf: make([]byte, 0),
}
}
mp.chclose = make(chan chan struct{})
mp.chouter = make(chan []byte)
if len(mp.mp) < 2 {
return nil
}
f := mp.mp[0].GetF()
logger := f.NewEntry(mp).T... | go | {
"resource": ""
} |
q174370 | PublishPort | validation | func (s *RunConfig) PublishPort(hostPort, containerPort uint16) {
s.Options = append(s.Options, "-p",
fmt.Sprintf("%d:%d", hostPort, containerPort))
} | go | {
"resource": ""
} |
q174371 | Name | validation | func (s *RunConfig) Name(name string) {
s.Options = append(s.Options, "--name", name)
} | go | {
"resource": ""
} |
q174372 | AddArgs | validation | func (s *RunConfig) AddArgs(args ...string) {
s.Args = append(s.Args, args...)
} | go | {
"resource": ""
} |
q174373 | NewCORSHandler | validation | func NewCORSHandler() *CORSHandler {
return &CORSHandler{
PredicateOrigin: raiqub.TrueForAll,
Headers: []string{
"Origin", "X-Requested-With", "Content-Type",
"Accept", "Authorization",
},
ExposedHeaders: make([]string, 0),
}
} | go | {
"resource": ""
} |
q174374 | CreatePreflight | validation | func (s *CORSHandler) CreatePreflight(routes Routes) Routes {
list := make(Routes, 0, len(routes))
hList := make(map[string]*CORSPreflight, len(routes))
for _, v := range routes {
preflight, ok := hList[v.Path]
if !ok {
preflight = &CORSPreflight{
*s,
make([]string, 0, 1),
v.MustAuth,
}
hLis... | go | {
"resource": ""
} |
q174375 | ServeHTTP | validation | func (s *CORSPreflight) ServeHTTP(w http.ResponseWriter, r *http.Request) {
origin := HttpHeader_Origin().GetReader(r.Header)
status := http.StatusBadRequest
msg := ""
defer func() {
w.WriteHeader(status)
w.Write([]byte(msg))
}()
if origin.Value != "" {
if !s.PredicateOrigin(origin.Value) {
status = htt... | go | {
"resource": ""
} |
q174376 | Handle | validation | func (s *CORSMiddleware) Handle(next http.Handler) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
origin := HttpHeader_Origin().GetReader(r.Header)
if r.Method != DEFAULT_CORS_PREFLIGHT_METHOD && origin.Value != "" {
if !s.PredicateOrigin(origin.Value) {
return
}
HttpHeader_Acces... | go | {
"resource": ""
} |
q174377 | NewRandomSourceListSecure | validation | func NewRandomSourceListSecure() RandomSourceList {
return RandomSourceList{
RandomSource{
Reader: rand.Reader,
Weight: DEFAULT_SYS_RAND_SIZE,
},
RandomSource{
Reader: NewRandom(),
Weight: DEFAULT_RAIQUB_RAND_SIZE,
},
}
} | go | {
"resource": ""
} |
q174378 | Handle | validation | func (handler *SyslogHandler) Handle(record *Record) error {
if handler.writter == nil {
writter, err := syslog.Dial(
handler.Network,
handler.Address,
handler.Facility|handler.Severity,
handler.Tag,
)
if err != nil {
return err
}
handler.writter = writter
}
msg := handler.Formatter.Forma... | go | {
"resource": ""
} |
q174379 | Close | validation | func (handler *SyslogHandler) Close() error {
if handler.writter == nil {
return nil
}
return handler.writter.Close()
} | go | {
"resource": ""
} |
q174380 | hasDatePrefix | validation | func hasDatePrefix(s string) bool {
if len(s) < 10 {
return false
}
var count int
for i, r := range s {
if count != i {
return false
}
switch i {
case 4, 7:
if r != '-' {
return false
}
default:
if !isDigit(r) {
return false
}
}
if i == 9 {
// month
if s[5] == '1' {
... | go | {
"resource": ""
} |
q174381 | Match | validation | func (f RuneMatcherFunc) Match(str string) (offset int, matchStr string) {
offset = -1
length := len(str)
if length == 0 {
return
}
for i, r := range str {
if f(r) {
continue
}
if i != 0 {
offset = i
matchStr = str[:i]
return
}
return
}
offset = length
matchStr = str
return
} | go | {
"resource": ""
} |
q174382 | Match | validation | func (m *SuffixMatcher) Match(str string) (offset int, matchStr string) {
offset = -1
// at least 1 character is required to match suffix and matcher
d := len(str) - len(m.suffix)
if d < 1 {
return
}
for i, r := range str {
if i > d {
return
}
// peek string to match to suffix pattern
if i != 0 &&... | go | {
"resource": ""
} |
q174383 | MatchRune | validation | func (m *SuffixMatcher) MatchRune(r rune) bool {
return m.matcher.MatchRune(r)
} | go | {
"resource": ""
} |
q174384 | Match | validation | func (m *FixedLengthMatcher) Match(s string) (offset int, matchStr string) {
if len(s) < m.length || !m.match(s) {
offset = -1
return
}
return m.length, s[:m.length]
} | go | {
"resource": ""
} |
q174385 | Alloc | validation | func (b *RefCountBox) Alloc() (DB, error) {
b.Lock()
defer b.Unlock()
if b.db.DB == nil {
if b.DataPath == nil {
return DB{}, errorsp.WithStacks(ErrBoxDataPathNotSpecified)
}
var db DB
var err error
if b.OpenFunc == nil {
db, err = Open(b.DataPath(), 0644, nil)
} else {
db, err = b.OpenFunc(b.D... | go | {
"resource": ""
} |
q174386 | Free | validation | func (b *RefCountBox) Free() {
b.Lock()
defer b.Unlock()
b.count--
if b.count == 0 {
b.db.Close()
b.db = DB{}
}
} | go | {
"resource": ""
} |
q174387 | Infof | validation | func (g GRPCLoggerV2) Infof(format string, args ...interface{}) {
g.l.Infof(format, args...)
} | go | {
"resource": ""
} |
q174388 | Warningf | validation | func (g GRPCLoggerV2) Warningf(format string, args ...interface{}) {
g.l.Warningf(format, args...)
} | go | {
"resource": ""
} |
q174389 | Errorf | validation | func (g GRPCLoggerV2) Errorf(format string, args ...interface{}) {
g.l.Errorf(format, args...)
} | go | {
"resource": ""
} |
q174390 | Fatalf | validation | func (g GRPCLoggerV2) Fatalf(format string, args ...interface{}) {
g.l.Criticalf(format, args...)
} | go | {
"resource": ""
} |
q174391 | ToPhone | validation | func ToPhone(theString, delimiter string) (string, error) {
f := New(theString)
f.removeNonDigits()
if f.length < 10 {
return "", errors.New(lengthError)
}
var buffer bytes.Buffer
count := 0
switch f.length {
case 10:
buffer.WriteString("(")
for _, i := range f.theString {
count++
buffer.WriteStri... | go | {
"resource": ""
} |
q174392 | ToURL | validation | func ToURL(theString, subdomain string, secure bool) (string, error) {
f := New(theString)
if f.length < 4 {
return "", errors.New(lengthError)
}
f.makeLower()
if secure {
if len(subdomain) > 0 {
return fmt.Sprintf("https://%s.%s", subdomain, f.theString), nil
}
return fmt.Sprintf("https://%s", f.the... | go | {
"resource": ""
} |
q174393 | ToSSN | validation | func ToSSN(theString, delimiter string) (string, error) {
f := New(theString)
f.removeNonDigits()
if f.length != 9 {
return "", errors.New("string needs to be 9 digits for Social Security Numbers")
}
var buffer bytes.Buffer
count := 0
for _, i := range f.theString {
count++
buffer.WriteString(string(i)... | go | {
"resource": ""
} |
q174394 | ToMorseCode | validation | func ToMorseCode(theString string) (string, error) {
f := New(theString)
if f.length < 1 {
return "", errors.New(lengthError)
}
f.makeLower()
var buffer bytes.Buffer
for _, i := range f.theString {
key := string(i)
if _, ok := morse[key]; ok {
buffer.WriteString(morse[key])
} else if key == " " {
... | go | {
"resource": ""
} |
q174395 | ToPirateSpeak | validation | func ToPirateSpeak(theString string) (string, error) {
f := New(theString)
if f.length < 1 {
return "", errors.New(lengthError)
}
f.urlEncodeSpaces()
response, err := http.Get(fmt.Sprintf(pirateLink, f.theString))
if err != nil {
return "", errors.New("unable to convert")
}
defer response.Body.Close()
... | go | {
"resource": ""
} |
q174396 | ToIRSA | validation | func ToIRSA(theString string) (string, error) {
f := New(theString)
if f.length < 1 {
return "", errors.New(lengthError)
}
f.makeLower()
var buffer bytes.Buffer
for _, i := range f.theString {
key := strings.ToLower(string(i))
if _, ok := irsa[key]; ok {
buffer.WriteString(irsa[key] + " ")
}
}
re... | go | {
"resource": ""
} |
q174397 | newDefaultLogger | validation | func newDefaultLogger() *Logger {
return NewLogger("default", DEBUG, []Handler{
&WriteHandler{
Level: DEBUG,
Formatter: &StandardFormatter{TimeFormat: StandardTimeFormat},
Writer: os.Stderr,
},
}, 0)
} | go | {
"resource": ""
} |
q174398 | Logf | validation | func Logf(level Level, format string, a ...interface{}) {
getDefaultLogger().log(level, format, a...)
} | go | {
"resource": ""
} |
q174399 | Sections | validation | func (c *Config) Sections() []string {
var sections []string
for _, sect := range c.sections {
sections = append(sections, sect.name)
}
return sections
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.