_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q30000 | wrapStreamStatusRPC | train | func wrapStreamStatusRPC(responses chan common.Status, errs chan error) (*common.Status, error) {
var status common.Status
var err multi.Errors
read:
for {
select {
case s, ok := <-responses:
if !ok {
break read
}
status = s
case e := <-errs:
err = append(err, e)
}
}
// drain remaining er... | go | {
"resource": ""
} |
q30001 | NewReceived | train | func NewReceived(numBlock NumBlock, numChaincode NumChaincode) Received {
return Received{NumBlock: numBlock, NumChaincode: numChaincode}
} | go | {
"resource": ""
} |
q30002 | NewLedger | train | func NewLedger(chName string) (*Ledger, error) {
l := Ledger{
chName: chName,
}
return &l, nil
} | go | {
"resource": ""
} |
q30003 | QueryBlockByHash | train | func (c *Ledger) QueryBlockByHash(reqCtx reqContext.Context, blockHash []byte, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*common.Block, error) {
if len(blockHash) == 0 {
return nil, errors.New("blockHash is required")
}
cir := createBlockByHashInvokeRequest(c.chName, blockHash)
tprs, errs :... | go | {
"resource": ""
} |
q30004 | QueryBlockByTxID | train | func (c *Ledger) QueryBlockByTxID(reqCtx reqContext.Context, txID fab.TransactionID, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*common.Block, error) {
if txID == "" {
return nil, errors.New("txID is required")
}
cir := createBlockByTxIDInvokeRequest(c.chName, txID)
tprs, errs := queryChainc... | go | {
"resource": ""
} |
q30005 | QueryTransaction | train | func (c *Ledger) QueryTransaction(reqCtx reqContext.Context, transactionID fab.TransactionID, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*pb.ProcessedTransaction, error) {
cir := createTransactionByIDInvokeRequest(c.chName, transactionID)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, target... | go | {
"resource": ""
} |
q30006 | QueryInstantiatedChaincodes | train | func (c *Ledger) QueryInstantiatedChaincodes(reqCtx reqContext.Context, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*pb.ChaincodeQueryResponse, error) {
cir := createChaincodeInvokeRequest()
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses := []*pb.ChaincodeQueryRe... | go | {
"resource": ""
} |
q30007 | QueryCollectionsConfig | train | func (c *Ledger) QueryCollectionsConfig(reqCtx reqContext.Context, chaincodeName string, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*common.CollectionConfigPackage, error) {
cir := createCollectionsConfigInvokeRequest(chaincodeName)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, veri... | go | {
"resource": ""
} |
q30008 | QueryConfigBlock | train | func (c *Ledger) QueryConfigBlock(reqCtx reqContext.Context, targets []fab.ProposalProcessor, verifier ResponseVerifier) (*common.Block, error) {
if len(targets) == 0 {
return nil, errors.New("target(s) required")
}
cir := createConfigBlockInvokeRequest(c.chName)
tprs, err := queryChaincode(reqCtx, c.chName, cir... | go | {
"resource": ""
} |
q30009 | WithBlockNum | train | func WithBlockNum(from uint64) ClientOption {
return func(c *Client) error {
c.fromBlock = from
return nil
}
} | go | {
"resource": ""
} |
q30010 | WithSeekType | train | func WithSeekType(seek seek.Type) ClientOption {
return func(c *Client) error {
c.seekType = seek
return nil
}
} | go | {
"resource": ""
} |
q30011 | NewMockStatefulPeer | train | func NewMockStatefulPeer(name, url string, opts ...MockPeerOpt) *MockPeer {
p := &MockPeer{
MockPeer: fabmocks.NewMockPeer(name, url),
}
for _, opt := range opts {
opt(p)
}
return p
} | go | {
"resource": ""
} |
q30012 | BlockHeight | train | func (p *MockPeer) BlockHeight() uint64 {
p.lock.RLock()
defer p.lock.RUnlock()
return p.blockHeight
} | go | {
"resource": ""
} |
q30013 | SetBlockHeight | train | func (p *MockPeer) SetBlockHeight(blockHeight uint64) {
p.lock.Lock()
defer p.lock.Unlock()
p.blockHeight = blockHeight
} | go | {
"resource": ""
} |
q30014 | New | train | func New(channelProvider context.ChannelProvider, opts ...ClientOption) (*Client, error) {
channelContext, err := channelProvider()
if err != nil {
return nil, err
}
if channelContext.ChannelService() == nil {
return nil, errors.New("channel service not initialized")
}
membership, err := channelContext.Cha... | go | {
"resource": ""
} |
q30015 | prepareRequestOpts | train | func (c *Client) prepareRequestOpts(options ...RequestOption) (requestOptions, error) {
opts := requestOptions{}
for _, option := range options {
err := option(c.ctx, &opts)
if err != nil {
return opts, errors.WithMessage(err, "Failed to read request opts")
}
}
// Set defaults for max targets
if opts.Max... | go | {
"resource": ""
} |
q30016 | newCtxtCacheKey | train | func newCtxtCacheKey(ctx fab.ClientContext) (*ctxtCacheKey, error) {
identity, err := ctx.Serialize()
if err != nil {
return nil, err
}
h := sha256.New()
if _, err := h.Write(identity); err != nil {
return nil, err
}
hash := h.Sum(nil)
return &ctxtCacheKey{
key: string(hash),
context: ctx,
}, ni... | go | {
"resource": ""
} |
q30017 | newEventCacheKey | train | func newEventCacheKey(chConfig fab.ChannelCfg, opts ...options.Opt) (*eventCacheKey, error) {
params := defaultParams()
options.Apply(params, opts)
h := sha256.New()
if _, err := h.Write([]byte(params.getOptKey())); err != nil {
return nil, err
}
hash := h.Sum([]byte(chConfig.ID()))
return &eventCacheKey{
... | go | {
"resource": ""
} |
q30018 | CAConfig | train | func (c *MockConfig) CAConfig(org string) (*msp.CAConfig, bool) {
caConfig := msp.CAConfig{
CAName: "org1",
}
return &caConfig, true
} | go | {
"resource": ""
} |
q30019 | Timeout | train | func (c *MockConfig) Timeout(arg fab.TimeoutType) time.Duration {
return time.Second * 10
} | go | {
"resource": ""
} |
q30020 | PeersConfig | train | func (c *MockConfig) PeersConfig(org string) ([]fab.PeerConfig, bool) {
return nil, false
} | go | {
"resource": ""
} |
q30021 | PeerConfig | train | func (c *MockConfig) PeerConfig(nameOrURL string) (*fab.PeerConfig, bool) {
if nameOrURL == "invalid" {
return nil, false
}
if c.customPeerCfg != nil {
return c.customPeerCfg, true
}
cfg := fab.PeerConfig{
URL: "example.com",
}
return &cfg, true
} | go | {
"resource": ""
} |
q30022 | OrderersConfig | train | func (c *MockConfig) OrderersConfig() []fab.OrdererConfig {
oConfig, _ := c.OrdererConfig("")
return []fab.OrdererConfig{*oConfig}
} | go | {
"resource": ""
} |
q30023 | OrdererConfig | train | func (c *MockConfig) OrdererConfig(name string) (*fab.OrdererConfig, bool) {
if name == "Invalid" {
return nil, false
}
if c.customOrdererCfg != nil {
return c.customOrdererCfg, true
}
oConfig := fab.OrdererConfig{
URL: "example.com",
}
return &oConfig, true
} | go | {
"resource": ""
} |
q30024 | SetCustomChannelConfig | train | func (c *MockConfig) SetCustomChannelConfig(channelID string, config *fab.ChannelEndpointConfig) {
if c.chConfig == nil {
c.chConfig = make(map[string]*fab.ChannelEndpointConfig)
}
c.chConfig[channelID] = config
} | go | {
"resource": ""
} |
q30025 | Lookup | train | func (c *MockConfig) Lookup(key string) (interface{}, bool) {
if key == "invalid" {
return nil, false
}
value, ok := c.Lookup(key)
if !ok {
return nil, false
}
return value, true
} | go | {
"resource": ""
} |
q30026 | Broadcast | train | func (m *MockBroadcastServer) Broadcast(server po.AtomicBroadcast_BroadcastServer) error {
res, err := server.Recv()
if err == io.EOF {
return nil
}
if err != nil {
return err
}
if m.BroadcastError != nil {
return m.BroadcastError
}
if m.BroadcastInternalServerError {
return server.Send(broadcastResp... | go | {
"resource": ""
} |
q30027 | Deliver | train | func (m *MockBroadcastServer) Deliver(server po.AtomicBroadcast_DeliverServer) error {
if m.DeliverError != nil {
return m.DeliverError
}
if m.DeliverResponse != nil {
if _, err := server.Recv(); err != nil {
return err
}
if err := server.SendMsg(m.DeliverResponse); err != nil {
return err
}
retur... | go | {
"resource": ""
} |
q30028 | Start | train | func (m *MockBroadcastServer) Start(address string) string {
if m.srv != nil {
panic("MockBroadcastServer already started")
}
// pass in TLS creds if present
if m.Creds != nil {
m.srv = grpc.NewServer(grpc.Creds(m.Creds))
} else {
m.srv = grpc.NewServer()
}
lis, err := net.Listen("tcp", address)
if err ... | go | {
"resource": ""
} |
q30029 | New | train | func New(opts ...coptions.Opt) options.PeerSorter {
params := defaultParams()
coptions.Apply(params, opts)
sorter := &sorter{
params: params,
}
return func(peers []fab.Peer) []fab.Peer {
return sorter.Sort(peers)
}
} | go | {
"resource": ""
} |
q30030 | Sort | train | func (f *sorter) Sort(peers []fab.Peer) []fab.Peer {
if len(peers) <= 1 {
return peers
}
if f.blockHeightLagThreshold < 0 {
logger.Debugf("Returning all peers")
return f.balancer(peers)
}
maxHeight := getMaxBlockHeight(peers)
logger.Debugf("Max block height of peers: %d", maxHeight)
if maxHeight <= uint... | go | {
"resource": ""
} |
q30031 | CreateLocalDiscoveryService | train | func (dp *MockStaticDiscoveryProvider) CreateLocalDiscoveryService(mspID string) (fab.DiscoveryService, error) {
if dp.customDiscoveryService != nil {
return dp.customDiscoveryService, nil
}
return NewMockDiscoveryService(dp.Error, dp.Peers...), nil
} | go | {
"resource": ""
} |
q30032 | GetPeers | train | func (ds *MockStaticDiscoveryService) GetPeers() ([]fab.Peer, error) {
if ds.Error != nil {
return nil, ds.Error
}
if ds.Peers == nil {
mockPeer := MockPeer{MockName: "Peer1", MockURL: "http://peer1.com", MockRoles: []string{}, MockCert: nil, MockMSP: "Org1MSP"}
peers := make([]fab.Peer, 0)
peers = append(... | go | {
"resource": ""
} |
q30033 | NewRefCache | train | func NewRefCache(refresh time.Duration) *lazycache.Cache {
initializer := func(key lazycache.Key) (interface{}, error) {
ck, ok := key.(CacheKey)
if !ok {
return nil, errors.New("unexpected cache key")
}
return NewRef(refresh, ck.Context(), ck.ChConfigRef()), nil
}
return lazycache.New("Membership_Cache"... | go | {
"resource": ""
} |
q30034 | initMetrics | train | func (sdk *FabricSDK) initMetrics(configs *configs) {
if configs == nil {
return
}
if sdk.system == nil {
sdk.system = newOperationsSystem(configs)
err := sdk.system.Start()
if err != nil {
panic("metrics failed to start: " + err.Error())
}
// for now NewClientMetrics supports channel client. TODO: ... | go | {
"resource": ""
} |
q30035 | NewCachingConnector | train | func NewCachingConnector(sweepTime time.Duration, idleTime time.Duration) *CachingConnector {
cc := CachingConnector{
conns: map[string]*cachedConn{},
index: map[*grpc.ClientConn]*cachedConn{},
janitorDone: make(chan bool, 1),
janitorClosed: make(chan bool, 1),
sweepTime: sweepTime,
i... | go | {
"resource": ""
} |
q30036 | Close | train | func (cc *CachingConnector) Close() {
cc.lock.RLock()
// Safety check to see if the connector has been closed. This represents a
// bug in the calling code, but it's not good to panic here.
if cc.janitorDone == nil {
cc.lock.RUnlock()
logger.Warn("Trying to close connector after already closed")
return
}
cc... | go | {
"resource": ""
} |
q30037 | DialContext | train | func (cc *CachingConnector) DialContext(ctx context.Context, target string, opts ...grpc.DialOption) (*grpc.ClientConn, error) {
logger.Debugf("DialContext: %s", target)
cc.lock.Lock()
c, ok := cc.loadConn(target)
if !ok {
createdConn, err := cc.createConn(ctx, target, opts...)
if err != nil {
cc.lock.Unloc... | go | {
"resource": ""
} |
q30038 | ReleaseConn | train | func (cc *CachingConnector) ReleaseConn(conn *grpc.ClientConn) {
cc.lock.Lock()
defer cc.lock.Unlock()
// Safety check to see if the connector has been closed. This represents a
// bug in the calling code, but it's not good to panic here.
if cc.janitorDone == nil {
logger.Warn("Trying to release connection afte... | go | {
"resource": ""
} |
q30039 | NewSelectAndEndorseHandler | train | func NewSelectAndEndorseHandler(next ...Handler) Handler {
return &SelectAndEndorseHandler{
EndorsementHandler: NewEndorsementHandler(),
next: getNext(next),
}
} | go | {
"resource": ""
} |
q30040 | Handle | train | func (e *SelectAndEndorseHandler) Handle(requestContext *RequestContext, clientContext *ClientContext) {
var ccCalls []*fab.ChaincodeCall
targets := requestContext.Opts.Targets
if len(targets) == 0 {
var err error
ccCalls, requestContext.Opts.Targets, err = getEndorsers(requestContext, clientContext)
if err !=... | go | {
"resource": ""
} |
q30041 | NewChainedCCFilter | train | func NewChainedCCFilter(filters ...CCFilter) CCFilter {
return func(ccID string) bool {
for _, filter := range filters {
if !filter(ccID) {
return false
}
}
return true
}
} | go | {
"resource": ""
} |
q30042 | getCCCall | train | func getCCCall(invocChain []*fab.ChaincodeCall, ccID string) (*fab.ChaincodeCall, bool) {
for _, ccCall := range invocChain {
if ccCall.ID == ccID {
return ccCall, true
}
}
return nil, false
} | go | {
"resource": ""
} |
q30043 | merge | train | func merge(c1 *fab.ChaincodeCall, c2 *fab.ChaincodeCall) (*fab.ChaincodeCall, bool) {
c := &fab.ChaincodeCall{ID: c1.ID, Collections: c1.Collections}
merged := false
for _, coll := range c2.Collections {
if !contains(c.Collections, coll) {
c.Collections = append(c.Collections, coll)
merged = true
}
}
ret... | go | {
"resource": ""
} |
q30044 | prioritizePeers | train | func prioritizePeers(peers []fab.Peer) selectopts.PrioritySelector {
return func(peer1, peer2 fab.Peer) int {
hasPeer1 := containsPeer(peers, peer1)
hasPeer2 := containsPeer(peers, peer2)
if hasPeer1 && hasPeer2 {
return 0
}
if hasPeer1 {
return 1
}
if hasPeer2 {
return -1
}
return 0
}
} | go | {
"resource": ""
} |
q30045 | New | train | func New(initializer Initializer, opts ...options.Opt) *Reference {
return NewWithData(func(interface{}) (interface{}, error) {
return initializer()
}, opts...)
} | go | {
"resource": ""
} |
q30046 | NewWithData | train | func NewWithData(initializer InitializerWithData, opts ...options.Opt) *Reference {
lazyRef := &Reference{
params: params{
initialInit: InitOnFirstAccess,
},
initializer: initializer,
}
options.Apply(lazyRef, opts)
if lazyRef.expirationProvider != nil {
// This is an expiring reference. After the initi... | go | {
"resource": ""
} |
q30047 | Get | train | func (r *Reference) Get(data ...interface{}) (interface{}, error) {
if r.IsClosed() {
return nil, errors.New("reference is already closed")
}
// Try outside of a lock
if value, ok := r.get(); ok {
return value, nil
}
r.lock.Lock()
defer r.lock.Unlock()
// Try again inside the lock
if value, ok := r.get(... | go | {
"resource": ""
} |
q30048 | MustGet | train | func (r *Reference) MustGet() interface{} {
value, err := r.Get()
if err != nil {
panic(fmt.Sprintf("error returned from Get: %s", err))
}
return value
} | go | {
"resource": ""
} |
q30049 | GetLevel | train | func (l *ModuleLevels) GetLevel(module string) api.Level {
level, exists := l.levels[module]
if !exists {
level, exists = l.levels[""]
// no configuration exists, default to info
if !exists {
level = api.INFO
}
}
return level
} | go | {
"resource": ""
} |
q30050 | SetLevel | train | func (l *ModuleLevels) SetLevel(module string, level api.Level) {
if l.levels == nil {
l.levels = make(map[string]api.Level)
}
l.levels[module] = level
} | go | {
"resource": ""
} |
q30051 | IsEnabledFor | train | func (l *ModuleLevels) IsEnabledFor(module string, level api.Level) bool {
return level <= l.GetLevel(module)
} | go | {
"resource": ""
} |
q30052 | NewRef | train | func NewRef(ctx fab.ClientContext, pvdr Provider, channel string, opts ...options.Opt) *Ref {
params := newDefaultParams()
options.Apply(params, opts)
cfgRef := &Ref{
pvdr: pvdr,
ctx: ctx,
channelID: channel,
errHandler: params.errHandler,
}
cfgRef.Reference = lazyref.New(
cfgRef.initiali... | go | {
"resource": ""
} |
q30053 | New | train | func New(dispatcher eventservice.Dispatcher, opts ...options.Opt) *Client {
params := defaultParams()
options.Apply(params, opts)
return &Client{
Service: eventservice.New(dispatcher, opts...),
params: *params,
connectionState: int32(Disconnected),
}
} | go | {
"resource": ""
} |
q30054 | SetAfterConnectHandler | train | func (c *Client) SetAfterConnectHandler(h handler) {
c.Lock()
defer c.Unlock()
c.afterConnect = h
} | go | {
"resource": ""
} |
q30055 | SetBeforeReconnectHandler | train | func (c *Client) SetBeforeReconnectHandler(h handler) {
c.Lock()
defer c.Unlock()
c.beforeReconnect = h
} | go | {
"resource": ""
} |
q30056 | Connect | train | func (c *Client) Connect() error {
if c.maxConnAttempts == 1 {
return c.connect()
}
return c.connectWithRetry(c.maxConnAttempts, c.timeBetweenConnAttempts)
} | go | {
"resource": ""
} |
q30057 | CloseIfIdle | train | func (c *Client) CloseIfIdle() bool {
logger.Debug("Attempting to close event client...")
// Check if there are any outstanding registrations
regInfoCh := make(chan *esdispatcher.RegistrationInfo)
err := c.Submit(esdispatcher.NewRegistrationInfoEvent(regInfoCh))
if err != nil {
logger.Debugf("Submit failed %s",... | go | {
"resource": ""
} |
q30058 | TransferRegistrations | train | func (c *Client) TransferRegistrations(close bool) (fab.EventSnapshot, error) {
if !close {
return c.Transfer()
}
var snapshot fab.EventSnapshot
var err error
c.close(func() {
logger.Debug("Stopping dispatcher and taking snapshot of all registrations...")
snapshot, err = c.StopAndTransfer()
if err != nil ... | go | {
"resource": ""
} |
q30059 | registerConnectionEvent | train | func (c *Client) registerConnectionEvent() (fab.Registration, chan *dispatcher.ConnectionEvent, error) {
if c.Stopped() {
return nil, nil, errors.New("event client is closed")
}
eventch := make(chan *dispatcher.ConnectionEvent, c.eventConsumerBufferSize)
errch := make(chan error)
regch := make(chan fab.Registra... | go | {
"resource": ""
} |
q30060 | setConnectionState | train | func (c *Client) setConnectionState(currentState, newState ConnectionState) bool {
return atomic.CompareAndSwapInt32(&c.connectionState, int32(currentState), int32(newState))
} | go | {
"resource": ""
} |
q30061 | Handle | train | func (e *EndorsementHandler) Handle(requestContext *RequestContext, clientContext *ClientContext) {
if len(requestContext.Opts.Targets) == 0 {
requestContext.Error = status.New(status.ClientStatus, status.NoPeersFound.ToInt32(), "targets were not provided", nil)
return
}
// Endorse Tx
var TxnHeaderOpts []fab.... | go | {
"resource": ""
} |
q30062 | Handle | train | func (h *ProposalProcessorHandler) Handle(requestContext *RequestContext, clientContext *ClientContext) {
//Get proposal processor, if not supplied then use selection service to get available peers as endorser
if len(requestContext.Opts.Targets) == 0 {
var selectionOpts []options.Opt
if requestContext.SelectionFi... | go | {
"resource": ""
} |
q30063 | Handle | train | func (f *EndorsementValidationHandler) Handle(requestContext *RequestContext, clientContext *ClientContext) {
//Filter tx proposal responses
err := f.validate(requestContext.Response.Responses)
if err != nil {
requestContext.Error = errors.WithMessage(err, "endorsement validation failed")
return
}
//Delegate... | go | {
"resource": ""
} |
q30064 | Handle | train | func (c *CommitTxHandler) Handle(requestContext *RequestContext, clientContext *ClientContext) {
txnID := requestContext.Response.TransactionID
//Register Tx event
reg, statusNotifier, err := clientContext.EventService.RegisterTxStatusEvent(string(txnID)) // TODO: Change func to use TransactionID instead of string
... | go | {
"resource": ""
} |
q30065 | NewEndorsementHandlerWithOpts | train | func NewEndorsementHandlerWithOpts(next Handler, provider TxnHeaderOptsProvider) *EndorsementHandler {
return &EndorsementHandler{next: next, headerOptsProvider: provider}
} | go | {
"resource": ""
} |
q30066 | Choose | train | func (lbp *RoundRobin) Choose(peers []fab.Peer) (fab.Peer, error) {
if len(peers) == 0 {
logger.Warn("No peers to choose from!")
return nil, nil
}
return peers[lbp.counter.Next(len(peers))], nil
} | go | {
"resource": ""
} |
q30067 | New | train | func New(cryptoProvider core.CryptoSuite) (*SigningManager, error) {
return &SigningManager{cryptoProvider: cryptoProvider, hashOpts: cryptosuite.GetSHAOpts()}, nil
} | go | {
"resource": ""
} |
q30068 | NewBox | train | func NewBox(path string) Box {
var cd string
if !filepath.IsAbs(path) {
_, filename, _, _ := runtime.Caller(1)
cd = filepath.Dir(filename)
}
// this little hack courtesy of the `-cover` flag!!
cov := filepath.Join("_test", "_obj_test")
cd = strings.Replace(cd, string(filepath.Separator)+cov, "", 1)
if !file... | go | {
"resource": ""
} |
q30069 | String | train | func (b Box) String() string {
x, _ := json.Marshal(b)
return string(x)
} | go | {
"resource": ""
} |
q30070 | NewBox | train | func NewBox(name string, path string) *Box {
if len(name) == 0 {
name = path
}
name = strings.Replace(name, "\"", "", -1)
pwd, _ := os.Getwd()
box := &Box{
Name: name,
Path: path,
PWD: pwd,
}
return box
} | go | {
"resource": ""
} |
q30071 | Pack | train | func Pack(opts PackOptions) error {
pwd, err := os.Getwd()
if err != nil {
return err
}
opts.Roots = append(opts.Roots, pwd)
if err := Clean(opts.Roots...); err != nil {
return err
}
p, err := parser.NewFromRoots(opts.Roots, &parser.RootsOptions{
IgnoreImports: opts.IgnoreImports,
})
if err != nil {
... | go | {
"resource": ""
} |
q30072 | Run | train | func (b *Builder) Run() error {
wg := &errgroup.Group{}
root, err := filepath.EvalSymlinks(b.RootPath)
if err != nil {
return err
}
err = filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
if info == nil {
return filepath.SkipDir
}
base := strings.ToLower(filepath.Base(path))
... | go | {
"resource": ""
} |
q30073 | New | train | func New(ctx context.Context, path string) *Builder {
return &Builder{
Context: ctx,
RootPath: path,
IgnoredBoxes: []string{},
IgnoredFolders: []string{"vendor", ".git", "node_modules", ".idea"},
pkgs: map[string]pkg{},
moot: &sync.Mutex{},
}
} | go | {
"resource": ""
} |
q30074 | String | train | func (f *File) String() string {
src, _ := ioutil.ReadAll(f)
f.Reader = bytes.NewReader(src)
return string(src)
} | go | {
"resource": ""
} |
q30075 | NewFile | train | func NewFile(path string, r io.Reader) *File {
if r == nil {
r = &bytes.Buffer{}
}
if seek, ok := r.(io.Seeker); ok {
seek.Seek(0, 0)
}
abs := path
if !filepath.IsAbs(path) {
abs, _ = filepath.Abs(path)
}
return &File{
Reader: r,
Path: path,
AbsPath: abs,
}
} | go | {
"resource": ""
} |
q30076 | Resolve | train | func (p Pointer) Resolve(box string, path string) (file.File, error) {
plog.Debug(p, "Resolve", "box", box, "path", path, "forward-box", p.ForwardBox, "forward-path", p.ForwardPath)
b, err := findBox(p.ForwardBox)
if err != nil {
return nil, err
}
f, err := b.Resolve(p.ForwardPath)
if err != nil {
return f, e... | go | {
"resource": ""
} |
q30077 | Run | train | func (p *Parser) Run() (Boxes, error) {
var boxes Boxes
for _, pros := range p.Prospects {
plog.Debug(p, "Run", "parsing", pros.Name())
v := NewVisitor(pros)
pbr, err := v.Run()
if err != nil {
return boxes, err
}
for _, b := range pbr {
plog.Debug(p, "Run", "file", pros.Name(), "box", b.Name)
bo... | go | {
"resource": ""
} |
q30078 | PackBytes | train | func PackBytes(box string, name string, bb []byte) {
gil.Lock()
defer gil.Unlock()
if _, ok := data[box]; !ok {
data[box] = map[string][]byte{}
}
data[box][name] = bb
} | go | {
"resource": ""
} |
q30079 | PackBytesGzip | train | func PackBytesGzip(box string, name string, bb []byte) error {
var buf bytes.Buffer
w := gzip.NewWriter(&buf)
_, err := w.Write(bb)
if err != nil {
return err
}
err = w.Close()
if err != nil {
return err
}
PackBytes(box, name, buf.Bytes())
return nil
} | go | {
"resource": ""
} |
q30080 | PackJSONBytes | train | func PackJSONBytes(box string, name string, jbb string) error {
var bb []byte
err := json.Unmarshal([]byte(jbb), &bb)
if err != nil {
return err
}
PackBytes(box, name, bb)
return nil
} | go | {
"resource": ""
} |
q30081 | UnpackBytes | train | func UnpackBytes(box string) {
gil.Lock()
defer gil.Unlock()
delete(data, box)
} | go | {
"resource": ""
} |
q30082 | DecodeString | train | func DecodeString(s string) ([]byte, error) {
src := []byte(s)
// We can use the source slice itself as the destination
// because the decode loop increments by one and then the 'seen' byte is not used anymore.
n, err := Decode(src, src)
return src[:n], err
} | go | {
"resource": ""
} |
q30083 | Dump | train | func Dump(data []byte) string {
var buf bytes.Buffer
dumper := Dumper(&buf)
dumper.Write(data)
dumper.Close()
return buf.String()
} | go | {
"resource": ""
} |
q30084 | Load | train | func (m *resolversMap) Load(key string) (resolver.Resolver, bool) {
i, ok := m.data.Load(key)
if !ok {
return nil, false
}
s, ok := i.(resolver.Resolver)
return s, ok
} | go | {
"resource": ""
} |
q30085 | Range | train | func (m *resolversMap) Range(f func(key string, value resolver.Resolver) bool) {
m.data.Range(func(k, v interface{}) bool {
key, ok := k.(string)
if !ok {
return false
}
value, ok := v.(resolver.Resolver)
if !ok {
return false
}
return f(key, value)
})
} | go | {
"resource": ""
} |
q30086 | Store | train | func (m *resolversMap) Store(key string, value resolver.Resolver) {
m.data.Store(key, value)
} | go | {
"resource": ""
} |
q30087 | PackBytes | train | func PackBytes(box string, name string, bb []byte) {
b := NewBox(box)
d := resolver.NewInMemory(map[string]file.File{})
f, err := file.NewFile(name, bb)
if err != nil {
panic(err)
}
if err := d.Pack(name, f); err != nil {
panic(err)
}
b.SetResolver(name, d)
} | go | {
"resource": ""
} |
q30088 | PackBytesGzip | train | func PackBytesGzip(box string, name string, bb []byte) error {
// TODO: this function never did what it was supposed to do!
PackBytes(box, name, bb)
return nil
} | go | {
"resource": ""
} |
q30089 | String | train | func (b *Box) String(name string) string {
oncer.Deprecate(0, "github.com/gobuffalo/packr/v2#Box.String", "Use github.com/gobuffalo/packr/v2#Box.FindString instead.")
return string(b.Bytes(name))
} | go | {
"resource": ""
} |
q30090 | MustString | train | func (b *Box) MustString(name string) (string, error) {
oncer.Deprecate(0, "github.com/gobuffalo/packr/v2#Box.MustString", "Use github.com/gobuffalo/packr/v2#Box.FindString instead.")
return b.FindString(name)
} | go | {
"resource": ""
} |
q30091 | Delete | train | func (m *dirsMap) Delete(key string) {
m.data.Delete(m.normalizeKey(key))
} | go | {
"resource": ""
} |
q30092 | Load | train | func (m *dirsMap) Load(key string) (bool, bool) {
i, ok := m.data.Load(m.normalizeKey(key))
if !ok {
return false, false
}
s, ok := i.(bool)
return s, ok
} | go | {
"resource": ""
} |
q30093 | Store | train | func (m *dirsMap) Store(key string, value bool) {
d := m.normalizeKey(key)
m.data.Store(d, value)
m.data.Store(strings.TrimPrefix(d, "/"), value)
} | go | {
"resource": ""
} |
q30094 | Run | train | func Run() error {
fmt.Printf("! This updater will attempt to update your application to packr version: %s\n", packr.Version)
if !ask("Do you wish to continue?") {
fmt.Println("~~~ cancelling update ~~~")
return nil
}
r := &Runner{
Warnings: []string{},
}
defer func() {
if len(r.Warnings) == 0 {
retu... | go | {
"resource": ""
} |
q30095 | New | train | func New(name string, path string) *Box {
plog.Debug("packr", "New", "name", name, "path", path)
b, _ := findBox(name)
if b != nil {
return b
}
b = construct(name, path)
plog.Debug(b, "New", "Box", b, "ResolutionDir", b.ResolutionDir)
b, err := placeBox(b)
if err != nil {
panic(err)
}
return b
} | go | {
"resource": ""
} |
q30096 | SetResolver | train | func (b *Box) SetResolver(file string, res resolver.Resolver) {
d := filepath.Dir(file)
b.dirs.Store(d, true)
plog.Debug(b, "SetResolver", "file", file, "resolver", fmt.Sprintf("%T", res))
b.resolvers.Store(resolver.Key(file), res)
} | go | {
"resource": ""
} |
q30097 | AddString | train | func (b *Box) AddString(path string, t string) error {
return b.AddBytes(path, []byte(t))
} | go | {
"resource": ""
} |
q30098 | AddBytes | train | func (b *Box) AddBytes(path string, t []byte) error {
m := map[string]file.File{}
f, err := file.NewFile(path, t)
if err != nil {
return err
}
m[resolver.Key(path)] = f
res := resolver.NewInMemory(m)
b.SetResolver(path, res)
return nil
} | go | {
"resource": ""
} |
q30099 | FindString | train | func (b *Box) FindString(name string) (string, error) {
bb, err := b.Find(name)
return string(bb), err
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.