// Get returns an immutable snapshot reference for ID
483925
func (cm *cacheManager) Get(ctx context.Context, id string, opts ...RefOption) (ImmutableRef, error) {
	cm.mu.Lock()
	defer cm.mu.Unlock()
	return cm.get(ctx, id, false, opts...)
}
1107228
func (s *storeImpl) Get(ctx datastore.Context) (*StoredProperties, error) {
	val := &StoredProperties{}
	if err := s.ds.Get(ctx, Key(propsID), val); err != nil {
		return nil, err
	}
	return val, nil
}
1358673
func (m *Manager) Get(id string) (*Organization, error) {
	var organization Organization

	objectID := bson.ObjectIdHex(id)

	if err := m.collection.FindId(objectID).One(&organization); err != nil {
		return nil, err
	}

	return &organization, nil
}
1190178
func (s *LedisStore) Get(key interface{}) interface{} {
	s.lock.RLock()
	defer s.lock.RUnlock()

	return s.data[key]
}
118771
func (hm *SyncedHashMap) Get(key Hashable) (interface{}, bool) {
	hm.RLock()
	defer hm.RUnlock()
	if _, ok := (*hm).keys[key.Hash()]; ok {
		v, ok := (*hm).values[key.Hash()]
		return v, ok
	}
	return nil, false
}
580164
func (s *MemStore) Get(key interface{}) interface{} {
	s.lock.RLock()
	defer s.lock.RUnlock()

	return s.data[key]
}
627642
func (w *SnapshotWrapper) Get(key []byte, readOptions ReadOptions) (
	[]byte, error) {
	return w.ss.Get(key, readOptions)
}
698388
func (d *Datastore) Get(k ds.Key) ([]byte, error) {
	o, ok := d.buffer[k]
	if ok {
		if o.delete {
			return nil, ds.ErrNotFound
		}
		return o.value, nil
	}

	return d.child.Get(k)
}
249544
func (r *AppRepo) Get(id string) (*App, error) {
	app := &App{}

	if err := r.DB.Get(app, "SELECT * FROM apps WHERE id=$1", id); err != nil {
		if err == sql.ErrNoRows {
			return app, ErrAppNotExist
		}
		return app, err
	}

	return app, nil
}
1204715
func (d *NullDatastore) Get(key Key) (value []byte, err error) {
	return nil, ErrNotFound
}
1151330
func (vpcApi *VpcApi) Get(id string) (*Vpc, error) {
	data, err := vpcApi.entityService.Get(id, map[string]string{})
	if err != nil {
		return nil, err
	}
	return parseVpc(data), nil
}
1055394
func (s *inMemStore) Get(id string) Session {
	s.mux.RLock()
	defer s.mux.RUnlock()

	sess := s.sessions[id]
	if sess == nil {
		return nil
	}

	sess.Access()
	return sess
}
1217081
func (s *Store) Get(i interface{}) error {
	location := s.Path(i)

	file, err := ioutil.ReadFile(location)
	if err != nil {
		return err
	}

	err = yaml.Unmarshal(file, i)
	if err != nil {
		return err
	}

	return nil
}
21037
func (d *inMemoryDB) Get(key string) ([]byte, error) {
	d.lck.RLock()
	defer d.lck.RUnlock()
	v, ok := d.m[key]
	if !ok {
		return nil, ErrNotFound
	}
	return v, nil
}
205908
func (instanceApi *InstanceApi) Get(id string) (*Instance, error) {
	data, err := instanceApi.entityService.Get(id, map[string]string{})
	if err != nil {
		return nil, err
	}
	return parseInstance(data), nil
}
414686
func (db *DB) Get(id *identity.ID, env envelope.Envelope) error {
	return db.db.View(func(tx *bolt.Tx) error {
		bucket := tx.Bucket([]byte{id.Type()})
		if bucket == nil {
			return errors.New("ID not found")
		}

		b := bucket.Get(id[:])
		if b == nil {
			return errors.New("ID not found")
		}

		return json.Unmarshal(b, env)
	})
}
66755
func (d *Datastore) Get(k ds.Key) ([]byte, error) {
	var val []byte
	err := d.runOp(func() error {
		var err error
		val, err = d.Batching.Get(k)
		return err
	})

	return val, err
}