Golang strconv.Itob64函数代码示例

// Tack starts a fresh "this second Epoch". It does not mean it lasts a
// second, it's mere resolution limitation. Given a "Tack" all following
// events receive monotonically increasing "Ticks". If Tack detects
// that last second is still up it does not reset the "Ticks" counter.
func (o *uniq) Tack() os.Error {
	var sec string
	var cnt uint16
	// stamp := time.Format("2006 Jan 02 | 05 04 15  MST (-0700)")
	var err tdb.Error
	meta := db[META+EXT] // GLOBAL ENV rox!
	store := true
	// ahh, those intermunged concerns...
	if meta == nil {
		return os.NewError("uniq.Tack(): nil META db")
	} else {
		o.utc = time.UTC()
		o.sec = strconv.Itob64(o.utc.Seconds(), BASE)
		var cnt_s string
		if sec, err = meta.Fetch(NOW); err == nil {
			// trin // fuck // order
			if o.sec == sec {
				if cnt_s, err = meta.Fetch(CNT); err == nil {
					cnt_ugh, _ := strconv.Btoui64(cnt_s, BASE)
					cnt = uint16(cnt_ugh)
					if cnt > o.cnt {
						o.cnt = cnt
						store = false
					}
				}
			} else {
				o.cnt = 0
			}
		}
		// TODO tdb.Exists()
		if store {
			if err = meta.Store(NOW, o.sec, tdb.MODIFY); err != nil {
				// presumably it yet exists not...
				if err = meta.Store(NOW, o.sec, tdb.INSERT); err != nil {
					return err
				}
			}
			// lazy logic.
			cnt_s = strconv.Itob64(int64(o.cnt), BASE)
			// mip map
			if err = meta.Store(CNT, cnt_s, tdb.MODIFY); err != nil {
				// presumably it yet exists not...
				if err = meta.Store(CNT, cnt_s, tdb.INSERT); err != nil {
					return err
				}
			}
		}
	}
	return nil
}

// Encode x as an octal ASCII string and write it into b with leading zeros.
func (tw *Writer) octal(b []byte, x int64) {
	s := strconv.Itob64(x, 8)
	// leading zeros, but leave room for a NUL.
	for len(s)+1 < len(b) {
		s = "0" + s
	}
	tw.cString(b, s)
}

// Write x into b, either as octal or as binary (GNUtar/star extension).
func (tw *Writer) numeric(b []byte, x int64) {
	// Try octal first.
	s := strconv.Itob64(x, 8)
	if len(s) < len(b) {
		tw.octal(b, x)
		return
	}
	// Too big: use binary (big-endian).
	tw.usedBinary = true
	for i := len(b) - 1; x > 0 && i >= 0; i-- {
		b[i] = byte(x)
		x >>= 8
	}
	b[0] |= 0x80 // highest bit indicates binary format
}

// ServeFile responds to the request with the contents of the named file.
//
// If the "v" request parameter is set, then ServeFile sets the expires header
// and the cache control maximum age parameter to ten years in the future.
func ServeFile(req *Request, fname string, options *ServeFileOptions) {
	if options == nil {
		options = &defaultServeFileOptions
	}

	f, err := os.Open(fname)
	if err != nil {
		req.Error(StatusNotFound, err)
		return
	}
	defer f.Close()

	info, err := f.Stat()
	if err != nil || !info.IsRegular() {
		req.Error(StatusNotFound, err)
		return
	}

	status := StatusOK

	header := Header{}
	if options.Header != nil {
		for k, v := range options.Header {
			header[k] = v
		}
	}

	etag := strconv.Itob64(info.Mtime_ns, 36)
	header.Set(HeaderETag, QuoteHeaderValue(etag))

	for _, qetag := range req.Header.GetList(HeaderIfNoneMatch) {
		if etag == UnquoteHeaderValue(qetag) {
			status = StatusNotModified
			break
		}
	}

	if status == StatusNotModified {
		// Clear entity headers.
		for k, _ := range header {
			if strings.HasPrefix(k, "Content-") {
				header[k] = nil, false
			}
		}
	} else {
		// Set entity headers
		header.Set(HeaderContentLength, strconv.Itoa64(info.Size))
		if _, found := header[HeaderContentType]; !found {
			ext := path.Ext(fname)
			contentType := ""
			if options.MimeType != nil {
				contentType = options.MimeType[ext]
			}
			if contentType == "" {
				contentType = mime.TypeByExtension(ext)
			}
			if contentType != "" {
				header.Set(HeaderContentType, contentType)
			}
		}
	}

	if v := req.Param.Get("v"); v != "" {

		parts := header.GetList(HeaderCacheControl)
		i := 0
		for _, part := range parts {
			if strings.HasPrefix(part, "max-age=") {
				continue
			}
			parts[i] = part
			i += 1
		}
		if i != len(parts) {
			parts = parts[:i]
		}

		const maxAge = 60 * 60 * 24 * 365 * 10
		header.Set(HeaderExpires, FormatDeltaSeconds(maxAge))
		header.Set(HeaderCacheControl, strings.Join(append(parts, "max-age="+strconv.Itoa(maxAge)), ", "))
	}

	w := req.Responder.Respond(status, header)
	if req.Method != "HEAD" && status != StatusNotModified {
		io.Copy(w, f)
	}
}

// SignValue returns a string containing value, an expiration time and a
// signature. The expiration time is computed from the current time and
// maxAgeSeconds.  The signature is an HMAC SHA-1 signature of value, context
// and the expiration time. Use the function VerifyValue to extract the value,
// check the expiration time and verify the signature.
//
// SignValue can be used to store credentials in a cookie:
//
//  var secret string // Initialized by application
//  const uidCookieMaxAge = 3600 * 24 * 30
//
//  // uidCookieValue returns the Set-Cookie header value containing a
//  // signed and timestamped user id.
//  func uidCookieValue(uid string) string {
//      s := web.SignValue(secret, "uid", uidCookieMaxAge, uid)
//      return web.NewCookie("uid", s).MaxAge(uidCookieMaxAge).String()
//  }
//
//  // requestUid returns the user id from the request cookie. An error
//  // is returned if the cookie is missing, the value has expired or the
//  // signature is not valid.
//  func requestUid(req *web.Request) (string, os.Error) {
//      return web.VerifyValue(secret, "uid", req.Cookie.Get("uid"))
//  }
func SignValue(secret, context string, maxAgeSeconds int, value string) string {
	expiration := strconv.Itob64(time.Seconds()+int64(maxAgeSeconds), 16)
	sig := signature(secret, context, expiration, value)
	return sig + "~" + expiration + "~" + value
}

func (e DecodeError) String() string {
	return "decoding dwarf section " + e.Name + " at offset 0x" + strconv.Itob64(int64(e.Offset), 16) + ": " + e.Error
}

// Tick ticks me off... we should store each one in db or will well clubber
// himself on Tack. But for now... we Tack once per forkproc and Tick in hopes
// ... oh, we can always Tack on exit...
//
func (o *uniq) Tick() string {
	cnt_s := strconv.Itob64(int64(o.cnt), BASE)
	o.cnt++
	return o.sec + "." + cnt_s
}

func computeTestEtag() string {
	info, _ := os.Stat("handlers_test.go")
	return QuoteHeaderValue(strconv.Itob64(info.Mtime_ns, 36))
}