_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q181500 | Send | test | func (ia *InlineQueryAnswer) Send() error {
resp := &baseResponse{}
_, err := ia.api.c.postJSON(answerInlineQuery, resp, ia)
if err != nil {
return err
}
return check(resp)
} | go | {
"resource": ""
} |
q181501 | Send | test | func (kr *OutgoingKickChatMember) Send() error {
resp := &baseResponse{}
_, err := kr.api.c.postJSON(kickChatMember, resp, kr)
if err != nil {
return err
}
return check(resp)
} | go | {
"resource": ""
} |
q181502 | Send | test | func (ub *OutgoingUnbanChatMember) Send() error {
resp := &baseResponse{}
_, err := ub.api.c.postJSON(unbanChatMember, resp, ub)
if err != nil {
return err
}
return check(resp)
} | go | {
"resource": ""
} |
q181503 | Send | test | func (cbr *OutgoingCallbackQueryResponse) Send() error {
resp := &baseResponse{}
_, err := cbr.api.c.postJSON(answerCallbackQuery, resp, cbr)
if err != nil {
return err
}
return check(resp)
} | go | {
"resource": ""
} |
q181504 | NewAPIClient | test | func NewAPIClient(cfg *Configuration) *APIClient {
if cfg.HTTPClient == nil {
cfg.HTTPClient = http.DefaultClient
}
c := &APIClient{}
c.cfg = cfg
c.common.client = c
// API Services
c.ServiceProviderConfigApi = (*ServiceProviderConfigApiService)(&c.common)
c.UserApi = (*UserApiService)(&c.common)
return c... | go | {
"resource": ""
} |
q181505 | BeforeInsert | test | func (ts *TimeStamp) BeforeInsert() error {
n := now()
ts.CreatedAt = n
ts.UpdatedAt = n
return nil
} | go | {
"resource": ""
} |
q181506 | ColumnName | test | func ColumnName(d Dialect, tname, cname string) string {
if cname != "*" {
cname = d.Quote(cname)
}
if tname == "" {
return cname
}
return fmt.Sprintf("%s.%s", d.Quote(tname), cname)
} | go | {
"resource": ""
} |
q181507 | New | test | func New(dialect Dialect, dsn string) (*DB, error) {
db, err := sql.Open(dialect.Name(), dsn)
if err != nil {
return nil, err
}
return &DB{db: db, dialect: dialect, logger: defaultLogger}, nil
} | go | {
"resource": ""
} |
q181508 | From | test | func (db *DB) From(arg interface{}) *From {
t := reflect.Indirect(reflect.ValueOf(arg)).Type()
if t.Kind() != reflect.Struct {
panic(fmt.Errorf("From: argument must be struct (or that pointer) type, got %v", t))
}
return &From{TableName: db.tableName(t)}
} | go | {
"resource": ""
} |
q181509 | Where | test | func (db *DB) Where(cond interface{}, args ...interface{}) *Condition {
return newCondition(db).Where(cond, args...)
} | go | {
"resource": ""
} |
q181510 | OrderBy | test | func (db *DB) OrderBy(table interface{}, column interface{}, order ...interface{}) *Condition {
return newCondition(db).OrderBy(table, column, order...)
} | go | {
"resource": ""
} |
q181511 | Limit | test | func (db *DB) Limit(lim int) *Condition {
return newCondition(db).Limit(lim)
} | go | {
"resource": ""
} |
q181512 | Offset | test | func (db *DB) Offset(offset int) *Condition {
return newCondition(db).Offset(offset)
} | go | {
"resource": ""
} |
q181513 | Join | test | func (db *DB) Join(table interface{}) *JoinCondition {
return (&JoinCondition{db: db}).Join(table)
} | go | {
"resource": ""
} |
q181514 | Count | test | func (db *DB) Count(column ...interface{}) *Function {
switch len(column) {
case 0, 1:
// do nothing.
default:
panic(fmt.Errorf("Count: a number of argument must be 0 or 1, got %v", len(column)))
}
return &Function{
Name: "COUNT",
Args: column,
}
} | go | {
"resource": ""
} |
q181515 | Update | test | func (db *DB) Update(obj interface{}) (affected int64, err error) {
rv, rtype, tableName, err := db.tableValueOf("Update", obj)
if err != nil {
return -1, err
}
if hook, ok := obj.(BeforeUpdater); ok {
if err := hook.BeforeUpdate(); err != nil {
return -1, err
}
}
fieldIndexes := db.collectFieldIndexes(r... | go | {
"resource": ""
} |
q181516 | Delete | test | func (db *DB) Delete(obj interface{}) (affected int64, err error) {
objs, rtype, tableName, err := db.tableObjs("Delete", obj)
if err != nil {
return -1, err
}
if len(objs) < 1 {
return 0, nil
}
for _, obj := range objs {
if hook, ok := obj.(BeforeDeleter); ok {
if err := hook.BeforeDelete(); err != nil ... | go | {
"resource": ""
} |
q181517 | Begin | test | func (db *DB) Begin() error {
tx, err := db.db.Begin()
if err != nil {
return err
}
db.m.Lock()
defer db.m.Unlock()
db.tx = tx
return nil
} | go | {
"resource": ""
} |
q181518 | Commit | test | func (db *DB) Commit() error {
db.m.Lock()
defer db.m.Unlock()
if db.tx == nil {
return ErrTxDone
}
err := db.tx.Commit()
db.tx = nil
return err
} | go | {
"resource": ""
} |
q181519 | Quote | test | func (db *DB) Quote(s string) string {
return db.dialect.Quote(s)
} | go | {
"resource": ""
} |
q181520 | SetLogOutput | test | func (db *DB) SetLogOutput(w io.Writer) {
if w == nil {
db.logger = defaultLogger
} else {
db.logger = &templateLogger{w: w, t: defaultLoggerTemplate}
}
} | go | {
"resource": ""
} |
q181521 | selectToSlice | test | func (db *DB) selectToSlice(rows *sql.Rows, t reflect.Type) (reflect.Value, error) {
columns, err := rows.Columns()
if err != nil {
return reflect.Value{}, err
}
t = t.Elem()
ptrN := 0
for ; t.Kind() == reflect.Ptr; ptrN++ {
t = t.Elem()
}
fieldIndexes := make([][]int, len(columns))
for i, column := range ... | go | {
"resource": ""
} |
q181522 | selectToValue | test | func (db *DB) selectToValue(rows *sql.Rows, t reflect.Type) (reflect.Value, error) {
ptrN := 0
for ; t.Kind() == reflect.Ptr; ptrN++ {
t = t.Elem()
}
dest := reflect.New(t).Elem()
if rows.Next() {
if err := rows.Scan(dest.Addr().Interface()); err != nil {
return reflect.Value{}, err
}
}
for i := 0; i < ... | go | {
"resource": ""
} |
q181523 | fieldIndexByName | test | func (db *DB) fieldIndexByName(t reflect.Type, name string, index []int) []int {
for i := 0; i < t.NumField(); i++ {
field := t.Field(i)
if candidate := db.columnFromTag(field); candidate == name {
return append(index, i)
}
if field.Anonymous {
if idx := db.fieldIndexByName(field.Type, name, append(index... | go | {
"resource": ""
} |
q181524 | columns | test | func (db *DB) columns(tableName string, columns []interface{}) string {
if len(columns) == 0 {
return ColumnName(db.dialect, tableName, "*")
}
names := make([]string, len(columns))
for i, col := range columns {
switch c := col.(type) {
case Raw:
names[i] = fmt.Sprint(*c)
case string:
names[i] = Column... | go | {
"resource": ""
} |
q181525 | tagsFromField | test | func (db *DB) tagsFromField(field *reflect.StructField) (options []string) {
if db.hasSkipTag(field) {
return nil
}
for _, tag := range strings.Split(field.Tag.Get(dbTag), ",") {
if t := strings.ToLower(strings.TrimSpace(tag)); t != "" {
options = append(options, t)
}
}
return options
} | go | {
"resource": ""
} |
q181526 | hasSkipTag | test | func (db *DB) hasSkipTag(field *reflect.StructField) bool {
if field.Tag.Get(dbTag) == skipTag {
return true
}
return false
} | go | {
"resource": ""
} |
q181527 | hasPKTag | test | func (db *DB) hasPKTag(field *reflect.StructField) bool {
for _, tag := range db.tagsFromField(field) {
if tag == "pk" {
return true
}
}
return false
} | go | {
"resource": ""
} |
q181528 | isAutoIncrementable | test | func (db *DB) isAutoIncrementable(field *reflect.StructField) bool {
switch field.Type.Kind() {
case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return true
}
return false
} | go | {
"resource": ""
} |
q181529 | collectFieldIndexes | test | func (db *DB) collectFieldIndexes(typ reflect.Type, index []int) (indexes [][]int) {
for i := 0; i < typ.NumField(); i++ {
field := typ.Field(i)
if IsUnexportedField(field) {
continue
}
if !(db.hasSkipTag(&field) || (db.hasPKTag(&field) && db.isAutoIncrementable(&field))) {
tmp := make([]int, len(index)+... | go | {
"resource": ""
} |
q181530 | findPKIndex | test | func (db *DB) findPKIndex(typ reflect.Type, index []int) []int {
for i := 0; i < typ.NumField(); i++ {
field := typ.Field(i)
if IsUnexportedField(field) {
continue
}
if field.Anonymous {
if idx := db.findPKIndex(field.Type, append(index, i)); idx != nil {
return append(index, idx...)
}
continue... | go | {
"resource": ""
} |
q181531 | sizeFromTag | test | func (db *DB) sizeFromTag(field *reflect.StructField) (size uint64, err error) {
if s := field.Tag.Get(dbSizeTag); s != "" {
size, err = strconv.ParseUint(s, 10, 64)
}
return size, err
} | go | {
"resource": ""
} |
q181532 | columnFromTag | test | func (db *DB) columnFromTag(field reflect.StructField) string {
col := field.Tag.Get(dbColumnTag)
if col == "" {
return stringutil.ToSnakeCase(field.Name)
}
return col
} | go | {
"resource": ""
} |
q181533 | defaultFromTag | test | func (db *DB) defaultFromTag(field *reflect.StructField) (string, error) {
def := field.Tag.Get(dbDefaultTag)
if def == "" {
return "", nil
}
switch field.Type.Kind() {
case reflect.Bool:
b, err := strconv.ParseBool(def)
if err != nil {
return "", err
}
return fmt.Sprintf("DEFAULT %v", db.dialect.Form... | go | {
"resource": ""
} |
q181534 | Where | test | func (c *Condition) Where(cond interface{}, args ...interface{}) *Condition {
return c.appendQueryByCondOrExpr("Where", 0, Where, cond, args...)
} | go | {
"resource": ""
} |
q181535 | And | test | func (c *Condition) And(cond interface{}, args ...interface{}) *Condition {
return c.appendQueryByCondOrExpr("And", 100, And, cond, args...)
} | go | {
"resource": ""
} |
q181536 | Or | test | func (c *Condition) Or(cond interface{}, args ...interface{}) *Condition {
return c.appendQueryByCondOrExpr("Or", 100, Or, cond, args...)
} | go | {
"resource": ""
} |
q181537 | Like | test | func (c *Condition) Like(arg string) *Condition {
return c.appendQuery(100, Like, arg)
} | go | {
"resource": ""
} |
q181538 | Between | test | func (c *Condition) Between(from, to interface{}) *Condition {
return c.appendQuery(100, Between, &between{from, to})
} | go | {
"resource": ""
} |
q181539 | OrderBy | test | func (c *Condition) OrderBy(table, col interface{}, order ...interface{}) *Condition {
order = append([]interface{}{table, col}, order...)
orderbys := make([]orderBy, 0, 1)
for len(order) > 0 {
o, rest := order[0], order[1:]
if _, ok := o.(string); ok {
if len(rest) < 1 {
panic(fmt.Errorf("OrderBy: few ar... | go | {
"resource": ""
} |
q181540 | Limit | test | func (c *Condition) Limit(lim int) *Condition {
return c.appendQuery(500, Limit, lim)
} | go | {
"resource": ""
} |
q181541 | Offset | test | func (c *Condition) Offset(offset int) *Condition {
return c.appendQuery(700, Offset, offset)
} | go | {
"resource": ""
} |
q181542 | SetFormat | test | func (l *templateLogger) SetFormat(format string) error {
l.m.Lock()
defer l.m.Unlock()
t, err := template.New("genmai").Parse(format)
if err != nil {
return err
}
l.t = t
return nil
} | go | {
"resource": ""
} |
q181543 | Print | test | func (l *templateLogger) Print(start time.Time, query string, args ...interface{}) error {
if len(args) > 0 {
values := make([]string, len(args))
for i, arg := range args {
values[i] = fmt.Sprintf("%#v", arg)
}
query = fmt.Sprintf("%v; [%v]", query, strings.Join(values, ", "))
} else {
query = fmt.Sprint... | go | {
"resource": ""
} |
q181544 | Print | test | func (l *nullLogger) Print(start time.Time, query string, args ...interface{}) error {
return nil
} | go | {
"resource": ""
} |
q181545 | Quote | test | func (d *MySQLDialect) Quote(s string) string {
return fmt.Sprintf("`%s`", strings.Replace(s, "`", "``", -1))
} | go | {
"resource": ""
} |
q181546 | SQLType | test | func (d *PostgresDialect) SQLType(v interface{}, autoIncrement bool, size uint64) (name string, allowNull bool) {
switch v.(type) {
case bool:
return "boolean", false
case *bool, sql.NullBool:
return "boolean", true
case int8, int16, uint8, uint16:
return d.smallint(autoIncrement), false
case *int8, *int16, ... | go | {
"resource": ""
} |
q181547 | New | test | func New(file *os.File) Archive {
if filepath.Ext(file.Name()) == ".zip" {
return zip.New(file)
}
return tar.New(file)
} | go | {
"resource": ""
} |
q181548 | Disconnect | test | func (h *Host) Disconnect() {
// TODO(c4milo): Return an error to the user given that this error
// may be thrown due to insufficient hardware resources
if h.handle == C.VIX_E_CANCELLED {
return
}
if &h.handle != nil &&
h.handle != C.VIX_INVALID_HANDLE {
C.VixHost_Disconnect(h.handle)
h.handle = C.VIX_IN... | go | {
"resource": ""
} |
q181549 | nextNetworkAdapterID | test | func (v *VM) nextNetworkAdapterID(vmx map[string]string) int {
var nextID int
prefix := "ethernet"
for key := range vmx {
if strings.HasPrefix(key, prefix) {
ethN := strings.Split(key, ".")[0]
number, _ := strconv.Atoi(strings.Split(ethN, prefix)[1])
// If ethN is not present, its id is recycled
if v... | go | {
"resource": ""
} |
q181550 | totalNetworkAdapters | test | func (v *VM) totalNetworkAdapters(vmx map[string]string) int {
var total int
prefix := "ethernet"
for key := range vmx {
if strings.HasPrefix(key, prefix) {
ethN := strings.Split(key, ".")[0]
number, _ := strconv.Atoi(strings.Split(ethN, prefix)[1])
if number > total {
total = number
}
}
}
r... | go | {
"resource": ""
} |
q181551 | RemoveAllNetworkAdapters | test | func (v *VM) RemoveAllNetworkAdapters() error {
vmxPath, err := v.VmxPath()
if err != nil {
return err
}
vmx, err := readVmx(vmxPath)
if err != nil {
return err
}
for key := range vmx {
if strings.HasPrefix(key, "ethernet") {
delete(vmx, key)
}
}
return writeVmx(vmxPath, vmx)
} | go | {
"resource": ""
} |
q181552 | RemoveNetworkAdapter | test | func (v *VM) RemoveNetworkAdapter(adapter *NetworkAdapter) error {
isVMRunning, err := v.IsRunning()
if err != nil {
return err
}
if isVMRunning {
return &Error{
Operation: "vm.RemoveNetworkAdapter",
Code: 100000,
Text: "The VM has to be powered off in order to change its vmx settings",
}
... | go | {
"resource": ""
} |
q181553 | NetworkAdapters | test | func (v *VM) NetworkAdapters() ([]*NetworkAdapter, error) {
vmxPath, err := v.VmxPath()
if err != nil {
return nil, err
}
vmx, err := readVmx(vmxPath)
if err != nil {
return nil, err
}
var adapters []*NetworkAdapter
// VMX ethernet adapters seem to not be zero based
for i := 1; i <= v.totalNetworkAdapter... | go | {
"resource": ""
} |
q181554 | newArchive | test | func newArchive(path string, password *string) (*Archive, error) {
err := detect7zCached()
if err != nil {
return nil, err
}
cmd := exec.Command("7z", "l", "-slt", "-sccUTF-8", path)
out, err := cmd.CombinedOutput()
if err != nil {
return nil, err
}
entries, err := parse7zListOutput(out)
if err != nil {
... | go | {
"resource": ""
} |
q181555 | GetFileReader | test | func (a *Archive) GetFileReader(name string) (io.ReadCloser, error) {
found := false
for _, e := range a.Entries {
if e.Path == name {
found = true
break
}
}
if !found {
return nil, errors.New("file not in the archive")
}
params := []string{"x", "-so"}
if a.password != nil {
params = append(params... | go | {
"resource": ""
} |
q181556 | ExtractToWriter | test | func (a *Archive) ExtractToWriter(dst io.Writer, name string) error {
r, err := a.GetFileReader(name)
if err != nil {
return err
}
_, err = io.Copy(dst, r)
err2 := r.Close()
if err != nil {
return err
}
return err2
} | go | {
"resource": ""
} |
q181557 | ExtractToFile | test | func (a *Archive) ExtractToFile(dstPath string, name string) error {
f, err := os.Create(dstPath)
if err != nil {
return err
}
defer f.Close()
return a.ExtractToWriter(f, name)
} | go | {
"resource": ""
} |
q181558 | SharedFoldersParentDir | test | func (g *Guest) SharedFoldersParentDir() (string, error) {
var err C.VixError = C.VIX_OK
var path *C.char
err = C.get_property(g.handle,
C.VIX_PROPERTY_GUEST_SHAREDFOLDERS_SHARES_PATH,
unsafe.Pointer(&path))
defer C.Vix_FreeBuffer(unsafe.Pointer(path))
if C.VIX_OK != err {
return "", &Error{
Operation:... | go | {
"resource": ""
} |
q181559 | Name | test | func (s *Snapshot) Name() (string, error) {
var err C.VixError = C.VIX_OK
var name *C.char
err = C.get_property(s.handle,
C.VIX_PROPERTY_SNAPSHOT_DISPLAYNAME,
unsafe.Pointer(&name))
defer C.Vix_FreeBuffer(unsafe.Pointer(name))
if C.VIX_OK != err {
return "", &Error{
Operation: "snapshot.Name",
Code:... | go | {
"resource": ""
} |
q181560 | Description | test | func (s *Snapshot) Description() (string, error) {
var err C.VixError = C.VIX_OK
var desc *C.char
err = C.get_property(s.handle,
C.VIX_PROPERTY_SNAPSHOT_DESCRIPTION,
unsafe.Pointer(&desc))
defer C.Vix_FreeBuffer(unsafe.Pointer(desc))
if C.VIX_OK != err {
return "", &Error{
Operation: "snapshot.Descript... | go | {
"resource": ""
} |
q181561 | cleanupSnapshot | test | func cleanupSnapshot(s *Snapshot) {
if s.handle != C.VIX_INVALID_HANDLE {
C.Vix_ReleaseHandle(s.handle)
s.handle = C.VIX_INVALID_HANDLE
}
} | go | {
"resource": ""
} |
q181562 | BusTypeFromID | test | func BusTypeFromID(ID string) vmx.BusType {
var bus vmx.BusType
switch {
case strings.HasPrefix(ID, string(vmx.IDE)):
bus = vmx.IDE
case strings.HasPrefix(ID, string(vmx.SCSI)):
bus = vmx.SCSI
case strings.HasPrefix(ID, string(vmx.SATA)):
bus = vmx.SATA
}
return bus
} | go | {
"resource": ""
} |
q181563 | Read | test | func (vmxfile *VMXFile) Read() error {
data, err := ioutil.ReadFile(vmxfile.path)
if err != nil {
return err
}
model := new(vmx.VirtualMachine)
err = vmx.Unmarshal(data, model)
if err != nil {
return err
}
vmxfile.model = model
return nil
} | go | {
"resource": ""
} |
q181564 | Write | test | func (vmxfile *VMXFile) Write() error {
file, err := os.Create(vmxfile.path)
if err != nil {
return err
}
defer file.Close()
data, err := vmx.Marshal(vmxfile.model)
if err != nil {
return err
}
_, err = file.Write(data)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q181565 | NewVirtualMachine | test | func NewVirtualMachine(handle C.VixHandle, vmxpath string) (*VM, error) {
vmxfile := &VMXFile{
path: vmxpath,
}
// Loads VMX file in memory
err := vmxfile.Read()
if err != nil {
return nil, err
}
vm := &VM{
handle: handle,
vmxfile: vmxfile,
}
runtime.SetFinalizer(vm, cleanupVM)
return vm, nil
} | go | {
"resource": ""
} |
q181566 | Vcpus | test | func (v *VM) Vcpus() (uint8, error) {
var err C.VixError = C.VIX_OK
vcpus := C.VIX_PROPERTY_NONE
err = C.get_property(v.handle,
C.VIX_PROPERTY_VM_NUM_VCPUS,
unsafe.Pointer(&vcpus))
if C.VIX_OK != err {
return 0, &Error{
Operation: "vm.Vcpus",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vi... | go | {
"resource": ""
} |
q181567 | VmxPath | test | func (v *VM) VmxPath() (string, error) {
var err C.VixError = C.VIX_OK
var path *C.char
err = C.get_property(v.handle,
C.VIX_PROPERTY_VM_VMX_PATHNAME,
unsafe.Pointer(&path))
defer C.Vix_FreeBuffer(unsafe.Pointer(path))
if C.VIX_OK != err {
return "", &Error{
Operation: "vm.VmxPath",
Code: int(e... | go | {
"resource": ""
} |
q181568 | MemorySize | test | func (v *VM) MemorySize() (uint, error) {
var err C.VixError = C.VIX_OK
memsize := C.VIX_PROPERTY_NONE
err = C.get_property(v.handle,
C.VIX_PROPERTY_VM_MEMORY_SIZE,
unsafe.Pointer(&memsize))
if C.VIX_OK != err {
return 0, &Error{
Operation: "vm.MemorySize",
Code: int(err & 0xFFFF),
Text: ... | go | {
"resource": ""
} |
q181569 | ReadOnly | test | func (v *VM) ReadOnly() (bool, error) {
var err C.VixError = C.VIX_OK
readonly := C.VIX_PROPERTY_NONE
err = C.get_property(v.handle,
C.VIX_PROPERTY_VM_READ_ONLY,
unsafe.Pointer(&readonly))
if C.VIX_OK != err {
return false, &Error{
Operation: "vm.ReadOnly",
Code: int(err & 0xFFFF),
Text: ... | go | {
"resource": ""
} |
q181570 | InVMTeam | test | func (v *VM) InVMTeam() (bool, error) {
var err C.VixError = C.VIX_OK
inTeam := C.VIX_PROPERTY_NONE
err = C.get_property(v.handle,
C.VIX_PROPERTY_VM_IN_VMTEAM,
unsafe.Pointer(&inTeam))
if C.VIX_OK != err {
return false, &Error{
Operation: "vm.InVmTeam",
Code: int(err & 0xFFFF),
Text: C.Go... | go | {
"resource": ""
} |
q181571 | PowerState | test | func (v *VM) PowerState() (VMPowerState, error) {
var err C.VixError = C.VIX_OK
var state C.VixPowerState = 0x0
err = C.get_property(v.handle,
C.VIX_PROPERTY_VM_POWER_STATE,
unsafe.Pointer(&state))
if C.VIX_OK != err {
return VMPowerState(0x0), &Error{
Operation: "vm.PowerState",
Code: int(err & ... | go | {
"resource": ""
} |
q181572 | ToolsState | test | func (v *VM) ToolsState() (GuestToolsState, error) {
var err C.VixError = C.VIX_OK
state := C.VIX_TOOLSSTATE_UNKNOWN
err = C.get_property(v.handle,
C.VIX_PROPERTY_VM_TOOLS_STATE,
unsafe.Pointer(&state))
if C.VIX_OK != err {
return TOOLSSTATE_UNKNOWN, &Error{
Operation: "vm.ToolsState",
Code: int(... | go | {
"resource": ""
} |
q181573 | IsRunning | test | func (v *VM) IsRunning() (bool, error) {
var err C.VixError = C.VIX_OK
running := C.VIX_PROPERTY_NONE
err = C.get_property(v.handle,
C.VIX_PROPERTY_VM_IS_RUNNING,
unsafe.Pointer(&running))
if C.VIX_OK != err {
return false, &Error{
Operation: "vm.IsRunning",
Code: int(err & 0xFFFF),
Text: ... | go | {
"resource": ""
} |
q181574 | GuestOS | test | func (v *VM) GuestOS() (string, error) {
var err C.VixError = C.VIX_OK
var os *C.char
err = C.get_property(v.handle,
C.VIX_PROPERTY_VM_GUESTOS,
unsafe.Pointer(&os))
defer C.Vix_FreeBuffer(unsafe.Pointer(os))
if C.VIX_OK != err {
return "", &Error{
Operation: "vm.GuestOS",
Code: int(err & 0xFFFF... | go | {
"resource": ""
} |
q181575 | cleanupVM | test | func cleanupVM(v *VM) {
if v.handle != C.VIX_INVALID_HANDLE {
C.Vix_ReleaseHandle(v.handle)
v.handle = C.VIX_INVALID_HANDLE
}
} | go | {
"resource": ""
} |
q181576 | updateVMX | test | func (v *VM) updateVMX(updateFunc func(model *vmx.VirtualMachine) error) error {
isVMRunning, err := v.IsRunning()
if err != nil {
return err
}
if isVMRunning {
return &Error{
Operation: "vm.updateVMX",
Code: 100000,
Text: "The VM has to be powered off in order to change its vmx settings",
... | go | {
"resource": ""
} |
q181577 | SetMemorySize | test | func (v *VM) SetMemorySize(size uint) error {
if size == 0 {
size = 4
}
// Makes sure memory size is divisible by 4, otherwise VMware is going to
// silently fail, cancelling vix operations.
if size%4 != 0 {
size = uint(math.Floor(float64((size / 4) * 4)))
}
return v.updateVMX(func(model *vmx.VirtualMachin... | go | {
"resource": ""
} |
q181578 | SetNumberVcpus | test | func (v *VM) SetNumberVcpus(vcpus uint) error {
if vcpus < 1 {
vcpus = 1
}
return v.updateVMX(func(model *vmx.VirtualMachine) error {
model.NumvCPUs = vcpus
return nil
})
} | go | {
"resource": ""
} |
q181579 | SetDisplayName | test | func (v *VM) SetDisplayName(name string) error {
return v.updateVMX(func(model *vmx.VirtualMachine) error {
model.DisplayName = name
return nil
})
} | go | {
"resource": ""
} |
q181580 | SetAnnotation | test | func (v *VM) SetAnnotation(text string) error {
return v.updateVMX(func(model *vmx.VirtualMachine) error {
model.Annotation = text
return nil
})
} | go | {
"resource": ""
} |
q181581 | SetVirtualHwVersion | test | func (v *VM) SetVirtualHwVersion(version string) error {
return v.updateVMX(func(model *vmx.VirtualMachine) error {
version, err := strconv.ParseInt(version, 10, 32)
if err != nil {
return err
}
model.Vhardware.Compat = "hosted"
model.Vhardware.Version = int(version)
return nil
})
} | go | {
"resource": ""
} |
q181582 | Error | test | func (e *Error) Error() string {
return fmt.Sprintf("VIX Error: %s, code: %d, operation: %s", e.Text, e.Code, e.Operation)
} | go | {
"resource": ""
} |
q181583 | Errorf | test | func Errorf(message string, a ...interface{}) error {
return wrap(fmt.Errorf(message, a...))
} | go | {
"resource": ""
} |
q181584 | Error | test | func (t *traceableError) Error() string {
str := t.err.Error()
for _, frame := range t.stack {
str += fmt.Sprintf("\n at %s", frame.string())
}
return str
} | go | {
"resource": ""
} |
q181585 | string | test | func (s *stackFrame) string() string {
return fmt.Sprintf("%s (%s:%d)", s.function, s.file, s.line)
} | go | {
"resource": ""
} |
q181586 | newStackFrame | test | func newStackFrame(pc uintptr) *stackFrame {
fn := runtime.FuncForPC(pc)
file, line := fn.FileLine(pc)
packagePath, funcSignature := parseFuncName(fn.Name())
_, fileName := filepath.Split(file)
return &stackFrame{
file: filepath.Join(packagePath, fileName),
line: line,
function: funcSignature,
}
} | go | {
"resource": ""
} |
q181587 | captureStack | test | func captureStack(skip, maxDepth int) []*stackFrame {
pcs := make([]uintptr, maxDepth)
count := runtime.Callers(skip+1, pcs)
frames := make([]*stackFrame, count)
for i, pc := range pcs[0:count] {
frames[i] = newStackFrame(pc)
}
return frames
} | go | {
"resource": ""
} |
q181588 | parseFuncName | test | func parseFuncName(fnName string) (packagePath, signature string) {
regEx := regexp.MustCompile("([^\\(]*)\\.(.*)")
parts := regEx.FindStringSubmatch(fnName)
packagePath = parts[1]
signature = parts[2]
return
} | go | {
"resource": ""
} |
q181589 | Stack | test | func Stack(err interface{}) {
stack := make([]byte, 64<<10)
stack = stack[:runtime.Stack(stack, false)]
log.Printf("%v\n%s", err, stack)
} | go | {
"resource": ""
} |
q181590 | StackWithCaller | test | func StackWithCaller(err interface{}) {
stack := make([]byte, 64<<10)
stack = stack[:runtime.Stack(stack, false)]
if pack, ok := callerPackage(); ok {
log.Printf("%s: %v\n%s", pack, err, stack)
} else {
log.Printf("%v\n%s", err, stack)
}
} | go | {
"resource": ""
} |
q181591 | Write | test | func (w responseWriterBinder) Write(p []byte) (int, error) {
for _, f := range w.before {
f(p)
}
return w.Writer.Write(p)
} | go | {
"resource": ""
} |
q181592 | ResponseStatus | test | func ResponseStatus(w http.ResponseWriter) int {
return int(httpResponseStruct(reflect.ValueOf(w)).FieldByName("status").Int())
} | go | {
"resource": ""
} |
q181593 | httpResponseStruct | test | func httpResponseStruct(v reflect.Value) reflect.Value {
if v.Kind() == reflect.Ptr {
v = v.Elem()
}
if v.Type().String() == "http.response" {
return v
}
return httpResponseStruct(v.FieldByName("ResponseWriter").Elem())
} | go | {
"resource": ""
} |
q181594 | SetDetectedContentType | test | func SetDetectedContentType(w http.ResponseWriter, p []byte) string {
ct := w.Header().Get("Content-Type")
if ct == "" {
ct = http.DetectContentType(p)
w.Header().Set("Content-Type", ct)
}
return ct
} | go | {
"resource": ""
} |
q181595 | New | test | func (e *ServerError) New(message string) *ServerError {
e.HTTPCode = http.StatusInternalServerError
e.Errno = 0
e.Message = message
return e
} | go | {
"resource": ""
} |
q181596 | New | test | func (e *DBError) New(dbName string, message string) *DBError {
e.HTTPCode = http.StatusInternalServerError
e.Errno = 0
e.Message = message
e.DBName = dbName
return e
} | go | {
"resource": ""
} |
q181597 | New | test | func (e *ValidationError) New(message string) *ValidationError {
e.HTTPCode = http.StatusBadRequest
e.Errno = 0
e.Message = message
return e
} | go | {
"resource": ""
} |
q181598 | New | test | func (e *NotFoundError) New(message string) *NotFoundError {
e.HTTPCode = http.StatusNotFound
e.Errno = 0
e.Message = message
return e
} | go | {
"resource": ""
} |
q181599 | StrLength | test | func (c *Controller) StrLength(fieldName string, p interface{}, n int) string {
if p == nil {
p = ""
}
v, ok := p.(string)
if ok == false {
panic((&ValidationError{}).New(fieldName + "长度应该为" + strconv.Itoa(n)))
}
b := c.Validate.Length(v, n)
if b == false {
panic((&ValidationError{}).New(fieldName + "长度应该为... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.