Golang uint64_t示例

说明

golang uint64_t示例是从最受好评的开源项目中提取的实现代码,你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: C

示例#1
文件: session.go 项目: DemonVex/elliptics-go

//ReadKey performs a read operation by key.
func (s *Session) ReadKey(key *Key, offset, size uint64) <-chan ReadResult {
	responseCh := make(chan ReadResult, defaultVOLUME)
	onResultContext := NextContext()
	onFinishContext := NextContext()

	onResult := func(result *readResult) {
		responseCh <- result
	}

	onFinish := func(err error) {
		if err != nil {
			responseCh <- &readResult{err: err}
		}

		close(responseCh)
		Pool.Delete(onResultContext)
		Pool.Delete(onFinishContext)
	}

	Pool.Store(onResultContext, onResult)
	Pool.Store(onFinishContext, onFinish)

	C.session_read_data(s.session,
		C.context_t(onResultContext), C.context_t(onFinishContext),
		key.key, C.uint64_t(offset), C.uint64_t(size))
	return responseCh
}

示例#2
文件: rocksdb.go 项目: liugangnhm/cockroach

// Open creates options and opens the database. If the database
// doesn't yet exist at the specified directory, one is initialized
// from scratch. The RocksDB Open and Close methods are reference
// counted such that subsequent Open calls to an already opened
// RocksDB instance only bump the reference count. The RocksDB is only
// closed when a sufficient number of Close calls are performed to
// bring the reference count down to 0.
func (r *RocksDB) Open() error {
	if r.rdb != nil {
		return nil
	}

	if len(r.dir) != 0 {
		log.Infof("opening rocksdb instance at %q", r.dir)
	}
	status := C.DBOpen(&r.rdb, goToCSlice([]byte(r.dir)),
		C.DBOptions{
			cache_size:      C.uint64_t(r.cacheSize),
			memtable_budget: C.uint64_t(r.memtableBudget),
			allow_os_buffer: C.bool(true),
			logging_enabled: C.bool(log.V(3)),
		})
	err := statusToError(status)
	if err != nil {
		return util.Errorf("could not open rocksdb instance: %s", err)
	}

	// Start a goroutine that will finish when the underlying handle
	// is deallocated. This is used to check a leak in tests.
	go func() {
		<-r.deallocated
	}()
	r.stopper.AddCloser(r)
	return nil
}

示例#3
文件: rocksdb.go 项目: csdigi/cockroach

// Open creates options and opens the database. If the database
// doesn't yet exist at the specified directory, one is initialized
// from scratch. The RocksDB Open and Close methods are reference
// counted such that subsequent Open calls to an already opened
// RocksDB instance only bump the reference count. The RocksDB is only
// closed when a sufficient number of Close calls are performed to
// bring the reference count down to 0.
func (r *RocksDB) Open() error {
	if r.rdb != nil {
		return nil
	}

	if r.memtableBudget < minMemtableBudget {
		return util.Errorf("memtable budget must be at least %s: %s",
			humanize.IBytes(minMemtableBudget), humanizeutil.IBytes(r.memtableBudget))
	}

	var ver storageVersion
	if len(r.dir) != 0 {
		log.Infof("opening rocksdb instance at %q", r.dir)

		// Check the version number.
		var err error
		if ver, err = getVersion(r.dir); err != nil {
			return err
		}
		if ver < versionMinimum || ver > versionCurrent {
			// Instead of an error, we should call a migration if possible when
			// one is needed immediately following the DBOpen call.
			return fmt.Errorf("incompatible rocksdb data version, current:%d, on disk:%d, minimum:%d",
				versionCurrent, ver, versionMinimum)
		}
	} else {
		log.Infof("opening in memory rocksdb instance")

		// In memory dbs are always current.
		ver = versionCurrent
	}

	status := C.DBOpen(&r.rdb, goToCSlice([]byte(r.dir)),
		C.DBOptions{
			cache_size:      C.uint64_t(r.cacheSize),
			memtable_budget: C.uint64_t(r.memtableBudget),
			block_size:      C.uint64_t(envutil.EnvOrDefaultBytes("rocksdb_block_size", defaultBlockSize)),
			wal_ttl_seconds: C.uint64_t(envutil.EnvOrDefaultDuration("rocksdb_wal_ttl", 0).Seconds()),
			allow_os_buffer: C.bool(true),
			logging_enabled: C.bool(log.V(3)),
		})
	if err := statusToError(status); err != nil {
		return util.Errorf("could not open rocksdb instance: %s", err)
	}

	// Update or add the version file if needed.
	if ver < versionCurrent {
		if err := writeVersionFile(r.dir); err != nil {
			return err
		}
	}

	// Start a goroutine that will finish when the underlying handle
	// is deallocated. This is used to check a leak in tests.
	go func() {
		<-r.deallocated
	}()
	r.stopper.AddCloser(r)
	return nil
}

示例#4
文件: tdb.go 项目: traildb/traildb-go

func (cons *TrailDBConstructor) Add(cookie string, timestamp int64, values []string) error {
	if len(cookie) != 32 {
		return errors.New("Cookie in the wrong format, needs to be 32 chars: " + cookie)
	}
	cookiebin, err := rawCookie(cookie)
	if err != nil {
		return err
	}
	var values_p *C.char

	ptrSize := unsafe.Sizeof(values_p)

	// Assign each byte slice to its appropriate offset.
	var currentString string
	passedLength := len(values)
	for i := 0; i < len(cons.ofields); i++ {
		element := (**C.char)(unsafe.Pointer(uintptr(cons.valuePtr) + uintptr(i)*ptrSize))
		if i+1 <= passedLength {
			currentString = values[i]
		} else {
			currentString = ""
		}
		cvalues := C.CString(currentString)
		defer C.free(unsafe.Pointer(cvalues))
		cons.valueLengths[i] = C.uint64_t(len(currentString))
		*element = cvalues
	}
	valueLengthsPtr := (*C.uint64_t)(unsafe.Pointer(&cons.valueLengths[0]))
	err1 := C.tdb_cons_add(cons.cons, cookiebin, C.uint64_t(timestamp), cons.valuePtr, valueLengthsPtr)
	if err1 != 0 {
		return errors.New(errToString(err1))
	}
	return nil
}

示例#5
文件: session.go 项目: DemonVex/elliptics-go

func (s *Session) setOrUpdateIndexes(operation int, key string, indexes map[string]string) <-chan Indexer {
	ekey, err := NewKey(key)
	if err != nil {
		panic(err)
	}
	defer ekey.Free()
	responseCh := make(chan Indexer, defaultVOLUME)

	var cindexes []*C.char
	var cdatas []C.struct_go_data_pointer

	for index, data := range indexes {
		cindex := C.CString(index) // free this
		defer C.free(unsafe.Pointer(cindex))
		cindexes = append(cindexes, cindex)

		cdata := C.new_data_pointer(
			C.CString(data), // freed by ellipics::data_pointer in std::vector ???
			C.int(len(data)),
		)
		cdatas = append(cdatas, cdata)
	}

	onResultContext := NextContext()
	onFinishContext := NextContext()

	onResult := func() {
		//It's never called. For the future.
	}

	onFinish := func(err error) {
		if err != nil {
			responseCh <- &indexResult{err: err}
		}
		close(responseCh)

		Pool.Delete(onResultContext)
		Pool.Delete(onFinishContext)
	}

	Pool.Store(onResultContext, onResult)
	Pool.Store(onFinishContext, onFinish)
	// TODO: Reimplement this with pointer on functions
	switch operation {
	case indexesSet:
		C.session_set_indexes(s.session, C.context_t(onResultContext), C.context_t(onFinishContext),
			ekey.key,
			(**C.char)(&cindexes[0]),
			(*C.struct_go_data_pointer)(&cdatas[0]),
			C.uint64_t(len(cindexes)))

	case indexesUpdate:
		C.session_update_indexes(s.session, C.context_t(onResultContext), C.context_t(onFinishContext),
			ekey.key,
			(**C.char)(&cindexes[0]),
			(*C.struct_go_data_pointer)(&cdatas[0]),
			C.uint64_t(len(cindexes)))
	}
	return responseCh
}

示例#6
文件: iterators.go 项目: DemonVex/elliptics-go

func (s *Session) IteratorStart(id *DnetRawID, ranges []DnetIteratorRange,
	itype uint64, iflags uint64, timeFrame ...time.Time) <-chan IteratorResult {
	ekey, onResultContext, onFinishContext, responseCh, err := iteratorHelper(id)
	if err != nil {
		return responseCh
	}
	defer ekey.Free()

	var ctime_begin, ctime_end C.struct_dnet_time

	if err := adjustTimeFrame(&ctime_begin, &ctime_end, timeFrame...); err != nil {
		context, pool_err := Pool.Get(onFinishContext)
		if pool_err != nil {
			panic("Unable to find session number")
		}
		context.(func(error))(err)
		return responseCh
	}
	if len(timeFrame) != 0 {
		iflags |= DNET_IFLAGS_TS_RANGE
	}

	iflags |= DNET_IFLAGS_KEY_RANGE
	cranges := convertRanges(ranges)

	C.session_start_iterator(s.session, C.context_t(onResultContext), C.context_t(onFinishContext),
		(*C.struct_go_iterator_range)(&cranges[0]),
		C.size_t(len(cranges)),
		ekey.key,
		C.uint64_t(itype),
		C.uint64_t(iflags),
		ctime_begin,
		ctime_end)
	return responseCh
}

示例#7
文件: message.go 项目: jeffallen/miniv

func Write(m message.Message) ([]byte, error) {
	var b C.buf_t
	m2 := C.messageNew()

	switch m1 := m.(type) {
	case *message.Setup:
		m2.mtype = C.Setup
		s := (*C.struct_Setup)(unsafe.Pointer(ptr(m2.u[:])))
		s.ver_min = C.uint32_t(m1.Versions.Min)
		s.ver_max = C.uint32_t(m1.Versions.Max)
		for i, x := range m1.PeerNaClPublicKey {
			s.PeerNaClPublicKey[i] = C.uchar(x)
		}
		s.mtu = C.uint64_t(m1.Mtu)
		s.sharedTokens = C.uint64_t(m1.SharedTokens)
	default:
		panic("not impl yet")
	}

	err := C.messageAppend(m2, &b)
	if err != C.ERR_OK {
		return nil, GoError(err)
	}

	out := C.GoBytes(unsafe.Pointer(b.buf), C.int(b.len))
	C.bufDealloc(&b)
	return out, nil
}

示例#8
文件: p3.go 项目: hacatu/project-euler

func main() {
	r := C.uint64_t(math.Sqrt(number))
	var s C.size_t
	pp := C.primesieve_generate_primes(0, r, &s, C.UINT64_PRIMES)
	hdr := reflect.SliceHeader{
		Data: uintptr(pp),
		Len:  int(s),
		Cap:  int(s),
	}
	ps := *(*[]C.uint64_t)(unsafe.Pointer(&hdr)) //Forgive this criminal hackery

	n := C.uint64_t(number)

	for _, p := range ps {
		if p > r {
			break
		}
		if n%p == 0 {
			n /= p
			r = C.uint64_t(math.Sqrt(float64(n)))
		}
	}

	C.primesieve_free(unsafe.Pointer(pp))

	fmt.Println(n)
}

示例#9
文件: process.go 项目: zinic/libct

func (p *ProcessDesc) SetRlimit(resource int, soft uint64, hard uint64) error {
	ret := C.libct_process_desc_set_rlimit(p.desc, C.int(resource), C.uint64_t(soft), C.uint64_t(hard))
	if ret < 0 {
		return LibctError{int(ret)}
	}
	return nil
}

示例#10
文件: objects.go 项目: objStorage/grados

// SetAllocationHint sets the expected object size and expected write size of an object. As per latest doc, this may not
// actually do anything.
func (o *Object) SetAllocationHint(expectedObjectSize, expectedWriteSize uint64) {
	oid := C.CString(o.name)
	defer freeString(oid)
	es := C.uint64_t(expectedObjectSize)
	ews := C.uint64_t(expectedWriteSize)
	C.rados_set_alloc_hint(o.ioContext, oid, es, ews)
}

示例#11
文件: ethash.go 项目: CedarLogic/go-ethereum

// Verify checks whether the block's nonce is valid.
func (l *Light) Verify(block pow.Block) bool {
	// TODO: do ethash_quick_verify before getCache in order
	// to prevent DOS attacks.
	var (
		blockNum   = block.NumberU64()
		difficulty = block.Difficulty()
		cache      = l.getCache(blockNum)
		dagSize    = C.ethash_get_datasize(C.uint64_t(blockNum))
	)
	if l.test {
		dagSize = dagSizeForTesting
	}
	if blockNum >= epochLength*2048 {
		glog.V(logger.Debug).Infof("block number %d too high, limit is %d", epochLength*2048)
		return false
	}
	// Recompute the hash using the cache.
	hash := hashToH256(block.HashNoNonce())
	ret := C.ethash_light_compute_internal(cache.ptr, dagSize, hash, C.uint64_t(block.Nonce()))
	if !ret.success {
		return false
	}
	// Make sure cache is live until after the C call.
	// This is important because a GC might happen and execute
	// the finalizer before the call completes.
	_ = cache
	// The actual check.
	target := new(big.Int).Div(minDifficulty, difficulty)
	return h256ToHash(ret.result).Big().Cmp(target) <= 0
}

示例#12
文件: protocol.go 项目: jonesgithub/goscon

func Gentoken(key uint64) (token uint64, secret uint64) {
	random := uint64(C.randomint64())
	token = uint64(C.exchange(C.uint64_t(C.uint64_t(random))))
	secret = uint64(C.secret(C.uint64_t(key), C.uint64_t(random)))
	Debug("random:%x, token:%x, secret:%x\n", random, token, secret)
	return
}

示例#13
文件: session.go 项目: noxiouz/elliptics-go

func (s *Session) SetTimestamp(ts time.Time) {
	dtime := C.struct_dnet_time{
		tsec:  C.uint64_t(ts.Unix()),
		tnsec: C.uint64_t(ts.Nanosecond()),
	}

	C.session_set_timestamp(s.session, &dtime)
}

示例#14
文件: ygor.go 项目: rescrv/ygor

func NewDataLogger(output string, scale_when uint64, scale_data uint64) (*DataLogger, error) {
	o := C.CString(output)
	dl, err := C.ygor_data_logger_create(o, C.uint64_t(scale_when), C.uint64_t(scale_data))
	if dl == nil {
		return nil, err
	}
	return &DataLogger{dl}, nil
}

示例#15
文件: tilecone.go 项目: orofarne/gotilecone

func (db *DB) SetTile(x uint64, y uint64, data []byte) error {
	rc := C.tc_set_tile(db.db, C.uint64_t(x), C.uint64_t(y), unsafe.Pointer(&data[0]), C.size_t(len(data)))
	if 0 != rc {
		errCStr := C.tc_last_error(db.db)
		return errors.New(C.GoString(errCStr))
	}
	return nil
}

示例#16
文件: system_cgo.go 项目: willbittner/mojo

func (c *CGoSystem) MapBuffer(handle uint32, offset, numBytes uint64, flags uint32) (result uint32, buf []byte) {
	var bufPtr unsafe.Pointer
	r := C.MojoMapBuffer(C.MojoHandle(handle), C.uint64_t(offset), C.uint64_t(numBytes), &bufPtr, C.MojoMapBufferFlags(flags))
	if r != C.MOJO_RESULT_OK {
		return uint32(r), nil
	}
	return uint32(r), unsafeByteSlice(bufPtr, int(numBytes))
}

示例#17

func (r *RocksDB) open() error {
	var ver storageVersion
	if len(r.dir) != 0 {
		log.Infof(context.TODO(), "opening rocksdb instance at %q", r.dir)

		// Check the version number.
		var err error
		if ver, err = getVersion(r.dir); err != nil {
			return err
		}
		if ver < versionMinimum || ver > versionCurrent {
			// Instead of an error, we should call a migration if possible when
			// one is needed immediately following the DBOpen call.
			return fmt.Errorf("incompatible rocksdb data version, current:%d, on disk:%d, minimum:%d",
				versionCurrent, ver, versionMinimum)
		}
	} else {
		if log.V(2) {
			log.Infof(context.TODO(), "opening in memory rocksdb instance")
		}

		// In memory dbs are always current.
		ver = versionCurrent
	}

	blockSize := envutil.EnvOrDefaultBytes("COCKROACH_ROCKSDB_BLOCK_SIZE", defaultBlockSize)
	walTTL := envutil.EnvOrDefaultDuration("COCKROACH_ROCKSDB_WAL_TTL", 0).Seconds()

	status := C.DBOpen(&r.rdb, goToCSlice([]byte(r.dir)),
		C.DBOptions{
			cache:           r.cache.cache,
			block_size:      C.uint64_t(blockSize),
			wal_ttl_seconds: C.uint64_t(walTTL),
			allow_os_buffer: C.bool(true),
			logging_enabled: C.bool(log.V(3)),
			num_cpu:         C.int(runtime.NumCPU()),
			max_open_files:  C.int(r.maxOpenFiles),
		})
	if err := statusToError(status); err != nil {
		return errors.Errorf("could not open rocksdb instance: %s", err)
	}

	// Update or add the version file if needed.
	if ver < versionCurrent {
		if err := writeVersionFile(r.dir); err != nil {
			return err
		}
	}

	// Start a goroutine that will finish when the underlying handle
	// is deallocated. This is used to check a leak in tests.
	go func() {
		<-r.deallocated
	}()
	return nil
}

示例#18
文件: ygor.go 项目: rescrv/ygor

func (d *DataLogger) Record(series uint32, when uint64, data uint64) error {
	var dr C.struct_ygor_data_record
	dr.series = C.uint32_t(series)
	dr.when = C.uint64_t(when)
	dr.data = C.uint64_t(data)
	x, err := C.ygor_data_logger_record(d.dl, &dr)
	if x < 0 {
		return err
	}
	return nil
}

示例#19
文件: devmapper_wrapper.go 项目: NERSC/docker

func dmTaskAddTargetFct(task *CDmTask,
	start, size uint64, ttype, params string) int {

	Cttype := C.CString(ttype)
	defer free(Cttype)

	Cparams := C.CString(params)
	defer free(Cparams)

	return int(C.dm_task_add_target((*C.struct_dm_task)(task), C.uint64_t(start), C.uint64_t(size), Cttype, Cparams))
}

示例#20
文件: hook.go 项目: RKX1209/unicorn

func (u *uc) HookAdd(htype int, cb interface{}, extra ...uint64) (Hook, error) {
	var callback unsafe.Pointer
	var iarg1 C.int
	var uarg1, uarg2 C.uint64_t
	rangeMode := false
	switch htype {
	case HOOK_BLOCK, HOOK_CODE:
		rangeMode = true
		callback = C.hookCode_cgo
	case HOOK_MEM_READ, HOOK_MEM_WRITE, HOOK_MEM_READ | HOOK_MEM_WRITE:
		rangeMode = true
		callback = C.hookMemAccess_cgo
	case HOOK_INTR:
		callback = C.hookInterrupt_cgo
	case HOOK_INSN:
		iarg1 = C.int(extra[0])
		switch iarg1 {
		case X86_INS_IN:
			callback = C.hookX86In_cgo
		case X86_INS_OUT:
			callback = C.hookX86Out_cgo
		case X86_INS_SYSCALL, X86_INS_SYSENTER:
			callback = C.hookX86Syscall_cgo
		default:
			return 0, errors.New("Unknown instruction type.")
		}
	default:
		// special case for mask
		if htype&(HOOK_MEM_READ_UNMAPPED|HOOK_MEM_WRITE_UNMAPPED|HOOK_MEM_FETCH_UNMAPPED|
			HOOK_MEM_READ_PROT|HOOK_MEM_WRITE_PROT|HOOK_MEM_FETCH_PROT) != 0 {
			rangeMode = true
			callback = C.hookMemInvalid_cgo
		} else {
			return 0, errors.New("Unknown hook type.")
		}
	}
	var h2 C.uc_hook
	data := &HookData{u, cb}
	uptr := uintptr(unsafe.Pointer(data))
	if rangeMode {
		if len(extra) == 2 {
			uarg1 = C.uint64_t(extra[0])
			uarg2 = C.uint64_t(extra[1])
		} else {
			uarg1, uarg2 = 1, 0
		}
		C.uc_hook_add_u2(u.handle, &h2, C.uc_hook_type(htype), callback, C.uintptr_t(uptr), uarg1, uarg2)
	} else {
		C.uc_hook_add_i1(u.handle, &h2, C.uc_hook_type(htype), callback, C.uintptr_t(uptr), iarg1)
	}
	hookDataMap[uptr] = data
	hookToUintptr[Hook(h2)] = uptr
	return Hook(h2), nil
}

示例#21
文件: dibuilder.go 项目: leloulight/rootsubtree

// CreateBasicType creates basic type debug metadata.
func (d *DIBuilder) CreateBasicType(t DIBasicType) Metadata {
	name := C.CString(t.Name)
	defer C.free(unsafe.Pointer(name))
	result := C.LLVMDIBuilderCreateBasicType(
		d.ref,
		name,
		C.uint64_t(t.SizeInBits),
		C.uint64_t(t.AlignInBits),
		C.unsigned(t.Encoding),
	)
	return Metadata{C: result}
}

示例#22
文件: write_op.go 项目: glycerine/radosgo

// Clone range.
func (o *WriteOperation) CloneRange(dstOffset uint64, src string, srcOffset uint64, length uint64) error {
	if o.op == nil {
		return ErrAlreadyExecuted
	}

	csrc := C.CString(src)
	defer C.free(unsafe.Pointer(csrc))

	C.radosext_write_op_clone_range(o.op, C.uint64_t(dstOffset), csrc, C.uint64_t(srcOffset), C.size_t(length))

	return nil
}

示例#23
文件: dibuilder.go 项目: leloulight/rootsubtree

// CreateBasicType creates basic type debug metadata.
func (d *DIBuilder) CreatePointerType(t DIPointerType) Metadata {
	name := C.CString(t.Name)
	defer C.free(unsafe.Pointer(name))
	result := C.LLVMDIBuilderCreatePointerType(
		d.ref,
		t.Pointee.C,
		C.uint64_t(t.SizeInBits),
		C.uint64_t(t.AlignInBits),
		name,
	)
	return Metadata{C: result}
}

示例#24
文件: object.go 项目: glycerine/radosgo

// Clone a range between two objects.
func (c *Context) CloneRange(dst string, dstOffset uint64, src string, srcOffset uint64, length uint64) error {
	cdst := C.CString(dst)
	defer C.free(unsafe.Pointer(cdst))
	csrc := C.CString(src)
	defer C.free(unsafe.Pointer(csrc))

	if cerr := C.rados_clone_range(c.ctx, cdst, C.uint64_t(dstOffset), csrc, C.uint64_t(srcOffset), C.size_t(length)); cerr < 0 {
		return radosReturnCodeError(cerr)
	}

	return nil
}

示例#25
文件: debug.go 项目: go-llvm/llvm

// CreateBasicType creates basic type debug metadata.
func (d *DIBuilder) CreatePointerType(t DIPointerType) Value {
	name := C.CString(t.Name)
	result := C.DIBuilderCreatePointerType(
		d.ref,
		t.Pointee.C,
		C.uint64_t(t.SizeInBits),
		C.uint64_t(t.AlignInBits),
		name,
	)
	C.free(unsafe.Pointer(name))
	return Value{C: result}
}

示例#26
文件: debug.go 项目: go-llvm/llvm

// CreateBasicType creates basic type debug metadata.
func (d *DIBuilder) CreateBasicType(t DIBasicType) Value {
	name := C.CString(t.Name)
	result := C.DIBuilderCreateBasicType(
		d.ref,
		name,
		C.uint64_t(t.SizeInBits),
		C.uint64_t(t.AlignInBits),
		C.unsigned(t.Encoding),
	)
	C.free(unsafe.Pointer(name))
	return Value{C: result}
}

示例#27
文件: session.go 项目: DemonVex/elliptics-go

//WriteKey writes blob by Key.
func (s *Session) WriteKey(key *Key, input io.Reader, offset, total_size uint64) <-chan Lookuper {
	responseCh := make(chan Lookuper, defaultVOLUME)
	onWriteContext := NextContext()
	onWriteFinishContext := NextContext()
	chunk_context := NextContext()

	onWriteResult := func(lookup *lookupResult) {
		responseCh <- lookup
	}

	onWriteFinish := func(err error) {
		if err != nil {
			responseCh <- &lookupResult{err: err}
		}
		close(responseCh)
		Pool.Delete(onWriteContext)
		Pool.Delete(onWriteFinishContext)
		Pool.Delete(chunk_context)
	}

	chunk, err := ioutil.ReadAll(input)
	if err != nil {
		responseCh <- &lookupResult{err: err}
		close(responseCh)
		return responseCh
	}

	if len(chunk) == 0 {
		responseCh <- &lookupResult{
			err: &DnetError{
				Code:    -22,
				Flags:   0,
				Message: "Invalid zero-length write request",
			},
		}
		close(responseCh)
		return responseCh
	}

	Pool.Store(onWriteContext, onWriteResult)
	Pool.Store(onWriteFinishContext, onWriteFinish)
	Pool.Store(chunk_context, chunk)

	C.session_write_data(s.session,
		C.context_t(onWriteContext), C.context_t(onWriteFinishContext),
		key.key, C.uint64_t(offset), (*C.char)(unsafe.Pointer(&chunk[0])), C.uint64_t(len(chunk)))

	return responseCh
}

示例#28
文件: dibuilder.go 项目: leloulight/rootsubtree

// CreateArrayType creates struct type debug metadata.
func (d *DIBuilder) CreateArrayType(t DIArrayType) Metadata {
	subscriptsSlice := make([]Metadata, len(t.Subscripts))
	for i, s := range t.Subscripts {
		subscriptsSlice[i] = d.getOrCreateSubrange(s.Lo, s.Count)
	}
	subscripts := d.getOrCreateArray(subscriptsSlice)
	result := C.LLVMDIBuilderCreateArrayType(
		d.ref,
		C.uint64_t(t.SizeInBits),
		C.uint64_t(t.AlignInBits),
		t.ElementType.C,
		subscripts.C,
	)
	return Metadata{C: result}
}

示例#29
文件: object.go 项目: boydc2014/rados.go

// ReadAt reads len(data) bytes from the given RADOS object at the byte
// offset off. It returns the number of bytes read and the error, if any.
// ReadAt always returns a non-nil error when n < len(data).
// At the end of file, that error is io.EOF.
//
// This function adopted from the Go os.ReadAt() function.
func (o *Object) ReadAt(data []byte, off int64) (n int, err error) {
	cname := C.CString(o.name)
	defer C.free(unsafe.Pointer(cname))

	for len(data) > 0 {
		cdata, cdatalen := byteSliceToBuffer(data)
		coff := C.uint64_t(off)

		cerr := C.rados_read(o.c.ctx, cname, cdata, cdatalen, coff)

		if cerr == 0 {
			return n, io.EOF
		}

		if cerr < 0 {
			err = fmt.Errorf("RADOS read %s: %s", o.name, strerror(cerr))
			break
		}

		n += int(cerr)
		data = data[cerr:]
		off += int64(cerr)
	}

	return
}

示例#30
文件: socketset.go 项目: Dragomir-Ivanov/zmq3

func (soc *Socket) setUInt64(opt C.int, value uint64) error {
	val := C.uint64_t(value)
	if i, err := C.zmq_setsockopt(soc.soc, opt, unsafe.Pointer(&val), C.size_t(unsafe.Sizeof(val))); i != 0 {
		return errget(err)
	}
	return nil
}

展开阅读全文