_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q172300 | pack9 | validation | func pack9(in []uint32) uint32 {
return 2<<28 |
in[0]<<1 |
in[1]<<4 |
in[2]<<7 |
in[3]<<10 |
in[4]<<13 |
in[5]<<16 |
in[6]<<19 |
in[7]<<22 |
in[8]<<25
} | go | {
"resource": ""
} |
q172301 | pack7 | validation | func pack7(in []uint32) uint32 {
return 3<<28 |
in[0] |
in[1]<<4 |
in[2]<<8 |
in[3]<<12 |
in[4]<<16 |
in[5]<<20 |
in[6]<<24
} | go | {
"resource": ""
} |
q172302 | DecodeAll | validation | func DecodeAll(dst, src []uint64) (value int, err error) {
j := 0
for _, v := range src {
sel := v >> 60
if sel >= 16 {
return 0, fmt.Errorf("invalid selector value: %b", sel)
}
selector[sel].unpack(v, (*[240]uint64)(unsafe.Pointer(&dst[j])))
j += selector[sel].n
}
return j, nil
} | go | {
"resource": ""
} |
q172303 | Out | validation | func (c *Client) Out() []byte {
if c.out.Len() == 0 {
return nil
}
return c.out.Bytes()
} | go | {
"resource": ""
} |
q172304 | Step | validation | func (c *Client) Step(in []byte) bool {
c.out.Reset()
if c.step > 2 || c.err != nil {
return false
}
c.step++
switch c.step {
case 1:
c.err = c.step1(in)
case 2:
c.err = c.step2(in)
case 3:
c.err = c.step3(in)
}
return c.step > 2 || c.err != nil
} | go | {
"resource": ""
} |
q172305 | DialWithTimeout | validation | func DialWithTimeout(url string, timeout time.Duration) (*Session, error) {
info, err := ParseURL(url)
if err != nil {
return nil, err
}
info.Timeout = timeout
return DialWithInfo(info)
} | go | {
"resource": ""
} |
q172306 | ParseURL | validation | func ParseURL(url string) (*DialInfo, error) {
uinfo, err := extractURL(url)
if err != nil {
return nil, err
}
direct := false
mechanism := ""
service := ""
source := ""
setName := ""
poolLimit := 0
for k, v := range uinfo.options {
switch k {
case "authSource":
source = v
case "authMechanism":
... | go | {
"resource": ""
} |
q172307 | LiveServers | validation | func (s *Session) LiveServers() (addrs []string) {
s.m.RLock()
addrs = s.cluster().LiveServers()
s.m.RUnlock()
return addrs
} | go | {
"resource": ""
} |
q172308 | DB | validation | func (s *Session) DB(name string) *Database {
if name == "" {
name = s.defaultdb
}
return &Database{s, name}
} | go | {
"resource": ""
} |
q172309 | C | validation | func (db *Database) C(name string) *Collection {
return &Collection{db, name, db.Name + "." + name}
} | go | {
"resource": ""
} |
q172310 | With | validation | func (db *Database) With(s *Session) *Database {
newdb := *db
newdb.Session = s
return &newdb
} | go | {
"resource": ""
} |
q172311 | With | validation | func (c *Collection) With(s *Session) *Collection {
newdb := *c.Database
newdb.Session = s
newc := *c
newc.Database = &newdb
return &newc
} | go | {
"resource": ""
} |
q172312 | Logout | validation | func (db *Database) Logout() {
session := db.Session
dbname := db.Name
session.m.Lock()
found := false
for i, cred := range session.creds {
if cred.Source == dbname {
copy(session.creds[i:], session.creds[i+1:])
session.creds = session.creds[:len(session.creds)-1]
found = true
break
}
}
if found ... | go | {
"resource": ""
} |
q172313 | LogoutAll | validation | func (s *Session) LogoutAll() {
s.m.Lock()
for _, cred := range s.creds {
if s.masterSocket != nil {
s.masterSocket.Logout(cred.Source)
}
if s.slaveSocket != nil {
s.slaveSocket.Logout(cred.Source)
}
}
s.creds = s.creds[0:0]
s.m.Unlock()
} | go | {
"resource": ""
} |
q172314 | RemoveUser | validation | func (db *Database) RemoveUser(user string) error {
err := db.Run(bson.D{{"dropUser", user}}, nil)
if isNoCmd(err) {
users := db.C("system.users")
return users.Remove(bson.M{"user": user})
}
if isNotFound(err) {
return ErrNotFound
}
return err
} | go | {
"resource": ""
} |
q172315 | New | validation | func (s *Session) New() *Session {
s.m.Lock()
scopy := copySession(s, false)
s.m.Unlock()
scopy.Refresh()
return scopy
} | go | {
"resource": ""
} |
q172316 | Copy | validation | func (s *Session) Copy() *Session {
s.m.Lock()
scopy := copySession(s, true)
s.m.Unlock()
scopy.Refresh()
return scopy
} | go | {
"resource": ""
} |
q172317 | Clone | validation | func (s *Session) Clone() *Session {
s.m.Lock()
scopy := copySession(s, true)
s.m.Unlock()
return scopy
} | go | {
"resource": ""
} |
q172318 | Close | validation | func (s *Session) Close() {
s.m.Lock()
if s.cluster_ != nil {
debugf("Closing session %p", s)
s.unsetSocket()
s.cluster_.Release()
s.cluster_ = nil
}
s.m.Unlock()
} | go | {
"resource": ""
} |
q172319 | Refresh | validation | func (s *Session) Refresh() {
s.m.Lock()
s.slaveOk = s.consistency != Strong
s.unsetSocket()
s.m.Unlock()
} | go | {
"resource": ""
} |
q172320 | SetSyncTimeout | validation | func (s *Session) SetSyncTimeout(d time.Duration) {
s.m.Lock()
s.syncTimeout = d
s.m.Unlock()
} | go | {
"resource": ""
} |
q172321 | SetSocketTimeout | validation | func (s *Session) SetSocketTimeout(d time.Duration) {
s.m.Lock()
s.sockTimeout = d
if s.masterSocket != nil {
s.masterSocket.SetTimeout(d)
}
if s.slaveSocket != nil {
s.slaveSocket.SetTimeout(d)
}
s.m.Unlock()
} | go | {
"resource": ""
} |
q172322 | SetCursorTimeout | validation | func (s *Session) SetCursorTimeout(d time.Duration) {
s.m.Lock()
if d == 0 {
s.queryConfig.op.flags |= flagNoCursorTimeout
} else {
panic("SetCursorTimeout: only 0 (disable timeout) supported for now")
}
s.m.Unlock()
} | go | {
"resource": ""
} |
q172323 | SetPoolLimit | validation | func (s *Session) SetPoolLimit(limit int) {
s.m.Lock()
s.poolLimit = limit
s.m.Unlock()
} | go | {
"resource": ""
} |
q172324 | Safe | validation | func (s *Session) Safe() (safe *Safe) {
s.m.Lock()
defer s.m.Unlock()
if s.safeOp != nil {
cmd := s.safeOp.query.(*getLastError)
safe = &Safe{WTimeout: cmd.WTimeout, FSync: cmd.FSync, J: cmd.J}
switch w := cmd.W.(type) {
case string:
safe.WMode = w
case int:
safe.W = w
}
}
return
} | go | {
"resource": ""
} |
q172325 | Fsync | validation | func (s *Session) Fsync(async bool) error {
return s.Run(bson.D{{"fsync", 1}, {"async", async}}, nil)
} | go | {
"resource": ""
} |
q172326 | FsyncUnlock | validation | func (s *Session) FsyncUnlock() error {
return s.DB("admin").C("$cmd.sys.unlock").Find(nil).One(nil) // WTF?
} | go | {
"resource": ""
} |
q172327 | Repair | validation | func (c *Collection) Repair() *Iter {
// Clone session and set it to Monotonic mode so that the server
// used for the query may be safely obtained afterwards, if
// necessary for iteration when a cursor is received.
session := c.Database.Session
cloned := session.Clone()
cloned.SetMode(Monotonic, false)
defer c... | go | {
"resource": ""
} |
q172328 | Iter | validation | func (p *Pipe) Iter() *Iter {
// Clone session and set it to Monotonic mode so that the server
// used for the query may be safely obtained afterwards, if
// necessary for iteration when a cursor is received.
cloned := p.session.Clone()
cloned.SetMode(Monotonic, false)
defer cloned.Close()
c := p.collection.With... | go | {
"resource": ""
} |
q172329 | One | validation | func (p *Pipe) One(result interface{}) error {
iter := p.Iter()
if iter.Next(result) {
return nil
}
if err := iter.Err(); err != nil {
return err
}
return ErrNotFound
} | go | {
"resource": ""
} |
q172330 | Batch | validation | func (p *Pipe) Batch(n int) *Pipe {
p.batchSize = n
return p
} | go | {
"resource": ""
} |
q172331 | IsDup | validation | func IsDup(err error) bool {
// Besides being handy, helps with MongoDB bugs SERVER-7164 and SERVER-11493.
// What follows makes me sad. Hopefully conventions will be more clear over time.
switch e := err.(type) {
case *LastError:
return e.Code == 11000 || e.Code == 11001 || e.Code == 12582 || e.Code == 16460 && ... | go | {
"resource": ""
} |
q172332 | DropCollection | validation | func (c *Collection) DropCollection() error {
return c.Database.Run(bson.D{{"drop", c.Name}}, nil)
} | go | {
"resource": ""
} |
q172333 | Skip | validation | func (q *Query) Skip(n int) *Query {
q.m.Lock()
q.op.skip = int32(n)
q.m.Unlock()
return q
} | go | {
"resource": ""
} |
q172334 | Limit | validation | func (q *Query) Limit(n int) *Query {
q.m.Lock()
switch {
case n == 1:
q.limit = 1
q.op.limit = -1
case n == math.MinInt32: // -MinInt32 == -MinInt32
q.limit = math.MaxInt32
q.op.limit = math.MinInt32 + 1
case n < 0:
q.limit = int32(-n)
q.op.limit = int32(n)
default:
q.limit = int32(n)
q.op.limit ... | go | {
"resource": ""
} |
q172335 | SetMaxScan | validation | func (q *Query) SetMaxScan(n int) *Query {
q.m.Lock()
q.op.options.MaxScan = n
q.op.hasOptions = true
q.m.Unlock()
return q
} | go | {
"resource": ""
} |
q172336 | LogReplay | validation | func (q *Query) LogReplay() *Query {
q.m.Lock()
q.op.flags |= flagLogReplay
q.m.Unlock()
return q
} | go | {
"resource": ""
} |
q172337 | CollectionNames | validation | func (db *Database) CollectionNames() (names []string, err error) {
// Clone session and set it to Monotonic mode so that the server
// used for the query may be safely obtained afterwards, if
// necessary for iteration when a cursor is received.
session := db.Session
cloned := session.Clone()
cloned.SetMode(Mono... | go | {
"resource": ""
} |
q172338 | DatabaseNames | validation | func (s *Session) DatabaseNames() (names []string, err error) {
var result dbNames
err = s.Run("listDatabases", &result)
if err != nil {
return nil, err
}
for _, db := range result.Databases {
if !db.Empty {
names = append(names, db.Name)
}
}
sort.Strings(names)
return names, nil
} | go | {
"resource": ""
} |
q172339 | Timeout | validation | func (iter *Iter) Timeout() bool {
iter.m.Lock()
result := iter.timedout
iter.m.Unlock()
return result
} | go | {
"resource": ""
} |
q172340 | Count | validation | func (q *Query) Count() (n int, err error) {
q.m.Lock()
session := q.session
op := q.op
limit := q.limit
q.m.Unlock()
c := strings.Index(op.collection, ".")
if c < 0 {
return 0, errors.New("Bad collection name: " + op.collection)
}
dbname := op.collection[:c]
cname := op.collection[c+1:]
query := op.quer... | go | {
"resource": ""
} |
q172341 | Count | validation | func (c *Collection) Count() (n int, err error) {
return c.Find(nil).Count()
} | go | {
"resource": ""
} |
q172342 | VersionAtLeast | validation | func (bi *BuildInfo) VersionAtLeast(version ...int) bool {
for i := range version {
if i == len(bi.VersionArray) {
return false
}
if bi.VersionArray[i] < version[i] {
return false
}
}
return true
} | go | {
"resource": ""
} |
q172343 | BuildInfo | validation | func (s *Session) BuildInfo() (info BuildInfo, err error) {
err = s.Run(bson.D{{"buildInfo", "1"}}, &info)
if len(info.VersionArray) == 0 {
for _, a := range strings.Split(info.Version, ".") {
i, err := strconv.Atoi(a)
if err != nil {
break
}
info.VersionArray = append(info.VersionArray, i)
}
}
... | go | {
"resource": ""
} |
q172344 | setSocket | validation | func (s *Session) setSocket(socket *mongoSocket) {
info := socket.Acquire()
if info.Master {
if s.masterSocket != nil {
panic("setSocket(master) with existing master socket reserved")
}
s.masterSocket = socket
} else {
if s.slaveSocket != nil {
panic("setSocket(slave) with existing slave socket reserve... | go | {
"resource": ""
} |
q172345 | writeQuery | validation | func (c *Collection) writeQuery(op interface{}) (lerr *LastError, err error) {
s := c.Database.Session
dbname := c.Database.Name
socket, err := s.acquireSocket(dbname == "local")
if err != nil {
return nil, err
}
defer socket.Release()
s.m.RLock()
safeOp := s.safeOp
s.m.RUnlock()
// TODO Enable this path ... | go | {
"resource": ""
} |
q172346 | Acquire | validation | func (cluster *mongoCluster) Acquire() {
cluster.Lock()
cluster.references++
debugf("Cluster %p acquired (refs=%d)", cluster, cluster.references)
cluster.Unlock()
} | go | {
"resource": ""
} |
q172347 | Release | validation | func (cluster *mongoCluster) Release() {
cluster.Lock()
if cluster.references == 0 {
panic("cluster.Release() with references == 0")
}
cluster.references--
debugf("Cluster %p released (refs=%d)", cluster, cluster.references)
if cluster.references == 0 {
for _, server := range cluster.servers.Slice() {
serv... | go | {
"resource": ""
} |
q172348 | syncServersLoop | validation | func (cluster *mongoCluster) syncServersLoop() {
for {
debugf("SYNC Cluster %p is starting a sync loop iteration.", cluster)
cluster.Lock()
if cluster.references == 0 {
cluster.Unlock()
break
}
cluster.references++ // Keep alive while syncing.
direct := cluster.direct
cluster.Unlock()
cluster.s... | go | {
"resource": ""
} |
q172349 | Close | validation | func (server *mongoServer) Close() {
server.Lock()
server.closed = true
liveSockets := server.liveSockets
unusedSockets := server.unusedSockets
server.liveSockets = nil
server.unusedSockets = nil
server.Unlock()
logf("Connections to %s closing (%d live sockets).", server.Addr, len(liveSockets))
for i, s := ran... | go | {
"resource": ""
} |
q172350 | RecycleSocket | validation | func (server *mongoServer) RecycleSocket(socket *mongoSocket) {
server.Lock()
if !server.closed {
server.unusedSockets = append(server.unusedSockets, socket)
}
server.Unlock()
} | go | {
"resource": ""
} |
q172351 | AbendSocket | validation | func (server *mongoServer) AbendSocket(socket *mongoSocket) {
server.Lock()
server.abended = true
if server.closed {
server.Unlock()
return
}
server.liveSockets = removeSocket(server.liveSockets, socket)
server.unusedSockets = removeSocket(server.unusedSockets, socket)
server.Unlock()
// Maybe just a timeou... | go | {
"resource": ""
} |
q172352 | BestFit | validation | func (servers *mongoServers) BestFit(serverTags []bson.D) *mongoServer {
var best *mongoServer
for _, next := range servers.slice {
if best == nil {
best = next
best.RLock()
if serverTags != nil && !next.info.Mongos && !best.hasTags(serverTags) {
best.RUnlock()
best = nil
}
continue
}
nex... | go | {
"resource": ""
} |
q172353 | Add | validation | func (r *Render) Add(name string, tmpl *template.Template) {
if tmpl == nil {
panic("template can not be nil")
}
if len(name) == 0 {
panic("template name cannot be empty")
}
r.Templates[name] = tmpl
} | go | {
"resource": ""
} |
q172354 | Instance | validation | func (r *Render) Instance(name string, data interface{}) render.Render {
var tpl *template.Template
// Check if gin is running in debug mode and load the templates accordingly
if r.Debug {
tpl = r.loadTemplate(name)
} else {
tpl = r.Templates[name]
}
return render.HTML{
Template: tpl,
Data: data,
}... | go | {
"resource": ""
} |
q172355 | loadTemplate | validation | func (r *Render) loadTemplate(name string) *template.Template {
tpl, err := template.ParseFiles(r.Files[name]...)
if err != nil {
panic(name + " template name mismatch")
}
return template.Must(tpl, err)
} | go | {
"resource": ""
} |
q172356 | New | validation | func New() Render {
return Render{
Templates: make(map[string]*template.Template),
Files: make(map[string][]string),
TemplatesDir: TemplatesDir,
Layout: Layout,
Ext: Ext,
Debug: Debug,
}
} | go | {
"resource": ""
} |
q172357 | Create | validation | func (r *Render) Create() *Render {
r.Validate()
layout := r.TemplatesDir + r.Layout + r.Ext
// root dir
tplRoot, err := filepath.Glob(r.TemplatesDir + "*" + r.Ext)
if err != nil {
panic(err.Error())
}
// sub dirs
tplSub, err := filepath.Glob(r.TemplatesDir + "**/*" + r.Ext)
if err != nil {
panic(err.Er... | go | {
"resource": ""
} |
q172358 | Validate | validation | func (r *Render) Validate() {
// add trailing slash if the user has forgotten..
if !strings.HasSuffix(r.TemplatesDir, "/") {
r.TemplatesDir = r.TemplatesDir + "/"
}
// check for templates dir
if ok, _ := exists(r.TemplatesDir); !ok {
panic(r.TemplatesDir + " directory for rendering templates does not exist.\n... | go | {
"resource": ""
} |
q172359 | tokenFor | validation | func tokenFor(t *transaction) token {
nonce := t.Nonce
if nonce == "" {
nonce = newNonce()
}
return token(t.Id.Hex() + "_" + nonce)
} | go | {
"resource": ""
} |
q172360 | NewRunner | validation | func NewRunner(tc *mgo.Collection) *Runner {
return &Runner{tc, tc.Database.C(tc.Name + ".stash"), nil}
} | go | {
"resource": ""
} |
q172361 | Run | validation | func (r *Runner) Run(ops []Op, id bson.ObjectId, info interface{}) (err error) {
const efmt = "error in transaction op %d: %s"
for i := range ops {
op := &ops[i]
if op.C == "" || op.Id == nil {
return fmt.Errorf(efmt, i, "C or Id missing")
}
changes := 0
if op.Insert != nil {
changes++
}
if op.Upd... | go | {
"resource": ""
} |
q172362 | ResumeAll | validation | func (r *Runner) ResumeAll() (err error) {
debugf("Resuming all unfinished transactions")
iter := r.tc.Find(bson.D{{"s", bson.D{{"$in", []state{tpreparing, tprepared, tapplying}}}}}).Iter()
var t transaction
for iter.Next(&t) {
if t.State == tapplied || t.State == taborted {
continue
}
debugf("Resuming %s ... | go | {
"resource": ""
} |
q172363 | Resume | validation | func (r *Runner) Resume(id bson.ObjectId) (err error) {
t, err := r.load(id)
if err != nil {
return err
}
if !t.done() {
debugf("Resuming %s from %q", t, t.State)
if err := flush(r, t); err != nil {
return err
}
}
if t.State == taborted {
return ErrAborted
} else if t.State != tapplied {
panic(fmt... | go | {
"resource": ""
} |
q172364 | SetChaos | validation | func SetChaos(c Chaos) {
chaosSetting = c
chaosEnabled = c.KillChance > 0 || c.SlowdownChance > 0
} | go | {
"resource": ""
} |
q172365 | Connect | validation | func Connect(c *gin.Context) {
s := db.Session.Clone()
defer s.Close()
c.Set("db", s.DB(db.Mongo.Database))
c.Next()
} | go | {
"resource": ""
} |
q172366 | ErrorHandler | validation | func ErrorHandler(c *gin.Context) {
c.Next()
// TODO: Handle it in a better way
if len(c.Errors) > 0 {
c.HTML(http.StatusBadRequest, "400", gin.H{
"errors": c.Errors,
})
}
} | go | {
"resource": ""
} |
q172367 | assert | validation | func (f *flusher) assert(t *transaction, revnos []int64, pull map[bson.ObjectId]*transaction) error {
f.debugf("Asserting %s with revnos %v", t, revnos)
if t.State != tprepared {
panic(fmt.Errorf("asserting transaction in invalid state: %q", t.State))
}
qdoc := make(bson.D, 3)
revno := make(map[docKey]int64)
fo... | go | {
"resource": ""
} |
q172368 | Server | validation | func (socket *mongoSocket) Server() *mongoServer {
socket.Lock()
server := socket.server
socket.Unlock()
return server
} | go | {
"resource": ""
} |
q172369 | ServerInfo | validation | func (socket *mongoSocket) ServerInfo() *mongoServerInfo {
socket.Lock()
serverInfo := socket.serverInfo
socket.Unlock()
return serverInfo
} | go | {
"resource": ""
} |
q172370 | InitialAcquire | validation | func (socket *mongoSocket) InitialAcquire(serverInfo *mongoServerInfo, timeout time.Duration) error {
socket.Lock()
if socket.references > 0 {
panic("Socket acquired out of cache with references")
}
if socket.dead != nil {
dead := socket.dead
socket.Unlock()
return dead
}
socket.references++
socket.serve... | go | {
"resource": ""
} |
q172371 | Acquire | validation | func (socket *mongoSocket) Acquire() (info *mongoServerInfo) {
socket.Lock()
if socket.references == 0 {
panic("Socket got non-initial acquire with references == 0")
}
// We'll track references to dead sockets as well.
// Caller is still supposed to release the socket.
socket.references++
stats.socketRefs(+1)
... | go | {
"resource": ""
} |
q172372 | Release | validation | func (socket *mongoSocket) Release() {
socket.Lock()
if socket.references == 0 {
panic("socket.Release() with references == 0")
}
socket.references--
stats.socketRefs(-1)
if socket.references == 0 {
stats.socketsInUse(-1)
server := socket.server
socket.Unlock()
socket.LogoutAll()
// If the socket is d... | go | {
"resource": ""
} |
q172373 | SetTimeout | validation | func (socket *mongoSocket) SetTimeout(d time.Duration) {
socket.Lock()
socket.timeout = d
socket.Unlock()
} | go | {
"resource": ""
} |
q172374 | Error | validation | func (e *FieldError) Error() string {
if e.IsPlaceholderErr {
buff := bytes.NewBufferString("")
if e.IsSliceOrArray {
for j, err := range e.SliceOrArrayErrs {
buff.WriteString("\n")
buff.WriteString(fmt.Sprintf(sliceErrMsg, e.Field, j, "\n"+err.Error()))
}
} else if e.IsMap {
for key, err ... | go | {
"resource": ""
} |
q172375 | Error | validation | func (e *StructErrors) Error() string {
buff := bytes.NewBufferString(fmt.Sprintf(structErrMsg, e.Struct))
for _, err := range e.Errors {
buff.WriteString(err.Error())
buff.WriteString("\n")
}
for _, err := range e.StructErrors {
buff.WriteString(err.Error())
}
return strings.TrimSpace(buff.String())
} | go | {
"resource": ""
} |
q172376 | New | validation | func New(tagName string, funcs map[string]Func) *Validate {
structPool = &sync.Pool{New: newStructErrors}
return &Validate{
tagName: tagName,
validationFuncs: funcs,
}
} | go | {
"resource": ""
} |
q172377 | Field | validation | func (v *Validate) Field(f interface{}, tag string) *FieldError {
return v.FieldWithValue(nil, f, tag)
} | go | {
"resource": ""
} |
q172378 | FieldWithValue | validation | func (v *Validate) FieldWithValue(val interface{}, f interface{}, tag string) *FieldError {
return v.fieldWithNameAndValue(nil, val, f, tag, "", true, nil)
} | go | {
"resource": ""
} |
q172379 | Create | validation | func Create(c *gin.Context) {
db := c.MustGet("db").(*mgo.Database)
article := models.Article{}
err := c.Bind(&article)
if err != nil {
c.Error(err)
return
}
err = db.C(models.CollectionArticle).Insert(article)
if err != nil {
c.Error(err)
}
c.Redirect(http.StatusMovedPermanently, "/articles")
} | go | {
"resource": ""
} |
q172380 | Edit | validation | func Edit(c *gin.Context) {
db := c.MustGet("db").(*mgo.Database)
article := models.Article{}
oID := bson.ObjectIdHex(c.Param("_id"))
err := db.C(models.CollectionArticle).FindId(oID).One(&article)
if err != nil {
c.Error(err)
}
c.HTML(http.StatusOK, "articles/form", gin.H{
"title": "Edit article",
"art... | go | {
"resource": ""
} |
q172381 | List | validation | func List(c *gin.Context) {
db := c.MustGet("db").(*mgo.Database)
articles := []models.Article{}
err := db.C(models.CollectionArticle).Find(nil).Sort("-updated_on").All(&articles)
if err != nil {
c.Error(err)
}
c.HTML(http.StatusOK, "articles/list", gin.H{
"title": "Articles",
"articles": articles,
})
} | go | {
"resource": ""
} |
q172382 | Update | validation | func Update(c *gin.Context) {
db := c.MustGet("db").(*mgo.Database)
article := models.Article{}
err := c.Bind(&article)
if err != nil {
c.Error(err)
return
}
query := bson.M{"_id": bson.ObjectIdHex(c.Param("_id"))}
doc := bson.M{
"title": article.Title,
"body": article.Body,
"updated_on": ... | go | {
"resource": ""
} |
q172383 | Delete | validation | func Delete(c *gin.Context) {
db := c.MustGet("db").(*mgo.Database)
query := bson.M{"_id": bson.ObjectIdHex(c.Param("_id"))}
err := db.C(models.CollectionArticle).Remove(query)
if err != nil {
c.Error(err)
}
c.Redirect(http.StatusMovedPermanently, "/articles")
} | go | {
"resource": ""
} |
q172384 | ObjectIdHex | validation | func ObjectIdHex(s string) ObjectId {
d, err := hex.DecodeString(s)
if err != nil || len(d) != 12 {
panic(fmt.Sprintf("Invalid input to ObjectIdHex: %q", s))
}
return ObjectId(d)
} | go | {
"resource": ""
} |
q172385 | IsObjectIdHex | validation | func IsObjectIdHex(s string) bool {
if len(s) != 24 {
return false
}
_, err := hex.DecodeString(s)
return err == nil
} | go | {
"resource": ""
} |
q172386 | NewObjectId | validation | func NewObjectId() ObjectId {
var b [12]byte
// Timestamp, 4 bytes, big endian
binary.BigEndian.PutUint32(b[:], uint32(time.Now().Unix()))
// Machine, first 3 bytes of md5(hostname)
b[4] = machineId[0]
b[5] = machineId[1]
b[6] = machineId[2]
// Pid, 2 bytes, specs don't specify endianness, but we use big endian... | go | {
"resource": ""
} |
q172387 | NewObjectIdWithTime | validation | func NewObjectIdWithTime(t time.Time) ObjectId {
var b [12]byte
binary.BigEndian.PutUint32(b[:4], uint32(t.Unix()))
return ObjectId(string(b[:]))
} | go | {
"resource": ""
} |
q172388 | MarshalJSON | validation | func (id ObjectId) MarshalJSON() ([]byte, error) {
return []byte(fmt.Sprintf(`"%x"`, string(id))), nil
} | go | {
"resource": ""
} |
q172389 | byteSlice | validation | func (id ObjectId) byteSlice(start, end int) []byte {
if len(id) != 12 {
panic(fmt.Sprintf("Invalid ObjectId: %q", string(id)))
}
return []byte(string(id)[start:end])
} | go | {
"resource": ""
} |
q172390 | Time | validation | func (id ObjectId) Time() time.Time {
// First 4 bytes of ObjectId is 32-bit big-endian seconds from epoch.
secs := int64(binary.BigEndian.Uint32(id.byteSlice(0, 4)))
return time.Unix(secs, 0)
} | go | {
"resource": ""
} |
q172391 | Counter | validation | func (id ObjectId) Counter() int32 {
b := id.byteSlice(9, 12)
// Counter is stored as big-endian 3-byte value
return int32(uint32(b[0])<<16 | uint32(b[1])<<8 | uint32(b[2]))
} | go | {
"resource": ""
} |
q172392 | Insert | validation | func (b *Bulk) Insert(docs ...interface{}) {
b.inserts = append(b.inserts, docs...)
} | go | {
"resource": ""
} |
q172393 | Run | validation | func (b *Bulk) Run() (*BulkResult, error) {
op := &insertOp{b.c.FullName, b.inserts, 0}
if !b.ordered {
op.flags = 1 // ContinueOnError
}
_, err := b.c.writeQuery(op)
if err != nil {
return nil, &bulkError{err}
}
return &BulkResult{}, nil
} | go | {
"resource": ""
} |
q172394 | hasLengthOf | validation | func hasLengthOf(top interface{}, current interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
p := asInt(param)
return int64(utf8.RuneCountInString(st.String())) == p
case reflect.Slice, reflect.Map, reflect.Array:
p := asInt(param)
... | go | {
"resource": ""
} |
q172395 | hasMinOf | validation | func hasMinOf(top interface{}, current interface{}, field interface{}, param string) bool {
return isGte(top, current, field, param)
} | go | {
"resource": ""
} |
q172396 | hasMaxOf | validation | func hasMaxOf(top interface{}, current interface{}, field interface{}, param string) bool {
return isLte(top, current, field, param)
} | go | {
"resource": ""
} |
q172397 | Connect | validation | func Connect() {
uri := os.Getenv("MONGODB_URL")
if len(uri) == 0 {
uri = MongoDBUrl
}
mongo, err := mgo.ParseURL(uri)
s, err := mgo.Dial(uri)
if err != nil {
fmt.Printf("Can't connect to mongo, go error %v\n", err)
panic(err.Error())
}
s.SetSafe(&mgo.Safe{})
fmt.Println("Connected to", uri)
Session =... | go | {
"resource": ""
} |
q172398 | SetDebug | validation | func SetDebug(debug bool) {
if raceDetector {
globalMutex.Lock()
defer globalMutex.Unlock()
}
globalDebug = debug
} | go | {
"resource": ""
} |
q172399 | Remove | validation | func (gfs *GridFS) Remove(name string) (err error) {
iter := gfs.Files.Find(bson.M{"filename": name}).Select(bson.M{"_id": 1}).Iter()
var doc gfsDocId
for iter.Next(&doc) {
if e := gfs.RemoveId(doc.Id); e != nil {
err = e
}
}
if err == nil {
err = iter.Close()
}
return err
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.