_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q8200 | NetworkGetOper | train | func (ac *APIController) NetworkGetOper(network *contivModel.NetworkInspect) error {
log.Infof("Received NetworkInspect: %+v", network)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
nwCfg := &mastercfg.CfgNetworkState{}
nwCfg.StateDriver = stateDriver
networ... | go | {
"resource": ""
} |
q8201 | NetworkUpdate | train | func (ac *APIController) NetworkUpdate(network, params *contivModel.Network) error {
log.Infof("Received NetworkUpdate: %+v, params: %+v", network, params)
return core.Errorf("Cant change network parameters after its created")
} | go | {
"resource": ""
} |
q8202 | NetworkDelete | train | func (ac *APIController) NetworkDelete(network *contivModel.Network) error {
log.Infof("Received NetworkDelete: %+v", network)
// Find the tenant
tenant := contivModel.FindTenant(network.TenantName)
if tenant == nil {
return core.Errorf("Tenant not found")
}
// if the network has associated epgs, fail the del... | go | {
"resource": ""
} |
q8203 | NetprofileCreate | train | func (ac *APIController) NetprofileCreate(netProfile *contivModel.Netprofile) error {
log.Infof("Received NetprofileCreate: %+v", netProfile)
// Check if the tenant exists
if netProfile.TenantName == "" {
return core.Errorf("Invalid tenant name")
}
if netProfile.Burst > 0 && netProfile.Burst < 2 {
return cor... | go | {
"resource": ""
} |
q8204 | NetprofileUpdate | train | func (ac *APIController) NetprofileUpdate(profile, params *contivModel.Netprofile) error {
log.Infof("Received NetprofileUpdate: %+v, params: %+v", profile, params)
if params.Burst > 0 && params.Burst < 2 {
return core.Errorf("Invalid Burst size. burst size must be > 1500 bytes")
}
profile.Bandwidth = params.Ban... | go | {
"resource": ""
} |
q8205 | NetprofileDelete | train | func (ac *APIController) NetprofileDelete(netProfile *contivModel.Netprofile) error {
log.Infof("Deleting Netprofile:%s", netProfile.ProfileName)
// Find Tenant
tenant := contivModel.FindTenant(netProfile.TenantName)
if tenant == nil {
return core.Errorf("Tenant %s not found", netProfile.TenantName)
}
// Check... | go | {
"resource": ""
} |
q8206 | PolicyCreate | train | func (ac *APIController) PolicyCreate(policy *contivModel.Policy) error {
log.Infof("Received PolicyCreate: %+v", policy)
// Make sure tenant exists
if policy.TenantName == "" {
return core.Errorf("Invalid tenant name")
}
tenant := contivModel.FindTenant(policy.TenantName)
if tenant == nil {
return core.Err... | go | {
"resource": ""
} |
q8207 | PolicyGetOper | train | func (ac *APIController) PolicyGetOper(policy *contivModel.PolicyInspect) error {
log.Infof("Received PolicyInspect: %+v", policy)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// To hold total number of Endpoint count
var policyEPCount int
policyCfg := &ma... | go | {
"resource": ""
} |
q8208 | PolicyUpdate | train | func (ac *APIController) PolicyUpdate(policy, params *contivModel.Policy) error {
log.Infof("Received PolicyUpdate: %+v, params: %+v", policy, params)
return nil
} | go | {
"resource": ""
} |
q8209 | PolicyDelete | train | func (ac *APIController) PolicyDelete(policy *contivModel.Policy) error {
log.Infof("Received PolicyDelete: %+v", policy)
// Find Tenant
tenant := contivModel.FindTenant(policy.TenantName)
if tenant == nil {
return core.Errorf("Tenant %s not found", policy.TenantName)
}
// Check if any endpoint group is using... | go | {
"resource": ""
} |
q8210 | RuleUpdate | train | func (ac *APIController) RuleUpdate(rule, params *contivModel.Rule) error {
log.Infof("Received RuleUpdate: %+v, params: %+v", rule, params)
return errors.New("can not update a rule after its created")
} | go | {
"resource": ""
} |
q8211 | RuleDelete | train | func (ac *APIController) RuleDelete(rule *contivModel.Rule) error {
var epg *contivModel.EndpointGroup
epg = nil
log.Infof("Received RuleDelete: %+v", rule)
policyKey := GetpolicyKey(rule.TenantName, rule.PolicyName)
// find the policy
policy := contivModel.FindPolicy(policyKey)
if policy == nil {
log.Error... | go | {
"resource": ""
} |
q8212 | TenantCreate | train | func (ac *APIController) TenantCreate(tenant *contivModel.Tenant) error {
log.Infof("Received TenantCreate: %+v", tenant)
if tenant.TenantName == "" {
return core.Errorf("Invalid tenant name")
}
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Build tenan... | go | {
"resource": ""
} |
q8213 | getTenantNetworks | train | func getTenantNetworks(tenant *contivModel.TenantInspect) error {
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
tenantID := tenant.Config.TenantName
numEPs := 0
s := []string{}
networkID := ""
for _, net := range tenant.Config.LinkSets.Networks {
networkI... | go | {
"resource": ""
} |
q8214 | getTenantEPGs | train | func getTenantEPGs(tenant *contivModel.TenantInspect) error {
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
tenantID := tenant.Config.TenantName
s := []string{}
epgID := ""
for _, epg := range tenant.Config.LinkSets.EndpointGroups {
epgID = epg.ObjKey
lo... | go | {
"resource": ""
} |
q8215 | TenantGetOper | train | func (ac *APIController) TenantGetOper(tenant *contivModel.TenantInspect) error {
log.Infof("Received TenantInspect: %+v", tenant)
tenant.Oper.TotalNetworks = len(tenant.Config.LinkSets.Networks)
tenant.Oper.TotalEPGs = len(tenant.Config.LinkSets.EndpointGroups)
tenant.Oper.TotalNetprofiles = len(tenant.Config.Lin... | go | {
"resource": ""
} |
q8216 | TenantUpdate | train | func (ac *APIController) TenantUpdate(tenant, params *contivModel.Tenant) error {
log.Infof("Received TenantUpdate: %+v, params: %+v", tenant, params)
return core.Errorf("Cant change tenant parameters after its created")
} | go | {
"resource": ""
} |
q8217 | TenantDelete | train | func (ac *APIController) TenantDelete(tenant *contivModel.Tenant) error {
log.Infof("Received TenantDelete: %+v", tenant)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// if the tenant has associated app profiles, fail the delete
profCount := len(tenant.LinkS... | go | {
"resource": ""
} |
q8218 | BgpCreate | train | func (ac *APIController) BgpCreate(bgpCfg *contivModel.Bgp) error {
log.Infof("Received BgpCreate: %+v", bgpCfg)
if bgpCfg.Hostname == "" {
return core.Errorf("Invalid host name")
}
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Build bgp config
bgpInt... | go | {
"resource": ""
} |
q8219 | BgpDelete | train | func (ac *APIController) BgpDelete(bgpCfg *contivModel.Bgp) error {
log.Infof("Received delete for Bgp config on {%+v} ", bgpCfg.Hostname)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
err = master.DeleteBgp(stateDriver, bgpCfg.Hostname)
if err != nil {
log... | go | {
"resource": ""
} |
q8220 | BgpUpdate | train | func (ac *APIController) BgpUpdate(oldbgpCfg *contivModel.Bgp, NewbgpCfg *contivModel.Bgp) error {
log.Infof("Received BgpUpdate: %+v", NewbgpCfg)
if NewbgpCfg.Hostname == "" {
return core.Errorf("Invalid host name")
}
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return... | go | {
"resource": ""
} |
q8221 | BgpGetOper | train | func (ac *APIController) BgpGetOper(bgp *contivModel.BgpInspect) error {
var obj BgpInspect
var host string
srvList, err := ac.objdbClient.GetService("netplugin")
if err != nil {
log.Errorf("Error getting netplugin nodes. Err: %v", err)
return err
}
for _, srv := range srvList {
if srv.Hostname == bgp.Con... | go | {
"resource": ""
} |
q8222 | ServiceLBCreate | train | func (ac *APIController) ServiceLBCreate(serviceCfg *contivModel.ServiceLB) error {
log.Infof("Received Service Load Balancer create: %+v", serviceCfg)
if serviceCfg.ServiceName == "" {
return core.Errorf("Invalid service name")
}
if len(serviceCfg.Selectors) == 0 {
return core.Errorf("Invalid selector optio... | go | {
"resource": ""
} |
q8223 | ServiceLBUpdate | train | func (ac *APIController) ServiceLBUpdate(oldServiceCfg *contivModel.ServiceLB, serviceCfg *contivModel.ServiceLB) error {
log.Infof("Received Service Load Balancer update: %+v", serviceCfg)
err := ac.ServiceLBCreate(serviceCfg)
if err != nil {
return err
}
oldServiceCfg.ServiceName = serviceCfg.ServiceName
oldS... | go | {
"resource": ""
} |
q8224 | ServiceLBDelete | train | func (ac *APIController) ServiceLBDelete(serviceCfg *contivModel.ServiceLB) error {
log.Info("Received Service Load Balancer delete : {%+v}", serviceCfg)
if serviceCfg.ServiceName == "" {
return core.Errorf("Invalid service name")
}
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err !=... | go | {
"resource": ""
} |
q8225 | ServiceLBGetOper | train | func (ac *APIController) ServiceLBGetOper(serviceLB *contivModel.ServiceLBInspect) error {
log.Infof("Received Service load balancer inspect : %+v", serviceLB)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
serviceID := master.GetServiceID(serviceLB.Config.Servi... | go | {
"resource": ""
} |
q8226 | Init | train | func (p *NetPlugin) Init(pluginConfig Config) error {
var err error
if pluginConfig.Instance.HostLabel == "" {
return core.Errorf("empty host-label passed")
}
// initialize state driver
p.StateDriver, err = utils.GetStateDriver()
if err != nil {
p.StateDriver, err = utils.NewStateDriver(pluginConfig.Drivers.... | go | {
"resource": ""
} |
q8227 | Deinit | train | func (p *NetPlugin) Deinit() {
p.Lock()
defer p.Unlock()
if p.NetworkDriver != nil {
p.NetworkDriver.Deinit()
p.NetworkDriver = nil
}
if p.StateDriver != nil {
utils.ReleaseStateDriver()
p.StateDriver = nil
}
} | go | {
"resource": ""
} |
q8228 | DeleteNetwork | train | func (p *NetPlugin) DeleteNetwork(id, subnet, nwType, encap string, pktTag, extPktTag int, Gw string, tenant string) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.DeleteNetwork(id, subnet, nwType, encap, pktTag, extPktTag, Gw, tenant)
} | go | {
"resource": ""
} |
q8229 | FetchNetwork | train | func (p *NetPlugin) FetchNetwork(id string) (core.State, error) {
return nil, core.Errorf("Not implemented")
} | go | {
"resource": ""
} |
q8230 | CreateHostAccPort | train | func (p *NetPlugin) CreateHostAccPort(portName, globalIP string) (string, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.CreateHostAccPort(portName, globalIP, p.PluginConfig.Instance.HostPvtNW)
} | go | {
"resource": ""
} |
q8231 | DeleteHostAccPort | train | func (p *NetPlugin) DeleteHostAccPort(portName string) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.DeleteHostAccPort(portName)
} | go | {
"resource": ""
} |
q8232 | DeletePeerHost | train | func (p *NetPlugin) DeletePeerHost(node core.ServiceInfo) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.DeletePeerHost(node)
} | go | {
"resource": ""
} |
q8233 | AddServiceLB | train | func (p *NetPlugin) AddServiceLB(servicename string, spec *core.ServiceSpec) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.AddSvcSpec(servicename, spec)
} | go | {
"resource": ""
} |
q8234 | DeleteServiceLB | train | func (p *NetPlugin) DeleteServiceLB(servicename string, spec *core.ServiceSpec) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.DelSvcSpec(servicename, spec)
} | go | {
"resource": ""
} |
q8235 | GetEndpointStats | train | func (p *NetPlugin) GetEndpointStats() ([]byte, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.GetEndpointStats()
} | go | {
"resource": ""
} |
q8236 | InspectState | train | func (p *NetPlugin) InspectState() ([]byte, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.InspectState()
} | go | {
"resource": ""
} |
q8237 | InspectBgp | train | func (p *NetPlugin) InspectBgp() ([]byte, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.InspectBgp()
} | go | {
"resource": ""
} |
q8238 | InspectNameserver | train | func (p *NetPlugin) InspectNameserver() ([]byte, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.InspectNameserver()
} | go | {
"resource": ""
} |
q8239 | GlobalConfigUpdate | train | func (p *NetPlugin) GlobalConfigUpdate(cfg Config) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.GlobalConfigUpdate(cfg.Instance)
} | go | {
"resource": ""
} |
q8240 | Reinit | train | func (p *NetPlugin) Reinit(cfg Config) {
var err error
p.Lock()
defer p.Unlock()
if p.NetworkDriver != nil {
logrus.Infof("Reinit de-initializing NetworkDriver")
p.NetworkDriver.Deinit()
p.NetworkDriver = nil
}
cfg.Instance.StateDriver, _ = utils.GetStateDriver()
p.NetworkDriver, err = utils.NewNetworkDr... | go | {
"resource": ""
} |
q8241 | DelSvcSpec | train | func (p *NetPlugin) DelSvcSpec(svcName string, spec *core.ServiceSpec) {
p.Lock()
defer p.Unlock()
p.NetworkDriver.DelSvcSpec(svcName, spec)
} | go | {
"resource": ""
} |
q8242 | AddPolicyRule | train | func (p *NetPlugin) AddPolicyRule(id string) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.AddPolicyRule(id)
} | go | {
"resource": ""
} |
q8243 | InitK8SServiceWatch | train | func InitK8SServiceWatch(listenAddr string, isLeader func() bool) error {
npLog = log.WithField("k8s", "netpolicy")
npLog.Infof("Create contiv client at http://%s", listenAddr)
contivClient, err := client.NewContivClient("http://" + listenAddr)
if err != nil {
npLog.Errorf("failed to create contivclient %s", err... | go | {
"resource": ""
} |
q8244 | MarshalBinary | train | func (p *Point) MarshalBinary() ([]byte, error) {
var buf bytes.Buffer
err := binary.Write(&buf, binary.LittleEndian, p.lat)
if err != nil {
return nil, fmt.Errorf("unable to encode lat %v: %v", p.lat, err)
}
err = binary.Write(&buf, binary.LittleEndian, p.lng)
if err != nil {
return nil, fmt.Errorf("unable t... | go | {
"resource": ""
} |
q8245 | MarshalJSON | train | func (p *Point) MarshalJSON() ([]byte, error) {
res := fmt.Sprintf(`{"lat":%v, "lng":%v}`, p.lat, p.lng)
return []byte(res), nil
} | go | {
"resource": ""
} |
q8246 | UnmarshalJSON | train | func (p *Point) UnmarshalJSON(data []byte) error {
// TODO throw an error if there is an issue parsing the body.
dec := json.NewDecoder(bytes.NewReader(data))
var values map[string]float64
err := dec.Decode(&values)
if err != nil {
log.Print(err)
return err
}
*p = *NewPoint(values["lat"], values["lng"])
... | go | {
"resource": ""
} |
q8247 | HandleWithSQL | train | func HandleWithSQL() (*SQLMapper, error) {
sqlConf, sqlConfErr := GetSQLConf()
if sqlConfErr == nil {
s := &SQLMapper{conf: sqlConf}
db, err := sql.Open(s.conf.driver, s.conf.openStr)
if err != nil {
panic(err)
}
s.sqlConn = db
return s, err
}
return nil, sqlConfErr
} | go | {
"resource": ""
} |
q8248 | Geocode | train | func (g *OpenCageGeocoder) Geocode(address string) (*Point, error) {
queryStr, err := opencageGeocodeQueryStr(address)
if err != nil {
return nil, err
}
data, err := g.Request(queryStr)
if err != nil {
return nil, err
}
res := &opencageGeocodeResponse{}
json.Unmarshal(data, res)
if len(res.Results) == ... | go | {
"resource": ""
} |
q8249 | Geocode | train | func (g *MapQuestGeocoder) Geocode(address string) (*Point, error) {
queryStr, err := mapquestGeocodeQueryStr(address)
if err != nil {
return nil, err
}
data, err := g.Request(queryStr)
if err != nil {
return nil, err
}
res := []*mapQuestGeocodeResponse{}
json.Unmarshal(data, &res)
if len(res) == 0 {
... | go | {
"resource": ""
} |
q8250 | confFromYamlFile | train | func confFromYamlFile(config *yaml.File, goEnv string) (*SQLConf, error) {
// TODO Refactor this into a more generic method of retrieving info
// Get driver
driver, driveError := config.Get(fmt.Sprintf("%s.driver", goEnv))
if driveError != nil {
return nil, driveError
}
// Get openStr
openStr, openStrError ... | go | {
"resource": ""
} |
q8251 | Contains | train | func (p *Polygon) Contains(point *Point) bool {
if !p.IsClosed() {
return false
}
start := len(p.points) - 1
end := 0
contains := p.intersectsWithRaycast(point, p.points[start], p.points[end])
for i := 1; i < len(p.points); i++ {
if p.intersectsWithRaycast(point, p.points[i-1], p.points[i]) {
contains =... | go | {
"resource": ""
} |
q8252 | New | train | func New(limit int) SizedWaitGroup {
size := math.MaxInt32 // 2^32 - 1
if limit > 0 {
size = limit
}
return SizedWaitGroup{
Size: size,
current: make(chan struct{}, size),
wg: sync.WaitGroup{},
}
} | go | {
"resource": ""
} |
q8253 | AddWithContext | train | func (s *SizedWaitGroup) AddWithContext(ctx context.Context) error {
select {
case <-ctx.Done():
return ctx.Err()
case s.current <- struct{}{}:
break
}
s.wg.Add(1)
return nil
} | go | {
"resource": ""
} |
q8254 | PrettyOptions | train | func PrettyOptions(json []byte, opts *Options) []byte {
if opts == nil {
opts = DefaultOptions
}
buf := make([]byte, 0, len(json))
if len(opts.Prefix) != 0 {
buf = append(buf, opts.Prefix...)
}
buf, _, _, _ = appendPrettyAny(buf, json, 0, true,
opts.Width, opts.Prefix, opts.Indent, opts.SortKeys,
0, 0, -1... | go | {
"resource": ""
} |
q8255 | Ugly | train | func Ugly(json []byte) []byte {
buf := make([]byte, 0, len(json))
return ugly(buf, json)
} | go | {
"resource": ""
} |
q8256 | writeBlockSkip | train | func (d *compressor) writeBlockSkip(tok tokens, index int, eof bool) error {
if index > 0 || eof {
if d.blockStart <= index {
window := d.window[d.blockStart:index]
// If we removed less than a 64th of all literals
// we huffman compress the block.
if int(tok.n) > len(window)-int(tok.n>>6) {
d.w.writ... | go | {
"resource": ""
} |
q8257 | findMatch | train | func (d *compressor) findMatch(pos int, prevHead int, prevLength int, lookahead int) (length, offset int, ok bool) {
minMatchLook := maxMatchLength
if lookahead < minMatchLook {
minMatchLook = lookahead
}
win := d.window[0 : pos+minMatchLook]
// We quit when we get a match that's at least nice long
nice := le... | go | {
"resource": ""
} |
q8258 | bulkHash4 | train | func bulkHash4(b []byte, dst []uint32) {
if len(b) < minMatchLength {
return
}
hb := uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24
dst[0] = (hb * hashmul) >> (32 - hashBits)
end := len(b) - minMatchLength + 1
for i := 1; i < end; i++ {
hb = (hb << 8) | uint32(b[i+3])
dst[i] = (hb * ha... | go | {
"resource": ""
} |
q8259 | matchLen | train | func matchLen(a, b []byte, max int) int {
a = a[:max]
b = b[:len(a)]
for i, av := range a {
if b[i] != av {
return i
}
}
return max
} | go | {
"resource": ""
} |
q8260 | fillBlock | train | func (d *compressor) fillBlock(b []byte) int {
n := copy(d.window[d.windowEnd:], b)
d.windowEnd += n
return n
} | go | {
"resource": ""
} |
q8261 | write | train | func (d *compressor) write(b []byte) (n int, err error) {
if d.err != nil {
return 0, d.err
}
n = len(b)
for len(b) > 0 {
d.step(d)
b = b[d.fill(d, b):]
if d.err != nil {
return 0, d.err
}
}
return n, d.err
} | go | {
"resource": ""
} |
q8262 | reset | train | func (d *compressor) reset(w io.Writer) {
d.w.reset(w)
d.sync = false
d.err = nil
// We only need to reset a few things for Snappy.
if d.snap != nil {
d.snap.Reset()
d.windowEnd = 0
d.tokens.n = 0
return
}
switch d.compressionLevel.chain {
case 0:
// level was NoCompression or ConstantCompresssion.
... | go | {
"resource": ""
} |
q8263 | NewWriterDict | train | func NewWriterDict(w io.Writer, level int, dict []byte) (*Writer, error) {
dw := &dictWriter{w}
zw, err := NewWriter(dw, level)
if err != nil {
return nil, err
}
zw.d.fillWindow(dict)
zw.dict = append(zw.dict, dict...) // duplicate dictionary for Reset method.
return zw, err
} | go | {
"resource": ""
} |
q8264 | Write | train | func (w *Writer) Write(data []byte) (n int, err error) {
return w.d.write(data)
} | go | {
"resource": ""
} |
q8265 | Reset | train | func (w *Writer) Reset(dst io.Writer) {
if dw, ok := w.d.w.writer.(*dictWriter); ok {
// w was created with NewWriterDict
dw.w = dst
w.d.reset(dw)
w.d.fillWindow(w.dict)
} else {
// w was created with NewWriter
w.d.reset(dst)
}
} | go | {
"resource": ""
} |
q8266 | ResetDict | train | func (w *Writer) ResetDict(dst io.Writer, dict []byte) {
w.dict = dict
w.d.reset(dst)
w.d.fillWindow(w.dict)
} | go | {
"resource": ""
} |
q8267 | noEOF | train | func noEOF(err error) error {
if err == io.EOF {
return io.ErrUnexpectedEOF
}
return err
} | go | {
"resource": ""
} |
q8268 | NewReader | train | func NewReader(r io.Reader) (*Reader, error) {
z := new(Reader)
if err := z.Reset(r); err != nil {
return nil, err
}
return z, nil
} | go | {
"resource": ""
} |
q8269 | Reset | train | func (z *Reader) Reset(r io.Reader) error {
*z = Reader{
decompressor: z.decompressor,
multistream: true,
}
if rr, ok := r.(flate.Reader); ok {
z.r = rr
} else {
z.r = bufio.NewReader(r)
}
z.Header, z.err = z.readHeader()
return z.err
} | go | {
"resource": ""
} |
q8270 | readHeader | train | func (z *Reader) readHeader() (hdr Header, err error) {
if _, err = io.ReadFull(z.r, z.buf[:10]); err != nil {
// RFC 1952, section 2.2, says the following:
// A gzip file consists of a series of "members" (compressed data sets).
//
// Other than this, the specification does not clarify whether a
// "series"... | go | {
"resource": ""
} |
q8271 | Read | train | func (z *Reader) Read(p []byte) (n int, err error) {
if z.err != nil {
return 0, z.err
}
n, z.err = z.decompressor.Read(p)
z.digest = crc32.Update(z.digest, crc32.IEEETable, p[:n])
z.size += uint32(n)
if z.err != io.EOF {
// In the normal case we return here.
return n, z.err
}
// Finished file; check ch... | go | {
"resource": ""
} |
q8272 | addBits16NC | train | func (b *bitWriter) addBits16NC(value uint16, bits uint8) {
b.bitContainer |= uint64(value&bitMask16[bits&31]) << (b.nBits & 63)
b.nBits += bits
} | go | {
"resource": ""
} |
q8273 | addBits16ZeroNC | train | func (b *bitWriter) addBits16ZeroNC(value uint16, bits uint8) {
if bits == 0 {
return
}
value <<= (16 - bits) & 15
value >>= (16 - bits) & 15
b.bitContainer |= uint64(value) << (b.nBits & 63)
b.nBits += bits
} | go | {
"resource": ""
} |
q8274 | flush32 | train | func (b *bitWriter) flush32() {
if b.nBits < 32 {
return
}
b.out = append(b.out,
byte(b.bitContainer),
byte(b.bitContainer>>8),
byte(b.bitContainer>>16),
byte(b.bitContainer>>24))
b.nBits -= 32
b.bitContainer >>= 32
} | go | {
"resource": ""
} |
q8275 | flushAlign | train | func (b *bitWriter) flushAlign() {
nbBytes := (b.nBits + 7) >> 3
for i := uint8(0); i < nbBytes; i++ {
b.out = append(b.out, byte(b.bitContainer>>(i*8)))
}
b.nBits = 0
b.bitContainer = 0
} | go | {
"resource": ""
} |
q8276 | reset | train | func (b *bitWriter) reset(out []byte) {
b.bitContainer = 0
b.nBits = 0
b.out = out
} | go | {
"resource": ""
} |
q8277 | NewWriter | train | func NewWriter(w io.Writer) *Writer {
z, _ := NewWriterLevel(w, DefaultCompression)
return z
} | go | {
"resource": ""
} |
q8278 | NewWriterLevel | train | func NewWriterLevel(w io.Writer, level int) (*Writer, error) {
if level < HuffmanOnly || level > BestCompression {
return nil, fmt.Errorf("gzip: invalid compression level: %d", level)
}
z := new(Writer)
z.init(w, level)
return z, nil
} | go | {
"resource": ""
} |
q8279 | Reset | train | func (z *Writer) Reset(w io.Writer) {
z.init(w, z.level)
} | go | {
"resource": ""
} |
q8280 | writeBytes | train | func (z *Writer) writeBytes(b []byte) error {
if len(b) > 0xffff {
return errors.New("gzip.Write: Extra data is too large")
}
le.PutUint16(z.buf[:2], uint16(len(b)))
_, err := z.w.Write(z.buf[:2])
if err != nil {
return err
}
_, err = z.w.Write(b)
return err
} | go | {
"resource": ""
} |
q8281 | Write | train | func (z *Writer) Write(p []byte) (int, error) {
if z.err != nil {
return 0, z.err
}
var n int
// Write the GZIP header lazily.
if !z.wroteHeader {
z.wroteHeader = true
z.buf[0] = gzipID1
z.buf[1] = gzipID2
z.buf[2] = gzipDeflate
z.buf[3] = 0
if z.Extra != nil {
z.buf[3] |= 0x04
}
if z.Name != ... | go | {
"resource": ""
} |
q8282 | Flush | train | func (z *Writer) Flush() error {
if z.err != nil {
return z.err
}
if z.closed {
return nil
}
if !z.wroteHeader {
z.Write(nil)
if z.err != nil {
return z.err
}
}
z.err = z.compressor.Flush()
return z.err
} | go | {
"resource": ""
} |
q8283 | reset | train | func (b *blockDec) reset(br byteBuffer, windowSize uint64) error {
b.WindowSize = windowSize
tmp := br.readSmall(3)
if tmp == nil {
if debug {
println("Reading block header:", io.ErrUnexpectedEOF)
}
return io.ErrUnexpectedEOF
}
bh := uint32(tmp[0]) | (uint32(tmp[1]) << 8) | (uint32(tmp[2]) << 16)
b.Last ... | go | {
"resource": ""
} |
q8284 | sendErr | train | func (b *blockDec) sendErr(err error) {
b.Last = true
b.Type = blockTypeReserved
b.err = err
b.input <- struct{}{}
} | go | {
"resource": ""
} |
q8285 | Close | train | func (b *blockDec) Close() {
close(b.input)
close(b.history)
close(b.result)
} | go | {
"resource": ""
} |
q8286 | startDecoder | train | func (b *blockDec) startDecoder() {
for range b.input {
//println("blockDec: Got block input")
switch b.Type {
case blockTypeRLE:
if cap(b.dst) < int(b.RLESize) {
if b.lowMem {
b.dst = make([]byte, b.RLESize)
} else {
b.dst = make([]byte, maxBlockSize)
}
}
o := decodeOutput{
d:... | go | {
"resource": ""
} |
q8287 | decodeBuf | train | func (b *blockDec) decodeBuf(hist *history) error {
switch b.Type {
case blockTypeRLE:
if cap(b.dst) < int(b.RLESize) {
if b.lowMem {
b.dst = make([]byte, b.RLESize)
} else {
b.dst = make([]byte, maxBlockSize)
}
}
b.dst = b.dst[:b.RLESize]
v := b.data[0]
for i := range b.dst {
b.dst[i] =... | go | {
"resource": ""
} |
q8288 | init | train | func (b *bitReader) init(in []byte) error {
if len(in) < 1 {
return errors.New("corrupt stream: too short")
}
b.in = in
b.off = uint(len(in))
// The highest bit of the last byte indicates where to start
v := in[len(in)-1]
if v == 0 {
return errors.New("corrupt stream, did not find end of stream")
}
b.bitsR... | go | {
"resource": ""
} |
q8289 | close | train | func (b *bitReader) close() error {
// Release reference.
b.in = nil
if b.bitsRead > 64 {
return io.ErrUnexpectedEOF
}
return nil
} | go | {
"resource": ""
} |
q8290 | RegisterDecompressor | train | func RegisterDecompressor(method uint16, d Decompressor) {
mu.Lock()
defer mu.Unlock()
if _, ok := decompressors[method]; ok {
panic("decompressor already registered")
}
decompressors[method] = d
} | go | {
"resource": ""
} |
q8291 | RegisterCompressor | train | func RegisterCompressor(method uint16, comp Compressor) {
mu.Lock()
defer mu.Unlock()
if _, ok := compressors[method]; ok {
panic("compressor already registered")
}
compressors[method] = comp
} | go | {
"resource": ""
} |
q8292 | init | train | func (s *sequenceDec) init(br *bitReader) error {
if s.fse == nil {
return errors.New("sequence decoder not defined")
}
s.state.init(br, s.fse.actualTableLog, s.fse.dt[:1<<s.fse.actualTableLog])
return nil
} | go | {
"resource": ""
} |
q8293 | initialize | train | func (s *sequenceDecs) initialize(br *bitReader, hist *history, literals, out []byte) error {
if err := s.litLengths.init(br); err != nil {
return errors.New("litLengths:" + err.Error())
}
if err := s.offsets.init(br); err != nil {
return errors.New("litLengths:" + err.Error())
}
if err := s.matchLengths.init(... | go | {
"resource": ""
} |
q8294 | nextFast | train | func (s *sequenceDecs) nextFast(br *bitReader) (ll, mo, ml int) {
// Final will not read from stream.
ll, llB := s.litLengths.state.final()
ml, mlB := s.matchLengths.state.final()
mo, moB := s.offsets.state.final()
// extra bits are stored in reverse order.
br.fillFast()
if s.maxBits <= 32 {
mo += br.getBits(... | go | {
"resource": ""
} |
q8295 | mergeHistory | train | func (s *sequenceDecs) mergeHistory(hist *sequenceDecs) (*sequenceDecs, error) {
for i := uint(0); i < 3; i++ {
var sNew, sHist *sequenceDec
switch i {
default:
// same as "case 0":
sNew = &s.litLengths
sHist = &hist.litLengths
case 1:
sNew = &s.offsets
sHist = &hist.offsets
case 2:
sNew = ... | go | {
"resource": ""
} |
q8296 | Compress1X | train | func Compress1X(in []byte, s *Scratch) (out []byte, reUsed bool, err error) {
s, err = s.prepare(in)
if err != nil {
return nil, false, err
}
return compress(in, s, s.compress1X)
} | go | {
"resource": ""
} |
q8297 | Compress4X | train | func Compress4X(in []byte, s *Scratch) (out []byte, reUsed bool, err error) {
s, err = s.prepare(in)
if err != nil {
return nil, false, err
}
if false {
// TODO: compress4Xp only slightly faster.
const parallelThreshold = 8 << 10
if len(in) < parallelThreshold || runtime.GOMAXPROCS(0) == 1 {
return compr... | go | {
"resource": ""
} |
q8298 | compress4Xp | train | func (s *Scratch) compress4Xp(src []byte) ([]byte, error) {
if len(src) < 12 {
return nil, ErrIncompressible
}
// Add placeholder for output length
s.Out = s.Out[:6]
segmentSize := (len(src) + 3) / 4
var wg sync.WaitGroup
var errs [4]error
wg.Add(4)
for i := 0; i < 4; i++ {
toDo := src
if len(toDo) > se... | go | {
"resource": ""
} |
q8299 | minTableLog | train | func (s *Scratch) minTableLog() uint8 {
minBitsSrc := highBit32(uint32(s.br.remain()-1)) + 1
minBitsSymbols := highBit32(uint32(s.symbolLen-1)) + 2
if minBitsSrc < minBitsSymbols {
return uint8(minBitsSrc)
}
return uint8(minBitsSymbols)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.