id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c5800 | make([]DocumentID, len(l))
for i, m := range l {
ids[i] = m.ID
}
return ids
} | |
c5801 | err := c.conn.Do(ctx, req)
if err != nil {
return VersionInfo{}, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return VersionInfo{}, WithStack(err)
}
var data VersionInfo
if err := resp.ParseBody("", &data); err != nil {
return VersionInfo{}, WithStack(err)
}
return data, nil
} | |
c5802 | ServerRoleDBServer, nil
case "COORDINATOR":
return ServerRoleCoordinator, nil
case "AGENT":
return ServerRoleAgent, nil
case "UNDEFINED":
return ServerRoleUndefined, nil
default:
return ServerRoleUndefined, nil
}
} | |
c5803 | {
return ServerRoleUndefined, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return ServerRoleUndefined, WithStack(err)
}
var data roleResponse
if err := resp.ParseBody("", &data); err != nil {
return ServerRoleUndefined, WithStack(err)
}
role, err := data.asServerRole(ctx, c)
if err != n... | |
c5804 | resp, err := c.conn.Do(ctx, req)
if err != nil {
return "", WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return "", WithStack(err)
}
var data idResponse
if err := resp.ParseBody("", &data); err != nil {
return "", WithStack(err)
}
return data.ID, nil
} | |
c5805 | '%s' is empty", string(id)))
}
if parts[1] == "" {
return WithStack(fmt.Errorf("Key part of '%s' is empty", string(id)))
}
return nil
} | |
c5806 | id.Validate(); err != nil {
return WithStack(err)
}
return nil
} | |
c5807 | "/")
return pathUnescape(parts[0])
} | |
c5808 | return pathUnescape(parts[1])
}
return ""
} | |
c5809 | {
return DocumentID(pathEscape(collection) + "/" + pathEscape(key))
} | |
c5810 | {
return context.WithValue(contextOrBackground(parent), keyRevision, revision)
} | |
c5811 | {
return context.WithValue(contextOrBackground(parent), keyRevisions, revisions)
} | |
c5812 | {
return context.WithValue(contextOrBackground(parent), keyReturnNew, result)
} | |
c5813 | {
return context.WithValue(contextOrBackground(parent), keyReturnOld, result)
} | |
c5814 | context.WithValue(contextOrBackground(parent), keyEndpoint, endpoint)
} | |
c5815 | {
return context.WithValue(contextOrBackground(parent), keyAllowDirtyReads, wasDirtyRead)
} | |
c5816 | {
return context.WithValue(contextOrBackground(parent), keyRawResponse, value)
} | |
c5817 | {
return context.WithValue(contextOrBackground(parent), keyResponse, value)
} | |
c5818 | {
return context.WithValue(contextOrBackground(parent), keyImportDetails, value)
} | |
c5819 | context.WithValue(contextOrBackground(parent), keyIgnoreRevs, v)
} | |
c5820 |
if len(value) == 1 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyConfigured, v)
} | |
c5821 | {
return context.WithValue(contextOrBackground(parent), keyDBServerID, id)
} | |
c5822 | {
return context.WithValue(contextOrBackground(parent), keyBatchID, id)
} | |
c5823 | {
return context.WithValue(contextOrBackground(parent), keyJobIDResponse, jobID)
} | |
c5824 | true // The documentation does not say anything about the actual value (dirtyRead == "true")
} else {
*cs.DirtyReadFlag = false
}
}
} | |
c5825 | ok := v.(*bool); ok && ref != nil {
*ref = wasDirty
}
}
} | |
c5826 | fmt.Sprintf("Key '%s' not found", strings.Join(e.Key, "/"))
} | |
c5827 |
JobQueue: jobQueue,
dispatcher: newDispatcher(workerPool, jobQueue),
}
return pool
} | |
c5828 | := checkGoqueType(dataDir, goqueQueue)
if err != nil {
return q, err
}
if !ok {
return q, ErrIncompatibleType
}
// Set isOpen and return.
q.isOpen = true
return q, q.init()
} | |
c5829 | queue.
item, err := q.getItemByID(q.head + 1)
if err != nil {
return nil, err
}
// Remove this item from the queue.
if err := q.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Increment head position.
q.head++
return item, nil
} | |
c5830 |
return nil, ErrDBClosed
}
return q.getItemByID(q.head + 1)
} | |
c5831 | }
// Reset queue head and tail and set
// isOpen to false.
q.head = 0
q.tail = 0
q.isOpen = false
return nil
} | |
c5832 | }
return os.RemoveAll(q.DataDir)
} | |
c5833 |
// Set queue tail to the last item.
if iter.Last() {
q.tail = keyToID(iter.Key())
}
return iter.Error()
} | |
c5834 | err = f.Read(fb)
if err != nil {
return false, err
}
// Convert the file byte to its goqueType.
filegt := goqueType(fb[0])
// Compare the types.
if filegt == gt {
return true, nil
} else if filegt == goqueStack && gt == goqueQueue {
return true, nil
} else if filegt == goqueQueue && gt == goqueStack {
... | |
c5835 | leveldb.OpenFile(dataDir, nil)
if err != nil {
return nil, err
}
// Check if this Goque type can open the requested data directory.
ok, err := checkGoqueType(dataDir, goquePrefixQueue)
if err != nil {
return nil, err
}
if !ok {
return nil, ErrIncompatibleType
}
// Set isOpen and return.
pq.isOpen = t... | |
c5836 |
return pq.Enqueue([]byte(prefix), []byte(value))
} | |
c5837 |
return nil, err
}
// Increment head position and decrement prefix queue size.
q.Head++
pq.size--
// Save the queue.
if err := pq.saveQueue(prefix, q); err != nil {
return nil, err
}
// Save main prefix queue data.
if err := pq.save(); err != nil {
return nil, err
}
return item, nil
} | |
c5838 |
return pq.Dequeue([]byte(prefix))
} | |
c5839 | q, err := pq.getQueue(prefix)
if err != nil {
return nil, err
}
return pq.getItemByPrefixID(prefix, q.Head+1)
} | |
c5840 |
return pq.Peek([]byte(prefix))
} | |
c5841 | {
return pq.PeekByID([]byte(prefix), id)
} | |
c5842 | ErrOutOfBounds
}
// Create new Item.
item := &Item{
ID: id,
Key: generateKeyPrefixID(prefix, id),
Value: newValue,
}
// Update this item in the queue.
if err := pq.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
return item, nil
} | |
c5843 | value string) (*Item, error) {
return pq.Update([]byte(prefix), id, []byte(value))
} | |
c5844 | nil {
return err
}
// Reset size and set isOpen to false.
pq.size = 0
pq.isOpen = false
return nil
} | |
c5845 | }
return os.RemoveAll(pq.DataDir)
} | |
c5846 | err == errors.ErrNotFound {
return nil, ErrEmpty
} else if err != nil {
return nil, err
}
// Decode gob to our queue type.
q := &queue{}
buffer := bytes.NewBuffer(qval)
dec := gob.NewDecoder(buffer)
return q, dec.Decode(q)
} | |
c5847 |
// Save it to the database.
return pq.db.Put(generateKeyPrefixData(prefix), buffer.Bytes(), nil)
} | |
c5848 | return pq.db.Put(pq.getDataKey(), val, nil)
} | |
c5849 | prefixDelimiter)
return append(key, []byte(":main_data")...)
} | |
c5850 |
// Get item from database.
item := &Item{
ID: id,
Key: generateKeyPrefixID(prefix, id),
}
if item.Value, err = pq.db.Get(item.Key, nil); err != nil {
return nil, err
}
return item, nil
} | |
c5851 |
if err == errors.ErrNotFound {
return nil
} else if err != nil {
return err
}
pq.size = binary.BigEndian.Uint64(val)
return nil
} | |
c5852 | the item ID.
key = append(key, idToKey(id)...)
return key
} | |
c5853 |
ok, err := checkGoqueType(dataDir, goquePriorityQueue)
if err != nil {
return pq, err
}
if !ok {
return pq, ErrIncompatibleType
}
// Set isOpen and return.
pq.isOpen = true
return pq, pq.init()
} | |
c5854 |
// Add it to the priority queue.
if err := pq.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
// Increment tail position.
level.tail++
// If this priority level is more important than the curLevel.
if pq.cmpAsc(priority) || pq.cmpDesc(priority) {
pq.curLevel = priority
}
return item, ... | |
c5855 | item, err := pq.getNextItem()
if err != nil {
return nil, err
}
// Remove this item from the priority queue.
if err = pq.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Increment head position.
pq.levels[pq.curLevel].head++
return item, nil
} | |
c5856 | nil, err
}
// Remove this item from the priority queue.
if err = pq.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Increment head position.
pq.levels[priority].head++
return item, nil
} | |
c5857 | if !pq.isOpen {
return nil, ErrDBClosed
}
return pq.getNextItem()
} | |
c5858 | defer pq.RUnlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
return pq.getItemByPriorityID(priority, id)
} | |
c5859 |
Key: pq.generateKey(priority, id),
Value: newValue,
}
// Update this item in the queue.
if err := pq.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
return item, nil
} | |
c5860 | := range pq.levels {
length += v.length()
}
return length
} | |
c5861 | err := pq.db.Close(); err != nil {
return err
}
// Reset head and tail of each priority level
// and set isOpen to false.
for i := 0; i <= 255; i++ {
pq.levels[uint8(i)].head = 0
pq.levels[uint8(i)].tail = 0
}
pq.isOpen = false
return nil
} | |
c5862 | pq.order == ASC && priority < pq.curLevel
} | |
c5863 | pq.order == DESC && priority > pq.curLevel
} | |
c5864 | } else if pq.order == DESC {
pq.curLevel = 0
}
} | |
c5865 | current level based on ordering and contains items.
if cmpLevels(uint8(newLevel), curLevel) && pq.levels[uint8(newLevel)].length() > 0 {
curLevel = uint8(newLevel)
newLength := pq.levels[curLevel].length()
// If the offset is within the current priority level.
if length+newLength >= offset+1 {
retur... | |
c5866 | still empty, return queue empty error.
if pq.levels[pq.curLevel].length() == 0 {
return nil, ErrEmpty
}
}
// Try to get the next item in the current priority level.
return pq.getItemByPriorityID(pq.curLevel, pq.levels[pq.curLevel].head+1)
} | |
c5867 | make([]byte, 2)
prefix[0] = byte(level)
prefix[1] = prefixSep[0]
return prefix
} | |
c5868 | := make([]byte, 10)
copy(key[0:2], pq.generatePrefix(priority))
copy(key[2:], idToKey(id))
return key
} | |
c5869 | &priorityLevel{
head: 0,
tail: 0,
}
// Set priority level head to the first item.
if iter.First() {
pl.head = keyToID(iter.Key()[2:]) - 1
// Since this priority level has item(s), handle updating curLevel.
if pq.cmpAsc(uint8(i)) || pq.cmpDesc(uint8(i)) {
pq.curLevel = uint8(i)
}
}
//... | |
c5870 | binary.BigEndian.PutUint64(key, id)
return key
} | |
c5871 | := checkGoqueType(dataDir, goqueStack)
if err != nil {
return s, err
}
if !ok {
return s, ErrIncompatibleType
}
// Set isOpen and return.
s.isOpen = true
return s, s.init()
} | |
c5872 | if err := s.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
// Increment head position.
s.head++
return item, nil
} | |
c5873 | return s.Push([]byte(value))
} | |
c5874 | stack.
item, err := s.getItemByID(s.head)
if err != nil {
return nil, err
}
// Remove this item from the stack.
if err := s.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Decrement head position.
s.head--
return item, nil
} | |
c5875 | {
return nil, ErrDBClosed
}
return s.getItemByID(s.head)
} | |
c5876 | if !s.isOpen {
return nil, ErrDBClosed
}
return s.getItemByID(s.head - offset)
} | |
c5877 | Key: idToKey(id),
Value: newValue,
}
// Update this item in the stack.
if err := s.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
return item, nil
} | |
c5878 | }
// Reset stack head and tail and set
// isOpen to false.
s.head = 0
s.tail = 0
s.isOpen = false
return nil
} | |
c5879 | }
return os.RemoveAll(s.DataDir)
} | |
c5880 | // Set stack tail to the first item.
if iter.First() {
s.tail = keyToID(iter.Key()) - 1
}
return iter.Error()
} | |
c5881 | attributeStatement != nil {
for _, attribute := range attributeStatement.Attributes {
assertionInfo.Values[attribute.Name] = attribute
}
}
if assertion.AuthnStatement != nil {
if assertion.AuthnStatement.AuthnInstant != nil {
assertionInfo.AuthnInstant = assertion.AuthnStatement.AuthnInstant
}
if as... | |
c5882 |
return "", err
}
return sp.BuildAuthURLFromDocument(relayState, doc)
} | |
c5883 | if err != nil {
return err
}
http.Redirect(w, r, url, http.StatusFound)
return nil
} | |
c5884 | return ErrInvalidValue{
Reason: ReasonUnsupported,
Key: "SAML version",
Expected: "2.0",
Actual: response.Version,
}
}
return nil
} | |
c5885 |
} else if err != nil {
return nil, err
} else {
assertionSignaturesValidated = true
}
}
decodedResponse := &types.Response{}
err = xmlUnmarshalElement(el, decodedResponse)
if err != nil {
return nil, fmt.Errorf("unable to unmarshal response: %v", err)
}
decodedResponse.SignatureValidated = respons... | |
c5886 |
response = &types.UnverifiedBaseResponse{}
return xml.Unmarshal(maybeXML, response)
})
if err != nil {
return nil, err
}
return response, nil
} | |
c5887 | deflated, err := ioutil.ReadAll(flate.NewReader(bytes.NewReader(data)))
if err != nil {
return err
}
return decoder(deflated)
} | |
c5888 | return nil, nil, err
}
el := doc.Root()
if el == nil {
return nil, nil, fmt.Errorf("unable to parse response")
}
return doc, el, nil
} | |
c5889 | assertion: %v", err)
}
assertion := &Assertion{}
err = xml.Unmarshal(plaintext, assertion)
if err != nil {
return nil, fmt.Errorf("Error unmarshaling assertion: %v", err)
}
return assertion, nil
} | |
c5890 | = sha256.New()
case MethodSHA512:
h = sha512.New()
default:
return nil, fmt.Errorf("unsupported digest algorithm: %v",
ek.EncryptionMethod.DigestMethod.Algorithm)
}
switch ek.EncryptionMethod.Algorithm {
case "":
return nil, fmt.Errorf("missing encryption algorithm")
case MethodRSAOAEP, Metho... | |
c5891 |
matched = true
break
}
}
if !matched {
warningInfo.NotInAudience = true
break
}
}
if conditions.OneTimeUse != nil {
warningInfo.OneTimeUse = true
}
proxyRestriction := conditions.ProxyRestriction
if proxyRestriction != nil {
proxyRestrictionInfo := &ProxyRestriction{
Count: pro... | |
c5892 | subjectConfirmation.SubjectConfirmationData
if subjectConfirmationData == nil {
return ErrMissingElement{Tag: SubjectConfirmationDataTag}
}
if subjectConfirmationData.Recipient != sp.AssertionConsumerServiceURL {
return ErrInvalidValue{
Key: RecipientAttr,
Expected: sp.AssertionConsumerServic... | |
c5893 | syscall.PARODD
case PARITY_EVEN:
t2.c_cflag |= syscall.PARENB
default:
return nil, errors.New("invalid setting for ParityMode")
}
switch options.DataBits {
case 5:
t2.c_cflag |= syscall.CS5
case 6:
t2.c_cflag |= syscall.CS6
case 7:
t2.c_cflag |= syscall.CS7
case 8:
t2.c_cflag |= syscall.CS8
def... | |
c5894 | {
return os.NewSyscallError("SYS_IOCTL", errno)
}
// Just in case, check the return value as well.
if r1 != 0 {
return errors.New("Unknown error from SYS_IOCTL.")
}
return nil
} | |
c5895 | changes <- c.CurrentStatus
case wsvc.Stop, wsvc.Shutdown:
changes <- wsvc.Status{State: wsvc.StopPending}
err := ws.i.Stop()
if err != nil {
ws.setError(err)
return true, 2
}
break loop
default:
continue loop
}
}
return false, 0
} | |
c5896 | sig = []os.Signal{syscall.SIGINT, syscall.SIGTERM}
}
signalChan := make(chan os.Signal, 1)
signalNotify(signalChan, sig...)
<-signalChan
return service.Stop()
} | |
c5897 | Cond: Cond,
CaseList: CaseList,
}
} | |
c5898 |
PhpDocComment: PhpDocComment,
ConstantName: ConstantName,
Expr: Expr,
}
} | |
c5899 | Left: Variable,
Right: Expression,
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.