本文整理汇总了Golang中github.com/golang/protobuf/proto.Uint64函数的典型用法代码示例。如果您正苦于以下问题:Golang Uint64函数的具体用法?Golang Uint64怎么用?Golang Uint64使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了Uint64函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: toProto
func (this *Delete) toProto() pb.Message {
d := &proto.MutationProto{
Row: this.key,
MutateType: proto.MutationProto_DELETE.Enum(),
}
for i, v := range this.families {
cv := &proto.MutationProto_ColumnValue{
Family: v,
QualifierValue: make([]*proto.MutationProto_ColumnValue_QualifierValue, 0),
}
if len(this.qualifiers[i]) == 0 {
cv.QualifierValue = append(cv.QualifierValue, &proto.MutationProto_ColumnValue_QualifierValue{
Qualifier: nil,
Timestamp: pb.Uint64(uint64(math.MaxInt64)),
DeleteType: proto.MutationProto_DELETE_FAMILY.Enum(),
})
}
for _, v := range this.qualifiers[i] {
cv.QualifierValue = append(cv.QualifierValue, &proto.MutationProto_ColumnValue_QualifierValue{
Qualifier: v,
Timestamp: pb.Uint64(uint64(math.MaxInt64)),
DeleteType: proto.MutationProto_DELETE_MULTIPLE_VERSIONS.Enum(),
})
}
d.ColumnValue = append(d.ColumnValue, cv)
}
return d
}
示例2: Encode
// Encodes the SnapshotRecoveryRequest to a buffer. Returns the number of bytes
// written and any error that may have occurred.
func (req *SnapshotRecoveryRequest) Encode(w io.Writer) (int, error) {
protoPeers := make([]*protobuf.SnapshotRecoveryRequest_Peer, len(req.Peers))
for i, peer := range req.Peers {
protoPeers[i] = &protobuf.SnapshotRecoveryRequest_Peer{
Name: proto.String(peer.Name),
ConnectionString: proto.String(peer.ConnectionString),
}
}
pb := &protobuf.SnapshotRecoveryRequest{
LeaderName: proto.String(req.LeaderName),
LastIndex: proto.Uint64(req.LastIndex),
LastTerm: proto.Uint64(req.LastTerm),
Peers: protoPeers,
State: req.State,
}
p, err := proto.Marshal(pb)
if err != nil {
return -1, err
}
return w.Write(p)
}
示例3: FindGame
func (s *GameMasterService) FindGame(body []byte) ([]byte, error) {
req := &game_master_service.FindGameRequest{}
proto.Unmarshal(body, req)
token := s.sess.receivedToken
fmt.Println(req.String())
advNotification := false
if req.AdvancedNotification != nil {
advNotification = *req.AdvancedNotification
}
player := req.Player[0]
notify := NewNotification(NotifyFindGameRequest, map[string]interface{}{
"advanced_notification": advNotification,
})
// TODO: care about game_properties and other stuff
notify.Attributes = append(notify.Attributes, player.Attribute...)
s.sess.OnceNotified(NotifyFindGameResponse, func(n *Notification) {
m := n.Map()
res := &game_master_service.FindGameResponse{}
res.Queued = proto.Bool(m["queued"].(bool))
res.RequestId = proto.Uint64(m["requestId"].(uint64))
res.FactoryId = proto.Uint64(0)
buf, err := proto.Marshal(res)
if err != nil {
panic(err)
}
s.sess.Respond(token, buf)
})
s.sess.ServerNotifications <- notify
return nil, nil
}
示例4: writeBlockWriteRequest
func (bw *BlockWriter) writeBlockWriteRequest(w io.Writer) error {
targets := bw.currentPipeline()[1:]
op := &hdfs.OpWriteBlockProto{
Header: &hdfs.ClientOperationHeaderProto{
BaseHeader: &hdfs.BaseHeaderProto{
Block: bw.block.GetB(),
Token: bw.block.GetBlockToken(),
},
ClientName: proto.String(bw.clientName),
},
Targets: targets,
Stage: bw.currentStage().Enum(),
PipelineSize: proto.Uint32(uint32(len(targets))),
MinBytesRcvd: proto.Uint64(bw.block.GetB().GetNumBytes()),
MaxBytesRcvd: proto.Uint64(uint64(bw.offset)), // I don't understand these two fields
LatestGenerationStamp: proto.Uint64(uint64(bw.generationTimestamp())),
RequestedChecksum: &hdfs.ChecksumProto{
Type: hdfs.ChecksumTypeProto_CHECKSUM_CRC32.Enum(),
BytesPerChecksum: proto.Uint32(outboundChunkSize),
},
}
return writeBlockOpRequest(w, writeBlockOp, op)
}
示例5: UpdateFrozenUser
// Update the datastore with the user's current state.
func (server *Server) UpdateFrozenUser(client *Client, state *mumbleproto.UserState) {
// Full sync If there's no userstate messgae provided, or if there is one, and
// it includes a registration operation.
user := client.user
nanos := time.Now().Unix()
if state == nil || state.UserId != nil {
fu, err := user.Freeze()
if err != nil {
server.Fatal(err)
}
fu.LastActive = proto.Uint64(uint64(nanos))
err = server.freezelog.Put(fu)
if err != nil {
server.Fatal(err)
}
} else {
fu := &freezer.User{}
fu.Id = proto.Uint32(user.Id)
if state.ChannelId != nil {
fu.LastChannelId = proto.Uint32(uint32(client.Channel.Id))
}
if state.TextureHash != nil {
fu.TextureBlob = proto.String(user.TextureBlob)
}
if state.CommentHash != nil {
fu.CommentBlob = proto.String(user.CommentBlob)
}
fu.LastActive = proto.Uint64(uint64(nanos))
err := server.freezelog.Put(fu)
if err != nil {
server.Fatal(err)
}
}
server.numLogOps += 1
}
示例6: usageString
// usageString returns a description of the amount of space taken up by a body
// with the given contents and a bool indicating overflow.
func (draft *Draft) usageString() (string, bool) {
var replyToId *uint64
if draft.inReplyTo != 0 {
replyToId = proto.Uint64(1)
}
var dhPub [32]byte
msg := &pond.Message{
Id: proto.Uint64(0),
Time: proto.Int64(1 << 62),
Body: []byte(draft.body),
BodyEncoding: pond.Message_RAW.Enum(),
InReplyTo: replyToId,
MyNextDh: dhPub[:],
Files: draft.attachments,
DetachedFiles: draft.detachments,
SupportedVersion: proto.Int32(protoVersion),
}
serialized, err := proto.Marshal(msg)
if err != nil {
panic("error while serialising candidate Message: " + err.Error())
}
s := fmt.Sprintf("%s of %s bytes", prettyNumber(uint64(len(serialized))), prettyNumber(pond.MaxSerializedMessage))
return s, len(serialized) > pond.MaxSerializedMessage
}
示例7: commitRow
func (rpc *themisRPC) commitRow(tbl, row []byte, mutations []*columnMutation,
prewriteTs, commitTs uint64, primaryOffset int) error {
req := &ThemisCommitRequest{}
req.ThemisCommit = &ThemisCommit{
Row: row,
PrewriteTs: pb.Uint64(prewriteTs),
CommitTs: pb.Uint64(commitTs),
PrimaryIndex: pb.Int(primaryOffset),
}
for _, m := range mutations {
req.ThemisCommit.Mutations = append(req.ThemisCommit.Mutations, m.toCell())
}
var res ThemisCommitResponse
err := rpc.call("commitRow", tbl, row, req, &res)
if err != nil {
return errors.Trace(err)
}
ok := res.GetResult()
if !ok {
if primaryOffset == -1 {
return errors.Errorf("commit secondary failed, tbl: %s row: %q ts: %d", tbl, row, commitTs)
}
return errors.Errorf("commit primary failed, tbl: %s row: %q ts: %d", tbl, row, commitTs)
}
return nil
}
示例8: ToProto
func (g *Get) ToProto() pb.Message {
get := &proto.Get{
Row: g.Row,
}
if g.TsRangeFrom != 0 && g.TsRangeTo != 0 && g.TsRangeFrom <= g.TsRangeTo {
get.TimeRange = &proto.TimeRange{
From: pb.Uint64(g.TsRangeFrom),
To: pb.Uint64(g.TsRangeTo),
}
}
for v, _ := range g.Families {
col := &proto.Column{
Family: []byte(v),
}
var quals [][]byte
for qual, _ := range g.FamilyQuals[v] {
quals = append(quals, []byte(qual))
}
col.Qualifier = quals
get.Column = append(get.Column, col)
}
get.MaxVersions = pb.Uint32(uint32(g.Versions))
return get
}
示例9: commitThenGet
// If key == nil then only commit but value is nil
func (l *txnLock) commitThenGet(commitVersion uint64) ([]byte, error) {
req := &pb.Request{
Type: pb.MessageType_CmdCommitThenGet.Enum(),
CmdCommitGetReq: &pb.CmdCommitThenGetRequest{
Key: l.key,
LockVersion: proto.Uint64(l.pl.version),
CommitVersion: proto.Uint64(commitVersion),
GetVersion: proto.Uint64(l.ver),
},
}
var backoffErr error
for backoff := regionMissBackoff(); backoffErr == nil; backoffErr = backoff() {
region, err := l.store.regionCache.GetRegion(l.key)
if err != nil {
return nil, errors.Trace(err)
}
resp, err := l.store.SendKVReq(req, region.VerID())
if err != nil {
return nil, errors.Trace(err)
}
if regionErr := resp.GetRegionError(); regionErr != nil {
continue
}
cmdCommitGetResp := resp.GetCmdCommitGetResp()
if cmdCommitGetResp == nil {
return nil, errors.Trace(errBodyMissing)
}
if keyErr := cmdCommitGetResp.GetError(); keyErr != nil {
return nil, errors.Errorf("unexpected commit err: %s", keyErr.String())
}
return cmdCommitGetResp.GetValue(), nil
}
return nil, errors.Annotate(backoffErr, txnRetryableMark)
}
示例10: sendDraft
func (c *client) sendDraft(draft *Draft) (uint64, time.Time, error) {
to := c.contacts[draft.to]
// Zero length bodies are ACKs.
if len(draft.body) == 0 {
draft.body = " "
}
id := c.randId()
created := c.Now()
message := &pond.Message{
Id: proto.Uint64(id),
Time: proto.Int64(created.Unix()),
Body: []byte(draft.body),
BodyEncoding: pond.Message_RAW.Enum(),
Files: draft.attachments,
DetachedFiles: draft.detachments,
SupportedVersion: proto.Int32(protoVersion),
}
if r := draft.inReplyTo; r != 0 {
message.InReplyTo = proto.Uint64(r)
}
if to.ratchet == nil {
var nextDHPub [32]byte
curve25519.ScalarBaseMult(&nextDHPub, &to.currentDHPrivate)
message.MyNextDh = nextDHPub[:]
}
err := c.send(to, message)
return id, created, err
}
示例11: newLogEntry
// Creates a new log entry associated with a log.
func newLogEntry(log *Log, event *ev, index uint64, term uint64, command Command) (*LogEntry, error) {
var buf bytes.Buffer
var commandName string
if command != nil {
commandName = command.CommandName()
if encoder, ok := command.(CommandEncoder); ok {
if err := encoder.Encode(&buf); err != nil {
return nil, err
}
} else {
if err := json.NewEncoder(&buf).Encode(command); err != nil {
return nil, err
}
}
}
pb := &protobuf.LogEntry{
Index: proto.Uint64(index),
Term: proto.Uint64(term),
CommandName: proto.String(commandName),
Command: buf.Bytes(),
}
e := &LogEntry{
pb: pb,
log: log,
event: event,
}
return e, nil
}
示例12: checkContext
func (h *rpcHandler) checkContext(ctx *kvrpcpb.Context) *errorpb.Error {
region, leaderID := h.cluster.GetRegion(ctx.GetRegionId())
// No region found.
if region == nil {
return &errorpb.Error{
Message: proto.String("region not found"),
RegionNotFound: &errorpb.RegionNotFound{
RegionId: proto.Uint64(ctx.GetRegionId()),
},
}
}
var storePeer, leaderPeer *metapb.Peer
for _, p := range region.Peers {
if p.GetStoreId() == h.storeID {
storePeer = p
}
if p.GetId() == leaderID {
leaderPeer = p
}
}
// The Store does not contain a Peer of the Region.
if storePeer == nil {
return &errorpb.Error{
Message: proto.String("region not found"),
RegionNotFound: &errorpb.RegionNotFound{
RegionId: proto.Uint64(ctx.GetRegionId()),
},
}
}
// No leader.
if leaderPeer == nil {
return &errorpb.Error{
Message: proto.String("no leader"),
NotLeader: &errorpb.NotLeader{
RegionId: proto.Uint64(ctx.GetRegionId()),
},
}
}
// The Peer on the Store is not leader.
if storePeer.GetId() != leaderPeer.GetId() {
return &errorpb.Error{
Message: proto.String("not leader"),
NotLeader: &errorpb.NotLeader{
RegionId: proto.Uint64(ctx.GetRegionId()),
Leader: leaderPeer,
},
}
}
// Region epoch does not match.
if !proto.Equal(region.GetRegionEpoch(), ctx.GetRegionEpoch()) {
return &errorpb.Error{
Message: proto.String("stale epoch"),
StaleEpoch: &errorpb.StaleEpoch{},
}
}
h.startKey, h.endKey = region.StartKey, region.EndKey
return nil
}
示例13: TestSuccessPath
// This function tests that basic workflow works.
func TestSuccessPath(t *testing.T) {
pbs := []*pb.LanzRecord{
{
ConfigRecord: &pb.ConfigRecord{
Timestamp: proto.Uint64(146591697107544),
LanzVersion: proto.Uint32(1),
NumOfPorts: proto.Uint32(146),
SegmentSize: proto.Uint32(512),
MaxQueueSize: proto.Uint32(524288000),
PortConfigRecord: []*pb.ConfigRecord_PortConfigRecord{
{
IntfName: proto.String("Cpu"),
SwitchId: proto.Uint32(2048),
PortId: proto.Uint32(4096),
InternalPort: proto.Bool(false),
HighThreshold: proto.Uint32(50000),
LowThreshold: proto.Uint32(25000),
},
},
GlobalUsageReportingEnabled: proto.Bool(true),
},
},
{
CongestionRecord: &pb.CongestionRecord{
Timestamp: proto.Uint64(146591697107546),
IntfName: proto.String("Cpu"),
SwitchId: proto.Uint32(2048),
PortId: proto.Uint32(4096),
QueueSize: proto.Uint32(30000),
},
},
{
ErrorRecord: &pb.ErrorRecord{
Timestamp: proto.Uint64(146591697107549),
ErrorMessage: proto.String("Error"),
},
},
}
conn := &testConnector{reader: bytes.NewReader(pbsToStream(pbs))}
ch := make(chan *pb.LanzRecord)
c, done := launchClient(ch, conn)
for i, p := range pbs {
r, ok := <-ch
if !ok {
t.Fatalf("Unexpected closed channel")
}
if !test.DeepEqual(p, r) {
t.Fatalf("Test case %d: expected %v, but got %v", i, p, r)
}
}
c.Stop()
<-done
if conn.open {
t.Fatalf("Connection still open after stopping")
}
}
示例14: fillResult
func fillResult(result *subprocess.SubprocessResult, response *contester_proto.LocalExecutionResult) {
if result.TotalProcesses > 0 {
response.TotalProcesses = proto.Uint64(result.TotalProcesses)
}
response.ReturnCode = proto.Uint32(result.ExitCode)
response.Flags = parseSuccessCode(result.SuccessCode)
response.Time = parseTime(result)
response.Memory = proto.Uint64(result.PeakMemory)
response.StdOut, _ = contester_proto.NewBlob(result.Output)
response.StdErr, _ = contester_proto.NewBlob(result.Error)
}
示例15: Serialize
// Serialize generates a string containing all data that can be preserved over
// shutdown (i.e. no data directly referencing runtime components).
func (msg Message) Serialize() ([]byte, error) {
serializable := &SerializedMessage{
StreamID: proto.Uint64(uint64(msg.StreamID)),
PrevStreamID: proto.Uint64(uint64(msg.PrevStreamID)),
Timestamp: proto.Int64(msg.Timestamp.UnixNano()),
Sequence: proto.Uint64(msg.Sequence),
Data: msg.Data,
}
return proto.Marshal(serializable)
}