_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q24300 | CheckAndSetDefaults | train | func (m *Metadata) CheckAndSetDefaults() error {
if m.Name == "" {
return trace.BadParameter("missing parameter Name")
}
if m.Namespace == "" {
m.Namespace = defaults.Namespace
}
// adjust expires time to utc if it's set
if m.Expires != nil {
utils.UTC(m.Expires)
}
return nil
} | go | {
"resource": ""
} |
q24301 | ParseShortcut | train | func ParseShortcut(in string) (string, error) {
if in == "" {
return "", trace.BadParameter("missing resource name")
}
switch strings.ToLower(in) {
case "role", "roles":
return KindRole, nil
case "namespaces", "ns":
return KindNamespace, nil
case "auth_servers", "auth":
return KindAuthServer, nil
case "p... | go | {
"resource": ""
} |
q24302 | walk | train | func walk(node ast.Node) ([]string, error) {
var l []string
switch n := node.(type) {
case *ast.IndexExpr:
ret, err := walk(n.X)
if err != nil {
return nil, err
}
l = append(l, ret...)
ret, err = walk(n.Index)
if err != nil {
return nil, err
}
l = append(l, ret...)
case *ast.SelectorExpr:
... | go | {
"resource": ""
} |
q24303 | NewAuditLog | train | func NewAuditLog(cfg AuditLogConfig) (*AuditLog, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
ctx, cancel := context.WithCancel(cfg.Context)
al := &AuditLog{
playbackDir: filepath.Join(cfg.DataDir, PlaybackDir, SessionLogsDir, defaults.Namespace),
AuditLogConfig:... | go | {
"resource": ""
} |
q24304 | CheckAndSetDefaults | train | func (l *SessionRecording) CheckAndSetDefaults() error {
if l.Recording == nil {
return trace.BadParameter("missing parameter Recording")
}
if l.SessionID.IsZero() {
return trace.BadParameter("missing parameter session ID")
}
if l.Namespace == "" {
l.Namespace = defaults.Namespace
}
return nil
} | go | {
"resource": ""
} |
q24305 | chunkFileNames | train | func (idx *sessionIndex) chunkFileNames() []string {
fileNames := make([]string, len(idx.chunks))
for i := 0; i < len(idx.chunks); i++ {
fileNames[i] = idx.chunksFileName(i)
}
return fileNames
} | go | {
"resource": ""
} |
q24306 | createOrGetDownload | train | func (l *AuditLog) createOrGetDownload(path string) (context.Context, context.CancelFunc) {
l.Lock()
defer l.Unlock()
ctx, ok := l.activeDownloads[path]
if ok {
return ctx, nil
}
ctx, cancel := context.WithCancel(context.TODO())
l.activeDownloads[path] = ctx
return ctx, func() {
cancel()
l.Lock()
defer ... | go | {
"resource": ""
} |
q24307 | GetSessionChunk | train | func (l *AuditLog) GetSessionChunk(namespace string, sid session.ID, offsetBytes, maxBytes int) ([]byte, error) {
if l.UploadHandler != nil {
if err := l.downloadSession(namespace, sid); err != nil {
return nil, trace.Wrap(err)
}
}
var data []byte
for {
out, err := l.getSessionChunk(namespace, sid, offsetB... | go | {
"resource": ""
} |
q24308 | EmitAuditEvent | train | func (l *AuditLog) EmitAuditEvent(event Event, fields EventFields) error {
// If an external logger has been set, use it as the emitter, otherwise
// fallback to the local disk based emitter.
var emitAuditEvent func(event Event, fields EventFields) error
if l.ExternalLog != nil {
emitAuditEvent = l.ExternalLog.Em... | go | {
"resource": ""
} |
q24309 | emitEvent | train | func (l *AuditLog) emitEvent(e AuditLogEvent) {
if l.EventsC == nil {
return
}
select {
case l.EventsC <- &e:
return
default:
l.Warningf("Blocked on the events channel.")
}
} | go | {
"resource": ""
} |
q24310 | auditDirs | train | func (l *AuditLog) auditDirs() ([]string, error) {
authServers, err := l.getAuthServers()
if err != nil {
return nil, trace.Wrap(err)
}
var out []string
for _, serverID := range authServers {
out = append(out, filepath.Join(l.DataDir, serverID))
}
return out, nil
} | go | {
"resource": ""
} |
q24311 | Close | train | func (l *AuditLog) Close() error {
if l.ExternalLog != nil {
if err := l.ExternalLog.Close(); err != nil {
log.Warningf("Close failure: %v", err)
}
}
l.cancel()
l.Lock()
defer l.Unlock()
if l.localLog != nil {
if err := l.localLog.Close(); err != nil {
log.Warningf("Close failure: %v", err)
}
l.l... | go | {
"resource": ""
} |
q24312 | periodicSpaceMonitor | train | func (l *AuditLog) periodicSpaceMonitor() {
ticker := time.NewTicker(defaults.DiskAlertInterval)
defer ticker.Stop()
for {
select {
case <-ticker.C:
// Find out what percentage of disk space is used. If the syscall fails,
// emit that to prometheus as well.
usedPercent, err := percentUsed(l.DataDir)
... | go | {
"resource": ""
} |
q24313 | New | train | func New(params legacy.Params) (*Backend, error) {
rootDir := params.GetString("path")
if rootDir == "" {
rootDir = params.GetString("data_dir")
}
if rootDir == "" {
return nil, trace.BadParameter("filesystem backend: 'path' is not set")
}
// Ensure that the path to the root directory exists.
err := os.Mkdi... | go | {
"resource": ""
} |
q24314 | GetKeys | train | func (bk *Backend) GetKeys(bucket []string) ([]string, error) {
// Get all the key/value pairs for this bucket.
items, err := bk.GetItems(bucket)
if err != nil {
return nil, trace.Wrap(err)
}
// Return only the keys, the keys are already sorted by GetItems.
keys := make([]string, len(items))
for i, e := range... | go | {
"resource": ""
} |
q24315 | GetVal | train | func (bk *Backend) GetVal(bucket []string, key string) ([]byte, error) {
// Open the bucket to work on the items.
b, err := bk.openBucket(bk.flatten(bucket), os.O_RDWR)
if err != nil {
// GetVal on a bucket needs to return trace.BadParameter. If opening the
// bucket failed a partial match up to a bucket may sti... | go | {
"resource": ""
} |
q24316 | CompareAndSwapVal | train | func (bk *Backend) CompareAndSwapVal(bucket []string, key string, val []byte, prevVal []byte, ttl time.Duration) error {
// Open the bucket to work on the items.
b, err := bk.openBucket(bk.flatten(bucket), os.O_CREATE|os.O_RDWR)
if err != nil {
er := trace.ConvertSystemError(err)
if trace.IsNotFound(er) {
ret... | go | {
"resource": ""
} |
q24317 | DeleteKey | train | func (bk *Backend) DeleteKey(bucket []string, key string) error {
// Open the bucket to work on the items.
b, err := bk.openBucket(bk.flatten(bucket), os.O_RDWR)
if err != nil {
return trace.Wrap(err)
}
defer b.Close()
// If the key doesn't exist, return trace.NotFound.
_, ok := b.getItem(key)
if !ok {
ret... | go | {
"resource": ""
} |
q24318 | DeleteBucket | train | func (bk *Backend) DeleteBucket(parent []string, bucket string) error {
fullBucket := append(parent, bucket)
err := os.Remove(bk.flatten(fullBucket))
if err != nil {
return trace.ConvertSystemError(err)
}
return nil
} | go | {
"resource": ""
} |
q24319 | AcquireLock | train | func (bk *Backend) AcquireLock(token string, ttl time.Duration) (err error) {
bk.log.Debugf("AcquireLock(%s)", token)
if err = legacy.ValidateLockTTL(ttl); err != nil {
return trace.Wrap(err)
}
bucket := []string{locksBucket}
for {
// GetVal will clear TTL on a lock
bk.GetVal(bucket, token)
// CreateVal... | go | {
"resource": ""
} |
q24320 | ReleaseLock | train | func (bk *Backend) ReleaseLock(token string) (err error) {
bk.log.Debugf("ReleaseLock(%s)", token)
if err = bk.DeleteKey([]string{locksBucket}, token); err != nil {
if !os.IsNotExist(err) {
return trace.ConvertSystemError(err)
}
}
return nil
} | go | {
"resource": ""
} |
q24321 | pathToBucket | train | func (bk *Backend) pathToBucket(bucket string) string {
return filepath.Join(bk.rootDir, bucket)
} | go | {
"resource": ""
} |
q24322 | decodeBucket | train | func decodeBucket(bucket string) ([]string, error) {
decoded, err := url.QueryUnescape(bucket)
if err != nil {
return nil, trace.Wrap(err)
}
return filepath.SplitList(decoded), nil
} | go | {
"resource": ""
} |
q24323 | isExpired | train | func (bk *Backend) isExpired(bv bucketItem) bool {
if bv.ExpiryTime.IsZero() {
return false
}
return bk.Clock().Now().After(bv.ExpiryTime)
} | go | {
"resource": ""
} |
q24324 | openBucket | train | func (bk *Backend) openBucket(prefix string, openFlag int) (*bucket, error) {
// Open bucket with requested flags.
file, err := os.OpenFile(prefix, openFlag, defaultFileMode)
if err != nil {
return nil, trace.ConvertSystemError(err)
}
// Lock the bucket so no one else can access it.
if err := utils.FSWriteLock... | go | {
"resource": ""
} |
q24325 | readBucket | train | func readBucket(f *os.File) (map[string]bucketItem, error) {
// If the file is empty, return an empty bucket.
ok, err := isEmpty(f)
if err != nil {
return nil, trace.Wrap(err)
}
if ok {
return map[string]bucketItem{}, nil
}
// The file is not empty, read it into a map.
var items map[string]bucketItem
byte... | go | {
"resource": ""
} |
q24326 | writeBucket | train | func writeBucket(f *os.File, items map[string]bucketItem) error {
// Marshal items to disk format.
bytes, err := json.Marshal(items)
if err != nil {
return trace.Wrap(err)
}
// Truncate the file.
if _, err := f.Seek(0, 0); err != nil {
return trace.ConvertSystemError(err)
}
if err := f.Truncate(0); err != ... | go | {
"resource": ""
} |
q24327 | isEmpty | train | func isEmpty(f *os.File) (bool, error) {
fi, err := f.Stat()
if err != nil {
return false, trace.Wrap(err)
}
if fi.Size() > 0 {
return false, nil
}
return true, nil
} | go | {
"resource": ""
} |
q24328 | Less | train | func (i *btreeItem) Less(iother btree.Item) bool {
switch other := iother.(type) {
case *btreeItem:
return bytes.Compare(i.Key, other.Key) < 0
case *prefixItem:
return !iother.Less(i)
default:
return false
}
} | go | {
"resource": ""
} |
q24329 | Less | train | func (p *prefixItem) Less(iother btree.Item) bool {
other := iother.(*btreeItem)
if bytes.HasPrefix(other.Key, p.prefix) {
return false
}
return true
} | go | {
"resource": ""
} |
q24330 | NewRemoteCluster | train | func NewRemoteCluster(name string) (RemoteCluster, error) {
return &RemoteClusterV3{
Kind: KindRemoteCluster,
Version: V3,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
}, nil
} | go | {
"resource": ""
} |
q24331 | SetLastHeartbeat | train | func (c *RemoteClusterV3) SetLastHeartbeat(t time.Time) {
c.Status.LastHeartbeat = t
} | go | {
"resource": ""
} |
q24332 | String | train | func (r *RemoteClusterV3) String() string {
return fmt.Sprintf("RemoteCluster(%v, %v)", r.Metadata.Name, r.Status.Connection)
} | go | {
"resource": ""
} |
q24333 | UnmarshalRemoteCluster | train | func UnmarshalRemoteCluster(bytes []byte, opts ...MarshalOption) (RemoteCluster, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
var cluster RemoteClusterV3
if len(bytes) == 0 {
return nil, trace.BadParameter("missing resource data")
}
if cfg.SkipValidation {
err ... | go | {
"resource": ""
} |
q24334 | MarshalRemoteCluster | train | func MarshalRemoteCluster(c RemoteCluster, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch resource := c.(type) {
case *RemoteClusterV3:
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpec... | go | {
"resource": ""
} |
q24335 | New | train | func New(certPEM, keyPEM []byte) (*CertAuthority, error) {
ca := &CertAuthority{}
var err error
ca.Cert, err = ParseCertificatePEM(certPEM)
if err != nil {
return nil, trace.Wrap(err)
}
if len(keyPEM) != 0 {
ca.Signer, err = ParsePrivateKeyPEM(keyPEM)
if err != nil {
return nil, trace.Wrap(err)
}
}
r... | go | {
"resource": ""
} |
q24336 | Subject | train | func (id *Identity) Subject() pkix.Name {
subject := pkix.Name{
CommonName: id.Username,
}
subject.Organization = append([]string{}, id.Groups...)
subject.OrganizationalUnit = append([]string{}, id.Usage...)
subject.Locality = append([]string{}, id.Principals...)
subject.Province = append([]string{}, id.Kuberne... | go | {
"resource": ""
} |
q24337 | FromSubject | train | func FromSubject(subject pkix.Name) (*Identity, error) {
i := &Identity{
Username: subject.CommonName,
Groups: subject.Organization,
Usage: subject.OrganizationalUnit,
Principals: subject.Locality,
KubernetesGroups: subject.Province,
}
if err := i.CheckAndSetDefaults(); e... | go | {
"resource": ""
} |
q24338 | GenerateCertificate | train | func (ca *CertAuthority) GenerateCertificate(req CertificateRequest) ([]byte, error) {
if err := req.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
if err != nil {
return n... | go | {
"resource": ""
} |
q24339 | HandleExec | train | func (t *TermHandlers) HandleExec(ch ssh.Channel, req *ssh.Request, ctx *ServerContext) error {
execRequest, err := parseExecRequest(req, ctx)
if err != nil {
return trace.Wrap(err)
}
// a terminal has been previously allocate for this command.
// run this inside an interactive session
if ctx.GetTerm() != nil ... | go | {
"resource": ""
} |
q24340 | HandlePTYReq | train | func (t *TermHandlers) HandlePTYReq(ch ssh.Channel, req *ssh.Request, ctx *ServerContext) error {
// parse and extract the requested window size of the pty
ptyRequest, err := parsePTYReq(req)
if err != nil {
return trace.Wrap(err)
}
termModes, err := ptyRequest.TerminalModes()
if err != nil {
return trace.Wr... | go | {
"resource": ""
} |
q24341 | HandleShell | train | func (t *TermHandlers) HandleShell(ch ssh.Channel, req *ssh.Request, ctx *ServerContext) error {
var err error
// creating an empty exec request implies a interactive shell was requested
ctx.ExecRequest, err = NewExecRequest(ctx, "")
if err != nil {
return trace.Wrap(err)
}
if err := t.SessionRegistry.OpenSes... | go | {
"resource": ""
} |
q24342 | HandleWinChange | train | func (t *TermHandlers) HandleWinChange(ch ssh.Channel, req *ssh.Request, ctx *ServerContext) error {
params, err := parseWinChange(req)
if err != nil {
return trace.Wrap(err)
}
// Update any other members in the party that the window size has changed
// and to update their terminal windows accordingly.
err = t... | go | {
"resource": ""
} |
q24343 | NewServer | train | func NewServer(cfg Config) (Server, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
ctx, cancel := context.WithCancel(cfg.Context)
srv := &server{
Config: cfg,
localSites: []*localSite{},
remoteSites: []*remoteSite{},
localAuthClient: cfg.Loca... | go | {
"resource": ""
} |
q24344 | disconnectClusters | train | func (s *server) disconnectClusters() error {
connectedRemoteClusters := s.getRemoteClusters()
if len(connectedRemoteClusters) == 0 {
return nil
}
remoteClusters, err := s.localAuthClient.GetRemoteClusters()
if err != nil {
return trace.Wrap(err)
}
remoteMap := remoteClustersMap(remoteClusters)
for _, clust... | go | {
"resource": ""
} |
q24345 | isHostAuthority | train | func (s *server) isHostAuthority(auth ssh.PublicKey, address string) bool {
keys, err := s.getTrustedCAKeys(services.HostCA)
if err != nil {
s.Errorf("failed to retrieve trusted keys, err: %v", err)
return false
}
for _, k := range keys {
if sshutils.KeysEqual(k, auth) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q24346 | isUserAuthority | train | func (s *server) isUserAuthority(auth ssh.PublicKey) bool {
keys, err := s.getTrustedCAKeys(services.UserCA)
if err != nil {
s.Errorf("failed to retrieve trusted keys, err: %v", err)
return false
}
for _, k := range keys {
if sshutils.KeysEqual(k, auth) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q24347 | checkHostCert | train | func (s *server) checkHostCert(logger *log.Entry, user string, clusterName string, cert *ssh.Certificate) error {
if cert.CertType != ssh.HostCert {
return trace.BadParameter("expected host cert, got wrong cert type: %d", cert.CertType)
}
// fetch keys of the certificate authority to check
// if there is a match... | go | {
"resource": ""
} |
q24348 | GetSite | train | func (s *server) GetSite(name string) (RemoteSite, error) {
s.RLock()
defer s.RUnlock()
for i := range s.remoteSites {
if s.remoteSites[i].GetName() == name {
return s.remoteSites[i], nil
}
}
for i := range s.localSites {
if s.localSites[i].GetName() == name {
return s.localSites[i], nil
}
}
for i ... | go | {
"resource": ""
} |
q24349 | newRemoteSite | train | func newRemoteSite(srv *server, domainName string) (*remoteSite, error) {
connInfo, err := services.NewTunnelConnection(
fmt.Sprintf("%v-%v", srv.ID, domainName),
services.TunnelConnectionSpecV2{
ClusterName: domainName,
ProxyName: srv.ID,
LastHeartbeat: time.Now().UTC(),
},
)
if err != nil {
... | go | {
"resource": ""
} |
q24350 | getExtent | train | func (mc *xlsxMergeCells) getExtent(cellRef string) (int, int, error) {
if mc == nil {
return 0, 0, nil
}
for _, cell := range mc.Cells {
if strings.HasPrefix(cell.Ref, cellRef+cellRangeChar) {
parts := strings.Split(cell.Ref, cellRangeChar)
startx, starty, err := GetCoordsFromCellIDString(parts[0])
if ... | go | {
"resource": ""
} |
q24351 | SetType | train | func (c *Col) SetType(cellType CellType) {
switch cellType {
case CellTypeString:
c.numFmt = builtInNumFmt[builtInNumFmtIndex_STRING]
case CellTypeNumeric:
c.numFmt = builtInNumFmt[builtInNumFmtIndex_INT]
case CellTypeBool:
c.numFmt = builtInNumFmt[builtInNumFmtIndex_GENERAL] //TEMP
case CellTypeInline:
c.... | go | {
"resource": ""
} |
q24352 | SetDataValidation | train | func (c *Col) SetDataValidation(dd *xlsxCellDataValidation, start, end int) {
if end < 0 {
end = Excel2006MaxRowIndex
}
dd.minRow = start
dd.maxRow = end
tmpDD := make([]*xlsxCellDataValidation, 0)
for _, item := range c.DataValidation {
if item.maxRow < dd.minRow {
tmpDD = append(tmpDD, item) //No inter... | go | {
"resource": ""
} |
q24353 | SetDataValidationWithStart | train | func (c *Col) SetDataValidationWithStart(dd *xlsxCellDataValidation, start int) {
c.SetDataValidation(dd, start, -1)
} | go | {
"resource": ""
} |
q24354 | NewStreamFileBuilder | train | func NewStreamFileBuilder(writer io.Writer) *StreamFileBuilder {
return &StreamFileBuilder{
zipWriter: zip.NewWriter(writer),
xlsxFile: NewFile(),
cellTypeToStyleIds: make(map[CellType]int),
maxStyleId: initMaxStyleId,
}
} | go | {
"resource": ""
} |
q24355 | NewStreamFileBuilderForPath | train | func NewStreamFileBuilderForPath(path string) (*StreamFileBuilder, error) {
file, err := os.Create(path)
if err != nil {
return nil, err
}
return NewStreamFileBuilder(file), nil
} | go | {
"resource": ""
} |
q24356 | AddSheet | train | func (sb *StreamFileBuilder) AddSheet(name string, headers []string, cellTypes []*CellType) error {
if sb.built {
return BuiltStreamFileBuilderError
}
if len(cellTypes) > len(headers) {
return errors.New("cellTypes is longer than headers")
}
sheet, err := sb.xlsxFile.AddSheet(name)
if err != nil {
// Set bu... | go | {
"resource": ""
} |
q24357 | AddValidation | train | func (sb *StreamFileBuilder) AddValidation(sheetIndex, colIndex, rowStartIndex int, validation *xlsxCellDataValidation) {
sheet := sb.xlsxFile.Sheets[sheetIndex]
column := sheet.Col(colIndex)
column.SetDataValidationWithStart(validation, rowStartIndex)
} | go | {
"resource": ""
} |
q24358 | Build | train | func (sb *StreamFileBuilder) Build() (*StreamFile, error) {
if sb.built {
return nil, BuiltStreamFileBuilderError
}
sb.built = true
parts, err := sb.xlsxFile.MarshallParts()
if err != nil {
return nil, err
}
es := &StreamFile{
zipWriter: sb.zipWriter,
xlsxFile: sb.xlsxFile,
sheetXmlPrefix: m... | go | {
"resource": ""
} |
q24359 | processEmptySheetXML | train | func (sb *StreamFileBuilder) processEmptySheetXML(sf *StreamFile, path, data string) error {
// Get the sheet index from the path
sheetIndex, err := getSheetIndex(sf, path)
if err != nil {
return err
}
// Remove the Dimension tag. Since more rows are going to be written to the sheet, it will be wrong.
// It is... | go | {
"resource": ""
} |
q24360 | removeDimensionTag | train | func removeDimensionTag(data string, sheet *Sheet) (string, error) {
x := len(sheet.Cols) - 1
y := len(sheet.Rows) - 1
if x < 0 {
x = 0
}
if y < 0 {
y = 0
}
var dimensionRef string
if x == 0 && y == 0 {
dimensionRef = "A1"
} else {
endCoordinate := GetCellIDStringFromCoords(x, y)
dimensionRef = "A1:"... | go | {
"resource": ""
} |
q24361 | splitSheetIntoPrefixAndSuffix | train | func splitSheetIntoPrefixAndSuffix(data string) (string, string, error) {
// Split the sheet at the end of its SheetData tag so that more rows can be added inside.
sheetParts := strings.Split(data, endSheetDataTag)
if len(sheetParts) != 2 {
return "", "", errors.New("unexpected Sheet XML: SheetData close tag not f... | go | {
"resource": ""
} |
q24362 | Write | train | func (sf *StreamFile) Write(cells []string) error {
if sf.err != nil {
return sf.err
}
err := sf.write(cells)
if err != nil {
sf.err = err
return err
}
return sf.zipWriter.Flush()
} | go | {
"resource": ""
} |
q24363 | NextSheet | train | func (sf *StreamFile) NextSheet() error {
if sf.err != nil {
return sf.err
}
var sheetIndex int
if sf.currentSheet != nil {
if sf.currentSheet.index >= len(sf.xlsxFile.Sheets) {
sf.err = AlreadyOnLastSheetError
return AlreadyOnLastSheetError
}
if err := sf.writeSheetEnd(); err != nil {
sf.currentSh... | go | {
"resource": ""
} |
q24364 | Close | train | func (sf *StreamFile) Close() error {
if sf.err != nil {
return sf.err
}
// If there are sheets that have not been written yet, call NextSheet() which will add files to the zip for them.
// XLSX readers may error if the sheets registered in the metadata are not present in the file.
if sf.currentSheet != nil {
... | go | {
"resource": ""
} |
q24365 | writeSheetStart | train | func (sf *StreamFile) writeSheetStart() error {
if sf.currentSheet == nil {
return NoCurrentSheetError
}
return sf.currentSheet.write(sf.sheetXmlPrefix[sf.currentSheet.index-1])
} | go | {
"resource": ""
} |
q24366 | writeSheetEnd | train | func (sf *StreamFile) writeSheetEnd() error {
if sf.currentSheet == nil {
return NoCurrentSheetError
}
if err := sf.currentSheet.write(endSheetDataTag); err != nil {
return err
}
return sf.currentSheet.write(sf.sheetXmlSuffix[sf.currentSheet.index-1])
} | go | {
"resource": ""
} |
q24367 | compareFormatString | train | func compareFormatString(fmt1, fmt2 string) bool {
if fmt1 == fmt2 {
return true
}
if fmt1 == "" || strings.EqualFold(fmt1, "general") {
fmt1 = "general"
}
if fmt2 == "" || strings.EqualFold(fmt2, "general") {
fmt2 = "general"
}
return fmt1 == fmt2
} | go | {
"resource": ""
} |
q24368 | splitFormatOnSemicolon | train | func splitFormatOnSemicolon(format string) ([]string, error) {
var formats []string
prevIndex := 0
for i := 0; i < len(format); i++ {
if format[i] == ';' {
formats = append(formats, format[prevIndex:i])
prevIndex = i + 1
} else if format[i] == '\\' {
i++
} else if format[i] == '"' {
endQuoteIndex :... | go | {
"resource": ""
} |
q24369 | SetError | train | func (dd *xlsxCellDataValidation) SetError(style DataValidationErrorStyle, title, msg *string) {
dd.ShowErrorMessage = true
dd.Error = msg
dd.ErrorTitle = title
strStyle := styleStop
switch style {
case StyleStop:
strStyle = styleStop
case StyleWarning:
strStyle = styleWarning
case StyleInformation:
strSt... | go | {
"resource": ""
} |
q24370 | SetRange | train | func (dd *xlsxCellDataValidation) SetRange(f1, f2 int, t DataValidationType, o DataValidationOperator) error {
formula1 := fmt.Sprintf("%d", f1)
formula2 := fmt.Sprintf("%d", f2)
switch o {
case DataValidationOperatorBetween:
if f1 > f2 {
tmp := formula1
formula1 = formula2
formula2 = tmp
}
case Data... | go | {
"resource": ""
} |
q24371 | NewStyle | train | func NewStyle() *Style {
return &Style{
Alignment: *DefaultAlignment(),
Border: *DefaultBorder(),
Fill: *DefaultFill(),
Font: *DefaultFont(),
}
} | go | {
"resource": ""
} |
q24372 | makeXLSXStyleElements | train | func (style *Style) makeXLSXStyleElements() (xFont xlsxFont, xFill xlsxFill, xBorder xlsxBorder, xCellXf xlsxXf) {
xFont = xlsxFont{}
xFill = xlsxFill{}
xBorder = xlsxBorder{}
xCellXf = xlsxXf{}
xFont.Sz.Val = strconv.Itoa(style.Font.Size)
xFont.Name.Val = style.Font.Name
xFont.Family.Val = strconv.Itoa(style.Fo... | go | {
"resource": ""
} |
q24373 | ColIndexToLetters | train | func ColIndexToLetters(colRef int) string {
parts := intToBase26(colRef)
return formatColumnName(smooshBase26Slice(parts))
} | go | {
"resource": ""
} |
q24374 | GetCellIDStringFromCoords | train | func GetCellIDStringFromCoords(x, y int) string {
return GetCellIDStringFromCoordsWithFixed(x, y, false, false)
} | go | {
"resource": ""
} |
q24375 | GetCellIDStringFromCoordsWithFixed | train | func GetCellIDStringFromCoordsWithFixed(x, y int, xFixed, yFixed bool) string {
xStr := ColIndexToLetters(x)
if xFixed {
xStr = fixedCellRefChar + xStr
}
yStr := RowIndexToString(y)
if yFixed {
yStr = fixedCellRefChar + yStr
}
return xStr + yStr
} | go | {
"resource": ""
} |
q24376 | calculateMaxMinFromWorksheet | train | func calculateMaxMinFromWorksheet(worksheet *xlsxWorksheet) (minx, miny, maxx, maxy int, err error) {
// Note, this method could be very slow for large spreadsheets.
var x, y int
var maxVal int
maxVal = int(^uint(0) >> 1)
minx = maxVal
miny = maxVal
maxy = 0
maxx = 0
for _, row := range worksheet.SheetData.Row... | go | {
"resource": ""
} |
q24377 | makeRowFromRaw | train | func makeRowFromRaw(rawrow xlsxRow, sheet *Sheet) *Row {
var upper int
var row *Row
var cell *Cell
row = new(Row)
row.Sheet = sheet
upper = -1
for _, rawcell := range rawrow.C {
if rawcell.R != "" {
x, _, error := GetCoordsFromCellIDString(rawcell.R)
if error != nil {
panic(fmt.Sprintf("Invalid Cel... | go | {
"resource": ""
} |
q24378 | fillCellDataFromInlineString | train | func fillCellDataFromInlineString(rawcell xlsxC, cell *Cell) {
cell.Value = ""
if rawcell.Is != nil {
if rawcell.Is.T != "" {
cell.Value = strings.Trim(rawcell.Is.T, " \t\n\r")
} else {
for _, r := range rawcell.Is.R {
cell.Value += r.T
}
}
}
} | go | {
"resource": ""
} |
q24379 | readSheetsFromZipFile | train | func readSheetsFromZipFile(f *zip.File, file *File, sheetXMLMap map[string]string, rowLimit int) (map[string]*Sheet, []*Sheet, error) {
var workbook *xlsxWorkbook
var err error
var rc io.ReadCloser
var decoder *xml.Decoder
var sheetCount int
workbook = new(xlsxWorkbook)
rc, err = f.Open()
if err != nil {
retu... | go | {
"resource": ""
} |
q24380 | truncateSheetXML | train | func truncateSheetXML(r io.Reader, rowLimit int) (io.Reader, error) {
var rowCount int
var token xml.Token
var readErr error
output := new(bytes.Buffer)
r = io.TeeReader(r, output)
decoder := xml.NewDecoder(r)
for {
token, readErr = decoder.Token()
if readErr == io.EOF {
break
} else if readErr != nil... | go | {
"resource": ""
} |
q24381 | FileToSliceUnmerged | train | func FileToSliceUnmerged(path string) ([][][]string, error) {
f, err := OpenFile(path)
if err != nil {
return nil, err
}
return f.ToSliceUnmerged()
} | go | {
"resource": ""
} |
q24382 | AddRowAtIndex | train | func (s *Sheet) AddRowAtIndex(index int) (*Row, error) {
if index < 0 || index > len(s.Rows) {
return nil, errors.New("AddRowAtIndex: index out of bounds")
}
row := &Row{Sheet: s}
s.Rows = append(s.Rows, nil)
if index < len(s.Rows) {
copy(s.Rows[index+1:], s.Rows[index:])
}
s.Rows[index] = row
if len(s.Row... | go | {
"resource": ""
} |
q24383 | RemoveRowAtIndex | train | func (s *Sheet) RemoveRowAtIndex(index int) error {
if index < 0 || index >= len(s.Rows) {
return errors.New("RemoveRowAtIndex: index out of bounds")
}
s.Rows = append(s.Rows[:index], s.Rows[index+1:]...)
return nil
} | go | {
"resource": ""
} |
q24384 | handleMerged | train | func (s *Sheet) handleMerged() {
merged := make(map[string]*Cell)
for r, row := range s.Rows {
for c, cell := range row.Cells {
if cell.HMerge > 0 || cell.VMerge > 0 {
coord := GetCellIDStringFromCoords(c, r)
merged[coord] = cell
}
}
}
// This loop iterates over all cells that should be merged a... | go | {
"resource": ""
} |
q24385 | GetTime | train | func (c *Cell) GetTime(date1904 bool) (t time.Time, err error) {
f, err := c.Float()
if err != nil {
return t, err
}
return TimeFromExcelTime(f, date1904), nil
} | go | {
"resource": ""
} |
q24386 | SetDateWithOptions | train | func (c *Cell) SetDateWithOptions(t time.Time, options DateTimeOptions) {
_, offset := t.In(options.Location).Zone()
t = time.Unix(t.Unix()+int64(offset), 0)
c.SetDateTimeWithFormat(TimeToExcelTime(t.In(timeLocationUTC), c.date1904), options.ExcelTimeFormat)
} | go | {
"resource": ""
} |
q24387 | setNumeric | train | func (c *Cell) setNumeric(s string) {
c.Value = s
c.NumFmt = builtInNumFmt[builtInNumFmtIndex_GENERAL]
c.formula = ""
c.cellType = CellTypeNumeric
} | go | {
"resource": ""
} |
q24388 | getNumberFormat | train | func (c *Cell) getNumberFormat() *parsedNumberFormat {
if c.parsedNumFmt == nil || c.parsedNumFmt.numFmt != c.NumFmt {
c.parsedNumFmt = parseFullNumberFormatString(c.NumFmt)
}
return c.parsedNumFmt
} | go | {
"resource": ""
} |
q24389 | FormattedValue | train | func (c *Cell) FormattedValue() (string, error) {
fullFormat := c.getNumberFormat()
returnVal, err := fullFormat.FormatValue(c)
if fullFormat.parseEncounteredError != nil {
return returnVal, *fullFormat.parseEncounteredError
}
return returnVal, err
} | go | {
"resource": ""
} |
q24390 | Validate | train | func (c *ConnectPacket) Validate() byte {
if c.PasswordFlag && !c.UsernameFlag {
return ErrRefusedBadUsernameOrPassword
}
if c.ReservedBit != 0 {
//Bad reserved bit
return ErrProtocolViolation
}
if (c.ProtocolName == "MQIsdp" && c.ProtocolVersion != 3) || (c.ProtocolName == "MQTT" && c.ProtocolVersion != 4) ... | go | {
"resource": ""
} |
q24391 | persistInbound | train | func persistInbound(s Store, m packets.ControlPacket) {
switch m.Details().Qos {
case 0:
switch m.(type) {
case *packets.PubackPacket, *packets.SubackPacket, *packets.UnsubackPacket, *packets.PubcompPacket:
// Received a puback. delete matching publish
// from obound
s.Del(outboundKeyFromMID(m.Details().... | go | {
"resource": ""
} |
q24392 | SetClientID | train | func (o *ClientOptions) SetClientID(id string) *ClientOptions {
o.ClientID = id
return o
} | go | {
"resource": ""
} |
q24393 | SetCleanSession | train | func (o *ClientOptions) SetCleanSession(clean bool) *ClientOptions {
o.CleanSession = clean
return o
} | go | {
"resource": ""
} |
q24394 | SetOrderMatters | train | func (o *ClientOptions) SetOrderMatters(order bool) *ClientOptions {
o.Order = order
return o
} | go | {
"resource": ""
} |
q24395 | SetStore | train | func (o *ClientOptions) SetStore(s Store) *ClientOptions {
o.Store = s
return o
} | go | {
"resource": ""
} |
q24396 | SetProtocolVersion | train | func (o *ClientOptions) SetProtocolVersion(pv uint) *ClientOptions {
if (pv >= 3 && pv <= 4) || (pv > 0x80) {
o.ProtocolVersion = pv
o.protocolVersionExplicit = true
}
return o
} | go | {
"resource": ""
} |
q24397 | SetOnConnectHandler | train | func (o *ClientOptions) SetOnConnectHandler(onConn OnConnectHandler) *ClientOptions {
o.OnConnect = onConn
return o
} | go | {
"resource": ""
} |
q24398 | SetConnectionLostHandler | train | func (o *ClientOptions) SetConnectionLostHandler(onLost ConnectionLostHandler) *ClientOptions {
o.OnConnectionLost = onLost
return o
} | go | {
"resource": ""
} |
q24399 | SetWriteTimeout | train | func (o *ClientOptions) SetWriteTimeout(t time.Duration) *ClientOptions {
o.WriteTimeout = t
return o
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.