_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q5800 | IDs | train | func (l DocumentMetaSlice) IDs() []DocumentID {
ids := make([]DocumentID, len(l))
for i, m := range l {
ids[i] = m.ID
}
return ids
} | go | {
"resource": ""
} |
q5801 | Version | train | func (c *client) Version(ctx context.Context) (VersionInfo, error) {
req, err := c.conn.NewRequest("GET", "_api/version")
if err != nil {
return VersionInfo{}, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := c.conn.Do(ctx, req)
if err != nil {
return VersionInfo{}, WithStack(err)
}
if err := re... | go | {
"resource": ""
} |
q5802 | asServerRole | train | func (r roleResponse) asServerRole(ctx context.Context, c *client) (ServerRole, error) {
switch r.Role {
case "SINGLE":
switch r.Mode {
case "resilient":
if err := c.echo(ctx); IsNoLeader(err) {
return ServerRoleSinglePassive, nil
} else if err != nil {
return ServerRoleUndefined, WithStack(err)
... | go | {
"resource": ""
} |
q5803 | ServerRole | train | func (c *client) ServerRole(ctx context.Context) (ServerRole, error) {
req, err := c.conn.NewRequest("GET", "_admin/server/role")
if err != nil {
return ServerRoleUndefined, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := c.conn.Do(ctx, req)
if err != nil {
return ServerRoleUndefined, WithStack(e... | go | {
"resource": ""
} |
q5804 | ServerID | train | func (c *client) ServerID(ctx context.Context) (string, error) {
req, err := c.conn.NewRequest("GET", "_admin/server/id")
if err != nil {
return "", WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := c.conn.Do(ctx, req)
if err != nil {
return "", WithStack(err)
}
if err := resp.CheckStatus(200); e... | go | {
"resource": ""
} |
q5805 | Validate | train | func (id DocumentID) Validate() error {
if id == "" {
return WithStack(fmt.Errorf("DocumentID is empty"))
}
parts := strings.Split(string(id), "/")
if len(parts) != 2 {
return WithStack(fmt.Errorf("Expected 'collection/key', got '%s'", string(id)))
}
if parts[0] == "" {
return WithStack(fmt.Errorf("Collecti... | go | {
"resource": ""
} |
q5806 | ValidateOrEmpty | train | func (id DocumentID) ValidateOrEmpty() error {
if id == "" {
return nil
}
if err := id.Validate(); err != nil {
return WithStack(err)
}
return nil
} | go | {
"resource": ""
} |
q5807 | Collection | train | func (id DocumentID) Collection() string {
parts := strings.Split(string(id), "/")
return pathUnescape(parts[0])
} | go | {
"resource": ""
} |
q5808 | Key | train | func (id DocumentID) Key() string {
parts := strings.Split(string(id), "/")
if len(parts) == 2 {
return pathUnescape(parts[1])
}
return ""
} | go | {
"resource": ""
} |
q5809 | NewDocumentID | train | func NewDocumentID(collection, key string) DocumentID {
return DocumentID(pathEscape(collection) + "/" + pathEscape(key))
} | go | {
"resource": ""
} |
q5810 | WithRevision | train | func WithRevision(parent context.Context, revision string) context.Context {
return context.WithValue(contextOrBackground(parent), keyRevision, revision)
} | go | {
"resource": ""
} |
q5811 | WithRevisions | train | func WithRevisions(parent context.Context, revisions []string) context.Context {
return context.WithValue(contextOrBackground(parent), keyRevisions, revisions)
} | go | {
"resource": ""
} |
q5812 | WithReturnNew | train | func WithReturnNew(parent context.Context, result interface{}) context.Context {
return context.WithValue(contextOrBackground(parent), keyReturnNew, result)
} | go | {
"resource": ""
} |
q5813 | WithReturnOld | train | func WithReturnOld(parent context.Context, result interface{}) context.Context {
return context.WithValue(contextOrBackground(parent), keyReturnOld, result)
} | go | {
"resource": ""
} |
q5814 | WithEndpoint | train | func WithEndpoint(parent context.Context, endpoint string) context.Context {
endpoint = util.FixupEndpointURLScheme(endpoint)
return context.WithValue(contextOrBackground(parent), keyEndpoint, endpoint)
} | go | {
"resource": ""
} |
q5815 | WithAllowDirtyReads | train | func WithAllowDirtyReads(parent context.Context, wasDirtyRead *bool) context.Context {
return context.WithValue(contextOrBackground(parent), keyAllowDirtyReads, wasDirtyRead)
} | go | {
"resource": ""
} |
q5816 | WithRawResponse | train | func WithRawResponse(parent context.Context, value *[]byte) context.Context {
return context.WithValue(contextOrBackground(parent), keyRawResponse, value)
} | go | {
"resource": ""
} |
q5817 | WithResponse | train | func WithResponse(parent context.Context, value *Response) context.Context {
return context.WithValue(contextOrBackground(parent), keyResponse, value)
} | go | {
"resource": ""
} |
q5818 | WithImportDetails | train | func WithImportDetails(parent context.Context, value *[]string) context.Context {
return context.WithValue(contextOrBackground(parent), keyImportDetails, value)
} | go | {
"resource": ""
} |
q5819 | WithIgnoreRevisions | train | func WithIgnoreRevisions(parent context.Context, value ...bool) context.Context {
v := true
if len(value) == 1 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyIgnoreRevs, v)
} | go | {
"resource": ""
} |
q5820 | WithConfigured | train | func WithConfigured(parent context.Context, value ...bool) context.Context {
v := true
if len(value) == 1 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyConfigured, v)
} | go | {
"resource": ""
} |
q5821 | WithDBServerID | train | func WithDBServerID(parent context.Context, id string) context.Context {
return context.WithValue(contextOrBackground(parent), keyDBServerID, id)
} | go | {
"resource": ""
} |
q5822 | WithBatchID | train | func WithBatchID(parent context.Context, id string) context.Context {
return context.WithValue(contextOrBackground(parent), keyBatchID, id)
} | go | {
"resource": ""
} |
q5823 | WithJobIDResponse | train | func WithJobIDResponse(parent context.Context, jobID *string) context.Context {
return context.WithValue(contextOrBackground(parent), keyJobIDResponse, jobID)
} | go | {
"resource": ""
} |
q5824 | loadContextResponseValues | train | func loadContextResponseValues(cs contextSettings, resp Response) {
// Parse potential dirty read
if cs.DirtyReadFlag != nil {
if dirtyRead := resp.Header("X-Arango-Potential-Dirty-Read"); dirtyRead != "" {
*cs.DirtyReadFlag = true // The documentation does not say anything about the actual value (dirtyRead == "... | go | {
"resource": ""
} |
q5825 | setDirtyReadFlagIfRequired | train | func setDirtyReadFlagIfRequired(ctx context.Context, wasDirty bool) {
if v := ctx.Value(keyAllowDirtyReads); v != nil {
if ref, ok := v.(*bool); ok && ref != nil {
*ref = wasDirty
}
}
} | go | {
"resource": ""
} |
q5826 | Error | train | func (e KeyNotFoundError) Error() string {
return fmt.Sprintf("Key '%s' not found", strings.Join(e.Key, "/"))
} | go | {
"resource": ""
} |
q5827 | NewPool | train | func NewPool(numWorkers int, jobQueueLen int) *Pool {
jobQueue := make(chan Job, jobQueueLen)
workerPool := make(chan *worker, numWorkers)
pool := &Pool{
JobQueue: jobQueue,
dispatcher: newDispatcher(workerPool, jobQueue),
}
return pool
} | go | {
"resource": ""
} |
q5828 | OpenQueue | train | func OpenQueue(dataDir string) (*Queue, error) {
var err error
// Create a new Queue.
q := &Queue{
DataDir: dataDir,
db: &leveldb.DB{},
head: 0,
tail: 0,
isOpen: false,
}
// Open database for the queue.
q.db, err = leveldb.OpenFile(dataDir, nil)
if err != nil {
return q, err
}
// Che... | go | {
"resource": ""
} |
q5829 | Dequeue | train | func (q *Queue) Dequeue() (*Item, error) {
q.Lock()
defer q.Unlock()
// Check if queue is closed.
if !q.isOpen {
return nil, ErrDBClosed
}
// Try to get the next item in the queue.
item, err := q.getItemByID(q.head + 1)
if err != nil {
return nil, err
}
// Remove this item from the queue.
if err := q.... | go | {
"resource": ""
} |
q5830 | Peek | train | func (q *Queue) Peek() (*Item, error) {
q.RLock()
defer q.RUnlock()
// Check if queue is closed.
if !q.isOpen {
return nil, ErrDBClosed
}
return q.getItemByID(q.head + 1)
} | go | {
"resource": ""
} |
q5831 | Close | train | func (q *Queue) Close() error {
q.Lock()
defer q.Unlock()
// Check if queue is already closed.
if !q.isOpen {
return nil
}
// Close the LevelDB database.
if err := q.db.Close(); err != nil {
return err
}
// Reset queue head and tail and set
// isOpen to false.
q.head = 0
q.tail = 0
q.isOpen = false
... | go | {
"resource": ""
} |
q5832 | Drop | train | func (q *Queue) Drop() error {
if err := q.Close(); err != nil {
return err
}
return os.RemoveAll(q.DataDir)
} | go | {
"resource": ""
} |
q5833 | init | train | func (q *Queue) init() error {
// Create a new LevelDB Iterator.
iter := q.db.NewIterator(nil, nil)
defer iter.Release()
// Set queue head to the first item.
if iter.First() {
q.head = keyToID(iter.Key()) - 1
}
// Set queue tail to the last item.
if iter.Last() {
q.tail = keyToID(iter.Key())
}
return i... | go | {
"resource": ""
} |
q5834 | checkGoqueType | train | func checkGoqueType(dataDir string, gt goqueType) (bool, error) {
// Set the path to 'GOQUE' file.
path := filepath.Join(dataDir, "GOQUE")
// Read 'GOQUE' file for this directory.
f, err := os.OpenFile(path, os.O_RDONLY, 0)
if os.IsNotExist(err) {
f, err = os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0644)
if err... | go | {
"resource": ""
} |
q5835 | OpenPrefixQueue | train | func OpenPrefixQueue(dataDir string) (*PrefixQueue, error) {
var err error
// Create a new Queue.
pq := &PrefixQueue{
DataDir: dataDir,
db: &leveldb.DB{},
isOpen: false,
}
// Open database for the prefix queue.
pq.db, err = leveldb.OpenFile(dataDir, nil)
if err != nil {
return nil, err
}
// Ch... | go | {
"resource": ""
} |
q5836 | EnqueueString | train | func (pq *PrefixQueue) EnqueueString(prefix, value string) (*Item, error) {
return pq.Enqueue([]byte(prefix), []byte(value))
} | go | {
"resource": ""
} |
q5837 | Dequeue | train | func (pq *PrefixQueue) Dequeue(prefix []byte) (*Item, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Get the queue for this prefix.
q, err := pq.getQueue(prefix)
if err != nil {
return nil, err
}
// Try to get the next item in the queue.
... | go | {
"resource": ""
} |
q5838 | DequeueString | train | func (pq *PrefixQueue) DequeueString(prefix string) (*Item, error) {
return pq.Dequeue([]byte(prefix))
} | go | {
"resource": ""
} |
q5839 | Peek | train | func (pq *PrefixQueue) Peek(prefix []byte) (*Item, error) {
pq.RLock()
defer pq.RUnlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Get the queue for this prefix.
q, err := pq.getQueue(prefix)
if err != nil {
return nil, err
}
return pq.getItemByPrefixID(prefix, q.Head+1... | go | {
"resource": ""
} |
q5840 | PeekString | train | func (pq *PrefixQueue) PeekString(prefix string) (*Item, error) {
return pq.Peek([]byte(prefix))
} | go | {
"resource": ""
} |
q5841 | PeekByIDString | train | func (pq *PrefixQueue) PeekByIDString(prefix string, id uint64) (*Item, error) {
return pq.PeekByID([]byte(prefix), id)
} | go | {
"resource": ""
} |
q5842 | Update | train | func (pq *PrefixQueue) Update(prefix []byte, id uint64, newValue []byte) (*Item, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Get the queue for this prefix.
q, err := pq.getQueue(prefix)
if err != nil {
return nil, err
}
// Check if item... | go | {
"resource": ""
} |
q5843 | UpdateString | train | func (pq *PrefixQueue) UpdateString(prefix string, id uint64, value string) (*Item, error) {
return pq.Update([]byte(prefix), id, []byte(value))
} | go | {
"resource": ""
} |
q5844 | Close | train | func (pq *PrefixQueue) Close() error {
pq.Lock()
defer pq.Unlock()
// Check if queue is already closed.
if !pq.isOpen {
return nil
}
// Close the LevelDB database.
if err := pq.db.Close(); err != nil {
return err
}
// Reset size and set isOpen to false.
pq.size = 0
pq.isOpen = false
return nil
} | go | {
"resource": ""
} |
q5845 | Drop | train | func (pq *PrefixQueue) Drop() error {
if err := pq.Close(); err != nil {
return err
}
return os.RemoveAll(pq.DataDir)
} | go | {
"resource": ""
} |
q5846 | getQueue | train | func (pq *PrefixQueue) getQueue(prefix []byte) (*queue, error) {
// Try to get the queue gob value.
qval, err := pq.db.Get(generateKeyPrefixData(prefix), nil)
if err == errors.ErrNotFound {
return nil, ErrEmpty
} else if err != nil {
return nil, err
}
// Decode gob to our queue type.
q := &queue{}
buffer :... | go | {
"resource": ""
} |
q5847 | saveQueue | train | func (pq *PrefixQueue) saveQueue(prefix []byte, q *queue) error {
// Encode the queue using gob.
var buffer bytes.Buffer
enc := gob.NewEncoder(&buffer)
if err := enc.Encode(q); err != nil {
return err
}
// Save it to the database.
return pq.db.Put(generateKeyPrefixData(prefix), buffer.Bytes(), nil)
} | go | {
"resource": ""
} |
q5848 | save | train | func (pq *PrefixQueue) save() error {
val := make([]byte, 8)
binary.BigEndian.PutUint64(val, pq.size)
return pq.db.Put(pq.getDataKey(), val, nil)
} | go | {
"resource": ""
} |
q5849 | getDataKey | train | func (pq *PrefixQueue) getDataKey() []byte {
var key []byte
key = append(key, prefixDelimiter)
return append(key, []byte(":main_data")...)
} | go | {
"resource": ""
} |
q5850 | getItemByPrefixID | train | func (pq *PrefixQueue) getItemByPrefixID(prefix []byte, id uint64) (*Item, error) {
// Check if empty.
if pq.size == 0 {
return nil, ErrEmpty
}
// Get the queue for this prefix.
q, err := pq.getQueue(prefix)
if err != nil {
return nil, err
}
// Check if out of bounds.
if id <= q.Head || id > q.Tail {
r... | go | {
"resource": ""
} |
q5851 | init | train | func (pq *PrefixQueue) init() error {
// Get the main prefix queue data.
val, err := pq.db.Get(pq.getDataKey(), nil)
if err == errors.ErrNotFound {
return nil
} else if err != nil {
return err
}
pq.size = binary.BigEndian.Uint64(val)
return nil
} | go | {
"resource": ""
} |
q5852 | generateKeyPrefixID | train | func generateKeyPrefixID(prefix []byte, id uint64) []byte {
// Handle the prefix.
key := append(prefix, prefixDelimiter)
// Handle the item ID.
key = append(key, idToKey(id)...)
return key
} | go | {
"resource": ""
} |
q5853 | OpenPriorityQueue | train | func OpenPriorityQueue(dataDir string, order order) (*PriorityQueue, error) {
var err error
// Create a new PriorityQueue.
pq := &PriorityQueue{
DataDir: dataDir,
db: &leveldb.DB{},
order: order,
isOpen: false,
}
// Open database for the priority queue.
pq.db, err = leveldb.OpenFile(dataDir, nil... | go | {
"resource": ""
} |
q5854 | Enqueue | train | func (pq *PriorityQueue) Enqueue(priority uint8, value []byte) (*PriorityItem, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Get the priorityLevel.
level := pq.levels[priority]
// Create new PriorityItem.
item := &PriorityItem{
ID: l... | go | {
"resource": ""
} |
q5855 | Dequeue | train | func (pq *PriorityQueue) Dequeue() (*PriorityItem, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Try to get the next item.
item, err := pq.getNextItem()
if err != nil {
return nil, err
}
// Remove this item from the priority queue.
if er... | go | {
"resource": ""
} |
q5856 | DequeueByPriority | train | func (pq *PriorityQueue) DequeueByPriority(priority uint8) (*PriorityItem, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Try to get the next item in the given priority level.
item, err := pq.getItemByPriorityID(priority, pq.levels[priority].hea... | go | {
"resource": ""
} |
q5857 | Peek | train | func (pq *PriorityQueue) Peek() (*PriorityItem, error) {
pq.RLock()
defer pq.RUnlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
return pq.getNextItem()
} | go | {
"resource": ""
} |
q5858 | PeekByPriorityID | train | func (pq *PriorityQueue) PeekByPriorityID(priority uint8, id uint64) (*PriorityItem, error) {
pq.RLock()
defer pq.RUnlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
return pq.getItemByPriorityID(priority, id)
} | go | {
"resource": ""
} |
q5859 | Update | train | func (pq *PriorityQueue) Update(priority uint8, id uint64, newValue []byte) (*PriorityItem, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Check if item exists in queue.
if id <= pq.levels[priority].head || id > pq.levels[priority].tail {
retu... | go | {
"resource": ""
} |
q5860 | Length | train | func (pq *PriorityQueue) Length() uint64 {
pq.RLock()
defer pq.RUnlock()
var length uint64
for _, v := range pq.levels {
length += v.length()
}
return length
} | go | {
"resource": ""
} |
q5861 | Close | train | func (pq *PriorityQueue) Close() error {
pq.Lock()
defer pq.Unlock()
// Check if queue is already closed.
if !pq.isOpen {
return nil
}
// Close the LevelDB database.
if err := pq.db.Close(); err != nil {
return err
}
// Reset head and tail of each priority level
// and set isOpen to false.
for i := 0;... | go | {
"resource": ""
} |
q5862 | cmpAsc | train | func (pq *PriorityQueue) cmpAsc(priority uint8) bool {
return pq.order == ASC && priority < pq.curLevel
} | go | {
"resource": ""
} |
q5863 | cmpDesc | train | func (pq *PriorityQueue) cmpDesc(priority uint8) bool {
return pq.order == DESC && priority > pq.curLevel
} | go | {
"resource": ""
} |
q5864 | resetCurrentLevel | train | func (pq *PriorityQueue) resetCurrentLevel() {
if pq.order == ASC {
pq.curLevel = 255
} else if pq.order == DESC {
pq.curLevel = 0
}
} | go | {
"resource": ""
} |
q5865 | findOffset | train | func (pq *PriorityQueue) findOffset(offset uint64) (*PriorityItem, error) {
var length uint64
var curLevel uint8 = pq.curLevel
var newLevel int
// Handle newLevel initialization for descending order.
if pq.order == DESC {
newLevel = 255
}
// For condition expression.
condExpr := func(level int) bool {
if ... | go | {
"resource": ""
} |
q5866 | getNextItem | train | func (pq *PriorityQueue) getNextItem() (*PriorityItem, error) {
// If the current priority level is empty.
if pq.levels[pq.curLevel].length() == 0 {
// Set starting value for curLevel.
pq.resetCurrentLevel()
// Try to get the next priority level.
for i := 0; i <= 255; i++ {
if (pq.cmpAsc(uint8(i)) || pq.c... | go | {
"resource": ""
} |
q5867 | generatePrefix | train | func (pq *PriorityQueue) generatePrefix(level uint8) []byte {
// priority + prefixSep = 1 + 1 = 2
prefix := make([]byte, 2)
prefix[0] = byte(level)
prefix[1] = prefixSep[0]
return prefix
} | go | {
"resource": ""
} |
q5868 | generateKey | train | func (pq *PriorityQueue) generateKey(priority uint8, id uint64) []byte {
// prefix + key = 2 + 8 = 10
key := make([]byte, 10)
copy(key[0:2], pq.generatePrefix(priority))
copy(key[2:], idToKey(id))
return key
} | go | {
"resource": ""
} |
q5869 | init | train | func (pq *PriorityQueue) init() error {
// Set starting value for curLevel.
pq.resetCurrentLevel()
// Loop through each priority level.
for i := 0; i <= 255; i++ {
// Create a new LevelDB Iterator for this priority level.
prefix := pq.generatePrefix(uint8(i))
iter := pq.db.NewIterator(util.BytesPrefix(prefix... | go | {
"resource": ""
} |
q5870 | idToKey | train | func idToKey(id uint64) []byte {
key := make([]byte, 8)
binary.BigEndian.PutUint64(key, id)
return key
} | go | {
"resource": ""
} |
q5871 | OpenStack | train | func OpenStack(dataDir string) (*Stack, error) {
var err error
// Create a new Stack.
s := &Stack{
DataDir: dataDir,
db: &leveldb.DB{},
head: 0,
tail: 0,
isOpen: false,
}
// Open database for the stack.
s.db, err = leveldb.OpenFile(dataDir, nil)
if err != nil {
return s, err
}
// Che... | go | {
"resource": ""
} |
q5872 | Push | train | func (s *Stack) Push(value []byte) (*Item, error) {
s.Lock()
defer s.Unlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
// Create new Item.
item := &Item{
ID: s.head + 1,
Key: idToKey(s.head + 1),
Value: value,
}
// Add it to the stack.
if err := s.db.Put(item.Key, ... | go | {
"resource": ""
} |
q5873 | PushString | train | func (s *Stack) PushString(value string) (*Item, error) {
return s.Push([]byte(value))
} | go | {
"resource": ""
} |
q5874 | Pop | train | func (s *Stack) Pop() (*Item, error) {
s.Lock()
defer s.Unlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
// Try to get the next item in the stack.
item, err := s.getItemByID(s.head)
if err != nil {
return nil, err
}
// Remove this item from the stack.
if err := s.db.Delet... | go | {
"resource": ""
} |
q5875 | Peek | train | func (s *Stack) Peek() (*Item, error) {
s.RLock()
defer s.RUnlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
return s.getItemByID(s.head)
} | go | {
"resource": ""
} |
q5876 | PeekByOffset | train | func (s *Stack) PeekByOffset(offset uint64) (*Item, error) {
s.RLock()
defer s.RUnlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
return s.getItemByID(s.head - offset)
} | go | {
"resource": ""
} |
q5877 | Update | train | func (s *Stack) Update(id uint64, newValue []byte) (*Item, error) {
s.Lock()
defer s.Unlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
// Check if item exists in stack.
if id > s.head || id <= s.tail {
return nil, ErrOutOfBounds
}
// Create new Item.
item := &Item{
ID: ... | go | {
"resource": ""
} |
q5878 | Close | train | func (s *Stack) Close() error {
s.Lock()
defer s.Unlock()
// Check if stack is already closed.
if !s.isOpen {
return nil
}
// Close the LevelDB database.
if err := s.db.Close(); err != nil {
return err
}
// Reset stack head and tail and set
// isOpen to false.
s.head = 0
s.tail = 0
s.isOpen = false
... | go | {
"resource": ""
} |
q5879 | Drop | train | func (s *Stack) Drop() error {
if err := s.Close(); err != nil {
return err
}
return os.RemoveAll(s.DataDir)
} | go | {
"resource": ""
} |
q5880 | init | train | func (s *Stack) init() error {
// Create a new LevelDB Iterator.
iter := s.db.NewIterator(nil, nil)
defer iter.Release()
// Set stack head to the last item.
if iter.Last() {
s.head = keyToID(iter.Key())
}
// Set stack tail to the first item.
if iter.First() {
s.tail = keyToID(iter.Key()) - 1
}
return i... | go | {
"resource": ""
} |
q5881 | RetrieveAssertionInfo | train | func (sp *SAMLServiceProvider) RetrieveAssertionInfo(encodedResponse string) (*AssertionInfo, error) {
assertionInfo := &AssertionInfo{
Values: make(Values),
}
response, err := sp.ValidateEncodedResponse(encodedResponse)
if err != nil {
return nil, ErrVerification{Cause: err}
}
// TODO: Support multiple ass... | go | {
"resource": ""
} |
q5882 | BuildAuthURL | train | func (sp *SAMLServiceProvider) BuildAuthURL(relayState string) (string, error) {
doc, err := sp.BuildAuthRequestDocument()
if err != nil {
return "", err
}
return sp.BuildAuthURLFromDocument(relayState, doc)
} | go | {
"resource": ""
} |
q5883 | AuthRedirect | train | func (sp *SAMLServiceProvider) AuthRedirect(w http.ResponseWriter, r *http.Request, relayState string) (err error) {
url, err := sp.BuildAuthURL(relayState)
if err != nil {
return err
}
http.Redirect(w, r, url, http.StatusFound)
return nil
} | go | {
"resource": ""
} |
q5884 | validateResponseAttributes | train | func (sp *SAMLServiceProvider) validateResponseAttributes(response *types.Response) error {
if response.Destination != "" && response.Destination != sp.AssertionConsumerServiceURL {
return ErrInvalidValue{
Key: DestinationAttr,
Expected: sp.AssertionConsumerServiceURL,
Actual: response.Destination,
... | go | {
"resource": ""
} |
q5885 | ValidateEncodedResponse | train | func (sp *SAMLServiceProvider) ValidateEncodedResponse(encodedResponse string) (*types.Response, error) {
raw, err := base64.StdEncoding.DecodeString(encodedResponse)
if err != nil {
return nil, err
}
// Parse the raw response
doc, el, err := parseResponse(raw)
if err != nil {
return nil, err
}
var respon... | go | {
"resource": ""
} |
q5886 | DecodeUnverifiedBaseResponse | train | func DecodeUnverifiedBaseResponse(encodedResponse string) (*types.UnverifiedBaseResponse, error) {
raw, err := base64.StdEncoding.DecodeString(encodedResponse)
if err != nil {
return nil, err
}
var response *types.UnverifiedBaseResponse
err = maybeDeflate(raw, func(maybeXML []byte) error {
response = &types.... | go | {
"resource": ""
} |
q5887 | maybeDeflate | train | func maybeDeflate(data []byte, decoder func([]byte) error) error {
err := decoder(data)
if err == nil {
return nil
}
deflated, err := ioutil.ReadAll(flate.NewReader(bytes.NewReader(data)))
if err != nil {
return err
}
return decoder(deflated)
} | go | {
"resource": ""
} |
q5888 | parseResponse | train | func parseResponse(xml []byte) (*etree.Document, *etree.Element, error) {
var doc *etree.Document
err := maybeDeflate(xml, func(xml []byte) error {
doc = etree.NewDocument()
return doc.ReadFromBytes(xml)
})
if err != nil {
return nil, nil, err
}
el := doc.Root()
if el == nil {
return nil, nil, fmt.Erro... | go | {
"resource": ""
} |
q5889 | Decrypt | train | func (ea *EncryptedAssertion) Decrypt(cert *tls.Certificate) (*Assertion, error) {
plaintext, err := ea.DecryptBytes(cert)
if err != nil {
return nil, fmt.Errorf("Error decrypting assertion: %v", err)
}
assertion := &Assertion{}
err = xml.Unmarshal(plaintext, assertion)
if err != nil {
return nil, fmt.Error... | go | {
"resource": ""
} |
q5890 | DecryptSymmetricKey | train | func (ek *EncryptedKey) DecryptSymmetricKey(cert *tls.Certificate) (cipher.Block, error) {
if len(cert.Certificate) < 1 {
return nil, fmt.Errorf("decryption tls.Certificate has no public certs attached")
}
// The EncryptedKey may or may not include X509Data (certificate).
// If included, the EncryptedKey certifi... | go | {
"resource": ""
} |
q5891 | VerifyAssertionConditions | train | func (sp *SAMLServiceProvider) VerifyAssertionConditions(assertion *types.Assertion) (*WarningInfo, error) {
warningInfo := &WarningInfo{}
now := sp.Clock.Now()
conditions := assertion.Conditions
if conditions == nil {
return nil, ErrMissingElement{Tag: ConditionsTag}
}
if conditions.NotBefore == "" {
retur... | go | {
"resource": ""
} |
q5892 | Validate | train | func (sp *SAMLServiceProvider) Validate(response *types.Response) error {
err := sp.validateResponseAttributes(response)
if err != nil {
return err
}
if len(response.Assertions) == 0 {
return ErrMissingAssertion
}
issuer := response.Issuer
if issuer == nil {
// FIXME?: SAML Core 2.0 Section 3.2.2 has Res... | go | {
"resource": ""
} |
q5893 | makeTermios2 | train | func makeTermios2(options OpenOptions) (*termios2, error) {
// Sanity check inter-character timeout and minimum read size options.
vtime := uint(round(float64(options.InterCharacterTimeout)/100.0) * 100)
vmin := options.MinimumReadSize
if vmin == 0 && vtime < 100 {
return nil, errors.New("invalid values for In... | go | {
"resource": ""
} |
q5894 | setTermios | train | func setTermios(fd uintptr, src *termios) error {
// Make the ioctl syscall that sets the termios struct.
r1, _, errno :=
syscall.Syscall(
syscall.SYS_IOCTL,
fd,
uintptr(kTIOCSETA),
uintptr(unsafe.Pointer(src)))
// Did the syscall return an error?
if errno != 0 {
return os.NewSyscallError("SYS_IOCT... | go | {
"resource": ""
} |
q5895 | Execute | train | func (ws *windowsService) Execute(args []string, r <-chan wsvc.ChangeRequest, changes chan<- wsvc.Status) (bool, uint32) {
const cmdsAccepted = wsvc.AcceptStop | wsvc.AcceptShutdown
changes <- wsvc.Status{State: wsvc.StartPending}
if err := ws.i.Start(); err != nil {
ws.setError(err)
return true, 1
}
changes... | go | {
"resource": ""
} |
q5896 | Run | train | func Run(service Service, sig ...os.Signal) error {
env := environment{}
if err := service.Init(env); err != nil {
return err
}
if err := service.Start(); err != nil {
return err
}
if len(sig) == 0 {
sig = []os.Signal{syscall.SIGINT, syscall.SIGTERM}
}
signalChan := make(chan os.Signal, 1)
signalNotif... | go | {
"resource": ""
} |
q5897 | NewSwitch | train | func NewSwitch(Cond node.Node, CaseList *CaseList) *Switch {
return &Switch{
FreeFloating: nil,
Cond: Cond,
CaseList: CaseList,
}
} | go | {
"resource": ""
} |
q5898 | NewConstant | train | func NewConstant(ConstantName node.Node, Expr node.Node, PhpDocComment string) *Constant {
return &Constant{
FreeFloating: nil,
PhpDocComment: PhpDocComment,
ConstantName: ConstantName,
Expr: Expr,
}
} | go | {
"resource": ""
} |
q5899 | NewIdentical | train | func NewIdentical(Variable node.Node, Expression node.Node) *Identical {
return &Identical{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.