本文整理汇总了Golang中C.time_t函数的典型用法代码示例。如果您正苦于以下问题:Golang time_t函数的具体用法?Golang time_t怎么用?Golang time_t使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了time_t函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: SetDeadline
func (xpath *XPath) SetDeadline(deadline *time.Time) {
if deadline == nil {
C.xmlXPathContextSetDeadline(xpath.ContextPtr, C.time_t(0))
} else {
t := deadline.Unix()
C.xmlXPathContextSetDeadline(xpath.ContextPtr, C.time_t(t))
}
}
示例2: Fetch
// Fetch retrieves the values represented by an RRD file.
func Fetch(filename string, cf int, startTime int64, endTime int64, step uint64) (dsCount uint64, dsNames []string, data []map[int64]float64, err error) {
cfilename := C.CString(filename)
defer C.free(unsafe.Pointer(cfilename))
// Newer version requires indices
cf_idx := CfToString(cf)
if cf_idx == "" {
err = errors.New(fmt.Sprintf("Unable to convert cf : %d", cf))
return
}
ccf := C.CString(cf_idx)
var cdsCount C.ulong
cstep := C.ulong(step)
var cdsNames **C.char
var cdata *C.rrd_value_t
cst := C.time_t(startTime)
cet := C.time_t(endTime)
ret := C.rrd_fetch_r(cfilename, ccf, &cst, &cet, &cstep, &cdsCount, &cdsNames, &cdata)
if int(ret) != 0 {
err = errors.New(getError())
return
}
// Figure out count
dsCount = uint64(cdsCount)
// Decode names of data sources
dsNames = make([]string, dsCount)
data = make([]map[int64]float64, dsCount)
nptr := *cdsNames
for iter := 0; iter < int(dsCount); iter++ {
dsNames[iter] = C.GoString(nptr)
data[iter] = make(map[int64]float64)
nptr = (*C.char)(unsafe.Pointer(uintptr(unsafe.Pointer(cdsNames)) + uintptr(iter)))
}
vptr := cdata
for ti := startTime + int64(step); ti <= endTime; ti += int64(step) {
k := int64(ti)
for ii := 0; ii < int(dsCount); ii++ {
v := float64(*vptr)
// Add to appropriate map
data[ii][k] = v
vptr = (*C.rrd_value_t)(unsafe.Pointer(uintptr(unsafe.Pointer(vptr)) + 1))
}
}
return
}
示例3: xport
// Export data from RRD file(s)
func (e *Exporter) xport(start, end time.Time, step time.Duration) (XportResult, error) {
cStart := C.time_t(start.Unix())
cEnd := C.time_t(end.Unix())
cStep := C.ulong(step.Seconds())
args := e.makeArgs(start, end, step)
mutex.Lock()
defer mutex.Unlock()
var (
ret C.int
cXSize C.int
cColCnt C.ulong
cLegends **C.char
cData *C.double
)
err := makeError(C.rrdXport(
&ret,
C.int(len(args)),
&args[0],
&cXSize, &cStart, &cEnd, &cStep, &cColCnt, &cLegends, &cData,
))
if err != nil {
return XportResult{start, end, step, nil, 0, nil}, err
}
start = time.Unix(int64(cStart), 0)
end = time.Unix(int64(cEnd), 0)
step = time.Duration(cStep) * time.Second
colCnt := int(cColCnt)
legends := make([]string, colCnt)
for i := 0; i < colCnt; i++ {
legend := C.arrayGetCString(cLegends, C.int(i))
legends[i] = C.GoString(legend)
C.free(unsafe.Pointer(legend))
}
C.free(unsafe.Pointer(cLegends))
rowCnt := (int(cEnd)-int(cStart))/int(cStep) + 1
valuesLen := colCnt * rowCnt
values := make([]float64, valuesLen)
sliceHeader := (*reflect.SliceHeader)((unsafe.Pointer(&values)))
sliceHeader.Cap = valuesLen
sliceHeader.Len = valuesLen
sliceHeader.Data = uintptr(unsafe.Pointer(cData))
return XportResult{start, end, step, legends, rowCnt, values}, nil
}
示例4: Delete
func (self *memcached) Delete(key string, expiration time.Duration) error {
cs_key, key_len := cString(key)
defer C.free(unsafe.Pointer(cs_key))
return self.checkError(
C.memcached_delete(
self.mc, cs_key, key_len, C.time_t(expiration.Seconds())))
}
示例5: strftime
func strftime(format string, t time.Time) (s string) {
if format == "" {
return
}
fmt := C.CString(format)
defer C.free(unsafe.Pointer(fmt))
// pass timezone to strftime(3) through TZ environment var.
// XXX: this is not threadsafe; someone may set TZ to a different value
// between when we get and reset it. we could check that it's unchanged
// right before setting it back, but that would leave a race between
// testing and setting, and also a worse scenario where another thread sets
// TZ to the same value of `zone` as this one (which can't be detected),
// only to have us unhelpfully reset it to a now-stale value.
//
// since a runtime environment where different threads are stomping on TZ
// is inherently unsafe, don't waste time trying.
zone, _ := t.Zone()
oldZone := os.Getenv("TZ")
if oldZone != zone {
defer os.Setenv("TZ", oldZone)
os.Setenv("TZ", zone)
}
timep := C.time_t(t.Unix())
var tm C.struct_tm
C.localtime_r(&timep, &tm)
for size := initialBufSize; ; size *= 2 {
buf := (*C.char)(C.malloc(C.size_t(size))) // can panic
defer C.free(unsafe.Pointer(buf))
n := C.strftime(buf, C.size_t(size), fmt, &tm)
if n == 0 {
// strftime(3), unhelpfully: "Note that the return value 0 does not
// necessarily indicate an error; for example, in many locales %p
// yields an empty string." This leaves no definite way to
// distinguish between the cases where the value doesn't fit and
// where it does because the string is empty. In the latter case,
// allocating increasingly larger buffers will never change the
// result, so we need some heuristic for bailing out.
//
// Since a single 2-byte conversion sequence should not produce an
// output longer than about 24 bytes, we conservatively allow the
// buffer size to grow up to 20 times larger than the format string
// before giving up.
if size > 20*len(format) {
return
}
} else if int(n) < size {
s = C.GoStringN(buf, C.int(n))
return
}
}
return
}
示例6: Fetch
// Fetch retrieves data from RRD file.
func Fetch(filename, cf string, start, end time.Time, step time.Duration) (FetchResult, error) {
var null **C.char
fn := C.CString(filename)
defer freeCString(fn)
cCf := C.CString(cf)
defer freeCString(cCf)
cStart := C.time_t(start.Unix())
cEnd := C.time_t(end.Unix())
cStep := C.ulong(step.Seconds())
var (
ret C.int
cDsCnt C.ulong
cDsNames **C.char
cData *C.double
)
err := makeError(C.rrdFetch(&ret, fn, cCf, &cStart, &cEnd, &cStep, &cDsCnt, &cDsNames, &cData))
if err != nil {
return FetchResult{filename, cf, start, end, step, nil, 0, nil}, err
}
if cDsNames == null {
return FetchResult{filename, cf, start, end, step, nil, 0, nil}, Error("malloc error")
}
start = time.Unix(int64(cStart), 0)
end = time.Unix(int64(cEnd), 0)
step = time.Duration(cStep) * time.Second
dsCnt := int(cDsCnt)
dsNames := make([]string, dsCnt)
for i := 0; i < dsCnt; i++ {
dsName := C.arrayGetCString(cDsNames, C.int(i))
dsNames[i] = C.GoString(dsName)
C.free(unsafe.Pointer(dsName))
}
C.free(unsafe.Pointer(cDsNames))
rowCnt := (int(cEnd)-int(cStart))/int(cStep) + 1
valuesLen := dsCnt * rowCnt
var values []float64
sliceHeader := (*reflect.SliceHeader)((unsafe.Pointer(&values)))
sliceHeader.Cap = valuesLen
sliceHeader.Len = valuesLen
sliceHeader.Data = uintptr(unsafe.Pointer(cData))
return FetchResult{filename, cf, start, end, step, dsNames, rowCnt, values}, nil
}
示例7: createPPDCacheEntry
// createPPDCacheEntry creates an instance of ppdCache with the name field set,
// all else empty. The caller must free the name and buffer fields with
// ppdCacheEntry.free()
func createPPDCacheEntry(name string) (*ppdCacheEntry, error) {
pce := &ppdCacheEntry{
printername: C.CString(name),
modtime: C.time_t(0),
}
return pce, nil
}
示例8: NewFile
func NewFile(id uint32, parent uint32, storage_id uint32, filename string, size uint64,
mtime time.Time, fileType int) *File {
f := C.LIBMTP_new_file_t()
f.item_id = C.uint32_t(id)
f.parent_id = C.uint32_t(parent)
f.storage_id = C.uint32_t(storage_id)
f.filename = C.CString(filename)
f.filesize = C.uint64_t(size)
f.modificationdate = C.time_t(mtime.Unix())
f.filetype = C.LIBMTP_filetype_t(fileType)
return (*File)(f)
}
示例9: NewBitcask
func NewBitcask(dirpath string, depth, pos int, before int64) (b *Bitcask, err error) {
b = new(Bitcask)
b.path = dirpath
cpath := C.CString(dirpath)
defer C.free(unsafe.Pointer(cpath))
b.bc = C.bc_open(cpath, C.int(depth), C.int(pos), C.time_t(before))
if b.bc == nil {
return nil, errors.New("open bitcask failed" + dirpath)
}
return
}
示例10: Set
func (self *memcached) Set(key string, value interface{}, expiration time.Duration) (err error) {
buffer, flag, err := self.encode(value)
if err != nil {
return
}
cs_key, key_len := cString(key)
defer C.free(unsafe.Pointer(cs_key))
cs_value, value_len := cString(string(buffer))
defer C.free(unsafe.Pointer(cs_value))
return self.checkError(
C.memcached_set(
self.mc, cs_key, key_len, cs_value, value_len,
C.time_t(expiration.Seconds()), C.uint32_t(flag)))
}
示例11: create
func (c *Creator) create() error {
filename := C.CString(c.filename)
defer freeCString(filename)
args := makeArgs(c.args)
defer freeArgs(args)
e := C.rrdCreate(
filename,
C.ulong(c.step),
C.time_t(c.start.Unix()),
C.int(len(args)),
&args[0],
)
return makeError(e)
}
示例12: createPPDCacheEntry
// createPPDCacheEntry creates an instance of ppdCache with the name field set,
// all else empty. The caller must free the name and buffer fields with
// ppdCacheEntry.free()
func createPPDCacheEntry(name string) (*ppdCacheEntry, error) {
file, err := ioutil.TempFile("", "cups-connector-ppd-")
if err != nil {
return nil, fmt.Errorf("Failed to create PPD cache entry file: %s", err)
}
defer file.Close()
filename := file.Name()
pce := &ppdCacheEntry{
printername: C.CString(name),
modtime: C.time_t(0),
filename: filename,
}
return pce, nil
}
示例13: Create
// The Create function lets you set up new Round Robin Database (RRD) files.
// The file is created at its final, full size and filled with *UNKNOWN* data.
//
// filename::
// The name of the RRD you want to create. RRD files should end with the
// extension .rrd. However, it accept any filename.
// step::
// Specifies the base interval in seconds with which data will be
// fed into the RRD.
// start_time::
// Specifies the time in seconds since 1970-01-01 UTC when the first
// value should be added to the RRD. It will not accept any data timed
// before or at the time specified.
// values::
// A list of strings identifying datasources (in format "DS:ds-name:DST:dst arguments")
// and round robin archives - RRA (in format "RRA:CF:cf arguments").
// There should be at least one DS and RRA.
//
// See http://oss.oetiker.ch/rrdtool/doc/rrdcreate.en.html for detauls.
//
func Create(filename string, step, start_time int64, values []string) (err os.Error) {
cfilename := C.CString(filename)
defer C.free(unsafe.Pointer(cfilename))
cvalues := makeCStringArray(values)
defer freeCStringArray(cvalues)
clearError()
ret := C.rrd_create_r(cfilename, C.ulong(step), C.time_t(start_time),
C.int(len(values)), getCStringArrayPointer(cvalues))
if int(ret) != 0 {
err = os.NewError(error())
}
return
}
示例14: Update
func (r *cRepository) Update(pkg, destination string,
lifetime time.Duration) error {
cPkg := C.CString(pkg)
defer C.free(unsafe.Pointer(cPkg))
cDst := C.CString(destination)
defer C.free(unsafe.Pointer(cDst))
cErr := C.malloc(errSize)
defer C.free(cErr)
cRet := C.bunsan_pm_repository_update(r.repo, cPkg, cDst,
C.time_t(lifetime.Seconds()+0.5 /*round non-negative*/),
(*C.char)(cErr), errSize)
if cRet != 0 {
return &cError{C.GoString((*C.char)(cErr))}
}
return nil
}
示例15: Operate
func (wo *WriteOperation) Operate(object *Object, modifiedTime *time.Time, flags ...LibradosOperation) error {
oid := C.CString(object.name)
defer freeString(oid)
var mtime C.time_t
if modifiedTime != nil {
mtime = C.time_t(modifiedTime.Unix())
}
var f C.int = 0
for _, flag := range flags {
f |= C.int(flag)
}
ret := C.rados_write_op_operate(wo.opContext, wo.ioContext, oid, &mtime, f)
if err := toRadosError(ret); err != nil {
err.Message = "Unable to perform write operation."
return err
}
return nil
}