_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q10100 | CompareAndSet | train | func (ai *AtomicInt) CompareAndSet(expect int, update int) bool {
res := atomic.CompareAndSwapInt64(&ai.val, int64(expect), int64(update))
return res
} | go | {
"resource": ""
} |
q10101 | DecrementAndGet | train | func (ai *AtomicInt) DecrementAndGet() int {
res := int(atomic.AddInt64(&ai.val, -1))
return res
} | go | {
"resource": ""
} |
q10102 | Get | train | func (ai *AtomicInt) Get() int {
res := int(atomic.LoadInt64(&ai.val))
return res
} | go | {
"resource": ""
} |
q10103 | GetAndAdd | train | func (ai *AtomicInt) GetAndAdd(delta int) int {
newVal := atomic.AddInt64(&ai.val, int64(delta))
res := int(newVal - int64(delta))
return res
} | go | {
"resource": ""
} |
q10104 | GetAndDecrement | train | func (ai *AtomicInt) GetAndDecrement() int {
newVal := atomic.AddInt64(&ai.val, -1)
res := int(newVal + 1)
return res
} | go | {
"resource": ""
} |
q10105 | GetAndSet | train | func (ai *AtomicInt) GetAndSet(newValue int) int {
res := int(atomic.SwapInt64(&ai.val, int64(newValue)))
return res
} | go | {
"resource": ""
} |
q10106 | IncrementAndGet | train | func (ai *AtomicInt) IncrementAndGet() int {
res := int(atomic.AddInt64(&ai.val, 1))
return res
} | go | {
"resource": ""
} |
q10107 | Set | train | func (ai *AtomicInt) Set(newValue int) {
atomic.StoreInt64(&ai.val, int64(newValue))
} | go | {
"resource": ""
} |
q10108 | NewEqualFilter | train | func NewEqualFilter(binName string, value interface{}) *Filter {
val := NewValue(value)
return newFilter(binName, ICT_DEFAULT, val.GetType(), val, val)
} | go | {
"resource": ""
} |
q10109 | NewRangeFilter | train | func NewRangeFilter(binName string, begin int64, end int64) *Filter {
vBegin, vEnd := NewValue(begin), NewValue(end)
return newFilter(binName, ICT_DEFAULT, vBegin.GetType(), vBegin, vEnd)
} | go | {
"resource": ""
} |
q10110 | NewContainsFilter | train | func NewContainsFilter(binName string, indexCollectionType IndexCollectionType, value interface{}) *Filter {
v := NewValue(value)
return newFilter(binName, indexCollectionType, v.GetType(), v, v)
} | go | {
"resource": ""
} |
q10111 | NewContainsRangeFilter | train | func NewContainsRangeFilter(binName string, indexCollectionType IndexCollectionType, begin, end int64) *Filter {
vBegin, vEnd := NewValue(begin), NewValue(end)
return newFilter(binName, indexCollectionType, vBegin.GetType(), vBegin, vEnd)
} | go | {
"resource": ""
} |
q10112 | NewGeoWithinRegionFilter | train | func NewGeoWithinRegionFilter(binName, region string) *Filter {
v := NewStringValue(region)
return newFilter(binName, ICT_DEFAULT, ParticleType.GEOJSON, v, v)
} | go | {
"resource": ""
} |
q10113 | NewGeoWithinRegionForCollectionFilter | train | func NewGeoWithinRegionForCollectionFilter(binName string, collectionType IndexCollectionType, region string) *Filter {
v := NewStringValue(region)
return newFilter(binName, collectionType, ParticleType.GEOJSON, v, v)
} | go | {
"resource": ""
} |
q10114 | NewGeoRegionsContainingPointFilter | train | func NewGeoRegionsContainingPointFilter(binName, point string) *Filter {
v := NewStringValue(point)
return newFilter(binName, ICT_DEFAULT, ParticleType.GEOJSON, v, v)
} | go | {
"resource": ""
} |
q10115 | NewGeoRegionsContainingPointForCollectionFilter | train | func NewGeoRegionsContainingPointForCollectionFilter(binName string, collectionType IndexCollectionType, point string) *Filter {
v := NewStringValue(point)
return newFilter(binName, collectionType, ParticleType.GEOJSON, v, v)
} | go | {
"resource": ""
} |
q10116 | newFilter | train | func newFilter(name string, indexCollectionType IndexCollectionType, valueParticleType int, begin Value, end Value) *Filter {
return &Filter{
name: name,
idxType: indexCollectionType,
valueParticleType: valueParticleType,
begin: begin,
end: end,
}
} | go | {
"resource": ""
} |
q10117 | parseKey | train | func (cmd *batchCommandGet) parseKey(fieldCount int) error {
// var digest [20]byte
// var namespace, setName string
// var userKey Value
var err error
for i := 0; i < fieldCount; i++ {
if err = cmd.readBytes(4); err != nil {
return err
}
fieldlen := int(Buffer.BytesToUint32(cmd.dataBuffer, 0))
if err... | go | {
"resource": ""
} |
q10118 | parseRecord | train | func (cmd *batchCommandGet) parseRecord(key *Key, opCount int, generation, expiration uint32) (*Record, error) {
bins := make(BinMap, opCount)
for i := 0; i < opCount; i++ {
if err := cmd.readBytes(8); err != nil {
return nil, err
}
opSize := int(Buffer.BytesToUint32(cmd.dataBuffer, 0))
particleType := in... | go | {
"resource": ""
} |
q10119 | expireExample | train | func expireExample(client *as.Client) {
key, _ := as.NewKey(*shared.Namespace, *shared.Set, "expirekey ")
bin := as.NewBin("expirebin", "expirevalue")
log.Printf("Put: namespace=%s set=%s key=%s bin=%s value=%s expiration=2",
key.Namespace(), key.SetName(), key.Value(), bin.Name, bin.Value)
// Specify that reco... | go | {
"resource": ""
} |
q10120 | onComplete | train | func (btsk *baseTask) onComplete(ifc Task) chan error {
ch := make(chan error, 1)
// goroutine will loop every <interval> until IsDone() returns true or error
go func() {
// always close the channel on return
defer close(ch)
var interval = 100 * time.Millisecond
for {
select {
case <-time.After(inte... | go | {
"resource": ""
} |
q10121 | NewTransaction | train | func (d *Datastore) NewTransaction(readOnly bool) (ds.Txn, error) {
d.closeLk.RLock()
defer d.closeLk.RUnlock()
if d.closed {
return nil, ErrClosed
}
return &txn{d, d.DB.NewTransaction(!readOnly), false}, nil
} | go | {
"resource": ""
} |
q10122 | newImplicitTransaction | train | func (d *Datastore) newImplicitTransaction(readOnly bool) *txn {
return &txn{d, d.DB.NewTransaction(!readOnly), true}
} | go | {
"resource": ""
} |
q10123 | DiskUsage | train | func (d *Datastore) DiskUsage() (uint64, error) {
d.closeLk.RLock()
defer d.closeLk.RUnlock()
if d.closed {
return 0, ErrClosed
}
lsm, vlog := d.DB.Size()
return uint64(lsm + vlog), nil
} | go | {
"resource": ""
} |
q10124 | Close | train | func (t *txn) Close() error {
t.ds.closeLk.RLock()
defer t.ds.closeLk.RUnlock()
if t.ds.closed {
return ErrClosed
}
return t.close()
} | go | {
"resource": ""
} |
q10125 | updatePriority | train | func (pq *priorityQueue) updatePriority(item *expiringBuffer, priority int64) {
item.priority = priority
// NOTE: fix is a slightly more efficient version of calling Remove() and
// then Push()
heap.Fix(pq, item.index)
} | go | {
"resource": ""
} |
q10126 | peakTopPriority | train | func (pq *priorityQueue) peakTopPriority() (int64, error) {
if len(*pq) > 0 {
return (*pq)[0].priority, nil
} else {
return -1, fmt.Errorf("PriorityQueue is empty. No top priority.")
}
} | go | {
"resource": ""
} |
q10127 | getEventSubscriptionHandler | train | func getEventSubscriptionHandler(manager *golongpoll.LongpollManager) func(w http.ResponseWriter, r *http.Request) {
// Creates closure that captures the LongpollManager
// Wraps the manager.SubscriptionHandler with a layer of dummy access control validation
return func(w http.ResponseWriter, r *http.Request) {
ca... | go | {
"resource": ""
} |
q10128 | QueueEvent | train | func (eb *eventBuffer) QueueEvent(event *lpEvent) error {
if event == nil {
return errors.New("event was nil")
}
// Cull our buffer if we're at max capacity
if eb.List.Len() >= eb.MaxBufferSize {
oldestEvent := eb.List.Back()
if oldestEvent != nil {
eb.List.Remove(oldestEvent)
}
}
// Add event to front... | go | {
"resource": ""
} |
q10129 | getLongPollSubscriptionHandler | train | func getLongPollSubscriptionHandler(maxTimeoutSeconds int, subscriptionRequests chan clientSubscription,
clientTimeouts chan<- clientCategoryPair, loggingEnabled bool) func(w http.ResponseWriter, r *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
timeout, err := strconv.Atoi(r.URL.Query().Get(... | go | {
"resource": ""
} |
q10130 | run | train | func (sm *subscriptionManager) run() error {
if sm.LoggingEnabled {
log.Println("SubscriptionManager: Starting run.")
}
for {
// NOTE: we check to see if its time to purge old buffers whenever
// something happens or a period of inactivity has occurred.
// An alternative would be to have another goroutine wi... | go | {
"resource": ""
} |
q10131 | Start | train | func (c *Client) Start() {
u := c.url
if c.LoggingEnabled {
log.Println("Now observing changes on", u.String())
}
atomic.AddUint64(&(c.runID), 1)
currentRunID := atomic.LoadUint64(&(c.runID))
go func(runID uint64, u *url.URL) {
since := time.Now().Unix() * 1000
for {
pr, err := c.fetchEvents(since)
... | go | {
"resource": ""
} |
q10132 | fetchEvents | train | func (c Client) fetchEvents(since int64) (PollResponse, error) {
u := c.url
if c.LoggingEnabled {
log.Println("Checking for changes events since", since, "on URL", u.String())
}
query := u.Query()
query.Set("category", c.category)
query.Set("since_time", fmt.Sprintf("%d", since))
query.Set("timeout", fmt.Spri... | go | {
"resource": ""
} |
q10133 | NewGenerator | train | func NewGenerator(i *GeneratorInput) (*Generator, error) {
if i == nil {
i = new(GeneratorInput)
}
g := &Generator{
lowerLetters: i.LowerLetters,
upperLetters: i.UpperLetters,
digits: i.Digits,
symbols: i.Symbols,
}
if g.lowerLetters == "" {
g.lowerLetters = LowerLetters
}
if g.upperLet... | go | {
"resource": ""
} |
q10134 | Generate | train | func (g *Generator) Generate(length, numDigits, numSymbols int, noUpper, allowRepeat bool) (string, error) {
letters := g.lowerLetters
if !noUpper {
letters += g.upperLetters
}
chars := length - numDigits - numSymbols
if chars < 0 {
return "", ErrExceedsTotalLength
}
if !allowRepeat && chars > len(letters)... | go | {
"resource": ""
} |
q10135 | MustGenerate | train | func (g *Generator) MustGenerate(length, numDigits, numSymbols int, noUpper, allowRepeat bool) string {
res, err := g.Generate(length, numDigits, numSymbols, noUpper, allowRepeat)
if err != nil {
panic(err)
}
return res
} | go | {
"resource": ""
} |
q10136 | Generate | train | func Generate(length, numDigits, numSymbols int, noUpper, allowRepeat bool) (string, error) {
gen, err := NewGenerator(nil)
if err != nil {
return "", err
}
return gen.Generate(length, numDigits, numSymbols, noUpper, allowRepeat)
} | go | {
"resource": ""
} |
q10137 | randomInsert | train | func randomInsert(s, val string) (string, error) {
if s == "" {
return val, nil
}
n, err := rand.Int(rand.Reader, big.NewInt(int64(len(s)+1)))
if err != nil {
return "", err
}
i := n.Int64()
return s[0:i] + val + s[i:len(s)], nil
} | go | {
"resource": ""
} |
q10138 | randomElement | train | func randomElement(s string) (string, error) {
n, err := rand.Int(rand.Reader, big.NewInt(int64(len(s))))
if err != nil {
return "", err
}
return string(s[n.Int64()]), nil
} | go | {
"resource": ""
} |
q10139 | init | train | func init() {
sock, err := net.Listen("tcp", "localhost:8080")
if err != nil {
log.Printf("net listen error: %v", err)
}
go func() {
fmt.Println("Metrics available at http://localhost:8080/debug/vars")
http.Serve(sock, nil)
}()
} | go | {
"resource": ""
} |
q10140 | ShouldRetry | train | func (r *MyRetryer) ShouldRetry(err error) bool {
if awsErr, ok := err.(awserr.Error); ok {
switch awsErr.Code() {
case dynamodb.ErrCodeProvisionedThroughputExceededException, dynamodb.ErrCodeLimitExceededException:
return true
default:
return false
}
}
return false
} | go | {
"resource": ""
} |
q10141 | start | train | func (b *broker) start(ctx context.Context) {
b.findNewShards()
ticker := time.NewTicker(30 * time.Second)
// Note: while ticker is a rather naive approach to this problem,
// it actually simplies a few things. i.e. If we miss a new shard while
// AWS is resharding we'll pick it up max 30 seconds later.
// It m... | go | {
"resource": ""
} |
q10142 | findNewShards | train | func (b *broker) findNewShards() {
b.shardMu.Lock()
defer b.shardMu.Unlock()
b.logger.Log("[BROKER]", "fetching shards")
shards, err := b.listShards()
if err != nil {
b.logger.Log("[BROKER]", err)
return
}
for _, shard := range shards {
if _, ok := b.shards[*shard.ShardId]; ok {
continue
}
b.shar... | go | {
"resource": ""
} |
q10143 | listShards | train | func (b *broker) listShards() ([]*kinesis.Shard, error) {
var ss []*kinesis.Shard
var listShardsInput = &kinesis.ListShardsInput{
StreamName: aws.String(b.streamName),
}
for {
resp, err := b.client.ListShards(listShardsInput)
if err != nil {
return nil, fmt.Errorf("ListShards error: %v", err)
}
ss = a... | go | {
"resource": ""
} |
q10144 | WithMaxInterval | train | func WithMaxInterval(maxInterval time.Duration) Option {
return func(c *Checkpoint) {
c.maxInterval = maxInterval
}
} | go | {
"resource": ""
} |
q10145 | WithDynamoClient | train | func WithDynamoClient(svc dynamodbiface.DynamoDBAPI) Option {
return func(c *Checkpoint) {
c.client = svc
}
} | go | {
"resource": ""
} |
q10146 | New | train | func New(appName, tableName string, opts ...Option) (*Checkpoint, error) {
client := dynamodb.New(session.New(aws.NewConfig()))
ck := &Checkpoint{
tableName: tableName,
appName: appName,
client: client,
maxInterval: time.Duration(1 * time.Minute),
done: make(chan struct{}),
mu: ... | go | {
"resource": ""
} |
q10147 | WithClient | train | func WithClient(client kinesisiface.KinesisAPI) Option {
return func(c *Consumer) {
c.client = client
}
} | go | {
"resource": ""
} |
q10148 | New | train | func New(streamName string, opts ...Option) (*Consumer, error) {
if streamName == "" {
return nil, fmt.Errorf("must provide stream name")
}
// new consumer with no-op checkpoint, counter, and logger
c := &Consumer{
streamName: streamName,
initialShardIteratorType: kinesis.ShardIteratorTypeLates... | go | {
"resource": ""
} |
q10149 | Scan | train | func (c *Consumer) Scan(ctx context.Context, fn ScanFunc) error {
var (
errc = make(chan error, 1)
shardc = make(chan *kinesis.Shard, 1)
broker = newBroker(c.client, c.streamName, shardc, c.logger)
)
ctx, cancel := context.WithCancel(ctx)
defer cancel()
go broker.start(ctx)
go func() {
<-ctx.Done()
... | go | {
"resource": ""
} |
q10150 | ScanShard | train | func (c *Consumer) ScanShard(ctx context.Context, shardID string, fn ScanFunc) error {
// get last seq number from checkpoint
lastSeqNum, err := c.checkpoint.Get(c.streamName, shardID)
if err != nil {
return fmt.Errorf("get checkpoint error: %v", err)
}
// get shard iterator
shardIterator, err := c.getShardIte... | go | {
"resource": ""
} |
q10151 | New | train | func New(appName string) (*Checkpoint, error) {
addr := os.Getenv("REDIS_URL")
if addr == "" {
addr = localhost
}
client := redis.NewClient(&redis.Options{Addr: addr})
// verify we can ping server
_, err := client.Ping().Result()
if err != nil {
return nil, err
}
return &Checkpoint{
appName: appName,
... | go | {
"resource": ""
} |
q10152 | Get | train | func (c *Checkpoint) Get(streamName, shardID string) (string, error) {
val, _ := c.client.Get(c.key(streamName, shardID)).Result()
return val, nil
} | go | {
"resource": ""
} |
q10153 | key | train | func (c *Checkpoint) key(streamName, shardID string) string {
return fmt.Sprintf("%v:checkpoint:%v:%v", c.appName, streamName, shardID)
} | go | {
"resource": ""
} |
q10154 | New | train | func New(appName, tableName, connectionStr string, opts ...Option) (*Checkpoint, error) {
if appName == "" {
return nil, errors.New("application name not defined")
}
if tableName == "" {
return nil, errors.New("table name not defined")
}
conn, err := sql.Open("postgres", connectionStr)
if err != nil {
re... | go | {
"resource": ""
} |
q10155 | Shutdown | train | func (c *Checkpoint) Shutdown() error {
defer c.conn.Close()
c.done <- struct{}{}
return c.save()
} | go | {
"resource": ""
} |
q10156 | newNonTS | train | func newNonTS() *SetNonTS {
s := &SetNonTS{}
s.m = make(map[interface{}]struct{})
// Ensure interface compliance
var _ Interface = s
return s
} | go | {
"resource": ""
} |
q10157 | IsEqual | train | func (s *set) IsEqual(t Interface) bool {
// Force locking only if given set is threadsafe.
if conv, ok := t.(*Set); ok {
conv.l.RLock()
defer conv.l.RUnlock()
}
// return false if they are no the same size
if sameSize := len(s.m) == t.Size(); !sameSize {
return false
}
equal := true
t.Each(func(item in... | go | {
"resource": ""
} |
q10158 | String | train | func (s *set) String() string {
t := make([]string, 0, len(s.List()))
for _, item := range s.List() {
t = append(t, fmt.Sprintf("%v", item))
}
return fmt.Sprintf("[%s]", strings.Join(t, ", "))
} | go | {
"resource": ""
} |
q10159 | Intersection | train | func Intersection(set1, set2 Interface, sets ...Interface) Interface {
all := Union(set1, set2, sets...)
result := Union(set1, set2, sets...)
all.Each(func(item interface{}) bool {
if !set1.Has(item) || !set2.Has(item) {
result.Remove(item)
}
for _, set := range sets {
if !set.Has(item) {
result.Re... | go | {
"resource": ""
} |
q10160 | SymmetricDifference | train | func SymmetricDifference(s Interface, t Interface) Interface {
u := Difference(s, t)
v := Difference(t, s)
return Union(u, v)
} | go | {
"resource": ""
} |
q10161 | StringSlice | train | func StringSlice(s Interface) []string {
slice := make([]string, 0)
for _, item := range s.List() {
v, ok := item.(string)
if !ok {
continue
}
slice = append(slice, v)
}
return slice
} | go | {
"resource": ""
} |
q10162 | IntSlice | train | func IntSlice(s Interface) []int {
slice := make([]int, 0)
for _, item := range s.List() {
v, ok := item.(int)
if !ok {
continue
}
slice = append(slice, v)
}
return slice
} | go | {
"resource": ""
} |
q10163 | RequestTeamInfo | train | func RequestTeamInfo(tc *ginoauth2.TokenContainer, uri string) ([]byte, error) {
var uv = make(url.Values)
uv.Set("member", tc.Scopes["uid"].(string))
info_url := uri + "?" + uv.Encode()
client := &http.Client{Transport: &ginoauth2.Transport}
req, err := http.NewRequest("GET", info_url, nil)
if err != nil {
ret... | go | {
"resource": ""
} |
q10164 | GroupCheck | train | func GroupCheck(at []AccessTuple) func(tc *ginoauth2.TokenContainer, ctx *gin.Context) bool {
ats := at
return func(tc *ginoauth2.TokenContainer, ctx *gin.Context) bool {
blob, err := RequestTeamInfo(tc, TeamAPI)
if err != nil {
glog.Errorf("[Gin-OAuth] failed to get team info, caused by: %s", err)
return f... | go | {
"resource": ""
} |
q10165 | ScopeCheck | train | func ScopeCheck(name string, scopes ...string) func(tc *ginoauth2.TokenContainer, ctx *gin.Context) bool {
glog.Infof("ScopeCheck %s configured to grant access for scopes: %v", name, scopes)
configuredScopes := scopes
return func(tc *ginoauth2.TokenContainer, ctx *gin.Context) bool {
scopesFromToken := make([]stri... | go | {
"resource": ""
} |
q10166 | Valid | train | func (t *TokenContainer) Valid() bool {
if t.Token == nil {
return false
}
return t.Token.Valid()
} | go | {
"resource": ""
} |
q10167 | Setup | train | func Setup(redirectURL, credFile string, scopes []string, secret []byte) {
store = sessions.NewCookieStore(secret)
var c Credentials
file, err := ioutil.ReadFile(credFile)
if err != nil {
glog.Fatalf("[Gin-OAuth] File error: %v\n", err)
}
json.Unmarshal(file, &c)
conf = &oauth2.Config{
ClientID: c.Clien... | go | {
"resource": ""
} |
q10168 | Create | train | func Create(root vfs.Filesystem, prefix string) *FS {
return &FS{root, prefix}
} | go | {
"resource": ""
} |
q10169 | PrefixPath | train | func (fs *FS) PrefixPath(path string) string {
return fs.Prefix + string(fs.PathSeparator()) + path
} | go | {
"resource": ""
} |
q10170 | OpenFile | train | func (fs *FS) OpenFile(name string, flag int, perm os.FileMode) (vfs.File, error) {
return fs.Filesystem.OpenFile(fs.PrefixPath(name), flag, perm)
} | go | {
"resource": ""
} |
q10171 | Remove | train | func (fs *FS) Remove(name string) error {
return fs.Filesystem.Remove(fs.PrefixPath(name))
} | go | {
"resource": ""
} |
q10172 | Rename | train | func (fs *FS) Rename(oldpath, newpath string) error {
return fs.Filesystem.Rename(fs.PrefixPath(oldpath), fs.PrefixPath(newpath))
} | go | {
"resource": ""
} |
q10173 | Mkdir | train | func (fs *FS) Mkdir(name string, perm os.FileMode) error {
return fs.Filesystem.Mkdir(fs.PrefixPath(name), perm)
} | go | {
"resource": ""
} |
q10174 | Stat | train | func (fs *FS) Stat(name string) (os.FileInfo, error) {
return fs.Filesystem.Stat(fs.PrefixPath(name))
} | go | {
"resource": ""
} |
q10175 | ReadDir | train | func (fs *FS) ReadDir(path string) ([]os.FileInfo, error) {
return fs.Filesystem.ReadDir(fs.PrefixPath(path))
} | go | {
"resource": ""
} |
q10176 | NewMemFile | train | func NewMemFile(name string, rwMutex *sync.RWMutex, buf *[]byte) *MemFile {
return &MemFile{
Buffer: NewBuffer(buf),
mutex: rwMutex,
name: name,
}
} | go | {
"resource": ""
} |
q10177 | Truncate | train | func (b MemFile) Truncate(size int64) (err error) {
b.mutex.Lock()
err = b.Buffer.Truncate(size)
b.mutex.Unlock()
return
} | go | {
"resource": ""
} |
q10178 | ReadFile | train | func ReadFile(fs Filesystem, filename string) ([]byte, error) {
f, err := fs.OpenFile(filename, os.O_RDONLY, 0)
if err != nil {
return nil, err
}
defer f.Close()
// It's a good but not certain bet that FileInfo will tell us exactly how
// much to read, so let's try it but be prepared for the answer to be wrong... | go | {
"resource": ""
} |
q10179 | Mkdir | train | func (fs RoFS) Mkdir(name string, perm os.FileMode) error {
return ErrReadOnly
} | go | {
"resource": ""
} |
q10180 | Create | train | func Create() *MemFS {
root := &fileInfo{
name: "/",
dir: true,
}
return &MemFS{
root: root,
wd: root,
lock: &sync.RWMutex{},
}
} | go | {
"resource": ""
} |
q10181 | Mkdir | train | func (fs *MemFS) Mkdir(name string, perm os.FileMode) error {
fs.lock.Lock()
defer fs.lock.Unlock()
name = filepath.Clean(name)
base := filepath.Base(name)
parent, fi, err := fs.fileInfo(name)
if err != nil {
return &os.PathError{"mkdir", name, err}
}
if fi != nil {
return &os.PathError{"mkdir", name, fmt.E... | go | {
"resource": ""
} |
q10182 | Write | train | func (f *roFile) Write(p []byte) (n int, err error) {
return 0, ErrReadOnly
} | go | {
"resource": ""
} |
q10183 | Read | train | func (f *woFile) Read(p []byte) (n int, err error) {
return 0, ErrWriteOnly
} | go | {
"resource": ""
} |
q10184 | makeSlice | train | func makeSlice(n int) (b []byte, err error) {
// If the make fails, give a known error.
defer func() {
if recover() != nil {
b = nil
err = ErrTooLarge
return
}
}()
b = make([]byte, n)
return
} | go | {
"resource": ""
} |
q10185 | OpenFile | train | func (fs DummyFS) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
return nil, fs.err
} | go | {
"resource": ""
} |
q10186 | Mkdir | train | func (fs DummyFS) Mkdir(name string, perm os.FileMode) error {
return fs.err
} | go | {
"resource": ""
} |
q10187 | Stat | train | func (fs DummyFS) Stat(name string) (os.FileInfo, error) {
return nil, fs.err
} | go | {
"resource": ""
} |
q10188 | ReadDir | train | func (fs DummyFS) ReadDir(path string) ([]os.FileInfo, error) {
return nil, fs.err
} | go | {
"resource": ""
} |
q10189 | Write | train | func (f DumFile) Write(p []byte) (n int, err error) {
return 0, f.err
} | go | {
"resource": ""
} |
q10190 | ReadAt | train | func (f DumFile) ReadAt(p []byte, off int64) (n int, err error) {
return 0, f.err
} | go | {
"resource": ""
} |
q10191 | Seek | train | func (f DumFile) Seek(offset int64, whence int) (int64, error) {
return 0, f.err
} | go | {
"resource": ""
} |
q10192 | OpenFile | train | func (fs OsFS) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
return os.OpenFile(name, flag, perm)
} | go | {
"resource": ""
} |
q10193 | Mkdir | train | func (fs OsFS) Mkdir(name string, perm os.FileMode) error {
return os.Mkdir(name, perm)
} | go | {
"resource": ""
} |
q10194 | Rename | train | func (fs OsFS) Rename(oldpath, newpath string) error {
return os.Rename(oldpath, newpath)
} | go | {
"resource": ""
} |
q10195 | ReadDir | train | func (fs OsFS) ReadDir(path string) ([]os.FileInfo, error) {
return ioutil.ReadDir(path)
} | go | {
"resource": ""
} |
q10196 | Create | train | func Create(rootFS vfs.Filesystem) *MountFS {
return &MountFS{
rootFS: rootFS,
mounts: make(map[string]vfs.Filesystem),
parents: make(map[string][]string),
}
} | go | {
"resource": ""
} |
q10197 | findMount | train | func findMount(path string, mounts map[string]vfs.Filesystem, fallback vfs.Filesystem, pathSeparator string) (vfs.Filesystem, string) {
path = filepath.Clean(path)
segs := vfs.SplitPath(path, pathSeparator)
l := len(segs)
for i := l; i > 0; i-- {
mountPath := strings.Join(segs[0:i], pathSeparator)
if fs, ok := ... | go | {
"resource": ""
} |
q10198 | Remove | train | func (fs MountFS) Remove(name string) error {
mount, innerPath := findMount(name, fs.mounts, fs.rootFS, string(fs.PathSeparator()))
return mount.Remove(innerPath)
} | go | {
"resource": ""
} |
q10199 | Rename | train | func (fs MountFS) Rename(oldpath, newpath string) error {
oldMount, oldInnerPath := findMount(oldpath, fs.mounts, fs.rootFS, string(fs.PathSeparator()))
newMount, newInnerPath := findMount(newpath, fs.mounts, fs.rootFS, string(fs.PathSeparator()))
if oldMount != newMount {
return ErrBoundary
}
return oldMount.Re... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.