diff --git a/patch/0131-Update-criurpc.patch b/patch/0131-Update-criurpc.patch new file mode 100644 index 0000000000000000000000000000000000000000..7df95344a6792ba2b6a1896e3d8ecd089906af87 --- /dev/null +++ b/patch/0131-Update-criurpc.patch @@ -0,0 +1,689 @@ +From cbd735afea71dc3deb34affe072379f51e7a47a6 Mon Sep 17 00:00:00 2001 +From: bb-cat <405888464@qq.com> +Date: Sat, 29 Jan 2022 01:15:40 +0800 +Subject: [PATCH 1/4] Update criurpc + +Signed-off-by: Andrei Vagin +--- + libcontainer/criurpc/criurpc.pb.go | 421 +++++++++++++++++++++++------ + libcontainer/criurpc/criurpc.proto | 31 ++- + 2 files changed, 360 insertions(+), 92 deletions(-) + +diff --git a/libcontainer/criurpc/criurpc.pb.go b/libcontainer/criurpc/criurpc.pb.go +index 3c4fb77..1e5311b 100644 +--- a/libcontainer/criurpc/criurpc.pb.go ++++ b/libcontainer/criurpc/criurpc.pb.go +@@ -12,6 +12,7 @@ It has these top-level messages: + CriuPageServerInfo + CriuVethPair + ExtMountMap ++ JoinNamespace + InheritFd + CgroupRoot + UnixSk +@@ -26,17 +27,25 @@ It has these top-level messages: + package criurpc + + import proto "github.com/golang/protobuf/proto" ++import fmt "fmt" + import math "math" + + // Reference imports to suppress errors if they are not otherwise used. + var _ = proto.Marshal ++var _ = fmt.Errorf + var _ = math.Inf + ++// This is a compile-time assertion to ensure that this generated file ++// is compatible with the proto package it is being compiled against. ++// A compilation error at this line likely means your copy of the ++// proto package needs to be updated. ++const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package ++ + type CriuCgMode int32 + + const ( + CriuCgMode_IGNORE CriuCgMode = 0 +- CriuCgMode_NONE CriuCgMode = 1 ++ CriuCgMode_CG_NONE CriuCgMode = 1 + CriuCgMode_PROPS CriuCgMode = 2 + CriuCgMode_SOFT CriuCgMode = 3 + CriuCgMode_FULL CriuCgMode = 4 +@@ -46,7 +55,7 @@ const ( + + var CriuCgMode_name = map[int32]string{ + 0: "IGNORE", +- 1: "NONE", ++ 1: "CG_NONE", + 2: "PROPS", + 3: "SOFT", + 4: "FULL", +@@ -55,7 +64,7 @@ var CriuCgMode_name = map[int32]string{ + } + var CriuCgMode_value = map[string]int32{ + "IGNORE": 0, +- "NONE": 1, ++ "CG_NONE": 1, + "PROPS": 2, + "SOFT": 3, + "FULL": 4, +@@ -79,6 +88,7 @@ func (x *CriuCgMode) UnmarshalJSON(data []byte) error { + *x = CriuCgMode(value) + return nil + } ++func (CriuCgMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } + + type CriuReqType int32 + +@@ -136,6 +146,7 @@ func (x *CriuReqType) UnmarshalJSON(data []byte) error { + *x = CriuReqType(value) + return nil + } ++func (CriuReqType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } + + type CriuPageServerInfo struct { + Address *string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"` +@@ -145,9 +156,10 @@ type CriuPageServerInfo struct { + XXX_unrecognized []byte `json:"-"` + } + +-func (m *CriuPageServerInfo) Reset() { *m = CriuPageServerInfo{} } +-func (m *CriuPageServerInfo) String() string { return proto.CompactTextString(m) } +-func (*CriuPageServerInfo) ProtoMessage() {} ++func (m *CriuPageServerInfo) Reset() { *m = CriuPageServerInfo{} } ++func (m *CriuPageServerInfo) String() string { return proto.CompactTextString(m) } ++func (*CriuPageServerInfo) ProtoMessage() {} ++func (*CriuPageServerInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } + + func (m *CriuPageServerInfo) GetAddress() string { + if m != nil && m.Address != nil { +@@ -183,9 +195,10 @@ type CriuVethPair struct { + XXX_unrecognized []byte `json:"-"` + } + +-func (m *CriuVethPair) Reset() { *m = CriuVethPair{} } +-func (m *CriuVethPair) String() string { return proto.CompactTextString(m) } +-func (*CriuVethPair) ProtoMessage() {} ++func (m *CriuVethPair) Reset() { *m = CriuVethPair{} } ++func (m *CriuVethPair) String() string { return proto.CompactTextString(m) } ++func (*CriuVethPair) ProtoMessage() {} ++func (*CriuVethPair) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } + + func (m *CriuVethPair) GetIfIn() string { + if m != nil && m.IfIn != nil { +@@ -207,9 +220,10 @@ type ExtMountMap struct { + XXX_unrecognized []byte `json:"-"` + } + +-func (m *ExtMountMap) Reset() { *m = ExtMountMap{} } +-func (m *ExtMountMap) String() string { return proto.CompactTextString(m) } +-func (*ExtMountMap) ProtoMessage() {} ++func (m *ExtMountMap) Reset() { *m = ExtMountMap{} } ++func (m *ExtMountMap) String() string { return proto.CompactTextString(m) } ++func (*ExtMountMap) ProtoMessage() {} ++func (*ExtMountMap) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } + + func (m *ExtMountMap) GetKey() string { + if m != nil && m.Key != nil { +@@ -225,15 +239,49 @@ func (m *ExtMountMap) GetVal() string { + return "" + } + ++type JoinNamespace struct { ++ Ns *string `protobuf:"bytes,1,req,name=ns" json:"ns,omitempty"` ++ NsFile *string `protobuf:"bytes,2,req,name=ns_file" json:"ns_file,omitempty"` ++ ExtraOpt *string `protobuf:"bytes,3,opt,name=extra_opt" json:"extra_opt,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *JoinNamespace) Reset() { *m = JoinNamespace{} } ++func (m *JoinNamespace) String() string { return proto.CompactTextString(m) } ++func (*JoinNamespace) ProtoMessage() {} ++func (*JoinNamespace) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } ++ ++func (m *JoinNamespace) GetNs() string { ++ if m != nil && m.Ns != nil { ++ return *m.Ns ++ } ++ return "" ++} ++ ++func (m *JoinNamespace) GetNsFile() string { ++ if m != nil && m.NsFile != nil { ++ return *m.NsFile ++ } ++ return "" ++} ++ ++func (m *JoinNamespace) GetExtraOpt() string { ++ if m != nil && m.ExtraOpt != nil { ++ return *m.ExtraOpt ++ } ++ return "" ++} ++ + type InheritFd struct { + Key *string `protobuf:"bytes,1,req,name=key" json:"key,omitempty"` + Fd *int32 `protobuf:"varint,2,req,name=fd" json:"fd,omitempty"` + XXX_unrecognized []byte `json:"-"` + } + +-func (m *InheritFd) Reset() { *m = InheritFd{} } +-func (m *InheritFd) String() string { return proto.CompactTextString(m) } +-func (*InheritFd) ProtoMessage() {} ++func (m *InheritFd) Reset() { *m = InheritFd{} } ++func (m *InheritFd) String() string { return proto.CompactTextString(m) } ++func (*InheritFd) ProtoMessage() {} ++func (*InheritFd) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } + + func (m *InheritFd) GetKey() string { + if m != nil && m.Key != nil { +@@ -255,9 +303,10 @@ type CgroupRoot struct { + XXX_unrecognized []byte `json:"-"` + } + +-func (m *CgroupRoot) Reset() { *m = CgroupRoot{} } +-func (m *CgroupRoot) String() string { return proto.CompactTextString(m) } +-func (*CgroupRoot) ProtoMessage() {} ++func (m *CgroupRoot) Reset() { *m = CgroupRoot{} } ++func (m *CgroupRoot) String() string { return proto.CompactTextString(m) } ++func (*CgroupRoot) ProtoMessage() {} ++func (*CgroupRoot) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } + + func (m *CgroupRoot) GetCtrl() string { + if m != nil && m.Ctrl != nil { +@@ -278,9 +327,10 @@ type UnixSk struct { + XXX_unrecognized []byte `json:"-"` + } + +-func (m *UnixSk) Reset() { *m = UnixSk{} } +-func (m *UnixSk) String() string { return proto.CompactTextString(m) } +-func (*UnixSk) ProtoMessage() {} ++func (m *UnixSk) Reset() { *m = UnixSk{} } ++func (m *UnixSk) String() string { return proto.CompactTextString(m) } ++func (*UnixSk) ProtoMessage() {} ++func (*UnixSk) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } + + func (m *UnixSk) GetInode() uint32 { + if m != nil && m.Inode != nil { +@@ -290,51 +340,62 @@ func (m *UnixSk) GetInode() uint32 { + } + + type CriuOpts struct { +- ImagesDirFd *int32 `protobuf:"varint,1,req,name=images_dir_fd" json:"images_dir_fd,omitempty"` +- Pid *int32 `protobuf:"varint,2,opt,name=pid" json:"pid,omitempty"` +- LeaveRunning *bool `protobuf:"varint,3,opt,name=leave_running" json:"leave_running,omitempty"` +- ExtUnixSk *bool `protobuf:"varint,4,opt,name=ext_unix_sk" json:"ext_unix_sk,omitempty"` +- TcpEstablished *bool `protobuf:"varint,5,opt,name=tcp_established" json:"tcp_established,omitempty"` +- EvasiveDevices *bool `protobuf:"varint,6,opt,name=evasive_devices" json:"evasive_devices,omitempty"` +- ShellJob *bool `protobuf:"varint,7,opt,name=shell_job" json:"shell_job,omitempty"` +- FileLocks *bool `protobuf:"varint,8,opt,name=file_locks" json:"file_locks,omitempty"` +- LogLevel *int32 `protobuf:"varint,9,opt,name=log_level,def=2" json:"log_level,omitempty"` +- LogFile *string `protobuf:"bytes,10,opt,name=log_file" json:"log_file,omitempty"` +- Ps *CriuPageServerInfo `protobuf:"bytes,11,opt,name=ps" json:"ps,omitempty"` +- NotifyScripts *bool `protobuf:"varint,12,opt,name=notify_scripts" json:"notify_scripts,omitempty"` +- Root *string `protobuf:"bytes,13,opt,name=root" json:"root,omitempty"` +- ParentImg *string `protobuf:"bytes,14,opt,name=parent_img" json:"parent_img,omitempty"` +- TrackMem *bool `protobuf:"varint,15,opt,name=track_mem" json:"track_mem,omitempty"` +- AutoDedup *bool `protobuf:"varint,16,opt,name=auto_dedup" json:"auto_dedup,omitempty"` +- WorkDirFd *int32 `protobuf:"varint,17,opt,name=work_dir_fd" json:"work_dir_fd,omitempty"` +- LinkRemap *bool `protobuf:"varint,18,opt,name=link_remap" json:"link_remap,omitempty"` +- Veths []*CriuVethPair `protobuf:"bytes,19,rep,name=veths" json:"veths,omitempty"` +- CpuCap *uint32 `protobuf:"varint,20,opt,name=cpu_cap,def=4294967295" json:"cpu_cap,omitempty"` +- ForceIrmap *bool `protobuf:"varint,21,opt,name=force_irmap" json:"force_irmap,omitempty"` +- ExecCmd []string `protobuf:"bytes,22,rep,name=exec_cmd" json:"exec_cmd,omitempty"` +- ExtMnt []*ExtMountMap `protobuf:"bytes,23,rep,name=ext_mnt" json:"ext_mnt,omitempty"` +- ManageCgroups *bool `protobuf:"varint,24,opt,name=manage_cgroups" json:"manage_cgroups,omitempty"` +- CgRoot []*CgroupRoot `protobuf:"bytes,25,rep,name=cg_root" json:"cg_root,omitempty"` +- RstSibling *bool `protobuf:"varint,26,opt,name=rst_sibling" json:"rst_sibling,omitempty"` +- InheritFd []*InheritFd `protobuf:"bytes,27,rep,name=inherit_fd" json:"inherit_fd,omitempty"` +- AutoExtMnt *bool `protobuf:"varint,28,opt,name=auto_ext_mnt" json:"auto_ext_mnt,omitempty"` +- ExtSharing *bool `protobuf:"varint,29,opt,name=ext_sharing" json:"ext_sharing,omitempty"` +- ExtMasters *bool `protobuf:"varint,30,opt,name=ext_masters" json:"ext_masters,omitempty"` +- SkipMnt []string `protobuf:"bytes,31,rep,name=skip_mnt" json:"skip_mnt,omitempty"` +- EnableFs []string `protobuf:"bytes,32,rep,name=enable_fs" json:"enable_fs,omitempty"` +- UnixSkIno []*UnixSk `protobuf:"bytes,33,rep,name=unix_sk_ino" json:"unix_sk_ino,omitempty"` +- ManageCgroupsMode *CriuCgMode `protobuf:"varint,34,opt,name=manage_cgroups_mode,enum=CriuCgMode" json:"manage_cgroups_mode,omitempty"` +- GhostLimit *uint32 `protobuf:"varint,35,opt,name=ghost_limit,def=1048576" json:"ghost_limit,omitempty"` +- IrmapScanPaths []string `protobuf:"bytes,36,rep,name=irmap_scan_paths" json:"irmap_scan_paths,omitempty"` +- External []string `protobuf:"bytes,37,rep,name=external" json:"external,omitempty"` +- EmptyNs *uint32 `protobuf:"varint,38,opt,name=empty_ns" json:"empty_ns,omitempty"` +- NoSeccomp *bool `protobuf:"varint,39,opt,name=no_seccomp" json:"no_seccomp,omitempty"` +- XXX_unrecognized []byte `json:"-"` +-} +- +-func (m *CriuOpts) Reset() { *m = CriuOpts{} } +-func (m *CriuOpts) String() string { return proto.CompactTextString(m) } +-func (*CriuOpts) ProtoMessage() {} ++ ImagesDirFd *int32 `protobuf:"varint,1,req,name=images_dir_fd" json:"images_dir_fd,omitempty"` ++ Pid *int32 `protobuf:"varint,2,opt,name=pid" json:"pid,omitempty"` ++ LeaveRunning *bool `protobuf:"varint,3,opt,name=leave_running" json:"leave_running,omitempty"` ++ ExtUnixSk *bool `protobuf:"varint,4,opt,name=ext_unix_sk" json:"ext_unix_sk,omitempty"` ++ TcpEstablished *bool `protobuf:"varint,5,opt,name=tcp_established" json:"tcp_established,omitempty"` ++ EvasiveDevices *bool `protobuf:"varint,6,opt,name=evasive_devices" json:"evasive_devices,omitempty"` ++ ShellJob *bool `protobuf:"varint,7,opt,name=shell_job" json:"shell_job,omitempty"` ++ FileLocks *bool `protobuf:"varint,8,opt,name=file_locks" json:"file_locks,omitempty"` ++ LogLevel *int32 `protobuf:"varint,9,opt,name=log_level,def=2" json:"log_level,omitempty"` ++ LogFile *string `protobuf:"bytes,10,opt,name=log_file" json:"log_file,omitempty"` ++ Ps *CriuPageServerInfo `protobuf:"bytes,11,opt,name=ps" json:"ps,omitempty"` ++ NotifyScripts *bool `protobuf:"varint,12,opt,name=notify_scripts" json:"notify_scripts,omitempty"` ++ Root *string `protobuf:"bytes,13,opt,name=root" json:"root,omitempty"` ++ ParentImg *string `protobuf:"bytes,14,opt,name=parent_img" json:"parent_img,omitempty"` ++ TrackMem *bool `protobuf:"varint,15,opt,name=track_mem" json:"track_mem,omitempty"` ++ AutoDedup *bool `protobuf:"varint,16,opt,name=auto_dedup" json:"auto_dedup,omitempty"` ++ WorkDirFd *int32 `protobuf:"varint,17,opt,name=work_dir_fd" json:"work_dir_fd,omitempty"` ++ LinkRemap *bool `protobuf:"varint,18,opt,name=link_remap" json:"link_remap,omitempty"` ++ Veths []*CriuVethPair `protobuf:"bytes,19,rep,name=veths" json:"veths,omitempty"` ++ CpuCap *uint32 `protobuf:"varint,20,opt,name=cpu_cap,def=4294967295" json:"cpu_cap,omitempty"` ++ ForceIrmap *bool `protobuf:"varint,21,opt,name=force_irmap" json:"force_irmap,omitempty"` ++ ExecCmd []string `protobuf:"bytes,22,rep,name=exec_cmd" json:"exec_cmd,omitempty"` ++ ExtMnt []*ExtMountMap `protobuf:"bytes,23,rep,name=ext_mnt" json:"ext_mnt,omitempty"` ++ ManageCgroups *bool `protobuf:"varint,24,opt,name=manage_cgroups" json:"manage_cgroups,omitempty"` ++ CgRoot []*CgroupRoot `protobuf:"bytes,25,rep,name=cg_root" json:"cg_root,omitempty"` ++ RstSibling *bool `protobuf:"varint,26,opt,name=rst_sibling" json:"rst_sibling,omitempty"` ++ InheritFd []*InheritFd `protobuf:"bytes,27,rep,name=inherit_fd" json:"inherit_fd,omitempty"` ++ AutoExtMnt *bool `protobuf:"varint,28,opt,name=auto_ext_mnt" json:"auto_ext_mnt,omitempty"` ++ ExtSharing *bool `protobuf:"varint,29,opt,name=ext_sharing" json:"ext_sharing,omitempty"` ++ ExtMasters *bool `protobuf:"varint,30,opt,name=ext_masters" json:"ext_masters,omitempty"` ++ SkipMnt []string `protobuf:"bytes,31,rep,name=skip_mnt" json:"skip_mnt,omitempty"` ++ EnableFs []string `protobuf:"bytes,32,rep,name=enable_fs" json:"enable_fs,omitempty"` ++ UnixSkIno []*UnixSk `protobuf:"bytes,33,rep,name=unix_sk_ino" json:"unix_sk_ino,omitempty"` ++ ManageCgroupsMode *CriuCgMode `protobuf:"varint,34,opt,name=manage_cgroups_mode,enum=CriuCgMode" json:"manage_cgroups_mode,omitempty"` ++ GhostLimit *uint32 `protobuf:"varint,35,opt,name=ghost_limit,def=1048576" json:"ghost_limit,omitempty"` ++ IrmapScanPaths []string `protobuf:"bytes,36,rep,name=irmap_scan_paths" json:"irmap_scan_paths,omitempty"` ++ External []string `protobuf:"bytes,37,rep,name=external" json:"external,omitempty"` ++ EmptyNs *uint32 `protobuf:"varint,38,opt,name=empty_ns" json:"empty_ns,omitempty"` ++ JoinNs []*JoinNamespace `protobuf:"bytes,39,rep,name=join_ns" json:"join_ns,omitempty"` ++ CgroupProps *string `protobuf:"bytes,41,opt,name=cgroup_props" json:"cgroup_props,omitempty"` ++ CgroupPropsFile *string `protobuf:"bytes,42,opt,name=cgroup_props_file" json:"cgroup_props_file,omitempty"` ++ CgroupDumpController []string `protobuf:"bytes,43,rep,name=cgroup_dump_controller" json:"cgroup_dump_controller,omitempty"` ++ FreezeCgroup *string `protobuf:"bytes,44,opt,name=freeze_cgroup" json:"freeze_cgroup,omitempty"` ++ Timeout *uint32 `protobuf:"varint,45,opt,name=timeout" json:"timeout,omitempty"` ++ TcpSkipInFlight *bool `protobuf:"varint,46,opt,name=tcp_skip_in_flight" json:"tcp_skip_in_flight,omitempty"` ++ WeakSysctls *bool `protobuf:"varint,47,opt,name=weak_sysctls" json:"weak_sysctls,omitempty"` ++ LazyPages *bool `protobuf:"varint,48,opt,name=lazy_pages" json:"lazy_pages,omitempty"` ++ StatusFd *int32 `protobuf:"varint,49,opt,name=status_fd" json:"status_fd,omitempty"` ++ OrphanPtsMaster *bool `protobuf:"varint,50,opt,name=orphan_pts_master" json:"orphan_pts_master,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *CriuOpts) Reset() { *m = CriuOpts{} } ++func (m *CriuOpts) String() string { return proto.CompactTextString(m) } ++func (*CriuOpts) ProtoMessage() {} ++func (*CriuOpts) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } + + const Default_CriuOpts_LogLevel int32 = 2 + const Default_CriuOpts_CpuCap uint32 = 4294967295 +@@ -606,9 +667,79 @@ func (m *CriuOpts) GetEmptyNs() uint32 { + return 0 + } + +-func (m *CriuOpts) GetNoSeccomp() bool { +- if m != nil && m.NoSeccomp != nil { +- return *m.NoSeccomp ++func (m *CriuOpts) GetJoinNs() []*JoinNamespace { ++ if m != nil { ++ return m.JoinNs ++ } ++ return nil ++} ++ ++func (m *CriuOpts) GetCgroupProps() string { ++ if m != nil && m.CgroupProps != nil { ++ return *m.CgroupProps ++ } ++ return "" ++} ++ ++func (m *CriuOpts) GetCgroupPropsFile() string { ++ if m != nil && m.CgroupPropsFile != nil { ++ return *m.CgroupPropsFile ++ } ++ return "" ++} ++ ++func (m *CriuOpts) GetCgroupDumpController() []string { ++ if m != nil { ++ return m.CgroupDumpController ++ } ++ return nil ++} ++ ++func (m *CriuOpts) GetFreezeCgroup() string { ++ if m != nil && m.FreezeCgroup != nil { ++ return *m.FreezeCgroup ++ } ++ return "" ++} ++ ++func (m *CriuOpts) GetTimeout() uint32 { ++ if m != nil && m.Timeout != nil { ++ return *m.Timeout ++ } ++ return 0 ++} ++ ++func (m *CriuOpts) GetTcpSkipInFlight() bool { ++ if m != nil && m.TcpSkipInFlight != nil { ++ return *m.TcpSkipInFlight ++ } ++ return false ++} ++ ++func (m *CriuOpts) GetWeakSysctls() bool { ++ if m != nil && m.WeakSysctls != nil { ++ return *m.WeakSysctls ++ } ++ return false ++} ++ ++func (m *CriuOpts) GetLazyPages() bool { ++ if m != nil && m.LazyPages != nil { ++ return *m.LazyPages ++ } ++ return false ++} ++ ++func (m *CriuOpts) GetStatusFd() int32 { ++ if m != nil && m.StatusFd != nil { ++ return *m.StatusFd ++ } ++ return 0 ++} ++ ++func (m *CriuOpts) GetOrphanPtsMaster() bool { ++ if m != nil && m.OrphanPtsMaster != nil { ++ return *m.OrphanPtsMaster + } + return false + } +@@ -618,9 +749,10 @@ type CriuDumpResp struct { + XXX_unrecognized []byte `json:"-"` + } + +-func (m *CriuDumpResp) Reset() { *m = CriuDumpResp{} } +-func (m *CriuDumpResp) String() string { return proto.CompactTextString(m) } +-func (*CriuDumpResp) ProtoMessage() {} ++func (m *CriuDumpResp) Reset() { *m = CriuDumpResp{} } ++func (m *CriuDumpResp) String() string { return proto.CompactTextString(m) } ++func (*CriuDumpResp) ProtoMessage() {} ++func (*CriuDumpResp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } + + func (m *CriuDumpResp) GetRestored() bool { + if m != nil && m.Restored != nil { +@@ -634,9 +766,10 @@ type CriuRestoreResp struct { + XXX_unrecognized []byte `json:"-"` + } + +-func (m *CriuRestoreResp) Reset() { *m = CriuRestoreResp{} } +-func (m *CriuRestoreResp) String() string { return proto.CompactTextString(m) } +-func (*CriuRestoreResp) ProtoMessage() {} ++func (m *CriuRestoreResp) Reset() { *m = CriuRestoreResp{} } ++func (m *CriuRestoreResp) String() string { return proto.CompactTextString(m) } ++func (*CriuRestoreResp) ProtoMessage() {} ++func (*CriuRestoreResp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } + + func (m *CriuRestoreResp) GetPid() int32 { + if m != nil && m.Pid != nil { +@@ -651,9 +784,10 @@ type CriuNotify struct { + XXX_unrecognized []byte `json:"-"` + } + +-func (m *CriuNotify) Reset() { *m = CriuNotify{} } +-func (m *CriuNotify) String() string { return proto.CompactTextString(m) } +-func (*CriuNotify) ProtoMessage() {} ++func (m *CriuNotify) Reset() { *m = CriuNotify{} } ++func (m *CriuNotify) String() string { return proto.CompactTextString(m) } ++func (*CriuNotify) ProtoMessage() {} ++func (*CriuNotify) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } + + func (m *CriuNotify) GetScript() string { + if m != nil && m.Script != nil { +@@ -677,9 +811,10 @@ type CriuFeatures struct { + XXX_unrecognized []byte `json:"-"` + } + +-func (m *CriuFeatures) Reset() { *m = CriuFeatures{} } +-func (m *CriuFeatures) String() string { return proto.CompactTextString(m) } +-func (*CriuFeatures) ProtoMessage() {} ++func (m *CriuFeatures) Reset() { *m = CriuFeatures{} } ++func (m *CriuFeatures) String() string { return proto.CompactTextString(m) } ++func (*CriuFeatures) ProtoMessage() {} ++func (*CriuFeatures) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } + + func (m *CriuFeatures) GetMemTrack() bool { + if m != nil && m.MemTrack != nil { +@@ -705,9 +840,10 @@ type CriuReq struct { + XXX_unrecognized []byte `json:"-"` + } + +-func (m *CriuReq) Reset() { *m = CriuReq{} } +-func (m *CriuReq) String() string { return proto.CompactTextString(m) } +-func (*CriuReq) ProtoMessage() {} ++func (m *CriuReq) Reset() { *m = CriuReq{} } ++func (m *CriuReq) String() string { return proto.CompactTextString(m) } ++func (*CriuReq) ProtoMessage() {} ++func (*CriuReq) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } + + func (m *CriuReq) GetType() CriuReqType { + if m != nil && m.Type != nil { +@@ -753,12 +889,14 @@ type CriuResp struct { + Ps *CriuPageServerInfo `protobuf:"bytes,6,opt,name=ps" json:"ps,omitempty"` + CrErrno *int32 `protobuf:"varint,7,opt,name=cr_errno" json:"cr_errno,omitempty"` + Features *CriuFeatures `protobuf:"bytes,8,opt,name=features" json:"features,omitempty"` ++ CrErrmsg *string `protobuf:"bytes,9,opt,name=cr_errmsg" json:"cr_errmsg,omitempty"` + XXX_unrecognized []byte `json:"-"` + } + +-func (m *CriuResp) Reset() { *m = CriuResp{} } +-func (m *CriuResp) String() string { return proto.CompactTextString(m) } +-func (*CriuResp) ProtoMessage() {} ++func (m *CriuResp) Reset() { *m = CriuResp{} } ++func (m *CriuResp) String() string { return proto.CompactTextString(m) } ++func (*CriuResp) ProtoMessage() {} ++func (*CriuResp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } + + func (m *CriuResp) GetType() CriuReqType { + if m != nil && m.Type != nil { +@@ -816,7 +954,116 @@ func (m *CriuResp) GetFeatures() *CriuFeatures { + return nil + } + ++func (m *CriuResp) GetCrErrmsg() string { ++ if m != nil && m.CrErrmsg != nil { ++ return *m.CrErrmsg ++ } ++ return "" ++} ++ + func init() { ++ proto.RegisterType((*CriuPageServerInfo)(nil), "criu_page_server_info") ++ proto.RegisterType((*CriuVethPair)(nil), "criu_veth_pair") ++ proto.RegisterType((*ExtMountMap)(nil), "ext_mount_map") ++ proto.RegisterType((*JoinNamespace)(nil), "join_namespace") ++ proto.RegisterType((*InheritFd)(nil), "inherit_fd") ++ proto.RegisterType((*CgroupRoot)(nil), "cgroup_root") ++ proto.RegisterType((*UnixSk)(nil), "unix_sk") ++ proto.RegisterType((*CriuOpts)(nil), "criu_opts") ++ proto.RegisterType((*CriuDumpResp)(nil), "criu_dump_resp") ++ proto.RegisterType((*CriuRestoreResp)(nil), "criu_restore_resp") ++ proto.RegisterType((*CriuNotify)(nil), "criu_notify") ++ proto.RegisterType((*CriuFeatures)(nil), "criu_features") ++ proto.RegisterType((*CriuReq)(nil), "criu_req") ++ proto.RegisterType((*CriuResp)(nil), "criu_resp") + proto.RegisterEnum("CriuCgMode", CriuCgMode_name, CriuCgMode_value) + proto.RegisterEnum("CriuReqType", CriuReqType_name, CriuReqType_value) + } ++ ++func init() { proto.RegisterFile("criurpc.proto", fileDescriptor0) } ++ ++var fileDescriptor0 = []byte{ ++ // 1297 bytes of a gzipped FileDescriptorProto ++ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x7c, 0x56, 0xdb, 0x77, 0xd3, 0xc6, ++ 0x13, 0xfe, 0xc5, 0x71, 0x7c, 0x59, 0x5f, 0x22, 0x04, 0x84, 0xe5, 0x9e, 0x9f, 0x28, 0x6d, 0x49, ++ 0x5b, 0x03, 0x3e, 0x5c, 0x0a, 0x4f, 0xe5, 0x04, 0x87, 0xe6, 0x14, 0x62, 0x1f, 0xc7, 0xe9, 0x39, ++ 0x3c, 0xed, 0x11, 0xd2, 0xda, 0x5e, 0x2c, 0x69, 0xd5, 0xdd, 0x95, 0x21, 0xfc, 0x03, 0x7d, 0xec, ++ 0x63, 0x1f, 0xfb, 0xaf, 0x76, 0x76, 0x24, 0x05, 0x41, 0x39, 0xbc, 0x80, 0x35, 0x9a, 0xcb, 0x37, ++ 0xdf, 0xcc, 0x7c, 0x0a, 0xe9, 0x05, 0x4a, 0x64, 0x2a, 0x0d, 0x06, 0xa9, 0x92, 0x46, 0x7a, 0x63, ++ 0x72, 0xd1, 0x1a, 0x58, 0xea, 0x2f, 0x38, 0xd3, 0x5c, 0xad, 0xb9, 0x62, 0x22, 0x99, 0x4b, 0x77, ++ 0x9b, 0x34, 0xfd, 0x30, 0x54, 0x5c, 0x6b, 0xba, 0xb1, 0xbb, 0xf1, 0x7d, 0xdb, 0xed, 0x92, 0x7a, ++ 0x2a, 0x95, 0xa1, 0x35, 0x78, 0xda, 0x72, 0x3b, 0x64, 0x33, 0x15, 0x21, 0xdd, 0xc4, 0x07, 0x42, ++ 0x6a, 0xf3, 0x90, 0xd6, 0xed, 0x6f, 0xef, 0x2e, 0xe9, 0x63, 0xc2, 0x35, 0x37, 0x4b, 0xc8, 0x2a, ++ 0x94, 0xdb, 0x23, 0x5b, 0x62, 0x0e, 0x49, 0x21, 0x4f, 0x0d, 0xf2, 0xf4, 0x49, 0x03, 0x1e, 0x65, ++ 0x66, 0x33, 0xc1, 0xb3, 0x77, 0x87, 0xf4, 0xf8, 0x7b, 0xc3, 0x62, 0x99, 0x25, 0xf0, 0xaf, 0x9f, ++ 0xda, 0xd4, 0x2b, 0x7e, 0x5a, 0x78, 0xc3, 0xc3, 0xda, 0x8f, 0x0a, 0xd7, 0x5f, 0x48, 0xff, 0xad, ++ 0x14, 0x09, 0x4b, 0xfc, 0x98, 0xeb, 0xd4, 0x0f, 0xb8, 0xad, 0x9c, 0xe8, 0xc2, 0x15, 0x10, 0x27, ++ 0x9a, 0xcd, 0x45, 0xc4, 0x73, 0x77, 0xf7, 0x1c, 0x69, 0x43, 0x66, 0xe5, 0x33, 0x99, 0x1a, 0x44, ++ 0xda, 0xf6, 0x6e, 0x13, 0x22, 0x92, 0x25, 0x57, 0xc2, 0xb0, 0x79, 0xf8, 0x69, 0xa5, 0xbc, 0x09, ++ 0x1b, 0xb9, 0x05, 0x98, 0x3a, 0xc1, 0x42, 0xc9, 0x2c, 0x65, 0x4a, 0x4a, 0x63, 0x5b, 0x0f, 0x8c, ++ 0x8a, 0x2a, 0x44, 0xf8, 0x66, 0x59, 0x60, 0xa2, 0xa4, 0x99, 0x25, 0xe2, 0x3d, 0xd3, 0x2b, 0x6c, ++ 0x34, 0x91, 0x21, 0xc7, 0x84, 0x3d, 0xef, 0xef, 0x36, 0x69, 0x23, 0x15, 0x50, 0x5e, 0xbb, 0x17, ++ 0x49, 0x4f, 0xc4, 0x40, 0xb2, 0x66, 0xa1, 0x50, 0x50, 0x1c, 0x9d, 0xce, 0x78, 0xcc, 0x49, 0x05, ++ 0x9f, 0x88, 0xfb, 0x6b, 0xce, 0x54, 0x96, 0x24, 0x22, 0x59, 0x20, 0xe8, 0x96, 0x7b, 0x9e, 0x74, ++ 0x2c, 0x43, 0x45, 0x19, 0xe4, 0xb9, 0xe5, 0x5e, 0x22, 0xdb, 0x26, 0x48, 0x19, 0xd7, 0xc6, 0x7f, ++ 0x13, 0x09, 0xbd, 0xe4, 0x21, 0xdd, 0x2a, 0x5f, 0xf0, 0xb5, 0xaf, 0x05, 0xa4, 0x09, 0xf9, 0x5a, ++ 0x04, 0x5c, 0xd3, 0x06, 0xbe, 0x00, 0x3a, 0xc0, 0x2d, 0x8a, 0xd8, 0x5b, 0xf9, 0x86, 0x36, 0xd1, ++ 0x04, 0x4d, 0x5b, 0xbe, 0x58, 0x24, 0x83, 0x95, 0xa6, 0x2d, 0xb4, 0x5d, 0x20, 0xed, 0x48, 0x2e, ++ 0x58, 0xc4, 0xd7, 0x3c, 0xa2, 0x6d, 0x8b, 0xeb, 0xe9, 0xc6, 0xd0, 0x75, 0x48, 0xcb, 0x5a, 0x91, ++ 0x5d, 0x82, 0x34, 0x78, 0xa4, 0x96, 0x6a, 0xda, 0x81, 0xdf, 0x9d, 0xe1, 0xce, 0xe0, 0xcb, 0x4b, ++ 0xb4, 0x43, 0xfa, 0x89, 0x34, 0x62, 0x7e, 0xca, 0x34, 0x38, 0x00, 0x0d, 0xb4, 0x8b, 0x35, 0x80, ++ 0x42, 0x4b, 0x2c, 0xed, 0x61, 0x26, 0x40, 0x91, 0xfa, 0x8a, 0xc3, 0xf8, 0x45, 0xbc, 0xa0, 0x7d, ++ 0xb4, 0x01, 0x58, 0x98, 0x5c, 0xb0, 0x62, 0x31, 0x8f, 0xe9, 0x76, 0x09, 0xd6, 0xcf, 0x8c, 0x84, ++ 0xae, 0xc2, 0x2c, 0xa5, 0x4e, 0x49, 0xcd, 0x3b, 0xa9, 0x56, 0x25, 0xa7, 0xe7, 0x90, 0x46, 0x70, ++ 0x8c, 0x44, 0xb2, 0x62, 0x8a, 0xc3, 0x3a, 0x51, 0x17, 0x1d, 0x6f, 0x90, 0x2d, 0xbb, 0x91, 0x9a, ++ 0x9e, 0xdf, 0xdd, 0x04, 0xc0, 0xdb, 0x83, 0xcf, 0x96, 0xf4, 0x2a, 0x69, 0x06, 0x69, 0xc6, 0x02, ++ 0x08, 0xb8, 0x00, 0x01, 0xbd, 0xa7, 0xe4, 0xc1, 0xf0, 0xc9, 0x83, 0x27, 0x8f, 0x1e, 0x0f, 0x9f, ++ 0x3c, 0xb4, 0x55, 0xe6, 0x52, 0x05, 0x9c, 0x09, 0x65, 0x33, 0x5e, 0xc4, 0x8c, 0xc0, 0x08, 0x7f, ++ 0xcf, 0x03, 0x16, 0xc4, 0x21, 0xdd, 0x81, 0xa4, 0x6d, 0xf7, 0x26, 0x69, 0xe2, 0x26, 0x27, 0x86, ++ 0x5e, 0xc2, 0x2a, 0xfd, 0xc1, 0xa7, 0x9b, 0x0d, 0x74, 0xc4, 0x7e, 0x62, 0x49, 0xca, 0xb7, 0x4b, ++ 0x53, 0x8a, 0xa9, 0xae, 0x43, 0xf1, 0x05, 0xae, 0x1a, 0xbd, 0x8c, 0x81, 0xdd, 0x41, 0x75, 0xfd, ++ 0xa0, 0xbc, 0xd2, 0x86, 0x69, 0x01, 0x83, 0x86, 0xa5, 0xb8, 0x82, 0x31, 0x37, 0xab, 0x9b, 0x4c, ++ 0xaf, 0x62, 0x58, 0x67, 0x50, 0x59, 0xee, 0x0b, 0xa4, 0x8b, 0x74, 0x95, 0x90, 0xae, 0x55, 0x77, ++ 0x49, 0x2f, 0x7d, 0x65, 0x73, 0x5d, 0xaf, 0x1a, 0x63, 0x5f, 0x1b, 0xae, 0x34, 0xbd, 0x51, 0xf6, ++ 0xa7, 0x57, 0x22, 0xc5, 0xd8, 0x9b, 0xd8, 0x9f, 0xbd, 0xa7, 0x04, 0xb6, 0x8d, 0xb3, 0xb9, 0xa6, ++ 0xbb, 0x68, 0xba, 0x4e, 0x3a, 0xc5, 0x5a, 0xc2, 0xc0, 0x25, 0xfd, 0x3f, 0xc2, 0x68, 0x0d, 0xca, ++ 0x8b, 0xd8, 0x23, 0xe7, 0x3f, 0x6d, 0x18, 0xc8, 0x80, 0xfb, 0xf0, 0xa0, 0x40, 0x7f, 0xd8, 0xcb, ++ 0x67, 0x00, 0x9d, 0x5b, 0xa3, 0x7b, 0x8d, 0x74, 0x16, 0x4b, 0x09, 0x7d, 0x46, 0x22, 0x16, 0x86, ++ 0xde, 0xc2, 0x29, 0x34, 0xef, 0xdf, 0x7b, 0xf0, 0xf3, 0xc3, 0xc7, 0x8f, 0x5c, 0x4a, 0x1c, 0x24, ++ 0x1f, 0x16, 0xc9, 0x4f, 0x98, 0xbd, 0x3f, 0x4d, 0xbf, 0x41, 0x08, 0x38, 0x07, 0xc0, 0x9d, 0x80, ++ 0x4c, 0xdc, 0x3e, 0xb3, 0xc4, 0xa9, 0x39, 0x65, 0x20, 0x0d, 0xdf, 0xda, 0x34, 0xee, 0x2e, 0x69, ++ 0xe6, 0xc2, 0xa1, 0xe9, 0x77, 0xc5, 0xfc, 0x3f, 0x13, 0x12, 0x60, 0xab, 0xa0, 0x1c, 0x74, 0x11, ++ 0x06, 0x73, 0x07, 0xb7, 0xf0, 0x32, 0x39, 0x57, 0xb5, 0xe6, 0xeb, 0xbf, 0x87, 0xaf, 0x6e, 0x90, ++ 0x9d, 0xe2, 0x55, 0x98, 0xc5, 0x29, 0x0b, 0x64, 0x62, 0x94, 0x8c, 0x22, 0xae, 0xe8, 0x0f, 0x08, ++ 0x02, 0x6e, 0x79, 0xae, 0x38, 0xff, 0x50, 0xb6, 0x4e, 0x7f, 0xc4, 0x30, 0x10, 0x29, 0x23, 0x62, ++ 0x6e, 0xe5, 0xef, 0x27, 0x84, 0x76, 0x85, 0xb8, 0xf6, 0x8e, 0x91, 0x6a, 0x40, 0x34, 0x8f, 0xc4, ++ 0x62, 0x69, 0xe8, 0xa0, 0x38, 0xc5, 0xee, 0x3b, 0xee, 0xaf, 0x98, 0x3e, 0xd5, 0x81, 0x89, 0x34, ++ 0xbd, 0x5b, 0xde, 0x41, 0xe4, 0x7f, 0x38, 0xc5, 0x6b, 0xd3, 0xf4, 0xde, 0xd9, 0x6d, 0x1b, 0xdf, ++ 0x64, 0xda, 0x2e, 0xc3, 0x7d, 0xbc, 0x02, 0xc0, 0x2e, 0x55, 0xba, 0xb4, 0x6c, 0x19, 0x5d, 0xcc, ++ 0x96, 0x0e, 0xad, 0xb7, 0xe7, 0x15, 0x1a, 0x8d, 0xc8, 0x41, 0xe2, 0x53, 0x4b, 0x19, 0xfc, 0x6f, ++ 0xa4, 0xe2, 0x21, 0xaa, 0x5c, 0xcb, 0xdb, 0x85, 0xd6, 0xad, 0x4f, 0x61, 0xce, 0xdd, 0x0a, 0xb5, ++ 0x42, 0xe9, 0xf2, 0xf6, 0x40, 0x24, 0xad, 0x47, 0x7e, 0xe1, 0x56, 0xd7, 0xf3, 0x23, 0x2f, 0x64, ++ 0xb2, 0xaa, 0x6c, 0x50, 0x11, 0xbf, 0x3b, 0x6c, 0xce, 0x01, 0x24, 0xa4, 0xb2, 0x80, 0xe1, 0xb2, ++ 0x19, 0xde, 0x78, 0x51, 0xf1, 0xaf, 0x0d, 0xd2, 0x2a, 0x4a, 0xfe, 0x01, 0xdb, 0x50, 0x37, 0xa7, ++ 0x69, 0x2e, 0xa5, 0x7d, 0x38, 0xa4, 0xf2, 0x05, 0xb3, 0x56, 0xd8, 0x86, 0xba, 0x15, 0x55, 0x4c, ++ 0xde, 0x19, 0x92, 0xc1, 0x47, 0x99, 0xad, 0x28, 0x4e, 0x16, 0x04, 0xf6, 0xeb, 0xb5, 0x59, 0x12, ++ 0xb4, 0xe2, 0x3c, 0x05, 0x27, 0x9e, 0x14, 0x0a, 0xba, 0x4b, 0x5a, 0x25, 0x1c, 0x94, 0xce, 0x4e, ++ 0x59, 0xa6, 0xb4, 0x7a, 0x7f, 0xd6, 0x0a, 0x05, 0xc7, 0xe6, 0xbf, 0x0e, 0x09, 0x06, 0x5b, 0x56, ++ 0xb4, 0x1f, 0x06, 0x7b, 0xd4, 0x75, 0xcb, 0x2f, 0xd6, 0x3f, 0x13, 0x9c, 0x8f, 0x8c, 0xdf, 0x22, ++ 0xcd, 0x82, 0x5a, 0x84, 0xd3, 0x19, 0xba, 0x83, 0xff, 0xf2, 0x7d, 0x8d, 0x34, 0xf2, 0x6e, 0x0a, ++ 0x80, 0xdd, 0x41, 0x95, 0xf1, 0x5c, 0x81, 0x1b, 0x5f, 0x55, 0x60, 0xc7, 0x72, 0xca, 0xb8, 0x52, ++ 0x70, 0x9d, 0x4d, 0xdc, 0x8b, 0x6a, 0xdb, 0xad, 0x2f, 0xb5, 0x6d, 0xb9, 0xca, 0x63, 0x62, 0xbd, ++ 0xc0, 0x2f, 0x40, 0x7b, 0x8f, 0xc1, 0x79, 0x54, 0x8f, 0x95, 0x90, 0xc6, 0xe1, 0x8b, 0xa3, 0xf1, ++ 0x74, 0xe4, 0xfc, 0x0f, 0x06, 0xdd, 0xdc, 0x7f, 0xc1, 0x8e, 0xc6, 0x47, 0x23, 0x67, 0xc3, 0x6d, ++ 0x93, 0xad, 0xc9, 0x74, 0x3c, 0x39, 0x76, 0x6a, 0x6e, 0x8b, 0xd4, 0x8f, 0xc7, 0x07, 0x33, 0x67, ++ 0xd3, 0xfe, 0x3a, 0x38, 0x79, 0xf9, 0xd2, 0xa9, 0xdb, 0xb8, 0xe3, 0xd9, 0xf4, 0x70, 0x7f, 0xe6, ++ 0xd8, 0x4f, 0x5f, 0xf3, 0xf9, 0xe8, 0xe0, 0xd9, 0xc9, 0xcb, 0x99, 0xd3, 0xd8, 0xfb, 0x67, 0xa3, ++ 0xd8, 0x90, 0x33, 0x42, 0x21, 0xd3, 0xe8, 0xd5, 0x64, 0xf6, 0x1a, 0x2a, 0x40, 0xfc, 0xf3, 0x93, ++ 0x57, 0x13, 0x48, 0x0f, 0x31, 0xd3, 0xd1, 0xf1, 0xcc, 0x16, 0xae, 0x59, 0x8f, 0xfd, 0x5f, 0x47, ++ 0xfb, 0xbf, 0x41, 0x85, 0x2e, 0x69, 0x4d, 0xa6, 0x23, 0x86, 0x5e, 0x75, 0x98, 0x45, 0x67, 0xf2, ++ 0xec, 0xc5, 0x88, 0x1d, 0x8f, 0xa6, 0xbf, 0x8f, 0xa6, 0x8e, 0xfd, 0x03, 0xa5, 0x71, 0x34, 0x9e, ++ 0x1d, 0x1e, 0xbc, 0x76, 0x1a, 0xc0, 0x48, 0x77, 0x7f, 0x72, 0x72, 0x78, 0x74, 0x30, 0xce, 0xdd, ++ 0x9b, 0xd0, 0x6f, 0xaf, 0xb4, 0xe4, 0xf9, 0xec, 0xba, 0xf4, 0x0e, 0x46, 0xcf, 0x66, 0x27, 0x90, ++ 0x33, 0x37, 0xb5, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xed, 0xcb, 0xc7, 0x95, 0x39, 0x09, 0x00, ++ 0x00, ++} +diff --git a/libcontainer/criurpc/criurpc.proto b/libcontainer/criurpc/criurpc.proto +index 34fa988..f924b73 100644 +--- a/libcontainer/criurpc/criurpc.proto ++++ b/libcontainer/criurpc/criurpc.proto +@@ -1,3 +1,5 @@ ++syntax = "proto2"; ++ + message criu_page_server_info { + optional string address = 1; + optional int32 port = 2; +@@ -15,6 +17,12 @@ message ext_mount_map { + required string val = 2; + }; + ++message join_namespace { ++ required string ns = 1; ++ required string ns_file = 2; ++ optional string extra_opt = 3; ++} ++ + message inherit_fd { + required string key = 1; + required int32 fd = 2; +@@ -31,7 +39,7 @@ message unix_sk { + + enum criu_cg_mode { + IGNORE = 0; +- NONE = 1; ++ CG_NONE = 1; + PROPS = 2; + SOFT = 3; + FULL = 4; +@@ -63,13 +71,13 @@ message criu_opts { + + optional int32 work_dir_fd = 17; + optional bool link_remap = 18; +- repeated criu_veth_pair veths = 19; ++ repeated criu_veth_pair veths = 19; /* DEPRECATED, use external instead */ + + optional uint32 cpu_cap = 20 [default = 0xffffffff]; + optional bool force_irmap = 21; + repeated string exec_cmd = 22; + +- repeated ext_mount_map ext_mnt = 23; ++ repeated ext_mount_map ext_mnt = 23; /* DEPRECATED, use external instead */ + optional bool manage_cgroups = 24; /* backward compatibility */ + repeated cgroup_root cg_root = 25; + +@@ -83,14 +91,26 @@ message criu_opts { + repeated string skip_mnt = 31; + repeated string enable_fs = 32; + +- repeated unix_sk unix_sk_ino = 33; ++ repeated unix_sk unix_sk_ino = 33; /* DEPRECATED, use external instead */ + + optional criu_cg_mode manage_cgroups_mode = 34; + optional uint32 ghost_limit = 35 [default = 0x100000]; + repeated string irmap_scan_paths = 36; + repeated string external = 37; + optional uint32 empty_ns = 38; +- optional bool no_seccomp = 39; ++ repeated join_namespace join_ns = 39; ++ ++ optional string cgroup_props = 41; ++ optional string cgroup_props_file = 42; ++ repeated string cgroup_dump_controller = 43; ++ ++ optional string freeze_cgroup = 44; ++ optional uint32 timeout = 45; ++ optional bool tcp_skip_in_flight = 46; ++ optional bool weak_sysctls = 47; ++ optional bool lazy_pages = 48; ++ optional int32 status_fd = 49; ++ optional bool orphan_pts_master = 50; + } + + message criu_dump_resp { +@@ -171,4 +191,5 @@ message criu_resp { + + optional int32 cr_errno = 7; + optional criu_features features = 8; ++ optional string cr_errmsg = 9; + } +-- +2.32.0 + diff --git a/patch/0132-cr-set-a-freezer-cgroup-for-criu.patch b/patch/0132-cr-set-a-freezer-cgroup-for-criu.patch new file mode 100644 index 0000000000000000000000000000000000000000..1462939093f1cefcb786b8901e7d051f1431b0c1 --- /dev/null +++ b/patch/0132-cr-set-a-freezer-cgroup-for-criu.patch @@ -0,0 +1,35 @@ +From e24c23291df5049f8b4d5cc9a94b8d0c672694fb Mon Sep 17 00:00:00 2001 +From: bb-cat <405888464@qq.com> +Date: Sat, 29 Jan 2022 01:17:47 +0800 +Subject: [PATCH 2/4] cr: set a freezer cgroup for criu + +A freezer cgroup allows to dump processes faster. + +If a user wants to checkpoint a container and its storage, +he has to pause a container, but in this case we need to pass +a path to its freezer cgroup to "criu dump". + +Signed-off-by: Andrei Vagin +--- + libcontainer/container_linux.go | 5 +++++ + 1 file changed, 5 insertions(+) + +diff --git a/libcontainer/container_linux.go b/libcontainer/container_linux.go +index 7319286..e5212d5 100644 +--- a/libcontainer/container_linux.go ++++ b/libcontainer/container_linux.go +@@ -808,6 +808,11 @@ func (c *linuxContainer) Checkpoint(criuOpts *CriuOpts) error { + EmptyNs: proto.Uint32(criuOpts.EmptyNs), + } + ++ fcg := c.cgroupManager.GetPaths()["freezer"] ++ if fcg != "" { ++ rpcOpts.FreezeCgroup = proto.String(fcg) ++ } ++ + // append optional criu opts, e.g., page-server and port + if criuOpts.PageServer.Address != "" && criuOpts.PageServer.Port != 0 { + rpcOpts.Ps = &criurpc.CriuPageServerInfo{ +-- +2.32.0 + diff --git a/patch/0133-cr-don-t-dump-network-devices-and-their-configuratio.patch b/patch/0133-cr-don-t-dump-network-devices-and-their-configuratio.patch new file mode 100644 index 0000000000000000000000000000000000000000..d187f79b071a0d3a9bb431cc8312f78869a600ef --- /dev/null +++ b/patch/0133-cr-don-t-dump-network-devices-and-their-configuratio.patch @@ -0,0 +1,34 @@ +From d15d02a68b4ac3f610413e31e62028f23f2fe573 Mon Sep 17 00:00:00 2001 +From: bb-cat <405888464@qq.com> +Date: Sat, 29 Jan 2022 01:19:11 +0800 +Subject: [PATCH 3/4] cr: don't dump network devices and their configuration + +RunC doesn't manage network devices and their configuration, +so it is impossible to describe external dependencies to restore them +back. + +This means that all users have to set --empty-ns network, so let's do +this by default. + +Signed-off-by: Andrei Vagin +--- + checkpoint.go | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +diff --git a/checkpoint.go b/checkpoint.go +index 9b5663f..8297236 100644 +--- a/checkpoint.go ++++ b/checkpoint.go +@@ -117,7 +117,8 @@ var namespaceMapping = map[specs.LinuxNamespaceType]int{ + } + + func setEmptyNsMask(context *cli.Context, options *libcontainer.CriuOpts) error { +- var nsmask int ++ /* Runc doesn't manage network devices and their configuration */ ++ nsmask := syscall.CLONE_NEWNET + + for _, ns := range context.StringSlice("empty-ns") { + f, exists := namespaceMapping[specs.LinuxNamespaceType(ns)] +-- +2.32.0 + diff --git a/patch/0134-PATCH-Update-github.com-golang-protobuf.patch b/patch/0134-PATCH-Update-github.com-golang-protobuf.patch new file mode 100644 index 0000000000000000000000000000000000000000..c48edbdf06a8f40d8341cec0859916ad1dcf895a --- /dev/null +++ b/patch/0134-PATCH-Update-github.com-golang-protobuf.patch @@ -0,0 +1,14054 @@ +From c4a7a092f31278f411df9802e874c61a51c5c758 Mon Sep 17 00:00:00 2001 +From: bb-cat <405888464@qq.com> +Date: Sun, 6 Feb 2022 21:44:28 +0800 +Subject: [PATCH 4/4] [PATCH] Update github.com/golang/protobuf + +Signed-off-by: Andrei Vagin +--- + vendor.conf | 2 +- + vendor/github.com/golang/protobuf/README | 148 - + vendor/github.com/golang/protobuf/README.md | 241 ++ + .../golang/protobuf/descriptor/descriptor.go | 93 + + .../golang/protobuf/jsonpb/jsonpb.go | 974 ++++++ + .../jsonpb_test_proto/more_test_objects.pb.go | 207 ++ + .../jsonpb_test_proto/more_test_objects.proto | 57 + + .../jsonpb_test_proto/test_objects.pb.go | 789 +++++ + .../jsonpb_test_proto/test_objects.proto | 137 + + .../github.com/golang/protobuf/proto/clone.go | 52 +- + .../golang/protobuf/proto/decode.go | 177 +- + .../golang/protobuf/proto/encode.go | 142 +- + .../github.com/golang/protobuf/proto/equal.go | 72 +- + .../golang/protobuf/proto/extensions.go | 273 +- + .../github.com/golang/protobuf/proto/lib.go | 663 ++-- + .../golang/protobuf/proto/message_set.go | 84 +- + .../golang/protobuf/proto/pointer_reflect.go | 11 +- + .../golang/protobuf/proto/pointer_unsafe.go | 10 +- + .../golang/protobuf/proto/properties.go | 153 +- + .../protobuf/proto/proto3_proto/proto3.pb.go | 347 ++ + .../protobuf/proto/proto3_proto/proto3.proto | 87 + + .../github.com/golang/protobuf/proto/text.go | 301 +- + .../golang/protobuf/proto/text_parser.go | 364 ++- + .../protoc-gen-go/descriptor/descriptor.pb.go | 2065 ++++++++++++ + .../protoc-gen-go/generator/generator.go | 2806 +++++++++++++++++ + .../protobuf/protoc-gen-go/grpc/grpc.go | 463 +++ + .../protoc-gen-go/plugin/plugin.pb.go | 229 ++ + .../golang/protobuf/ptypes/any/any.pb.go | 155 + + .../golang/protobuf/ptypes/any/any.proto | 140 + + .../protobuf/ptypes/duration/duration.pb.go | 114 + + .../protobuf/ptypes/duration/duration.proto | 98 + + .../protobuf/ptypes/struct/struct.pb.go | 382 +++ + .../protobuf/ptypes/struct/struct.proto | 96 + + .../protobuf/ptypes/timestamp/timestamp.pb.go | 127 + + .../protobuf/ptypes/timestamp/timestamp.proto | 111 + + .../protobuf/ptypes/wrappers/wrappers.pb.go | 200 ++ + .../protobuf/ptypes/wrappers/wrappers.proto | 119 + + 37 files changed, 11707 insertions(+), 782 deletions(-) + delete mode 100644 vendor/github.com/golang/protobuf/README + create mode 100644 vendor/github.com/golang/protobuf/README.md + create mode 100644 vendor/github.com/golang/protobuf/descriptor/descriptor.go + create mode 100644 vendor/github.com/golang/protobuf/jsonpb/jsonpb.go + create mode 100644 vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/more_test_objects.pb.go + create mode 100644 vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/more_test_objects.proto + create mode 100644 vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/test_objects.pb.go + create mode 100644 vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/test_objects.proto + create mode 100644 vendor/github.com/golang/protobuf/proto/proto3_proto/proto3.pb.go + create mode 100644 vendor/github.com/golang/protobuf/proto/proto3_proto/proto3.proto + create mode 100644 vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go + create mode 100644 vendor/github.com/golang/protobuf/protoc-gen-go/generator/generator.go + create mode 100644 vendor/github.com/golang/protobuf/protoc-gen-go/grpc/grpc.go + create mode 100644 vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.go + create mode 100644 vendor/github.com/golang/protobuf/ptypes/any/any.pb.go + create mode 100644 vendor/github.com/golang/protobuf/ptypes/any/any.proto + create mode 100644 vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go + create mode 100644 vendor/github.com/golang/protobuf/ptypes/duration/duration.proto + create mode 100644 vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go + create mode 100644 vendor/github.com/golang/protobuf/ptypes/struct/struct.proto + create mode 100644 vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go + create mode 100644 vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto + create mode 100644 vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go + create mode 100644 vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.proto + +diff --git a/vendor.conf b/vendor.conf +index b961707..50d9052 100644 +--- a/vendor.conf ++++ b/vendor.conf +@@ -13,7 +13,7 @@ github.com/vishvananda/netlink 1e2e08e8a2dcdacaae3f14ac44c5cfa31361f270 + github.com/coreos/go-systemd v14 + github.com/coreos/pkg v3 + github.com/godbus/dbus v3 +-github.com/golang/protobuf f7137ae6b19afbfd61a94b746fda3b3fe0491874 ++github.com/golang/protobuf 18c9bb3261723cd5401db4d0c9fbc5c3b6c70fe8 + # Command-line interface. + github.com/docker/docker 0f5c9d301b9b1cca66b3ea0f9dec3b5317d3686d + github.com/docker/go-units v0.2.0 +diff --git a/vendor/github.com/golang/protobuf/README b/vendor/github.com/golang/protobuf/README +deleted file mode 100644 +index 28fdeec..0000000 +--- a/vendor/github.com/golang/protobuf/README ++++ /dev/null +@@ -1,148 +0,0 @@ +-Go support for Protocol Buffers - Google's data interchange format +-Copyright 2010 The Go Authors. +-https://github.com/golang/protobuf +- +-This package and the code it generates requires at least Go 1.2. +- +-This software implements Go bindings for protocol buffers. For +-information about protocol buffers themselves, see +- https://developers.google.com/protocol-buffers/ +-To use this software, you must first install the standard C++ +-implementation of protocol buffers from +- https://developers.google.com/protocol-buffers/ +-And of course you must also install the Go compiler and tools from +- https://golang.org/ +-See +- https://golang.org/doc/install +-for details or, if you are using gccgo, follow the instructions at +- https://golang.org/doc/install/gccgo +- +-This software has two parts: a 'protocol compiler plugin' that +-generates Go source files that, once compiled, can access and manage +-protocol buffers; and a library that implements run-time support for +-encoding (marshaling), decoding (unmarshaling), and accessing protocol +-buffers. +- +-There is no support for RPC in Go using protocol buffers. It may come +-once a standard RPC protocol develops for protobufs. +- +-There are no insertion points in the plugin. +- +-To install this code: +- +-The simplest way is to run go get. +- +- # Grab the code from the repository and install the proto package. +- go get -u github.com/golang/protobuf/{proto,protoc-gen-go} +- +-The compiler plugin, protoc-gen-go, will be installed in $GOBIN, +-defaulting to $GOPATH/bin. It must be in your $PATH for the protocol +-compiler, protoc, to find it. +- +-Once the software is installed, there are two steps to using it. +-First you must compile the protocol buffer definitions and then import +-them, with the support library, into your program. +- +-To compile the protocol buffer definition, run protoc with the --go_out +-parameter set to the directory you want to output the Go code to. +- +- protoc --go_out=. *.proto +- +-The generated files will be suffixed .pb.go. See the Test code below +-for an example using such a file. +- +- +-The package comment for the proto library contains text describing +-the interface provided in Go for protocol buffers. Here is an edited +-version. +- +-========== +- +-The proto package converts data structures to and from the +-wire format of protocol buffers. It works in concert with the +-Go source code generated for .proto files by the protocol compiler. +- +-A summary of the properties of the protocol buffer interface +-for a protocol buffer variable v: +- +- - Names are turned from camel_case to CamelCase for export. +- - There are no methods on v to set fields; just treat +- them as structure fields. +- - There are getters that return a field's value if set, +- and return the field's default value if unset. +- The getters work even if the receiver is a nil message. +- - The zero value for a struct is its correct initialization state. +- All desired fields must be set before marshaling. +- - A Reset() method will restore a protobuf struct to its zero state. +- - Non-repeated fields are pointers to the values; nil means unset. +- That is, optional or required field int32 f becomes F *int32. +- - Repeated fields are slices. +- - Helper functions are available to aid the setting of fields. +- Helpers for getting values are superseded by the +- GetFoo methods and their use is deprecated. +- msg.Foo = proto.String("hello") // set field +- - Constants are defined to hold the default values of all fields that +- have them. They have the form Default_StructName_FieldName. +- Because the getter methods handle defaulted values, +- direct use of these constants should be rare. +- - Enums are given type names and maps from names to values. +- Enum values are prefixed with the enum's type name. Enum types have +- a String method, and a Enum method to assist in message construction. +- - Nested groups and enums have type names prefixed with the name of +- the surrounding message type. +- - Extensions are given descriptor names that start with E_, +- followed by an underscore-delimited list of the nested messages +- that contain it (if any) followed by the CamelCased name of the +- extension field itself. HasExtension, ClearExtension, GetExtension +- and SetExtension are functions for manipulating extensions. +- - Marshal and Unmarshal are functions to encode and decode the wire format. +- +-Consider file test.proto, containing +- +- package example; +- +- enum FOO { X = 17; }; +- +- message Test { +- required string label = 1; +- optional int32 type = 2 [default=77]; +- repeated int64 reps = 3; +- optional group OptionalGroup = 4 { +- required string RequiredField = 5; +- } +- } +- +-To create and play with a Test object from the example package, +- +- package main +- +- import ( +- "log" +- +- "github.com/golang/protobuf/proto" +- "path/to/example" +- ) +- +- func main() { +- test := &example.Test { +- Label: proto.String("hello"), +- Type: proto.Int32(17), +- Optionalgroup: &example.Test_OptionalGroup { +- RequiredField: proto.String("good bye"), +- }, +- } +- data, err := proto.Marshal(test) +- if err != nil { +- log.Fatal("marshaling error: ", err) +- } +- newTest := &example.Test{} +- err = proto.Unmarshal(data, newTest) +- if err != nil { +- log.Fatal("unmarshaling error: ", err) +- } +- // Now test and newTest contain the same data. +- if test.GetLabel() != newTest.GetLabel() { +- log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel()) +- } +- // etc. +- } +diff --git a/vendor/github.com/golang/protobuf/README.md b/vendor/github.com/golang/protobuf/README.md +new file mode 100644 +index 0000000..037fc7c +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/README.md +@@ -0,0 +1,241 @@ ++# Go support for Protocol Buffers ++ ++Google's data interchange format. ++Copyright 2010 The Go Authors. ++https://github.com/golang/protobuf ++ ++This package and the code it generates requires at least Go 1.4. ++ ++This software implements Go bindings for protocol buffers. For ++information about protocol buffers themselves, see ++ https://developers.google.com/protocol-buffers/ ++ ++## Installation ## ++ ++To use this software, you must: ++- Install the standard C++ implementation of protocol buffers from ++ https://developers.google.com/protocol-buffers/ ++- Of course, install the Go compiler and tools from ++ https://golang.org/ ++ See ++ https://golang.org/doc/install ++ for details or, if you are using gccgo, follow the instructions at ++ https://golang.org/doc/install/gccgo ++- Grab the code from the repository and install the proto package. ++ The simplest way is to run `go get -u github.com/golang/protobuf/{proto,protoc-gen-go}`. ++ The compiler plugin, protoc-gen-go, will be installed in $GOBIN, ++ defaulting to $GOPATH/bin. It must be in your $PATH for the protocol ++ compiler, protoc, to find it. ++ ++This software has two parts: a 'protocol compiler plugin' that ++generates Go source files that, once compiled, can access and manage ++protocol buffers; and a library that implements run-time support for ++encoding (marshaling), decoding (unmarshaling), and accessing protocol ++buffers. ++ ++There is support for gRPC in Go using protocol buffers. ++See the note at the bottom of this file for details. ++ ++There are no insertion points in the plugin. ++ ++ ++## Using protocol buffers with Go ## ++ ++Once the software is installed, there are two steps to using it. ++First you must compile the protocol buffer definitions and then import ++them, with the support library, into your program. ++ ++To compile the protocol buffer definition, run protoc with the --go_out ++parameter set to the directory you want to output the Go code to. ++ ++ protoc --go_out=. *.proto ++ ++The generated files will be suffixed .pb.go. See the Test code below ++for an example using such a file. ++ ++ ++The package comment for the proto library contains text describing ++the interface provided in Go for protocol buffers. Here is an edited ++version. ++ ++========== ++ ++The proto package converts data structures to and from the ++wire format of protocol buffers. It works in concert with the ++Go source code generated for .proto files by the protocol compiler. ++ ++A summary of the properties of the protocol buffer interface ++for a protocol buffer variable v: ++ ++ - Names are turned from camel_case to CamelCase for export. ++ - There are no methods on v to set fields; just treat ++ them as structure fields. ++ - There are getters that return a field's value if set, ++ and return the field's default value if unset. ++ The getters work even if the receiver is a nil message. ++ - The zero value for a struct is its correct initialization state. ++ All desired fields must be set before marshaling. ++ - A Reset() method will restore a protobuf struct to its zero state. ++ - Non-repeated fields are pointers to the values; nil means unset. ++ That is, optional or required field int32 f becomes F *int32. ++ - Repeated fields are slices. ++ - Helper functions are available to aid the setting of fields. ++ Helpers for getting values are superseded by the ++ GetFoo methods and their use is deprecated. ++ msg.Foo = proto.String("hello") // set field ++ - Constants are defined to hold the default values of all fields that ++ have them. They have the form Default_StructName_FieldName. ++ Because the getter methods handle defaulted values, ++ direct use of these constants should be rare. ++ - Enums are given type names and maps from names to values. ++ Enum values are prefixed with the enum's type name. Enum types have ++ a String method, and a Enum method to assist in message construction. ++ - Nested groups and enums have type names prefixed with the name of ++ the surrounding message type. ++ - Extensions are given descriptor names that start with E_, ++ followed by an underscore-delimited list of the nested messages ++ that contain it (if any) followed by the CamelCased name of the ++ extension field itself. HasExtension, ClearExtension, GetExtension ++ and SetExtension are functions for manipulating extensions. ++ - Oneof field sets are given a single field in their message, ++ with distinguished wrapper types for each possible field value. ++ - Marshal and Unmarshal are functions to encode and decode the wire format. ++ ++When the .proto file specifies `syntax="proto3"`, there are some differences: ++ ++ - Non-repeated fields of non-message type are values instead of pointers. ++ - Getters are only generated for message and oneof fields. ++ - Enum types do not get an Enum method. ++ ++Consider file test.proto, containing ++ ++```proto ++ package example; ++ ++ enum FOO { X = 17; }; ++ ++ message Test { ++ required string label = 1; ++ optional int32 type = 2 [default=77]; ++ repeated int64 reps = 3; ++ optional group OptionalGroup = 4 { ++ required string RequiredField = 5; ++ } ++ } ++``` ++ ++To create and play with a Test object from the example package, ++ ++```go ++ package main ++ ++ import ( ++ "log" ++ ++ "github.com/golang/protobuf/proto" ++ "path/to/example" ++ ) ++ ++ func main() { ++ test := &example.Test { ++ Label: proto.String("hello"), ++ Type: proto.Int32(17), ++ Reps: []int64{1, 2, 3}, ++ Optionalgroup: &example.Test_OptionalGroup { ++ RequiredField: proto.String("good bye"), ++ }, ++ } ++ data, err := proto.Marshal(test) ++ if err != nil { ++ log.Fatal("marshaling error: ", err) ++ } ++ newTest := &example.Test{} ++ err = proto.Unmarshal(data, newTest) ++ if err != nil { ++ log.Fatal("unmarshaling error: ", err) ++ } ++ // Now test and newTest contain the same data. ++ if test.GetLabel() != newTest.GetLabel() { ++ log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel()) ++ } ++ // etc. ++ } ++``` ++ ++## Parameters ## ++ ++To pass extra parameters to the plugin, use a comma-separated ++parameter list separated from the output directory by a colon: ++ ++ ++ protoc --go_out=plugins=grpc,import_path=mypackage:. *.proto ++ ++ ++- `import_prefix=xxx` - a prefix that is added onto the beginning of ++ all imports. Useful for things like generating protos in a ++ subdirectory, or regenerating vendored protobufs in-place. ++- `import_path=foo/bar` - used as the package if no input files ++ declare `go_package`. If it contains slashes, everything up to the ++ rightmost slash is ignored. ++- `plugins=plugin1+plugin2` - specifies the list of sub-plugins to ++ load. The only plugin in this repo is `grpc`. ++- `Mfoo/bar.proto=quux/shme` - declares that foo/bar.proto is ++ associated with Go package quux/shme. This is subject to the ++ import_prefix parameter. ++ ++## gRPC Support ## ++ ++If a proto file specifies RPC services, protoc-gen-go can be instructed to ++generate code compatible with gRPC (http://www.grpc.io/). To do this, pass ++the `plugins` parameter to protoc-gen-go; the usual way is to insert it into ++the --go_out argument to protoc: ++ ++ protoc --go_out=plugins=grpc:. *.proto ++ ++## Compatibility ## ++ ++The library and the generated code are expected to be stable over time. ++However, we reserve the right to make breaking changes without notice for the ++following reasons: ++ ++- Security. A security issue in the specification or implementation may come to ++ light whose resolution requires breaking compatibility. We reserve the right ++ to address such security issues. ++- Unspecified behavior. There are some aspects of the Protocol Buffers ++ specification that are undefined. Programs that depend on such unspecified ++ behavior may break in future releases. ++- Specification errors or changes. If it becomes necessary to address an ++ inconsistency, incompleteness, or change in the Protocol Buffers ++ specification, resolving the issue could affect the meaning or legality of ++ existing programs. We reserve the right to address such issues, including ++ updating the implementations. ++- Bugs. If the library has a bug that violates the specification, a program ++ that depends on the buggy behavior may break if the bug is fixed. We reserve ++ the right to fix such bugs. ++- Adding methods or fields to generated structs. These may conflict with field ++ names that already exist in a schema, causing applications to break. When the ++ code generator encounters a field in the schema that would collide with a ++ generated field or method name, the code generator will append an underscore ++ to the generated field or method name. ++- Adding, removing, or changing methods or fields in generated structs that ++ start with `XXX`. These parts of the generated code are exported out of ++ necessity, but should not be considered part of the public API. ++- Adding, removing, or changing unexported symbols in generated code. ++ ++Any breaking changes outside of these will be announced 6 months in advance to ++protobuf@googlegroups.com. ++ ++You should, whenever possible, use generated code created by the `protoc-gen-go` ++tool built at the same commit as the `proto` package. The `proto` package ++declares package-level constants in the form `ProtoPackageIsVersionX`. ++Application code and generated code may depend on one of these constants to ++ensure that compilation will fail if the available version of the proto library ++is too old. Whenever we make a change to the generated code that requires newer ++library support, in the same commit we will increment the version number of the ++generated code and declare a new package-level constant whose name incorporates ++the latest version number. Removing a compatibility constant is considered a ++breaking change and would be subject to the announcement policy stated above. ++ ++The `protoc-gen-go/generator` package exposes a plugin interface, ++which is used by the gRPC code generation. This interface is not ++supported and is subject to incompatible changes without notice. +diff --git a/vendor/github.com/golang/protobuf/descriptor/descriptor.go b/vendor/github.com/golang/protobuf/descriptor/descriptor.go +new file mode 100644 +index 0000000..ac7e51b +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/descriptor/descriptor.go +@@ -0,0 +1,93 @@ ++// Go support for Protocol Buffers - Google's data interchange format ++// ++// Copyright 2016 The Go Authors. All rights reserved. ++// https://github.com/golang/protobuf ++// ++// Redistribution and use in source and binary forms, with or without ++// modification, are permitted provided that the following conditions are ++// met: ++// ++// * Redistributions of source code must retain the above copyright ++// notice, this list of conditions and the following disclaimer. ++// * Redistributions in binary form must reproduce the above ++// copyright notice, this list of conditions and the following disclaimer ++// in the documentation and/or other materials provided with the ++// distribution. ++// * Neither the name of Google Inc. nor the names of its ++// contributors may be used to endorse or promote products derived from ++// this software without specific prior written permission. ++// ++// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++// Package descriptor provides functions for obtaining protocol buffer ++// descriptors for generated Go types. ++// ++// These functions cannot go in package proto because they depend on the ++// generated protobuf descriptor messages, which themselves depend on proto. ++package descriptor ++ ++import ( ++ "bytes" ++ "compress/gzip" ++ "fmt" ++ "io/ioutil" ++ ++ "github.com/golang/protobuf/proto" ++ protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor" ++) ++ ++// extractFile extracts a FileDescriptorProto from a gzip'd buffer. ++func extractFile(gz []byte) (*protobuf.FileDescriptorProto, error) { ++ r, err := gzip.NewReader(bytes.NewReader(gz)) ++ if err != nil { ++ return nil, fmt.Errorf("failed to open gzip reader: %v", err) ++ } ++ defer r.Close() ++ ++ b, err := ioutil.ReadAll(r) ++ if err != nil { ++ return nil, fmt.Errorf("failed to uncompress descriptor: %v", err) ++ } ++ ++ fd := new(protobuf.FileDescriptorProto) ++ if err := proto.Unmarshal(b, fd); err != nil { ++ return nil, fmt.Errorf("malformed FileDescriptorProto: %v", err) ++ } ++ ++ return fd, nil ++} ++ ++// Message is a proto.Message with a method to return its descriptor. ++// ++// Message types generated by the protocol compiler always satisfy ++// the Message interface. ++type Message interface { ++ proto.Message ++ Descriptor() ([]byte, []int) ++} ++ ++// ForMessage returns a FileDescriptorProto and a DescriptorProto from within it ++// describing the given message. ++func ForMessage(msg Message) (fd *protobuf.FileDescriptorProto, md *protobuf.DescriptorProto) { ++ gz, path := msg.Descriptor() ++ fd, err := extractFile(gz) ++ if err != nil { ++ panic(fmt.Sprintf("invalid FileDescriptorProto for %T: %v", msg, err)) ++ } ++ ++ md = fd.MessageType[path[0]] ++ for _, i := range path[1:] { ++ md = md.NestedType[i] ++ } ++ return fd, md ++} +diff --git a/vendor/github.com/golang/protobuf/jsonpb/jsonpb.go b/vendor/github.com/golang/protobuf/jsonpb/jsonpb.go +new file mode 100644 +index 0000000..eff41c2 +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/jsonpb/jsonpb.go +@@ -0,0 +1,974 @@ ++// Go support for Protocol Buffers - Google's data interchange format ++// ++// Copyright 2015 The Go Authors. All rights reserved. ++// https://github.com/golang/protobuf ++// ++// Redistribution and use in source and binary forms, with or without ++// modification, are permitted provided that the following conditions are ++// met: ++// ++// * Redistributions of source code must retain the above copyright ++// notice, this list of conditions and the following disclaimer. ++// * Redistributions in binary form must reproduce the above ++// copyright notice, this list of conditions and the following disclaimer ++// in the documentation and/or other materials provided with the ++// distribution. ++// * Neither the name of Google Inc. nor the names of its ++// contributors may be used to endorse or promote products derived from ++// this software without specific prior written permission. ++// ++// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++/* ++Package jsonpb provides marshaling and unmarshaling between protocol buffers and JSON. ++It follows the specification at https://developers.google.com/protocol-buffers/docs/proto3#json. ++ ++This package produces a different output than the standard "encoding/json" package, ++which does not operate correctly on protocol buffers. ++*/ ++package jsonpb ++ ++import ( ++ "bytes" ++ "encoding/json" ++ "errors" ++ "fmt" ++ "io" ++ "reflect" ++ "sort" ++ "strconv" ++ "strings" ++ "time" ++ ++ "github.com/golang/protobuf/proto" ++ ++ stpb "github.com/golang/protobuf/ptypes/struct" ++) ++ ++// Marshaler is a configurable object for converting between ++// protocol buffer objects and a JSON representation for them. ++type Marshaler struct { ++ // Whether to render enum values as integers, as opposed to string values. ++ EnumsAsInts bool ++ ++ // Whether to render fields with zero values. ++ EmitDefaults bool ++ ++ // A string to indent each level by. The presence of this field will ++ // also cause a space to appear between the field separator and ++ // value, and for newlines to be appear between fields and array ++ // elements. ++ Indent string ++ ++ // Whether to use the original (.proto) name for fields. ++ OrigName bool ++} ++ ++// Marshal marshals a protocol buffer into JSON. ++func (m *Marshaler) Marshal(out io.Writer, pb proto.Message) error { ++ writer := &errWriter{writer: out} ++ return m.marshalObject(writer, pb, "", "") ++} ++ ++// MarshalToString converts a protocol buffer object to JSON string. ++func (m *Marshaler) MarshalToString(pb proto.Message) (string, error) { ++ var buf bytes.Buffer ++ if err := m.Marshal(&buf, pb); err != nil { ++ return "", err ++ } ++ return buf.String(), nil ++} ++ ++type int32Slice []int32 ++ ++// For sorting extensions ids to ensure stable output. ++func (s int32Slice) Len() int { return len(s) } ++func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] } ++func (s int32Slice) Swap(i, j int) { s[i], s[j] = s[j], s[i] } ++ ++type wkt interface { ++ XXX_WellKnownType() string ++} ++ ++// marshalObject writes a struct to the Writer. ++func (m *Marshaler) marshalObject(out *errWriter, v proto.Message, indent, typeURL string) error { ++ s := reflect.ValueOf(v).Elem() ++ ++ // Handle well-known types. ++ if wkt, ok := v.(wkt); ok { ++ switch wkt.XXX_WellKnownType() { ++ case "DoubleValue", "FloatValue", "Int64Value", "UInt64Value", ++ "Int32Value", "UInt32Value", "BoolValue", "StringValue", "BytesValue": ++ // "Wrappers use the same representation in JSON ++ // as the wrapped primitive type, ..." ++ sprop := proto.GetProperties(s.Type()) ++ return m.marshalValue(out, sprop.Prop[0], s.Field(0), indent) ++ case "Any": ++ // Any is a bit more involved. ++ return m.marshalAny(out, v, indent) ++ case "Duration": ++ // "Generated output always contains 3, 6, or 9 fractional digits, ++ // depending on required precision." ++ s, ns := s.Field(0).Int(), s.Field(1).Int() ++ d := time.Duration(s)*time.Second + time.Duration(ns)*time.Nanosecond ++ x := fmt.Sprintf("%.9f", d.Seconds()) ++ x = strings.TrimSuffix(x, "000") ++ x = strings.TrimSuffix(x, "000") ++ out.write(`"`) ++ out.write(x) ++ out.write(`s"`) ++ return out.err ++ case "Struct", "ListValue": ++ // Let marshalValue handle the `Struct.fields` map or the `ListValue.values` slice. ++ // TODO: pass the correct Properties if needed. ++ return m.marshalValue(out, &proto.Properties{}, s.Field(0), indent) ++ case "Timestamp": ++ // "RFC 3339, where generated output will always be Z-normalized ++ // and uses 3, 6 or 9 fractional digits." ++ s, ns := s.Field(0).Int(), s.Field(1).Int() ++ t := time.Unix(s, ns).UTC() ++ // time.RFC3339Nano isn't exactly right (we need to get 3/6/9 fractional digits). ++ x := t.Format("2006-01-02T15:04:05.000000000") ++ x = strings.TrimSuffix(x, "000") ++ x = strings.TrimSuffix(x, "000") ++ out.write(`"`) ++ out.write(x) ++ out.write(`Z"`) ++ return out.err ++ case "Value": ++ // Value has a single oneof. ++ kind := s.Field(0) ++ if kind.IsNil() { ++ // "absence of any variant indicates an error" ++ return errors.New("nil Value") ++ } ++ // oneof -> *T -> T -> T.F ++ x := kind.Elem().Elem().Field(0) ++ // TODO: pass the correct Properties if needed. ++ return m.marshalValue(out, &proto.Properties{}, x, indent) ++ } ++ } ++ ++ out.write("{") ++ if m.Indent != "" { ++ out.write("\n") ++ } ++ ++ firstField := true ++ ++ if typeURL != "" { ++ if err := m.marshalTypeURL(out, indent, typeURL); err != nil { ++ return err ++ } ++ firstField = false ++ } ++ ++ for i := 0; i < s.NumField(); i++ { ++ value := s.Field(i) ++ valueField := s.Type().Field(i) ++ if strings.HasPrefix(valueField.Name, "XXX_") { ++ continue ++ } ++ ++ // IsNil will panic on most value kinds. ++ switch value.Kind() { ++ case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: ++ if value.IsNil() { ++ continue ++ } ++ } ++ ++ if !m.EmitDefaults { ++ switch value.Kind() { ++ case reflect.Bool: ++ if !value.Bool() { ++ continue ++ } ++ case reflect.Int32, reflect.Int64: ++ if value.Int() == 0 { ++ continue ++ } ++ case reflect.Uint32, reflect.Uint64: ++ if value.Uint() == 0 { ++ continue ++ } ++ case reflect.Float32, reflect.Float64: ++ if value.Float() == 0 { ++ continue ++ } ++ case reflect.String: ++ if value.Len() == 0 { ++ continue ++ } ++ } ++ } ++ ++ // Oneof fields need special handling. ++ if valueField.Tag.Get("protobuf_oneof") != "" { ++ // value is an interface containing &T{real_value}. ++ sv := value.Elem().Elem() // interface -> *T -> T ++ value = sv.Field(0) ++ valueField = sv.Type().Field(0) ++ } ++ prop := jsonProperties(valueField, m.OrigName) ++ if !firstField { ++ m.writeSep(out) ++ } ++ if err := m.marshalField(out, prop, value, indent); err != nil { ++ return err ++ } ++ firstField = false ++ } ++ ++ // Handle proto2 extensions. ++ if ep, ok := v.(proto.Message); ok { ++ extensions := proto.RegisteredExtensions(v) ++ // Sort extensions for stable output. ++ ids := make([]int32, 0, len(extensions)) ++ for id, desc := range extensions { ++ if !proto.HasExtension(ep, desc) { ++ continue ++ } ++ ids = append(ids, id) ++ } ++ sort.Sort(int32Slice(ids)) ++ for _, id := range ids { ++ desc := extensions[id] ++ if desc == nil { ++ // unknown extension ++ continue ++ } ++ ext, extErr := proto.GetExtension(ep, desc) ++ if extErr != nil { ++ return extErr ++ } ++ value := reflect.ValueOf(ext) ++ var prop proto.Properties ++ prop.Parse(desc.Tag) ++ prop.JSONName = fmt.Sprintf("[%s]", desc.Name) ++ if !firstField { ++ m.writeSep(out) ++ } ++ if err := m.marshalField(out, &prop, value, indent); err != nil { ++ return err ++ } ++ firstField = false ++ } ++ ++ } ++ ++ if m.Indent != "" { ++ out.write("\n") ++ out.write(indent) ++ } ++ out.write("}") ++ return out.err ++} ++ ++func (m *Marshaler) writeSep(out *errWriter) { ++ if m.Indent != "" { ++ out.write(",\n") ++ } else { ++ out.write(",") ++ } ++} ++ ++func (m *Marshaler) marshalAny(out *errWriter, any proto.Message, indent string) error { ++ // "If the Any contains a value that has a special JSON mapping, ++ // it will be converted as follows: {"@type": xxx, "value": yyy}. ++ // Otherwise, the value will be converted into a JSON object, ++ // and the "@type" field will be inserted to indicate the actual data type." ++ v := reflect.ValueOf(any).Elem() ++ turl := v.Field(0).String() ++ val := v.Field(1).Bytes() ++ ++ // Only the part of type_url after the last slash is relevant. ++ mname := turl ++ if slash := strings.LastIndex(mname, "/"); slash >= 0 { ++ mname = mname[slash+1:] ++ } ++ mt := proto.MessageType(mname) ++ if mt == nil { ++ return fmt.Errorf("unknown message type %q", mname) ++ } ++ msg := reflect.New(mt.Elem()).Interface().(proto.Message) ++ if err := proto.Unmarshal(val, msg); err != nil { ++ return err ++ } ++ ++ if _, ok := msg.(wkt); ok { ++ out.write("{") ++ if m.Indent != "" { ++ out.write("\n") ++ } ++ if err := m.marshalTypeURL(out, indent, turl); err != nil { ++ return err ++ } ++ m.writeSep(out) ++ if m.Indent != "" { ++ out.write(indent) ++ out.write(m.Indent) ++ out.write(`"value": `) ++ } else { ++ out.write(`"value":`) ++ } ++ if err := m.marshalObject(out, msg, indent+m.Indent, ""); err != nil { ++ return err ++ } ++ if m.Indent != "" { ++ out.write("\n") ++ out.write(indent) ++ } ++ out.write("}") ++ return out.err ++ } ++ ++ return m.marshalObject(out, msg, indent, turl) ++} ++ ++func (m *Marshaler) marshalTypeURL(out *errWriter, indent, typeURL string) error { ++ if m.Indent != "" { ++ out.write(indent) ++ out.write(m.Indent) ++ } ++ out.write(`"@type":`) ++ if m.Indent != "" { ++ out.write(" ") ++ } ++ b, err := json.Marshal(typeURL) ++ if err != nil { ++ return err ++ } ++ out.write(string(b)) ++ return out.err ++} ++ ++// marshalField writes field description and value to the Writer. ++func (m *Marshaler) marshalField(out *errWriter, prop *proto.Properties, v reflect.Value, indent string) error { ++ if m.Indent != "" { ++ out.write(indent) ++ out.write(m.Indent) ++ } ++ out.write(`"`) ++ out.write(prop.JSONName) ++ out.write(`":`) ++ if m.Indent != "" { ++ out.write(" ") ++ } ++ if err := m.marshalValue(out, prop, v, indent); err != nil { ++ return err ++ } ++ return nil ++} ++ ++// marshalValue writes the value to the Writer. ++func (m *Marshaler) marshalValue(out *errWriter, prop *proto.Properties, v reflect.Value, indent string) error { ++ ++ var err error ++ v = reflect.Indirect(v) ++ ++ // Handle repeated elements. ++ if v.Kind() == reflect.Slice && v.Type().Elem().Kind() != reflect.Uint8 { ++ out.write("[") ++ comma := "" ++ for i := 0; i < v.Len(); i++ { ++ sliceVal := v.Index(i) ++ out.write(comma) ++ if m.Indent != "" { ++ out.write("\n") ++ out.write(indent) ++ out.write(m.Indent) ++ out.write(m.Indent) ++ } ++ if err := m.marshalValue(out, prop, sliceVal, indent+m.Indent); err != nil { ++ return err ++ } ++ comma = "," ++ } ++ if m.Indent != "" { ++ out.write("\n") ++ out.write(indent) ++ out.write(m.Indent) ++ } ++ out.write("]") ++ return out.err ++ } ++ ++ // Handle well-known types. ++ // Most are handled up in marshalObject (because 99% are messages). ++ type wkt interface { ++ XXX_WellKnownType() string ++ } ++ if wkt, ok := v.Interface().(wkt); ok { ++ switch wkt.XXX_WellKnownType() { ++ case "NullValue": ++ out.write("null") ++ return out.err ++ } ++ } ++ ++ // Handle enumerations. ++ if !m.EnumsAsInts && prop.Enum != "" { ++ // Unknown enum values will are stringified by the proto library as their ++ // value. Such values should _not_ be quoted or they will be interpreted ++ // as an enum string instead of their value. ++ enumStr := v.Interface().(fmt.Stringer).String() ++ var valStr string ++ if v.Kind() == reflect.Ptr { ++ valStr = strconv.Itoa(int(v.Elem().Int())) ++ } else { ++ valStr = strconv.Itoa(int(v.Int())) ++ } ++ isKnownEnum := enumStr != valStr ++ if isKnownEnum { ++ out.write(`"`) ++ } ++ out.write(enumStr) ++ if isKnownEnum { ++ out.write(`"`) ++ } ++ return out.err ++ } ++ ++ // Handle nested messages. ++ if v.Kind() == reflect.Struct { ++ return m.marshalObject(out, v.Addr().Interface().(proto.Message), indent+m.Indent, "") ++ } ++ ++ // Handle maps. ++ // Since Go randomizes map iteration, we sort keys for stable output. ++ if v.Kind() == reflect.Map { ++ out.write(`{`) ++ keys := v.MapKeys() ++ sort.Sort(mapKeys(keys)) ++ for i, k := range keys { ++ if i > 0 { ++ out.write(`,`) ++ } ++ if m.Indent != "" { ++ out.write("\n") ++ out.write(indent) ++ out.write(m.Indent) ++ out.write(m.Indent) ++ } ++ ++ b, err := json.Marshal(k.Interface()) ++ if err != nil { ++ return err ++ } ++ s := string(b) ++ ++ // If the JSON is not a string value, encode it again to make it one. ++ if !strings.HasPrefix(s, `"`) { ++ b, err := json.Marshal(s) ++ if err != nil { ++ return err ++ } ++ s = string(b) ++ } ++ ++ out.write(s) ++ out.write(`:`) ++ if m.Indent != "" { ++ out.write(` `) ++ } ++ ++ if err := m.marshalValue(out, prop, v.MapIndex(k), indent+m.Indent); err != nil { ++ return err ++ } ++ } ++ if m.Indent != "" { ++ out.write("\n") ++ out.write(indent) ++ out.write(m.Indent) ++ } ++ out.write(`}`) ++ return out.err ++ } ++ ++ // Default handling defers to the encoding/json library. ++ b, err := json.Marshal(v.Interface()) ++ if err != nil { ++ return err ++ } ++ needToQuote := string(b[0]) != `"` && (v.Kind() == reflect.Int64 || v.Kind() == reflect.Uint64) ++ if needToQuote { ++ out.write(`"`) ++ } ++ out.write(string(b)) ++ if needToQuote { ++ out.write(`"`) ++ } ++ return out.err ++} ++ ++// Unmarshaler is a configurable object for converting from a JSON ++// representation to a protocol buffer object. ++type Unmarshaler struct { ++ // Whether to allow messages to contain unknown fields, as opposed to ++ // failing to unmarshal. ++ AllowUnknownFields bool ++} ++ ++// UnmarshalNext unmarshals the next protocol buffer from a JSON object stream. ++// This function is lenient and will decode any options permutations of the ++// related Marshaler. ++func (u *Unmarshaler) UnmarshalNext(dec *json.Decoder, pb proto.Message) error { ++ inputValue := json.RawMessage{} ++ if err := dec.Decode(&inputValue); err != nil { ++ return err ++ } ++ return u.unmarshalValue(reflect.ValueOf(pb).Elem(), inputValue, nil) ++} ++ ++// Unmarshal unmarshals a JSON object stream into a protocol ++// buffer. This function is lenient and will decode any options ++// permutations of the related Marshaler. ++func (u *Unmarshaler) Unmarshal(r io.Reader, pb proto.Message) error { ++ dec := json.NewDecoder(r) ++ return u.UnmarshalNext(dec, pb) ++} ++ ++// UnmarshalNext unmarshals the next protocol buffer from a JSON object stream. ++// This function is lenient and will decode any options permutations of the ++// related Marshaler. ++func UnmarshalNext(dec *json.Decoder, pb proto.Message) error { ++ return new(Unmarshaler).UnmarshalNext(dec, pb) ++} ++ ++// Unmarshal unmarshals a JSON object stream into a protocol ++// buffer. This function is lenient and will decode any options ++// permutations of the related Marshaler. ++func Unmarshal(r io.Reader, pb proto.Message) error { ++ return new(Unmarshaler).Unmarshal(r, pb) ++} ++ ++// UnmarshalString will populate the fields of a protocol buffer based ++// on a JSON string. This function is lenient and will decode any options ++// permutations of the related Marshaler. ++func UnmarshalString(str string, pb proto.Message) error { ++ return new(Unmarshaler).Unmarshal(strings.NewReader(str), pb) ++} ++ ++// unmarshalValue converts/copies a value into the target. ++// prop may be nil. ++func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMessage, prop *proto.Properties) error { ++ targetType := target.Type() ++ ++ // Allocate memory for pointer fields. ++ if targetType.Kind() == reflect.Ptr { ++ target.Set(reflect.New(targetType.Elem())) ++ return u.unmarshalValue(target.Elem(), inputValue, prop) ++ } ++ ++ // Handle well-known types. ++ type wkt interface { ++ XXX_WellKnownType() string ++ } ++ if w, ok := target.Addr().Interface().(wkt); ok { ++ switch w.XXX_WellKnownType() { ++ case "DoubleValue", "FloatValue", "Int64Value", "UInt64Value", ++ "Int32Value", "UInt32Value", "BoolValue", "StringValue", "BytesValue": ++ // "Wrappers use the same representation in JSON ++ // as the wrapped primitive type, except that null is allowed." ++ // encoding/json will turn JSON `null` into Go `nil`, ++ // so we don't have to do any extra work. ++ return u.unmarshalValue(target.Field(0), inputValue, prop) ++ case "Any": ++ var jsonFields map[string]json.RawMessage ++ if err := json.Unmarshal(inputValue, &jsonFields); err != nil { ++ return err ++ } ++ ++ val, ok := jsonFields["@type"] ++ if !ok { ++ return errors.New("Any JSON doesn't have '@type'") ++ } ++ ++ var turl string ++ if err := json.Unmarshal([]byte(val), &turl); err != nil { ++ return fmt.Errorf("can't unmarshal Any's '@type': %q", val) ++ } ++ target.Field(0).SetString(turl) ++ ++ mname := turl ++ if slash := strings.LastIndex(mname, "/"); slash >= 0 { ++ mname = mname[slash+1:] ++ } ++ mt := proto.MessageType(mname) ++ if mt == nil { ++ return fmt.Errorf("unknown message type %q", mname) ++ } ++ ++ m := reflect.New(mt.Elem()).Interface().(proto.Message) ++ if _, ok := m.(wkt); ok { ++ val, ok := jsonFields["value"] ++ if !ok { ++ return errors.New("Any JSON doesn't have 'value'") ++ } ++ ++ if err := u.unmarshalValue(reflect.ValueOf(m).Elem(), val, nil); err != nil { ++ return fmt.Errorf("can't unmarshal Any's WKT: %v", err) ++ } ++ } else { ++ delete(jsonFields, "@type") ++ nestedProto, err := json.Marshal(jsonFields) ++ if err != nil { ++ return fmt.Errorf("can't generate JSON for Any's nested proto to be unmarshaled: %v", err) ++ } ++ ++ if err = u.unmarshalValue(reflect.ValueOf(m).Elem(), nestedProto, nil); err != nil { ++ return fmt.Errorf("can't unmarshal nested Any proto: %v", err) ++ } ++ } ++ ++ b, err := proto.Marshal(m) ++ if err != nil { ++ return fmt.Errorf("can't marshal proto into Any.Value: %v", err) ++ } ++ target.Field(1).SetBytes(b) ++ ++ return nil ++ case "Duration": ++ ivStr := string(inputValue) ++ if ivStr == "null" { ++ target.Field(0).SetInt(0) ++ target.Field(1).SetInt(0) ++ return nil ++ } ++ ++ unq, err := strconv.Unquote(ivStr) ++ if err != nil { ++ return err ++ } ++ d, err := time.ParseDuration(unq) ++ if err != nil { ++ return fmt.Errorf("bad Duration: %v", err) ++ } ++ ns := d.Nanoseconds() ++ s := ns / 1e9 ++ ns %= 1e9 ++ target.Field(0).SetInt(s) ++ target.Field(1).SetInt(ns) ++ return nil ++ case "Timestamp": ++ ivStr := string(inputValue) ++ if ivStr == "null" { ++ target.Field(0).SetInt(0) ++ target.Field(1).SetInt(0) ++ return nil ++ } ++ ++ unq, err := strconv.Unquote(ivStr) ++ if err != nil { ++ return err ++ } ++ t, err := time.Parse(time.RFC3339Nano, unq) ++ if err != nil { ++ return fmt.Errorf("bad Timestamp: %v", err) ++ } ++ target.Field(0).SetInt(int64(t.Unix())) ++ target.Field(1).SetInt(int64(t.Nanosecond())) ++ return nil ++ case "Struct": ++ if string(inputValue) == "null" { ++ // Interpret a null struct as empty. ++ return nil ++ } ++ var m map[string]json.RawMessage ++ if err := json.Unmarshal(inputValue, &m); err != nil { ++ return fmt.Errorf("bad StructValue: %v", err) ++ } ++ target.Field(0).Set(reflect.ValueOf(map[string]*stpb.Value{})) ++ for k, jv := range m { ++ pv := &stpb.Value{} ++ if err := u.unmarshalValue(reflect.ValueOf(pv).Elem(), jv, prop); err != nil { ++ return fmt.Errorf("bad value in StructValue for key %q: %v", k, err) ++ } ++ target.Field(0).SetMapIndex(reflect.ValueOf(k), reflect.ValueOf(pv)) ++ } ++ return nil ++ case "ListValue": ++ if string(inputValue) == "null" { ++ // Interpret a null ListValue as empty. ++ return nil ++ } ++ var s []json.RawMessage ++ if err := json.Unmarshal(inputValue, &s); err != nil { ++ return fmt.Errorf("bad ListValue: %v", err) ++ } ++ target.Field(0).Set(reflect.ValueOf(make([]*stpb.Value, len(s), len(s)))) ++ for i, sv := range s { ++ if err := u.unmarshalValue(target.Field(0).Index(i), sv, prop); err != nil { ++ return err ++ } ++ } ++ return nil ++ case "Value": ++ ivStr := string(inputValue) ++ if ivStr == "null" { ++ target.Field(0).Set(reflect.ValueOf(&stpb.Value_NullValue{})) ++ } else if v, err := strconv.ParseFloat(ivStr, 0); err == nil { ++ target.Field(0).Set(reflect.ValueOf(&stpb.Value_NumberValue{v})) ++ } else if v, err := strconv.Unquote(ivStr); err == nil { ++ target.Field(0).Set(reflect.ValueOf(&stpb.Value_StringValue{v})) ++ } else if v, err := strconv.ParseBool(ivStr); err == nil { ++ target.Field(0).Set(reflect.ValueOf(&stpb.Value_BoolValue{v})) ++ } else if err := json.Unmarshal(inputValue, &[]json.RawMessage{}); err == nil { ++ lv := &stpb.ListValue{} ++ target.Field(0).Set(reflect.ValueOf(&stpb.Value_ListValue{lv})) ++ return u.unmarshalValue(reflect.ValueOf(lv).Elem(), inputValue, prop) ++ } else if err := json.Unmarshal(inputValue, &map[string]json.RawMessage{}); err == nil { ++ sv := &stpb.Struct{} ++ target.Field(0).Set(reflect.ValueOf(&stpb.Value_StructValue{sv})) ++ return u.unmarshalValue(reflect.ValueOf(sv).Elem(), inputValue, prop) ++ } else { ++ return fmt.Errorf("unrecognized type for Value %q", ivStr) ++ } ++ return nil ++ } ++ } ++ ++ // Handle enums, which have an underlying type of int32, ++ // and may appear as strings. ++ // The case of an enum appearing as a number is handled ++ // at the bottom of this function. ++ if inputValue[0] == '"' && prop != nil && prop.Enum != "" { ++ vmap := proto.EnumValueMap(prop.Enum) ++ // Don't need to do unquoting; valid enum names ++ // are from a limited character set. ++ s := inputValue[1 : len(inputValue)-1] ++ n, ok := vmap[string(s)] ++ if !ok { ++ return fmt.Errorf("unknown value %q for enum %s", s, prop.Enum) ++ } ++ if target.Kind() == reflect.Ptr { // proto2 ++ target.Set(reflect.New(targetType.Elem())) ++ target = target.Elem() ++ } ++ target.SetInt(int64(n)) ++ return nil ++ } ++ ++ // Handle nested messages. ++ if targetType.Kind() == reflect.Struct { ++ var jsonFields map[string]json.RawMessage ++ if err := json.Unmarshal(inputValue, &jsonFields); err != nil { ++ return err ++ } ++ ++ consumeField := func(prop *proto.Properties) (json.RawMessage, bool) { ++ // Be liberal in what names we accept; both orig_name and camelName are okay. ++ fieldNames := acceptedJSONFieldNames(prop) ++ ++ vOrig, okOrig := jsonFields[fieldNames.orig] ++ vCamel, okCamel := jsonFields[fieldNames.camel] ++ if !okOrig && !okCamel { ++ return nil, false ++ } ++ // If, for some reason, both are present in the data, favour the camelName. ++ var raw json.RawMessage ++ if okOrig { ++ raw = vOrig ++ delete(jsonFields, fieldNames.orig) ++ } ++ if okCamel { ++ raw = vCamel ++ delete(jsonFields, fieldNames.camel) ++ } ++ return raw, true ++ } ++ ++ sprops := proto.GetProperties(targetType) ++ for i := 0; i < target.NumField(); i++ { ++ ft := target.Type().Field(i) ++ if strings.HasPrefix(ft.Name, "XXX_") { ++ continue ++ } ++ ++ valueForField, ok := consumeField(sprops.Prop[i]) ++ if !ok { ++ continue ++ } ++ ++ if err := u.unmarshalValue(target.Field(i), valueForField, sprops.Prop[i]); err != nil { ++ return err ++ } ++ } ++ // Check for any oneof fields. ++ if len(jsonFields) > 0 { ++ for _, oop := range sprops.OneofTypes { ++ raw, ok := consumeField(oop.Prop) ++ if !ok { ++ continue ++ } ++ nv := reflect.New(oop.Type.Elem()) ++ target.Field(oop.Field).Set(nv) ++ if err := u.unmarshalValue(nv.Elem().Field(0), raw, oop.Prop); err != nil { ++ return err ++ } ++ } ++ } ++ // Handle proto2 extensions. ++ if len(jsonFields) > 0 { ++ if ep, ok := target.Addr().Interface().(proto.Message); ok { ++ for _, ext := range proto.RegisteredExtensions(ep) { ++ name := fmt.Sprintf("[%s]", ext.Name) ++ raw, ok := jsonFields[name] ++ if !ok { ++ continue ++ } ++ delete(jsonFields, name) ++ nv := reflect.New(reflect.TypeOf(ext.ExtensionType).Elem()) ++ if err := u.unmarshalValue(nv.Elem(), raw, nil); err != nil { ++ return err ++ } ++ if err := proto.SetExtension(ep, ext, nv.Interface()); err != nil { ++ return err ++ } ++ } ++ } ++ } ++ if !u.AllowUnknownFields && len(jsonFields) > 0 { ++ // Pick any field to be the scapegoat. ++ var f string ++ for fname := range jsonFields { ++ f = fname ++ break ++ } ++ return fmt.Errorf("unknown field %q in %v", f, targetType) ++ } ++ return nil ++ } ++ ++ // Handle arrays (which aren't encoded bytes) ++ if targetType.Kind() == reflect.Slice && targetType.Elem().Kind() != reflect.Uint8 { ++ var slc []json.RawMessage ++ if err := json.Unmarshal(inputValue, &slc); err != nil { ++ return err ++ } ++ len := len(slc) ++ target.Set(reflect.MakeSlice(targetType, len, len)) ++ for i := 0; i < len; i++ { ++ if err := u.unmarshalValue(target.Index(i), slc[i], prop); err != nil { ++ return err ++ } ++ } ++ return nil ++ } ++ ++ // Handle maps (whose keys are always strings) ++ if targetType.Kind() == reflect.Map { ++ var mp map[string]json.RawMessage ++ if err := json.Unmarshal(inputValue, &mp); err != nil { ++ return err ++ } ++ target.Set(reflect.MakeMap(targetType)) ++ var keyprop, valprop *proto.Properties ++ if prop != nil { ++ // These could still be nil if the protobuf metadata is broken somehow. ++ // TODO: This won't work because the fields are unexported. ++ // We should probably just reparse them. ++ //keyprop, valprop = prop.mkeyprop, prop.mvalprop ++ } ++ for ks, raw := range mp { ++ // Unmarshal map key. The core json library already decoded the key into a ++ // string, so we handle that specially. Other types were quoted post-serialization. ++ var k reflect.Value ++ if targetType.Key().Kind() == reflect.String { ++ k = reflect.ValueOf(ks) ++ } else { ++ k = reflect.New(targetType.Key()).Elem() ++ if err := u.unmarshalValue(k, json.RawMessage(ks), keyprop); err != nil { ++ return err ++ } ++ } ++ ++ // Unmarshal map value. ++ v := reflect.New(targetType.Elem()).Elem() ++ if err := u.unmarshalValue(v, raw, valprop); err != nil { ++ return err ++ } ++ target.SetMapIndex(k, v) ++ } ++ return nil ++ } ++ ++ // 64-bit integers can be encoded as strings. In this case we drop ++ // the quotes and proceed as normal. ++ isNum := targetType.Kind() == reflect.Int64 || targetType.Kind() == reflect.Uint64 ++ if isNum && strings.HasPrefix(string(inputValue), `"`) { ++ inputValue = inputValue[1 : len(inputValue)-1] ++ } ++ ++ // Use the encoding/json for parsing other value types. ++ return json.Unmarshal(inputValue, target.Addr().Interface()) ++} ++ ++// jsonProperties returns parsed proto.Properties for the field and corrects JSONName attribute. ++func jsonProperties(f reflect.StructField, origName bool) *proto.Properties { ++ var prop proto.Properties ++ prop.Init(f.Type, f.Name, f.Tag.Get("protobuf"), &f) ++ if origName || prop.JSONName == "" { ++ prop.JSONName = prop.OrigName ++ } ++ return &prop ++} ++ ++type fieldNames struct { ++ orig, camel string ++} ++ ++func acceptedJSONFieldNames(prop *proto.Properties) fieldNames { ++ opts := fieldNames{orig: prop.OrigName, camel: prop.OrigName} ++ if prop.JSONName != "" { ++ opts.camel = prop.JSONName ++ } ++ return opts ++} ++ ++// Writer wrapper inspired by https://blog.golang.org/errors-are-values ++type errWriter struct { ++ writer io.Writer ++ err error ++} ++ ++func (w *errWriter) write(str string) { ++ if w.err != nil { ++ return ++ } ++ _, w.err = w.writer.Write([]byte(str)) ++} ++ ++// Map fields may have key types of non-float scalars, strings and enums. ++// The easiest way to sort them in some deterministic order is to use fmt. ++// If this turns out to be inefficient we can always consider other options, ++// such as doing a Schwartzian transform. ++// ++// Numeric keys are sorted in numeric order per ++// https://developers.google.com/protocol-buffers/docs/proto#maps. ++type mapKeys []reflect.Value ++ ++func (s mapKeys) Len() int { return len(s) } ++func (s mapKeys) Swap(i, j int) { s[i], s[j] = s[j], s[i] } ++func (s mapKeys) Less(i, j int) bool { ++ if k := s[i].Kind(); k == s[j].Kind() { ++ switch k { ++ case reflect.Int32, reflect.Int64: ++ return s[i].Int() < s[j].Int() ++ case reflect.Uint32, reflect.Uint64: ++ return s[i].Uint() < s[j].Uint() ++ } ++ } ++ return fmt.Sprint(s[i].Interface()) < fmt.Sprint(s[j].Interface()) ++} +diff --git a/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/more_test_objects.pb.go b/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/more_test_objects.pb.go +new file mode 100644 +index 0000000..d6ff641 +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/more_test_objects.pb.go +@@ -0,0 +1,207 @@ ++// Code generated by protoc-gen-go. ++// source: more_test_objects.proto ++// DO NOT EDIT! ++ ++/* ++Package jsonpb is a generated protocol buffer package. ++ ++It is generated from these files: ++ more_test_objects.proto ++ test_objects.proto ++ ++It has these top-level messages: ++ Simple3 ++ Mappy ++ Simple ++ Repeats ++ Widget ++ Maps ++ MsgWithOneof ++ Real ++ Complex ++ KnownTypes ++*/ ++package jsonpb ++ ++import proto "github.com/golang/protobuf/proto" ++import fmt "fmt" ++import math "math" ++ ++// Reference imports to suppress errors if they are not otherwise used. ++var _ = proto.Marshal ++var _ = fmt.Errorf ++var _ = math.Inf ++ ++// This is a compile-time assertion to ensure that this generated file ++// is compatible with the proto package it is being compiled against. ++// A compilation error at this line likely means your copy of the ++// proto package needs to be updated. ++const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package ++ ++type Numeral int32 ++ ++const ( ++ Numeral_UNKNOWN Numeral = 0 ++ Numeral_ARABIC Numeral = 1 ++ Numeral_ROMAN Numeral = 2 ++) ++ ++var Numeral_name = map[int32]string{ ++ 0: "UNKNOWN", ++ 1: "ARABIC", ++ 2: "ROMAN", ++} ++var Numeral_value = map[string]int32{ ++ "UNKNOWN": 0, ++ "ARABIC": 1, ++ "ROMAN": 2, ++} ++ ++func (x Numeral) String() string { ++ return proto.EnumName(Numeral_name, int32(x)) ++} ++func (Numeral) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } ++ ++type Simple3 struct { ++ Dub float64 `protobuf:"fixed64,1,opt,name=dub" json:"dub,omitempty"` ++} ++ ++func (m *Simple3) Reset() { *m = Simple3{} } ++func (m *Simple3) String() string { return proto.CompactTextString(m) } ++func (*Simple3) ProtoMessage() {} ++func (*Simple3) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } ++ ++func (m *Simple3) GetDub() float64 { ++ if m != nil { ++ return m.Dub ++ } ++ return 0 ++} ++ ++type Mappy struct { ++ Nummy map[int64]int32 `protobuf:"bytes,1,rep,name=nummy" json:"nummy,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` ++ Strry map[string]string `protobuf:"bytes,2,rep,name=strry" json:"strry,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` ++ Objjy map[int32]*Simple3 `protobuf:"bytes,3,rep,name=objjy" json:"objjy,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` ++ Buggy map[int64]string `protobuf:"bytes,4,rep,name=buggy" json:"buggy,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` ++ Booly map[bool]bool `protobuf:"bytes,5,rep,name=booly" json:"booly,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` ++ Enumy map[string]Numeral `protobuf:"bytes,6,rep,name=enumy" json:"enumy,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=jsonpb.Numeral"` ++ S32Booly map[int32]bool `protobuf:"bytes,7,rep,name=s32booly" json:"s32booly,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` ++ S64Booly map[int64]bool `protobuf:"bytes,8,rep,name=s64booly" json:"s64booly,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` ++ U32Booly map[uint32]bool `protobuf:"bytes,9,rep,name=u32booly" json:"u32booly,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` ++ U64Booly map[uint64]bool `protobuf:"bytes,10,rep,name=u64booly" json:"u64booly,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` ++} ++ ++func (m *Mappy) Reset() { *m = Mappy{} } ++func (m *Mappy) String() string { return proto.CompactTextString(m) } ++func (*Mappy) ProtoMessage() {} ++func (*Mappy) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } ++ ++func (m *Mappy) GetNummy() map[int64]int32 { ++ if m != nil { ++ return m.Nummy ++ } ++ return nil ++} ++ ++func (m *Mappy) GetStrry() map[string]string { ++ if m != nil { ++ return m.Strry ++ } ++ return nil ++} ++ ++func (m *Mappy) GetObjjy() map[int32]*Simple3 { ++ if m != nil { ++ return m.Objjy ++ } ++ return nil ++} ++ ++func (m *Mappy) GetBuggy() map[int64]string { ++ if m != nil { ++ return m.Buggy ++ } ++ return nil ++} ++ ++func (m *Mappy) GetBooly() map[bool]bool { ++ if m != nil { ++ return m.Booly ++ } ++ return nil ++} ++ ++func (m *Mappy) GetEnumy() map[string]Numeral { ++ if m != nil { ++ return m.Enumy ++ } ++ return nil ++} ++ ++func (m *Mappy) GetS32Booly() map[int32]bool { ++ if m != nil { ++ return m.S32Booly ++ } ++ return nil ++} ++ ++func (m *Mappy) GetS64Booly() map[int64]bool { ++ if m != nil { ++ return m.S64Booly ++ } ++ return nil ++} ++ ++func (m *Mappy) GetU32Booly() map[uint32]bool { ++ if m != nil { ++ return m.U32Booly ++ } ++ return nil ++} ++ ++func (m *Mappy) GetU64Booly() map[uint64]bool { ++ if m != nil { ++ return m.U64Booly ++ } ++ return nil ++} ++ ++func init() { ++ proto.RegisterType((*Simple3)(nil), "jsonpb.Simple3") ++ proto.RegisterType((*Mappy)(nil), "jsonpb.Mappy") ++ proto.RegisterEnum("jsonpb.Numeral", Numeral_name, Numeral_value) ++} ++ ++func init() { proto.RegisterFile("more_test_objects.proto", fileDescriptor0) } ++ ++var fileDescriptor0 = []byte{ ++ // 444 bytes of a gzipped FileDescriptorProto ++ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x94, 0xc1, 0x6b, 0xdb, 0x30, ++ 0x14, 0x87, 0xe7, 0xa4, 0x4e, 0xec, 0x17, 0xba, 0x19, 0x31, 0x98, 0x58, 0x2f, 0xa1, 0x30, 0x08, ++ 0x83, 0xf9, 0x90, 0x8c, 0xad, 0x6c, 0xa7, 0x74, 0xf4, 0x50, 0x46, 0x1d, 0x70, 0x09, 0x3b, 0x96, ++ 0x78, 0x13, 0x65, 0x9e, 0x6d, 0x19, 0xdb, 0x1a, 0xe8, 0x8f, 0x1f, 0x8c, 0x27, 0xcb, 0xb5, 0x6c, ++ 0x14, 0xd2, 0x9b, 0xcc, 0xef, 0xfb, 0xf2, 0x9e, 0xf4, 0x1e, 0x81, 0x37, 0x39, 0xaf, 0xd8, 0x43, ++ 0xc3, 0xea, 0xe6, 0x81, 0x27, 0x29, 0xfb, 0xd9, 0xd4, 0x61, 0x59, 0xf1, 0x86, 0x93, 0x59, 0x5a, ++ 0xf3, 0xa2, 0x4c, 0x2e, 0x2f, 0x60, 0x7e, 0xff, 0x3b, 0x2f, 0x33, 0xb6, 0x21, 0x01, 0x4c, 0x7f, ++ 0x89, 0x84, 0x3a, 0x4b, 0x67, 0xe5, 0xc4, 0x78, 0xbc, 0xfc, 0xe7, 0x81, 0x7b, 0x77, 0x28, 0x4b, ++ 0x49, 0x42, 0x70, 0x0b, 0x91, 0xe7, 0x92, 0x3a, 0xcb, 0xe9, 0x6a, 0xb1, 0xa6, 0x61, 0xab, 0x87, ++ 0x2a, 0x0d, 0x23, 0x8c, 0x6e, 0x8a, 0xa6, 0x92, 0x71, 0x8b, 0x21, 0x5f, 0x37, 0x55, 0x25, 0xe9, ++ 0xc4, 0xc6, 0xdf, 0x63, 0xa4, 0x79, 0x85, 0x21, 0xcf, 0x93, 0x34, 0x95, 0x74, 0x6a, 0xe3, 0x77, ++ 0x18, 0x69, 0x5e, 0x61, 0xc8, 0x27, 0xe2, 0xf1, 0x51, 0xd2, 0x33, 0x1b, 0x7f, 0x8d, 0x91, 0xe6, ++ 0x15, 0xa6, 0x78, 0xce, 0x33, 0x49, 0x5d, 0x2b, 0x8f, 0x51, 0xc7, 0xe3, 0x19, 0x79, 0x56, 0x88, ++ 0x5c, 0xd2, 0x99, 0x8d, 0xbf, 0xc1, 0x48, 0xf3, 0x0a, 0x23, 0x9f, 0xc1, 0xab, 0x37, 0xeb, 0xb6, ++ 0xc4, 0x5c, 0x29, 0x17, 0xa3, 0x2b, 0xeb, 0xb4, 0xb5, 0x9e, 0x60, 0x25, 0x7e, 0xfa, 0xd8, 0x8a, ++ 0x9e, 0x55, 0xd4, 0x69, 0x27, 0xea, 0x4f, 0x14, 0x45, 0x57, 0xd1, 0xb7, 0x89, 0xfb, 0x61, 0x45, ++ 0x61, 0x54, 0x14, 0x5d, 0x45, 0xb0, 0x8a, 0xc3, 0x8a, 0x1d, 0xfc, 0xf6, 0x0a, 0xa0, 0x1f, 0x34, ++ 0x6e, 0xcb, 0x1f, 0x26, 0xd5, 0xb6, 0x4c, 0x63, 0x3c, 0x92, 0xd7, 0xe0, 0xfe, 0x3d, 0x64, 0x82, ++ 0xd1, 0xc9, 0xd2, 0x59, 0xb9, 0x71, 0xfb, 0xf1, 0x65, 0x72, 0xe5, 0xa0, 0xd9, 0x8f, 0xdc, 0x34, ++ 0x7d, 0x8b, 0xe9, 0x9b, 0xe6, 0x2d, 0x40, 0x3f, 0x7c, 0xd3, 0x74, 0x5b, 0xf3, 0x9d, 0x69, 0x2e, ++ 0xd6, 0xaf, 0xba, 0x9b, 0xe8, 0x9d, 0x1e, 0x35, 0xd1, 0xef, 0xc5, 0xa9, 0xf6, 0xfd, 0xb1, 0xf9, ++ 0xf4, 0x20, 0xa6, 0xe9, 0x59, 0x4c, 0x6f, 0xd4, 0x7e, 0xbf, 0x2b, 0x96, 0x8b, 0x0f, 0xda, 0x7f, ++ 0xd9, 0xb7, 0x1f, 0x89, 0x9c, 0x55, 0x87, 0xcc, 0xfc, 0xa9, 0xaf, 0x70, 0x3e, 0xd8, 0x21, 0xcb, ++ 0x63, 0x1c, 0xef, 0x03, 0x65, 0x73, 0xaa, 0xa7, 0xae, 0x3f, 0x96, 0xf7, 0xc7, 0x2a, 0x9f, 0x3f, ++ 0x47, 0x3e, 0x56, 0xf9, 0xec, 0x84, 0xfc, 0xfe, 0x03, 0xcc, 0xf5, 0x4b, 0x90, 0x05, 0xcc, 0xf7, ++ 0xd1, 0xf7, 0x68, 0xf7, 0x23, 0x0a, 0x5e, 0x10, 0x80, 0xd9, 0x36, 0xde, 0x5e, 0xdf, 0x7e, 0x0b, ++ 0x1c, 0xe2, 0x83, 0x1b, 0xef, 0xee, 0xb6, 0x51, 0x30, 0x49, 0x66, 0xea, 0xaf, 0x6d, 0xf3, 0x3f, ++ 0x00, 0x00, 0xff, 0xff, 0xa2, 0x4b, 0xe1, 0x77, 0xf5, 0x04, 0x00, 0x00, ++} +diff --git a/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/more_test_objects.proto b/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/more_test_objects.proto +new file mode 100644 +index 0000000..43b440e +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/more_test_objects.proto +@@ -0,0 +1,57 @@ ++// Go support for Protocol Buffers - Google's data interchange format ++// ++// Copyright 2015 The Go Authors. All rights reserved. ++// https://github.com/golang/protobuf ++// ++// Redistribution and use in source and binary forms, with or without ++// modification, are permitted provided that the following conditions are ++// met: ++// ++// * Redistributions of source code must retain the above copyright ++// notice, this list of conditions and the following disclaimer. ++// * Redistributions in binary form must reproduce the above ++// copyright notice, this list of conditions and the following disclaimer ++// in the documentation and/or other materials provided with the ++// distribution. ++// * Neither the name of Google Inc. nor the names of its ++// contributors may be used to endorse or promote products derived from ++// this software without specific prior written permission. ++// ++// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++syntax = "proto3"; ++ ++package jsonpb; ++ ++message Simple3 { ++ double dub = 1; ++} ++ ++enum Numeral { ++ UNKNOWN = 0; ++ ARABIC = 1; ++ ROMAN = 2; ++} ++ ++message Mappy { ++ map nummy = 1; ++ map strry = 2; ++ map objjy = 3; ++ map buggy = 4; ++ map booly = 5; ++ map enumy = 6; ++ map s32booly = 7; ++ map s64booly = 8; ++ map u32booly = 9; ++ map u64booly = 10; ++} +diff --git a/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/test_objects.pb.go b/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/test_objects.pb.go +new file mode 100644 +index 0000000..3c5652f +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/test_objects.pb.go +@@ -0,0 +1,789 @@ ++// Code generated by protoc-gen-go. ++// source: test_objects.proto ++// DO NOT EDIT! ++ ++package jsonpb ++ ++import proto "github.com/golang/protobuf/proto" ++import fmt "fmt" ++import math "math" ++import google_protobuf "github.com/golang/protobuf/ptypes/any" ++import google_protobuf1 "github.com/golang/protobuf/ptypes/duration" ++import google_protobuf2 "github.com/golang/protobuf/ptypes/struct" ++import google_protobuf3 "github.com/golang/protobuf/ptypes/timestamp" ++import google_protobuf4 "github.com/golang/protobuf/ptypes/wrappers" ++ ++// Reference imports to suppress errors if they are not otherwise used. ++var _ = proto.Marshal ++var _ = fmt.Errorf ++var _ = math.Inf ++ ++type Widget_Color int32 ++ ++const ( ++ Widget_RED Widget_Color = 0 ++ Widget_GREEN Widget_Color = 1 ++ Widget_BLUE Widget_Color = 2 ++) ++ ++var Widget_Color_name = map[int32]string{ ++ 0: "RED", ++ 1: "GREEN", ++ 2: "BLUE", ++} ++var Widget_Color_value = map[string]int32{ ++ "RED": 0, ++ "GREEN": 1, ++ "BLUE": 2, ++} ++ ++func (x Widget_Color) Enum() *Widget_Color { ++ p := new(Widget_Color) ++ *p = x ++ return p ++} ++func (x Widget_Color) String() string { ++ return proto.EnumName(Widget_Color_name, int32(x)) ++} ++func (x *Widget_Color) UnmarshalJSON(data []byte) error { ++ value, err := proto.UnmarshalJSONEnum(Widget_Color_value, data, "Widget_Color") ++ if err != nil { ++ return err ++ } ++ *x = Widget_Color(value) ++ return nil ++} ++func (Widget_Color) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{2, 0} } ++ ++// Test message for holding primitive types. ++type Simple struct { ++ OBool *bool `protobuf:"varint,1,opt,name=o_bool,json=oBool" json:"o_bool,omitempty"` ++ OInt32 *int32 `protobuf:"varint,2,opt,name=o_int32,json=oInt32" json:"o_int32,omitempty"` ++ OInt64 *int64 `protobuf:"varint,3,opt,name=o_int64,json=oInt64" json:"o_int64,omitempty"` ++ OUint32 *uint32 `protobuf:"varint,4,opt,name=o_uint32,json=oUint32" json:"o_uint32,omitempty"` ++ OUint64 *uint64 `protobuf:"varint,5,opt,name=o_uint64,json=oUint64" json:"o_uint64,omitempty"` ++ OSint32 *int32 `protobuf:"zigzag32,6,opt,name=o_sint32,json=oSint32" json:"o_sint32,omitempty"` ++ OSint64 *int64 `protobuf:"zigzag64,7,opt,name=o_sint64,json=oSint64" json:"o_sint64,omitempty"` ++ OFloat *float32 `protobuf:"fixed32,8,opt,name=o_float,json=oFloat" json:"o_float,omitempty"` ++ ODouble *float64 `protobuf:"fixed64,9,opt,name=o_double,json=oDouble" json:"o_double,omitempty"` ++ OString *string `protobuf:"bytes,10,opt,name=o_string,json=oString" json:"o_string,omitempty"` ++ OBytes []byte `protobuf:"bytes,11,opt,name=o_bytes,json=oBytes" json:"o_bytes,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *Simple) Reset() { *m = Simple{} } ++func (m *Simple) String() string { return proto.CompactTextString(m) } ++func (*Simple) ProtoMessage() {} ++func (*Simple) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} } ++ ++func (m *Simple) GetOBool() bool { ++ if m != nil && m.OBool != nil { ++ return *m.OBool ++ } ++ return false ++} ++ ++func (m *Simple) GetOInt32() int32 { ++ if m != nil && m.OInt32 != nil { ++ return *m.OInt32 ++ } ++ return 0 ++} ++ ++func (m *Simple) GetOInt64() int64 { ++ if m != nil && m.OInt64 != nil { ++ return *m.OInt64 ++ } ++ return 0 ++} ++ ++func (m *Simple) GetOUint32() uint32 { ++ if m != nil && m.OUint32 != nil { ++ return *m.OUint32 ++ } ++ return 0 ++} ++ ++func (m *Simple) GetOUint64() uint64 { ++ if m != nil && m.OUint64 != nil { ++ return *m.OUint64 ++ } ++ return 0 ++} ++ ++func (m *Simple) GetOSint32() int32 { ++ if m != nil && m.OSint32 != nil { ++ return *m.OSint32 ++ } ++ return 0 ++} ++ ++func (m *Simple) GetOSint64() int64 { ++ if m != nil && m.OSint64 != nil { ++ return *m.OSint64 ++ } ++ return 0 ++} ++ ++func (m *Simple) GetOFloat() float32 { ++ if m != nil && m.OFloat != nil { ++ return *m.OFloat ++ } ++ return 0 ++} ++ ++func (m *Simple) GetODouble() float64 { ++ if m != nil && m.ODouble != nil { ++ return *m.ODouble ++ } ++ return 0 ++} ++ ++func (m *Simple) GetOString() string { ++ if m != nil && m.OString != nil { ++ return *m.OString ++ } ++ return "" ++} ++ ++func (m *Simple) GetOBytes() []byte { ++ if m != nil { ++ return m.OBytes ++ } ++ return nil ++} ++ ++// Test message for holding repeated primitives. ++type Repeats struct { ++ RBool []bool `protobuf:"varint,1,rep,name=r_bool,json=rBool" json:"r_bool,omitempty"` ++ RInt32 []int32 `protobuf:"varint,2,rep,name=r_int32,json=rInt32" json:"r_int32,omitempty"` ++ RInt64 []int64 `protobuf:"varint,3,rep,name=r_int64,json=rInt64" json:"r_int64,omitempty"` ++ RUint32 []uint32 `protobuf:"varint,4,rep,name=r_uint32,json=rUint32" json:"r_uint32,omitempty"` ++ RUint64 []uint64 `protobuf:"varint,5,rep,name=r_uint64,json=rUint64" json:"r_uint64,omitempty"` ++ RSint32 []int32 `protobuf:"zigzag32,6,rep,name=r_sint32,json=rSint32" json:"r_sint32,omitempty"` ++ RSint64 []int64 `protobuf:"zigzag64,7,rep,name=r_sint64,json=rSint64" json:"r_sint64,omitempty"` ++ RFloat []float32 `protobuf:"fixed32,8,rep,name=r_float,json=rFloat" json:"r_float,omitempty"` ++ RDouble []float64 `protobuf:"fixed64,9,rep,name=r_double,json=rDouble" json:"r_double,omitempty"` ++ RString []string `protobuf:"bytes,10,rep,name=r_string,json=rString" json:"r_string,omitempty"` ++ RBytes [][]byte `protobuf:"bytes,11,rep,name=r_bytes,json=rBytes" json:"r_bytes,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *Repeats) Reset() { *m = Repeats{} } ++func (m *Repeats) String() string { return proto.CompactTextString(m) } ++func (*Repeats) ProtoMessage() {} ++func (*Repeats) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} } ++ ++func (m *Repeats) GetRBool() []bool { ++ if m != nil { ++ return m.RBool ++ } ++ return nil ++} ++ ++func (m *Repeats) GetRInt32() []int32 { ++ if m != nil { ++ return m.RInt32 ++ } ++ return nil ++} ++ ++func (m *Repeats) GetRInt64() []int64 { ++ if m != nil { ++ return m.RInt64 ++ } ++ return nil ++} ++ ++func (m *Repeats) GetRUint32() []uint32 { ++ if m != nil { ++ return m.RUint32 ++ } ++ return nil ++} ++ ++func (m *Repeats) GetRUint64() []uint64 { ++ if m != nil { ++ return m.RUint64 ++ } ++ return nil ++} ++ ++func (m *Repeats) GetRSint32() []int32 { ++ if m != nil { ++ return m.RSint32 ++ } ++ return nil ++} ++ ++func (m *Repeats) GetRSint64() []int64 { ++ if m != nil { ++ return m.RSint64 ++ } ++ return nil ++} ++ ++func (m *Repeats) GetRFloat() []float32 { ++ if m != nil { ++ return m.RFloat ++ } ++ return nil ++} ++ ++func (m *Repeats) GetRDouble() []float64 { ++ if m != nil { ++ return m.RDouble ++ } ++ return nil ++} ++ ++func (m *Repeats) GetRString() []string { ++ if m != nil { ++ return m.RString ++ } ++ return nil ++} ++ ++func (m *Repeats) GetRBytes() [][]byte { ++ if m != nil { ++ return m.RBytes ++ } ++ return nil ++} ++ ++// Test message for holding enums and nested messages. ++type Widget struct { ++ Color *Widget_Color `protobuf:"varint,1,opt,name=color,enum=jsonpb.Widget_Color" json:"color,omitempty"` ++ RColor []Widget_Color `protobuf:"varint,2,rep,name=r_color,json=rColor,enum=jsonpb.Widget_Color" json:"r_color,omitempty"` ++ Simple *Simple `protobuf:"bytes,10,opt,name=simple" json:"simple,omitempty"` ++ RSimple []*Simple `protobuf:"bytes,11,rep,name=r_simple,json=rSimple" json:"r_simple,omitempty"` ++ Repeats *Repeats `protobuf:"bytes,20,opt,name=repeats" json:"repeats,omitempty"` ++ RRepeats []*Repeats `protobuf:"bytes,21,rep,name=r_repeats,json=rRepeats" json:"r_repeats,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *Widget) Reset() { *m = Widget{} } ++func (m *Widget) String() string { return proto.CompactTextString(m) } ++func (*Widget) ProtoMessage() {} ++func (*Widget) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} } ++ ++func (m *Widget) GetColor() Widget_Color { ++ if m != nil && m.Color != nil { ++ return *m.Color ++ } ++ return Widget_RED ++} ++ ++func (m *Widget) GetRColor() []Widget_Color { ++ if m != nil { ++ return m.RColor ++ } ++ return nil ++} ++ ++func (m *Widget) GetSimple() *Simple { ++ if m != nil { ++ return m.Simple ++ } ++ return nil ++} ++ ++func (m *Widget) GetRSimple() []*Simple { ++ if m != nil { ++ return m.RSimple ++ } ++ return nil ++} ++ ++func (m *Widget) GetRepeats() *Repeats { ++ if m != nil { ++ return m.Repeats ++ } ++ return nil ++} ++ ++func (m *Widget) GetRRepeats() []*Repeats { ++ if m != nil { ++ return m.RRepeats ++ } ++ return nil ++} ++ ++type Maps struct { ++ MInt64Str map[int64]string `protobuf:"bytes,1,rep,name=m_int64_str,json=mInt64Str" json:"m_int64_str,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` ++ MBoolSimple map[bool]*Simple `protobuf:"bytes,2,rep,name=m_bool_simple,json=mBoolSimple" json:"m_bool_simple,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *Maps) Reset() { *m = Maps{} } ++func (m *Maps) String() string { return proto.CompactTextString(m) } ++func (*Maps) ProtoMessage() {} ++func (*Maps) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} } ++ ++func (m *Maps) GetMInt64Str() map[int64]string { ++ if m != nil { ++ return m.MInt64Str ++ } ++ return nil ++} ++ ++func (m *Maps) GetMBoolSimple() map[bool]*Simple { ++ if m != nil { ++ return m.MBoolSimple ++ } ++ return nil ++} ++ ++type MsgWithOneof struct { ++ // Types that are valid to be assigned to Union: ++ // *MsgWithOneof_Title ++ // *MsgWithOneof_Salary ++ // *MsgWithOneof_Country ++ // *MsgWithOneof_HomeAddress ++ Union isMsgWithOneof_Union `protobuf_oneof:"union"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *MsgWithOneof) Reset() { *m = MsgWithOneof{} } ++func (m *MsgWithOneof) String() string { return proto.CompactTextString(m) } ++func (*MsgWithOneof) ProtoMessage() {} ++func (*MsgWithOneof) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{4} } ++ ++type isMsgWithOneof_Union interface { ++ isMsgWithOneof_Union() ++} ++ ++type MsgWithOneof_Title struct { ++ Title string `protobuf:"bytes,1,opt,name=title,oneof"` ++} ++type MsgWithOneof_Salary struct { ++ Salary int64 `protobuf:"varint,2,opt,name=salary,oneof"` ++} ++type MsgWithOneof_Country struct { ++ Country string `protobuf:"bytes,3,opt,name=Country,oneof"` ++} ++type MsgWithOneof_HomeAddress struct { ++ HomeAddress string `protobuf:"bytes,4,opt,name=home_address,json=homeAddress,oneof"` ++} ++ ++func (*MsgWithOneof_Title) isMsgWithOneof_Union() {} ++func (*MsgWithOneof_Salary) isMsgWithOneof_Union() {} ++func (*MsgWithOneof_Country) isMsgWithOneof_Union() {} ++func (*MsgWithOneof_HomeAddress) isMsgWithOneof_Union() {} ++ ++func (m *MsgWithOneof) GetUnion() isMsgWithOneof_Union { ++ if m != nil { ++ return m.Union ++ } ++ return nil ++} ++ ++func (m *MsgWithOneof) GetTitle() string { ++ if x, ok := m.GetUnion().(*MsgWithOneof_Title); ok { ++ return x.Title ++ } ++ return "" ++} ++ ++func (m *MsgWithOneof) GetSalary() int64 { ++ if x, ok := m.GetUnion().(*MsgWithOneof_Salary); ok { ++ return x.Salary ++ } ++ return 0 ++} ++ ++func (m *MsgWithOneof) GetCountry() string { ++ if x, ok := m.GetUnion().(*MsgWithOneof_Country); ok { ++ return x.Country ++ } ++ return "" ++} ++ ++func (m *MsgWithOneof) GetHomeAddress() string { ++ if x, ok := m.GetUnion().(*MsgWithOneof_HomeAddress); ok { ++ return x.HomeAddress ++ } ++ return "" ++} ++ ++// XXX_OneofFuncs is for the internal use of the proto package. ++func (*MsgWithOneof) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { ++ return _MsgWithOneof_OneofMarshaler, _MsgWithOneof_OneofUnmarshaler, _MsgWithOneof_OneofSizer, []interface{}{ ++ (*MsgWithOneof_Title)(nil), ++ (*MsgWithOneof_Salary)(nil), ++ (*MsgWithOneof_Country)(nil), ++ (*MsgWithOneof_HomeAddress)(nil), ++ } ++} ++ ++func _MsgWithOneof_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { ++ m := msg.(*MsgWithOneof) ++ // union ++ switch x := m.Union.(type) { ++ case *MsgWithOneof_Title: ++ b.EncodeVarint(1<<3 | proto.WireBytes) ++ b.EncodeStringBytes(x.Title) ++ case *MsgWithOneof_Salary: ++ b.EncodeVarint(2<<3 | proto.WireVarint) ++ b.EncodeVarint(uint64(x.Salary)) ++ case *MsgWithOneof_Country: ++ b.EncodeVarint(3<<3 | proto.WireBytes) ++ b.EncodeStringBytes(x.Country) ++ case *MsgWithOneof_HomeAddress: ++ b.EncodeVarint(4<<3 | proto.WireBytes) ++ b.EncodeStringBytes(x.HomeAddress) ++ case nil: ++ default: ++ return fmt.Errorf("MsgWithOneof.Union has unexpected type %T", x) ++ } ++ return nil ++} ++ ++func _MsgWithOneof_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { ++ m := msg.(*MsgWithOneof) ++ switch tag { ++ case 1: // union.title ++ if wire != proto.WireBytes { ++ return true, proto.ErrInternalBadWireType ++ } ++ x, err := b.DecodeStringBytes() ++ m.Union = &MsgWithOneof_Title{x} ++ return true, err ++ case 2: // union.salary ++ if wire != proto.WireVarint { ++ return true, proto.ErrInternalBadWireType ++ } ++ x, err := b.DecodeVarint() ++ m.Union = &MsgWithOneof_Salary{int64(x)} ++ return true, err ++ case 3: // union.Country ++ if wire != proto.WireBytes { ++ return true, proto.ErrInternalBadWireType ++ } ++ x, err := b.DecodeStringBytes() ++ m.Union = &MsgWithOneof_Country{x} ++ return true, err ++ case 4: // union.home_address ++ if wire != proto.WireBytes { ++ return true, proto.ErrInternalBadWireType ++ } ++ x, err := b.DecodeStringBytes() ++ m.Union = &MsgWithOneof_HomeAddress{x} ++ return true, err ++ default: ++ return false, nil ++ } ++} ++ ++func _MsgWithOneof_OneofSizer(msg proto.Message) (n int) { ++ m := msg.(*MsgWithOneof) ++ // union ++ switch x := m.Union.(type) { ++ case *MsgWithOneof_Title: ++ n += proto.SizeVarint(1<<3 | proto.WireBytes) ++ n += proto.SizeVarint(uint64(len(x.Title))) ++ n += len(x.Title) ++ case *MsgWithOneof_Salary: ++ n += proto.SizeVarint(2<<3 | proto.WireVarint) ++ n += proto.SizeVarint(uint64(x.Salary)) ++ case *MsgWithOneof_Country: ++ n += proto.SizeVarint(3<<3 | proto.WireBytes) ++ n += proto.SizeVarint(uint64(len(x.Country))) ++ n += len(x.Country) ++ case *MsgWithOneof_HomeAddress: ++ n += proto.SizeVarint(4<<3 | proto.WireBytes) ++ n += proto.SizeVarint(uint64(len(x.HomeAddress))) ++ n += len(x.HomeAddress) ++ case nil: ++ default: ++ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) ++ } ++ return n ++} ++ ++type Real struct { ++ Value *float64 `protobuf:"fixed64,1,opt,name=value" json:"value,omitempty"` ++ proto.XXX_InternalExtensions `json:"-"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *Real) Reset() { *m = Real{} } ++func (m *Real) String() string { return proto.CompactTextString(m) } ++func (*Real) ProtoMessage() {} ++func (*Real) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{5} } ++ ++var extRange_Real = []proto.ExtensionRange{ ++ {100, 536870911}, ++} ++ ++func (*Real) ExtensionRangeArray() []proto.ExtensionRange { ++ return extRange_Real ++} ++ ++func (m *Real) GetValue() float64 { ++ if m != nil && m.Value != nil { ++ return *m.Value ++ } ++ return 0 ++} ++ ++type Complex struct { ++ Imaginary *float64 `protobuf:"fixed64,1,opt,name=imaginary" json:"imaginary,omitempty"` ++ proto.XXX_InternalExtensions `json:"-"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *Complex) Reset() { *m = Complex{} } ++func (m *Complex) String() string { return proto.CompactTextString(m) } ++func (*Complex) ProtoMessage() {} ++func (*Complex) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{6} } ++ ++var extRange_Complex = []proto.ExtensionRange{ ++ {100, 536870911}, ++} ++ ++func (*Complex) ExtensionRangeArray() []proto.ExtensionRange { ++ return extRange_Complex ++} ++ ++func (m *Complex) GetImaginary() float64 { ++ if m != nil && m.Imaginary != nil { ++ return *m.Imaginary ++ } ++ return 0 ++} ++ ++var E_Complex_RealExtension = &proto.ExtensionDesc{ ++ ExtendedType: (*Real)(nil), ++ ExtensionType: (*Complex)(nil), ++ Field: 123, ++ Name: "jsonpb.Complex.real_extension", ++ Tag: "bytes,123,opt,name=real_extension,json=realExtension", ++ Filename: "test_objects.proto", ++} ++ ++type KnownTypes struct { ++ An *google_protobuf.Any `protobuf:"bytes,14,opt,name=an" json:"an,omitempty"` ++ Dur *google_protobuf1.Duration `protobuf:"bytes,1,opt,name=dur" json:"dur,omitempty"` ++ St *google_protobuf2.Struct `protobuf:"bytes,12,opt,name=st" json:"st,omitempty"` ++ Ts *google_protobuf3.Timestamp `protobuf:"bytes,2,opt,name=ts" json:"ts,omitempty"` ++ Lv *google_protobuf2.ListValue `protobuf:"bytes,15,opt,name=lv" json:"lv,omitempty"` ++ Val *google_protobuf2.Value `protobuf:"bytes,16,opt,name=val" json:"val,omitempty"` ++ Dbl *google_protobuf4.DoubleValue `protobuf:"bytes,3,opt,name=dbl" json:"dbl,omitempty"` ++ Flt *google_protobuf4.FloatValue `protobuf:"bytes,4,opt,name=flt" json:"flt,omitempty"` ++ I64 *google_protobuf4.Int64Value `protobuf:"bytes,5,opt,name=i64" json:"i64,omitempty"` ++ U64 *google_protobuf4.UInt64Value `protobuf:"bytes,6,opt,name=u64" json:"u64,omitempty"` ++ I32 *google_protobuf4.Int32Value `protobuf:"bytes,7,opt,name=i32" json:"i32,omitempty"` ++ U32 *google_protobuf4.UInt32Value `protobuf:"bytes,8,opt,name=u32" json:"u32,omitempty"` ++ Bool *google_protobuf4.BoolValue `protobuf:"bytes,9,opt,name=bool" json:"bool,omitempty"` ++ Str *google_protobuf4.StringValue `protobuf:"bytes,10,opt,name=str" json:"str,omitempty"` ++ Bytes *google_protobuf4.BytesValue `protobuf:"bytes,11,opt,name=bytes" json:"bytes,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *KnownTypes) Reset() { *m = KnownTypes{} } ++func (m *KnownTypes) String() string { return proto.CompactTextString(m) } ++func (*KnownTypes) ProtoMessage() {} ++func (*KnownTypes) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{7} } ++ ++func (m *KnownTypes) GetAn() *google_protobuf.Any { ++ if m != nil { ++ return m.An ++ } ++ return nil ++} ++ ++func (m *KnownTypes) GetDur() *google_protobuf1.Duration { ++ if m != nil { ++ return m.Dur ++ } ++ return nil ++} ++ ++func (m *KnownTypes) GetSt() *google_protobuf2.Struct { ++ if m != nil { ++ return m.St ++ } ++ return nil ++} ++ ++func (m *KnownTypes) GetTs() *google_protobuf3.Timestamp { ++ if m != nil { ++ return m.Ts ++ } ++ return nil ++} ++ ++func (m *KnownTypes) GetLv() *google_protobuf2.ListValue { ++ if m != nil { ++ return m.Lv ++ } ++ return nil ++} ++ ++func (m *KnownTypes) GetVal() *google_protobuf2.Value { ++ if m != nil { ++ return m.Val ++ } ++ return nil ++} ++ ++func (m *KnownTypes) GetDbl() *google_protobuf4.DoubleValue { ++ if m != nil { ++ return m.Dbl ++ } ++ return nil ++} ++ ++func (m *KnownTypes) GetFlt() *google_protobuf4.FloatValue { ++ if m != nil { ++ return m.Flt ++ } ++ return nil ++} ++ ++func (m *KnownTypes) GetI64() *google_protobuf4.Int64Value { ++ if m != nil { ++ return m.I64 ++ } ++ return nil ++} ++ ++func (m *KnownTypes) GetU64() *google_protobuf4.UInt64Value { ++ if m != nil { ++ return m.U64 ++ } ++ return nil ++} ++ ++func (m *KnownTypes) GetI32() *google_protobuf4.Int32Value { ++ if m != nil { ++ return m.I32 ++ } ++ return nil ++} ++ ++func (m *KnownTypes) GetU32() *google_protobuf4.UInt32Value { ++ if m != nil { ++ return m.U32 ++ } ++ return nil ++} ++ ++func (m *KnownTypes) GetBool() *google_protobuf4.BoolValue { ++ if m != nil { ++ return m.Bool ++ } ++ return nil ++} ++ ++func (m *KnownTypes) GetStr() *google_protobuf4.StringValue { ++ if m != nil { ++ return m.Str ++ } ++ return nil ++} ++ ++func (m *KnownTypes) GetBytes() *google_protobuf4.BytesValue { ++ if m != nil { ++ return m.Bytes ++ } ++ return nil ++} ++ ++var E_Name = &proto.ExtensionDesc{ ++ ExtendedType: (*Real)(nil), ++ ExtensionType: (*string)(nil), ++ Field: 124, ++ Name: "jsonpb.name", ++ Tag: "bytes,124,opt,name=name", ++ Filename: "test_objects.proto", ++} ++ ++func init() { ++ proto.RegisterType((*Simple)(nil), "jsonpb.Simple") ++ proto.RegisterType((*Repeats)(nil), "jsonpb.Repeats") ++ proto.RegisterType((*Widget)(nil), "jsonpb.Widget") ++ proto.RegisterType((*Maps)(nil), "jsonpb.Maps") ++ proto.RegisterType((*MsgWithOneof)(nil), "jsonpb.MsgWithOneof") ++ proto.RegisterType((*Real)(nil), "jsonpb.Real") ++ proto.RegisterType((*Complex)(nil), "jsonpb.Complex") ++ proto.RegisterType((*KnownTypes)(nil), "jsonpb.KnownTypes") ++ proto.RegisterEnum("jsonpb.Widget_Color", Widget_Color_name, Widget_Color_value) ++ proto.RegisterExtension(E_Complex_RealExtension) ++ proto.RegisterExtension(E_Name) ++} ++ ++func init() { proto.RegisterFile("test_objects.proto", fileDescriptor1) } ++ ++var fileDescriptor1 = []byte{ ++ // 1085 bytes of a gzipped FileDescriptorProto ++ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x95, 0xd1, 0x72, 0xdb, 0x44, ++ 0x17, 0xc7, 0x2b, 0xc9, 0x92, 0xed, 0x75, 0x9a, 0xfa, 0xdb, 0x49, 0x5b, 0xc5, 0x5f, 0x00, 0x8d, ++ 0x29, 0x45, 0x14, 0xea, 0x0e, 0x8a, 0xc7, 0xc3, 0x14, 0x6e, 0x92, 0xc6, 0x50, 0x86, 0xa6, 0xcc, ++ 0x6c, 0x1a, 0x7a, 0xe9, 0x91, 0xe3, 0x8d, 0xab, 0x22, 0x6b, 0x3d, 0xbb, 0xab, 0xa4, 0x1e, 0xb8, ++ 0xc8, 0x35, 0xd7, 0xbc, 0x02, 0x3c, 0x02, 0x17, 0x3c, 0x1d, 0x73, 0xce, 0x4a, 0x56, 0x62, 0xc7, ++ 0x57, 0xf1, 0xd1, 0xf9, 0x9f, 0x7f, 0x76, 0x7f, 0x7b, 0x76, 0x0f, 0xa1, 0x9a, 0x2b, 0x3d, 0x12, ++ 0xe3, 0xf7, 0xfc, 0x4c, 0xab, 0xde, 0x5c, 0x0a, 0x2d, 0xa8, 0xf7, 0x5e, 0x89, 0x6c, 0x3e, 0xee, ++ 0xec, 0x4e, 0x85, 0x98, 0xa6, 0xfc, 0x19, 0x7e, 0x1d, 0xe7, 0xe7, 0xcf, 0xe2, 0x6c, 0x61, 0x24, ++ 0x9d, 0x8f, 0x57, 0x53, 0x93, 0x5c, 0xc6, 0x3a, 0x11, 0x59, 0x91, 0xdf, 0x5b, 0xcd, 0x2b, 0x2d, ++ 0xf3, 0x33, 0x5d, 0x64, 0x3f, 0x59, 0xcd, 0xea, 0x64, 0xc6, 0x95, 0x8e, 0x67, 0xf3, 0x4d, 0xf6, ++ 0x97, 0x32, 0x9e, 0xcf, 0xb9, 0x2c, 0x56, 0xd8, 0xfd, 0xcb, 0x26, 0xde, 0x49, 0x32, 0x9b, 0xa7, ++ 0x9c, 0xde, 0x27, 0x9e, 0x18, 0x8d, 0x85, 0x48, 0x7d, 0x2b, 0xb0, 0xc2, 0x06, 0x73, 0xc5, 0xa1, ++ 0x10, 0x29, 0x7d, 0x48, 0xea, 0x62, 0x94, 0x64, 0x7a, 0x3f, 0xf2, 0xed, 0xc0, 0x0a, 0x5d, 0xe6, ++ 0x89, 0x1f, 0x21, 0x5a, 0x26, 0x06, 0x7d, 0xdf, 0x09, 0xac, 0xd0, 0x31, 0x89, 0x41, 0x9f, 0xee, ++ 0x92, 0x86, 0x18, 0xe5, 0xa6, 0xa4, 0x16, 0x58, 0xe1, 0x5d, 0x56, 0x17, 0xa7, 0x18, 0x56, 0xa9, ++ 0x41, 0xdf, 0x77, 0x03, 0x2b, 0xac, 0x15, 0xa9, 0xb2, 0x4a, 0x99, 0x2a, 0x2f, 0xb0, 0xc2, 0xff, ++ 0xb1, 0xba, 0x38, 0xb9, 0x56, 0xa5, 0x4c, 0x55, 0x3d, 0xb0, 0x42, 0x5a, 0xa4, 0x06, 0x7d, 0xb3, ++ 0x88, 0xf3, 0x54, 0xc4, 0xda, 0x6f, 0x04, 0x56, 0x68, 0x33, 0x4f, 0x7c, 0x0f, 0x91, 0xa9, 0x99, ++ 0x88, 0x7c, 0x9c, 0x72, 0xbf, 0x19, 0x58, 0xa1, 0xc5, 0xea, 0xe2, 0x08, 0xc3, 0xc2, 0x4e, 0xcb, ++ 0x24, 0x9b, 0xfa, 0x24, 0xb0, 0xc2, 0x26, 0xd8, 0x61, 0x68, 0xec, 0xc6, 0x0b, 0xcd, 0x95, 0xdf, ++ 0x0a, 0xac, 0x70, 0x8b, 0x79, 0xe2, 0x10, 0xa2, 0xee, 0xdf, 0x36, 0xa9, 0x33, 0x3e, 0xe7, 0xb1, ++ 0x56, 0x00, 0x4a, 0x96, 0xa0, 0x1c, 0x00, 0x25, 0x4b, 0x50, 0x72, 0x09, 0xca, 0x01, 0x50, 0x72, ++ 0x09, 0x4a, 0x2e, 0x41, 0x39, 0x00, 0x4a, 0x2e, 0x41, 0xc9, 0x0a, 0x94, 0x03, 0xa0, 0x64, 0x05, ++ 0x4a, 0x56, 0xa0, 0x1c, 0x00, 0x25, 0x2b, 0x50, 0xb2, 0x02, 0xe5, 0x00, 0x28, 0x79, 0x72, 0xad, ++ 0x6a, 0x09, 0xca, 0x01, 0x50, 0xb2, 0x02, 0x25, 0x97, 0xa0, 0x1c, 0x00, 0x25, 0x97, 0xa0, 0x64, ++ 0x05, 0xca, 0x01, 0x50, 0xb2, 0x02, 0x25, 0x2b, 0x50, 0x0e, 0x80, 0x92, 0x15, 0x28, 0xb9, 0x04, ++ 0xe5, 0x00, 0x28, 0x69, 0x40, 0xfd, 0x63, 0x13, 0xef, 0x6d, 0x32, 0x99, 0x72, 0x4d, 0x9f, 0x10, ++ 0xf7, 0x4c, 0xa4, 0x42, 0x62, 0x3f, 0x6d, 0x47, 0x3b, 0x3d, 0x73, 0x1b, 0x7a, 0x26, 0xdd, 0x7b, ++ 0x01, 0x39, 0x66, 0x24, 0xf4, 0x29, 0xf8, 0x19, 0x35, 0xc0, 0xdb, 0xa4, 0xf6, 0x24, 0xfe, 0xa5, ++ 0x8f, 0x89, 0xa7, 0xb0, 0x6b, 0xf1, 0x00, 0x5b, 0xd1, 0x76, 0xa9, 0x36, 0xbd, 0xcc, 0x8a, 0x2c, ++ 0xfd, 0xc2, 0x00, 0x41, 0x25, 0xac, 0x73, 0x5d, 0x09, 0x80, 0x0a, 0x69, 0x5d, 0x9a, 0x03, 0xf6, ++ 0x77, 0xd0, 0xf3, 0x5e, 0xa9, 0x2c, 0xce, 0x9d, 0x95, 0x79, 0xfa, 0x15, 0x69, 0xca, 0x51, 0x29, ++ 0xbe, 0x8f, 0xb6, 0x6b, 0xe2, 0x86, 0x2c, 0x7e, 0x75, 0x3f, 0x23, 0xae, 0x59, 0x74, 0x9d, 0x38, ++ 0x6c, 0x78, 0xd4, 0xbe, 0x43, 0x9b, 0xc4, 0xfd, 0x81, 0x0d, 0x87, 0xaf, 0xdb, 0x16, 0x6d, 0x90, ++ 0xda, 0xe1, 0xab, 0xd3, 0x61, 0xdb, 0xee, 0xfe, 0x69, 0x93, 0xda, 0x71, 0x3c, 0x57, 0xf4, 0x5b, ++ 0xd2, 0x9a, 0x99, 0x76, 0x01, 0xf6, 0xd8, 0x63, 0xad, 0xe8, 0xff, 0xa5, 0x3f, 0x48, 0x7a, 0xc7, ++ 0xd8, 0x3f, 0x27, 0x5a, 0x0e, 0x33, 0x2d, 0x17, 0xac, 0x39, 0x2b, 0x63, 0x7a, 0x40, 0xee, 0xce, ++ 0xb0, 0x37, 0xcb, 0x5d, 0xdb, 0x58, 0xfe, 0xd1, 0xcd, 0x72, 0xe8, 0x57, 0xb3, 0x6d, 0x63, 0xd0, ++ 0x9a, 0x55, 0x5f, 0x3a, 0xdf, 0x91, 0xed, 0x9b, 0xfe, 0xb4, 0x4d, 0x9c, 0x5f, 0xf9, 0x02, 0x8f, ++ 0xd1, 0x61, 0xf0, 0x93, 0xee, 0x10, 0xf7, 0x22, 0x4e, 0x73, 0x8e, 0x4f, 0x42, 0x93, 0x99, 0xe0, ++ 0xb9, 0xfd, 0x8d, 0xd5, 0x79, 0x4d, 0xda, 0xab, 0xf6, 0xd7, 0xeb, 0x1b, 0xa6, 0xfe, 0xd1, 0xf5, ++ 0xfa, 0xf5, 0x43, 0xa9, 0xfc, 0xba, 0x7f, 0x58, 0x64, 0xeb, 0x58, 0x4d, 0xdf, 0x26, 0xfa, 0xdd, ++ 0xcf, 0x19, 0x17, 0xe7, 0xf4, 0x01, 0x71, 0x75, 0xa2, 0x53, 0x8e, 0x76, 0xcd, 0x97, 0x77, 0x98, ++ 0x09, 0xa9, 0x4f, 0x3c, 0x15, 0xa7, 0xb1, 0x5c, 0xa0, 0xa7, 0xf3, 0xf2, 0x0e, 0x2b, 0x62, 0xda, ++ 0x21, 0xf5, 0x17, 0x22, 0x87, 0x95, 0xe0, 0x43, 0x05, 0x35, 0xe5, 0x07, 0xfa, 0x29, 0xd9, 0x7a, ++ 0x27, 0x66, 0x7c, 0x14, 0x4f, 0x26, 0x92, 0x2b, 0x85, 0xef, 0x15, 0x08, 0x5a, 0xf0, 0xf5, 0xc0, ++ 0x7c, 0x3c, 0xac, 0x13, 0x37, 0xcf, 0x12, 0x91, 0x75, 0x1f, 0x93, 0x1a, 0xe3, 0x71, 0x5a, 0x6d, ++ 0xdf, 0xc2, 0x97, 0xc5, 0x04, 0x4f, 0x1a, 0x8d, 0x49, 0xfb, 0xea, 0xea, 0xea, 0xca, 0xee, 0x5e, ++ 0xc2, 0x7f, 0x84, 0x9d, 0x7c, 0xa0, 0x7b, 0xa4, 0x99, 0xcc, 0xe2, 0x69, 0x92, 0xc1, 0xca, 0x8c, ++ 0xbc, 0xfa, 0x50, 0x95, 0x44, 0x47, 0x64, 0x5b, 0xf2, 0x38, 0x1d, 0xf1, 0x0f, 0x9a, 0x67, 0x2a, ++ 0x11, 0x19, 0xdd, 0xaa, 0x5a, 0x2a, 0x4e, 0xfd, 0xdf, 0x6e, 0xf6, 0x64, 0x61, 0xcf, 0xee, 0x42, ++ 0xd1, 0xb0, 0xac, 0xe9, 0xfe, 0xeb, 0x12, 0xf2, 0x53, 0x26, 0x2e, 0xb3, 0x37, 0x8b, 0x39, 0x57, ++ 0xf4, 0x11, 0xb1, 0xe3, 0xcc, 0xdf, 0xc6, 0xd2, 0x9d, 0x9e, 0x19, 0x05, 0xbd, 0x72, 0x14, 0xf4, ++ 0x0e, 0xb2, 0x05, 0xb3, 0xe3, 0x8c, 0x7e, 0x49, 0x9c, 0x49, 0x6e, 0x6e, 0x69, 0x2b, 0xda, 0x5d, ++ 0x93, 0x1d, 0x15, 0x03, 0x89, 0x81, 0x8a, 0x7e, 0x4e, 0x6c, 0xa5, 0xfd, 0x2d, 0xd4, 0x3e, 0x5c, ++ 0xd3, 0x9e, 0xe0, 0x70, 0x62, 0xb6, 0x82, 0xdb, 0x6f, 0x6b, 0x55, 0x9c, 0x6f, 0x67, 0x4d, 0xf8, ++ 0xa6, 0x9c, 0x53, 0xcc, 0xd6, 0x0a, 0xb4, 0xe9, 0x85, 0x7f, 0x6f, 0x83, 0xf6, 0x55, 0xa2, 0xf4, ++ 0x2f, 0x40, 0x98, 0xd9, 0xe9, 0x05, 0x0d, 0x89, 0x73, 0x11, 0xa7, 0x7e, 0x1b, 0xc5, 0x0f, 0xd6, ++ 0xc4, 0x46, 0x08, 0x12, 0xda, 0x23, 0xce, 0x64, 0x9c, 0xe2, 0x99, 0xb7, 0xa2, 0xbd, 0xf5, 0x7d, ++ 0xe1, 0x23, 0x57, 0xe8, 0x27, 0xe3, 0x94, 0x3e, 0x25, 0xce, 0x79, 0xaa, 0xb1, 0x05, 0xe0, 0xc2, ++ 0xad, 0xea, 0xf1, 0xb9, 0x2c, 0xe4, 0xe7, 0xa9, 0x06, 0x79, 0x52, 0x8c, 0xb1, 0xdb, 0xe4, 0x78, ++ 0x85, 0x0a, 0x79, 0x32, 0xe8, 0xc3, 0x6a, 0xf2, 0x41, 0x1f, 0x47, 0xdb, 0x6d, 0xab, 0x39, 0xbd, ++ 0xae, 0xcf, 0x07, 0x7d, 0xb4, 0xdf, 0x8f, 0x70, 0xde, 0x6d, 0xb0, 0xdf, 0x8f, 0x4a, 0xfb, 0xfd, ++ 0x08, 0xed, 0xf7, 0x23, 0x1c, 0x82, 0x9b, 0xec, 0x97, 0xfa, 0x1c, 0xf5, 0x35, 0x1c, 0x61, 0xcd, ++ 0x0d, 0xd0, 0xe1, 0x0e, 0x1b, 0x39, 0xea, 0xc0, 0x1f, 0x5e, 0x23, 0xb2, 0xc1, 0xdf, 0x8c, 0x85, ++ 0xc2, 0x5f, 0x69, 0x49, 0xbf, 0x26, 0x6e, 0x35, 0x47, 0x6f, 0xdb, 0x00, 0x8e, 0x0b, 0x53, 0x60, ++ 0x94, 0xcf, 0x03, 0x52, 0xcb, 0xe2, 0x19, 0x5f, 0x69, 0xfc, 0xdf, 0xf1, 0x85, 0xc1, 0xcc, 0x7f, ++ 0x01, 0x00, 0x00, 0xff, 0xff, 0x46, 0x96, 0x41, 0x24, 0x64, 0x09, 0x00, 0x00, ++} +diff --git a/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/test_objects.proto b/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/test_objects.proto +new file mode 100644 +index 0000000..a493ecc +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/test_objects.proto +@@ -0,0 +1,137 @@ ++// Go support for Protocol Buffers - Google's data interchange format ++// ++// Copyright 2015 The Go Authors. All rights reserved. ++// https://github.com/golang/protobuf ++// ++// Redistribution and use in source and binary forms, with or without ++// modification, are permitted provided that the following conditions are ++// met: ++// ++// * Redistributions of source code must retain the above copyright ++// notice, this list of conditions and the following disclaimer. ++// * Redistributions in binary form must reproduce the above ++// copyright notice, this list of conditions and the following disclaimer ++// in the documentation and/or other materials provided with the ++// distribution. ++// * Neither the name of Google Inc. nor the names of its ++// contributors may be used to endorse or promote products derived from ++// this software without specific prior written permission. ++// ++// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++syntax = "proto2"; ++ ++import "google/protobuf/any.proto"; ++import "google/protobuf/duration.proto"; ++import "google/protobuf/struct.proto"; ++import "google/protobuf/timestamp.proto"; ++import "google/protobuf/wrappers.proto"; ++ ++package jsonpb; ++ ++// Test message for holding primitive types. ++message Simple { ++ optional bool o_bool = 1; ++ optional int32 o_int32 = 2; ++ optional int64 o_int64 = 3; ++ optional uint32 o_uint32 = 4; ++ optional uint64 o_uint64 = 5; ++ optional sint32 o_sint32 = 6; ++ optional sint64 o_sint64 = 7; ++ optional float o_float = 8; ++ optional double o_double = 9; ++ optional string o_string = 10; ++ optional bytes o_bytes = 11; ++} ++ ++// Test message for holding repeated primitives. ++message Repeats { ++ repeated bool r_bool = 1; ++ repeated int32 r_int32 = 2; ++ repeated int64 r_int64 = 3; ++ repeated uint32 r_uint32 = 4; ++ repeated uint64 r_uint64 = 5; ++ repeated sint32 r_sint32 = 6; ++ repeated sint64 r_sint64 = 7; ++ repeated float r_float = 8; ++ repeated double r_double = 9; ++ repeated string r_string = 10; ++ repeated bytes r_bytes = 11; ++} ++ ++// Test message for holding enums and nested messages. ++message Widget { ++ enum Color { ++ RED = 0; ++ GREEN = 1; ++ BLUE = 2; ++ }; ++ optional Color color = 1; ++ repeated Color r_color = 2; ++ ++ optional Simple simple = 10; ++ repeated Simple r_simple = 11; ++ ++ optional Repeats repeats = 20; ++ repeated Repeats r_repeats = 21; ++} ++ ++message Maps { ++ map m_int64_str = 1; ++ map m_bool_simple = 2; ++} ++ ++message MsgWithOneof { ++ oneof union { ++ string title = 1; ++ int64 salary = 2; ++ string Country = 3; ++ string home_address = 4; ++ } ++} ++ ++message Real { ++ optional double value = 1; ++ extensions 100 to max; ++} ++ ++extend Real { ++ optional string name = 124; ++} ++ ++message Complex { ++ extend Real { ++ optional Complex real_extension = 123; ++ } ++ optional double imaginary = 1; ++ extensions 100 to max; ++} ++ ++message KnownTypes { ++ optional google.protobuf.Any an = 14; ++ optional google.protobuf.Duration dur = 1; ++ optional google.protobuf.Struct st = 12; ++ optional google.protobuf.Timestamp ts = 2; ++ optional google.protobuf.ListValue lv = 15; ++ optional google.protobuf.Value val = 16; ++ ++ optional google.protobuf.DoubleValue dbl = 3; ++ optional google.protobuf.FloatValue flt = 4; ++ optional google.protobuf.Int64Value i64 = 5; ++ optional google.protobuf.UInt64Value u64 = 6; ++ optional google.protobuf.Int32Value i32 = 7; ++ optional google.protobuf.UInt32Value u32 = 8; ++ optional google.protobuf.BoolValue bool = 9; ++ optional google.protobuf.StringValue str = 10; ++ optional google.protobuf.BytesValue bytes = 11; ++} +diff --git a/vendor/github.com/golang/protobuf/proto/clone.go b/vendor/github.com/golang/protobuf/proto/clone.go +index 6c6a7d9..e392575 100644 +--- a/vendor/github.com/golang/protobuf/proto/clone.go ++++ b/vendor/github.com/golang/protobuf/proto/clone.go +@@ -30,7 +30,7 @@ + // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + // Protocol buffer deep copy and merge. +-// TODO: MessageSet and RawMessage. ++// TODO: RawMessage. + + package proto + +@@ -75,17 +75,24 @@ func Merge(dst, src Message) { + } + + func mergeStruct(out, in reflect.Value) { ++ sprop := GetProperties(in.Type()) + for i := 0; i < in.NumField(); i++ { + f := in.Type().Field(i) + if strings.HasPrefix(f.Name, "XXX_") { + continue + } +- mergeAny(out.Field(i), in.Field(i)) ++ mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i]) + } + +- if emIn, ok := in.Addr().Interface().(extendableProto); ok { +- emOut := out.Addr().Interface().(extendableProto) +- mergeExtension(emOut.ExtensionMap(), emIn.ExtensionMap()) ++ if emIn, ok := extendable(in.Addr().Interface()); ok { ++ emOut, _ := extendable(out.Addr().Interface()) ++ mIn, muIn := emIn.extensionsRead() ++ if mIn != nil { ++ mOut := emOut.extensionsWrite() ++ muIn.Lock() ++ mergeExtension(mOut, mIn) ++ muIn.Unlock() ++ } + } + + uf := in.FieldByName("XXX_unrecognized") +@@ -98,7 +105,10 @@ func mergeStruct(out, in reflect.Value) { + } + } + +-func mergeAny(out, in reflect.Value) { ++// mergeAny performs a merge between two values of the same type. ++// viaPtr indicates whether the values were indirected through a pointer (implying proto2). ++// prop is set if this is a struct field (it may be nil). ++func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) { + if in.Type() == protoMessageType { + if !in.IsNil() { + if out.IsNil() { +@@ -112,7 +122,21 @@ func mergeAny(out, in reflect.Value) { + switch in.Kind() { + case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64, + reflect.String, reflect.Uint32, reflect.Uint64: ++ if !viaPtr && isProto3Zero(in) { ++ return ++ } + out.Set(in) ++ case reflect.Interface: ++ // Probably a oneof field; copy non-nil values. ++ if in.IsNil() { ++ return ++ } ++ // Allocate destination if it is not set, or set to a different type. ++ // Otherwise we will merge as normal. ++ if out.IsNil() || out.Elem().Type() != in.Elem().Type() { ++ out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T) ++ } ++ mergeAny(out.Elem(), in.Elem(), false, nil) + case reflect.Map: + if in.Len() == 0 { + return +@@ -127,7 +151,7 @@ func mergeAny(out, in reflect.Value) { + switch elemKind { + case reflect.Ptr: + val = reflect.New(in.Type().Elem().Elem()) +- mergeAny(val, in.MapIndex(key)) ++ mergeAny(val, in.MapIndex(key), false, nil) + case reflect.Slice: + val = in.MapIndex(key) + val = reflect.ValueOf(append([]byte{}, val.Bytes()...)) +@@ -143,13 +167,21 @@ func mergeAny(out, in reflect.Value) { + if out.IsNil() { + out.Set(reflect.New(in.Elem().Type())) + } +- mergeAny(out.Elem(), in.Elem()) ++ mergeAny(out.Elem(), in.Elem(), true, nil) + case reflect.Slice: + if in.IsNil() { + return + } + if in.Type().Elem().Kind() == reflect.Uint8 { + // []byte is a scalar bytes field, not a repeated field. ++ ++ // Edge case: if this is in a proto3 message, a zero length ++ // bytes field is considered the zero value, and should not ++ // be merged. ++ if prop != nil && prop.proto3 && in.Len() == 0 { ++ return ++ } ++ + // Make a deep copy. + // Append to []byte{} instead of []byte(nil) so that we never end up + // with a nil result. +@@ -167,7 +199,7 @@ func mergeAny(out, in reflect.Value) { + default: + for i := 0; i < n; i++ { + x := reflect.Indirect(reflect.New(in.Type().Elem())) +- mergeAny(x, in.Index(i)) ++ mergeAny(x, in.Index(i), false, nil) + out.Set(reflect.Append(out, x)) + } + } +@@ -184,7 +216,7 @@ func mergeExtension(out, in map[int32]Extension) { + eOut := Extension{desc: eIn.desc} + if eIn.value != nil { + v := reflect.New(reflect.TypeOf(eIn.value)).Elem() +- mergeAny(v, reflect.ValueOf(eIn.value)) ++ mergeAny(v, reflect.ValueOf(eIn.value), false, nil) + eOut.value = v.Interface() + } + if eIn.enc != nil { +diff --git a/vendor/github.com/golang/protobuf/proto/decode.go b/vendor/github.com/golang/protobuf/proto/decode.go +index 129792e..aa20729 100644 +--- a/vendor/github.com/golang/protobuf/proto/decode.go ++++ b/vendor/github.com/golang/protobuf/proto/decode.go +@@ -46,6 +46,10 @@ import ( + // errOverflow is returned when an integer is too large to be represented. + var errOverflow = errors.New("proto: integer overflow") + ++// ErrInternalBadWireType is returned by generated code when an incorrect ++// wire type is encountered. It does not get returned to user code. ++var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof") ++ + // The fundamental decoders that interpret bytes on the wire. + // Those that take integer types all return uint64 and are + // therefore of type valueDecoder. +@@ -57,7 +61,6 @@ var errOverflow = errors.New("proto: integer overflow") + // int32, int64, uint32, uint64, bool, and enum + // protocol buffer types. + func DecodeVarint(buf []byte) (x uint64, n int) { +- // x, n already 0 + for shift := uint(0); shift < 64; shift += 7 { + if n >= len(buf) { + return 0, 0 +@@ -74,13 +77,7 @@ func DecodeVarint(buf []byte) (x uint64, n int) { + return 0, 0 + } + +-// DecodeVarint reads a varint-encoded integer from the Buffer. +-// This is the format for the +-// int32, int64, uint32, uint64, bool, and enum +-// protocol buffer types. +-func (p *Buffer) DecodeVarint() (x uint64, err error) { +- // x, err already 0 +- ++func (p *Buffer) decodeVarintSlow() (x uint64, err error) { + i := p.index + l := len(p.buf) + +@@ -103,6 +100,107 @@ func (p *Buffer) DecodeVarint() (x uint64, err error) { + return + } + ++// DecodeVarint reads a varint-encoded integer from the Buffer. ++// This is the format for the ++// int32, int64, uint32, uint64, bool, and enum ++// protocol buffer types. ++func (p *Buffer) DecodeVarint() (x uint64, err error) { ++ i := p.index ++ buf := p.buf ++ ++ if i >= len(buf) { ++ return 0, io.ErrUnexpectedEOF ++ } else if buf[i] < 0x80 { ++ p.index++ ++ return uint64(buf[i]), nil ++ } else if len(buf)-i < 10 { ++ return p.decodeVarintSlow() ++ } ++ ++ var b uint64 ++ // we already checked the first byte ++ x = uint64(buf[i]) - 0x80 ++ i++ ++ ++ b = uint64(buf[i]) ++ i++ ++ x += b << 7 ++ if b&0x80 == 0 { ++ goto done ++ } ++ x -= 0x80 << 7 ++ ++ b = uint64(buf[i]) ++ i++ ++ x += b << 14 ++ if b&0x80 == 0 { ++ goto done ++ } ++ x -= 0x80 << 14 ++ ++ b = uint64(buf[i]) ++ i++ ++ x += b << 21 ++ if b&0x80 == 0 { ++ goto done ++ } ++ x -= 0x80 << 21 ++ ++ b = uint64(buf[i]) ++ i++ ++ x += b << 28 ++ if b&0x80 == 0 { ++ goto done ++ } ++ x -= 0x80 << 28 ++ ++ b = uint64(buf[i]) ++ i++ ++ x += b << 35 ++ if b&0x80 == 0 { ++ goto done ++ } ++ x -= 0x80 << 35 ++ ++ b = uint64(buf[i]) ++ i++ ++ x += b << 42 ++ if b&0x80 == 0 { ++ goto done ++ } ++ x -= 0x80 << 42 ++ ++ b = uint64(buf[i]) ++ i++ ++ x += b << 49 ++ if b&0x80 == 0 { ++ goto done ++ } ++ x -= 0x80 << 49 ++ ++ b = uint64(buf[i]) ++ i++ ++ x += b << 56 ++ if b&0x80 == 0 { ++ goto done ++ } ++ x -= 0x80 << 56 ++ ++ b = uint64(buf[i]) ++ i++ ++ x += b << 63 ++ if b&0x80 == 0 { ++ goto done ++ } ++ // x -= 0x80 << 63 // Always zero. ++ ++ return 0, errOverflow ++ ++done: ++ p.index = i ++ return x, nil ++} ++ + // DecodeFixed64 reads a 64-bit integer from the Buffer. + // This is the format for the + // fixed64, sfixed64, and double protocol buffer types. +@@ -314,10 +412,30 @@ func UnmarshalMerge(buf []byte, pb Message) error { + return NewBuffer(buf).Unmarshal(pb) + } + ++// DecodeMessage reads a count-delimited message from the Buffer. ++func (p *Buffer) DecodeMessage(pb Message) error { ++ enc, err := p.DecodeRawBytes(false) ++ if err != nil { ++ return err ++ } ++ return NewBuffer(enc).Unmarshal(pb) ++} ++ ++// DecodeGroup reads a tag-delimited group from the Buffer. ++func (p *Buffer) DecodeGroup(pb Message) error { ++ typ, base, err := getbase(pb) ++ if err != nil { ++ return err ++ } ++ return p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), true, base) ++} ++ + // Unmarshal parses the protocol buffer representation in the + // Buffer and places the decoded result in pb. If the struct + // underlying pb does not match the data in the buffer, the results can be + // unpredictable. ++// ++// Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal. + func (p *Buffer) Unmarshal(pb Message) error { + // If the object can unmarshal itself, let it. + if u, ok := pb.(Unmarshaler); ok { +@@ -356,6 +474,11 @@ func (o *Buffer) unmarshalType(st reflect.Type, prop *StructProperties, is_group + wire := int(u & 0x7) + if wire == WireEndGroup { + if is_group { ++ if required > 0 { ++ // Not enough information to determine the exact field. ++ // (See below.) ++ return &RequiredNotSetError{"{Unknown}"} ++ } + return nil // input is satisfied + } + return fmt.Errorf("proto: %s: wiretype end group for non-group", st) +@@ -368,15 +491,30 @@ func (o *Buffer) unmarshalType(st reflect.Type, prop *StructProperties, is_group + if !ok { + // Maybe it's an extension? + if prop.extendable { +- if e := structPointer_Interface(base, st).(extendableProto); isExtensionField(e, int32(tag)) { ++ if e, _ := extendable(structPointer_Interface(base, st)); isExtensionField(e, int32(tag)) { + if err = o.skip(st, tag, wire); err == nil { +- ext := e.ExtensionMap()[int32(tag)] // may be missing ++ extmap := e.extensionsWrite() ++ ext := extmap[int32(tag)] // may be missing + ext.enc = append(ext.enc, o.buf[oi:o.index]...) +- e.ExtensionMap()[int32(tag)] = ext ++ extmap[int32(tag)] = ext + } + continue + } + } ++ // Maybe it's a oneof? ++ if prop.oneofUnmarshaler != nil { ++ m := structPointer_Interface(base, st).(Message) ++ // First return value indicates whether tag is a oneof field. ++ ok, err = prop.oneofUnmarshaler(m, tag, wire, o) ++ if err == ErrInternalBadWireType { ++ // Map the error to something more descriptive. ++ // Do the formatting here to save generated code space. ++ err = fmt.Errorf("bad wiretype for oneof field in %T", m) ++ } ++ if ok { ++ continue ++ } ++ } + err = o.skipAndSave(st, tag, wire, base, prop.unrecField) + continue + } +@@ -561,9 +699,13 @@ func (o *Buffer) dec_slice_packed_bool(p *Properties, base structPointer) error + return err + } + nb := int(nn) // number of bytes of encoded bools ++ fin := o.index + nb ++ if fin < o.index { ++ return errOverflow ++ } + + y := *v +- for i := 0; i < nb; i++ { ++ for o.index < fin { + u, err := p.valDec(o) + if err != nil { + return err +@@ -675,7 +817,7 @@ func (o *Buffer) dec_new_map(p *Properties, base structPointer) error { + oi := o.index // index at the end of this map entry + o.index -= len(raw) // move buffer back to start of map entry + +- mptr := structPointer_Map(base, p.field, p.mtype) // *map[K]V ++ mptr := structPointer_NewAt(base, p.field, p.mtype) // *map[K]V + if mptr.Elem().IsNil() { + mptr.Elem().Set(reflect.MakeMap(mptr.Type().Elem())) + } +@@ -727,8 +869,15 @@ func (o *Buffer) dec_new_map(p *Properties, base structPointer) error { + return fmt.Errorf("proto: bad map data tag %d", raw[0]) + } + } ++ keyelem, valelem := keyptr.Elem(), valptr.Elem() ++ if !keyelem.IsValid() { ++ keyelem = reflect.Zero(p.mtype.Key()) ++ } ++ if !valelem.IsValid() { ++ valelem = reflect.Zero(p.mtype.Elem()) ++ } + +- v.SetMapIndex(keyptr.Elem(), valptr.Elem()) ++ v.SetMapIndex(keyelem, valelem) + return nil + } + +diff --git a/vendor/github.com/golang/protobuf/proto/encode.go b/vendor/github.com/golang/protobuf/proto/encode.go +index cd826e9..2b30f84 100644 +--- a/vendor/github.com/golang/protobuf/proto/encode.go ++++ b/vendor/github.com/golang/protobuf/proto/encode.go +@@ -64,8 +64,16 @@ var ( + // a struct with a repeated field containing a nil element. + errRepeatedHasNil = errors.New("proto: repeated field has nil element") + ++ // errOneofHasNil is the error returned if Marshal is called with ++ // a struct with a oneof field containing a nil element. ++ errOneofHasNil = errors.New("proto: oneof field has nil value") ++ + // ErrNil is the error returned if Marshal is called with nil. + ErrNil = errors.New("proto: Marshal called with nil") ++ ++ // ErrTooLarge is the error returned if Marshal is called with a ++ // message that encodes to >2GB. ++ ErrTooLarge = errors.New("proto: message encodes to over 2 GB") + ) + + // The fundamental encoders that put bytes on the wire. +@@ -74,6 +82,10 @@ var ( + + const maxVarintBytes = 10 // maximum length of a varint + ++// maxMarshalSize is the largest allowed size of an encoded protobuf, ++// since C++ and Java use signed int32s for the size. ++const maxMarshalSize = 1<<31 - 1 ++ + // EncodeVarint returns the varint encoding of x. + // This is the format for the + // int32, int64, uint32, uint64, bool, and enum +@@ -105,6 +117,11 @@ func (p *Buffer) EncodeVarint(x uint64) error { + return nil + } + ++// SizeVarint returns the varint encoding size of an integer. ++func SizeVarint(x uint64) int { ++ return sizeVarint(x) ++} ++ + func sizeVarint(x uint64) (n int) { + for { + n++ +@@ -217,10 +234,6 @@ func Marshal(pb Message) ([]byte, error) { + } + p := NewBuffer(nil) + err := p.Marshal(pb) +- var state errorState +- if err != nil && !state.shouldContinue(err, nil) { +- return nil, err +- } + if p.buf == nil && err == nil { + // Return a non-nil slice on success. + return []byte{}, nil +@@ -228,6 +241,20 @@ func Marshal(pb Message) ([]byte, error) { + return p.buf, err + } + ++// EncodeMessage writes the protocol buffer to the Buffer, ++// prefixed by a varint-encoded length. ++func (p *Buffer) EncodeMessage(pb Message) error { ++ t, base, err := getbase(pb) ++ if structPointer_IsNil(base) { ++ return ErrNil ++ } ++ if err == nil { ++ var state errorState ++ err = p.enc_len_struct(GetProperties(t.Elem()), base, &state) ++ } ++ return err ++} ++ + // Marshal takes the protocol buffer + // and encodes it into the wire format, writing the result to the + // Buffer. +@@ -235,11 +262,8 @@ func (p *Buffer) Marshal(pb Message) error { + // Can the object marshal itself? + if m, ok := pb.(Marshaler); ok { + data, err := m.Marshal() +- if err != nil { +- return err +- } + p.buf = append(p.buf, data...) +- return nil ++ return err + } + + t, base, err := getbase(pb) +@@ -251,9 +275,12 @@ func (p *Buffer) Marshal(pb Message) error { + } + + if collectStats { +- stats.Encode++ ++ (stats).Encode++ // Parens are to work around a goimports bug. + } + ++ if len(p.buf) > maxMarshalSize { ++ return ErrTooLarge ++ } + return err + } + +@@ -275,7 +302,7 @@ func Size(pb Message) (n int) { + } + + if collectStats { +- stats.Size++ ++ (stats).Size++ // Parens are to work around a goimports bug. + } + + return +@@ -318,7 +345,7 @@ func size_bool(p *Properties, base structPointer) int { + + func size_proto3_bool(p *Properties, base structPointer) int { + v := *structPointer_BoolVal(base, p.field) +- if !v { ++ if !v && !p.oneof { + return 0 + } + return len(p.tagcode) + 1 // each bool takes exactly one byte +@@ -361,7 +388,7 @@ func size_int32(p *Properties, base structPointer) (n int) { + func size_proto3_int32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32Val(base, p.field) + x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range +- if x == 0 { ++ if x == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) +@@ -407,7 +434,7 @@ func size_uint32(p *Properties, base structPointer) (n int) { + func size_proto3_uint32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32Val(base, p.field) + x := word32Val_Get(v) +- if x == 0 { ++ if x == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) +@@ -452,7 +479,7 @@ func size_int64(p *Properties, base structPointer) (n int) { + func size_proto3_int64(p *Properties, base structPointer) (n int) { + v := structPointer_Word64Val(base, p.field) + x := word64Val_Get(v) +- if x == 0 { ++ if x == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) +@@ -495,7 +522,7 @@ func size_string(p *Properties, base structPointer) (n int) { + + func size_proto3_string(p *Properties, base structPointer) (n int) { + v := *structPointer_StringVal(base, p.field) +- if v == "" { ++ if v == "" && !p.oneof { + return 0 + } + n += len(p.tagcode) +@@ -529,7 +556,7 @@ func (o *Buffer) enc_struct_message(p *Properties, base structPointer) error { + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) +- return nil ++ return state.err + } + + o.buf = append(o.buf, p.tagcode...) +@@ -667,7 +694,7 @@ func (o *Buffer) enc_proto3_slice_byte(p *Properties, base structPointer) error + + func size_slice_byte(p *Properties, base structPointer) (n int) { + s := *structPointer_Bytes(base, p.field) +- if s == nil { ++ if s == nil && !p.oneof { + return 0 + } + n += len(p.tagcode) +@@ -677,7 +704,7 @@ func size_slice_byte(p *Properties, base structPointer) (n int) { + + func size_proto3_slice_byte(p *Properties, base structPointer) (n int) { + s := *structPointer_Bytes(base, p.field) +- if len(s) == 0 { ++ if len(s) == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) +@@ -980,7 +1007,6 @@ func size_slice_struct_message(p *Properties, base structPointer) (n int) { + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, _ := m.Marshal() +- n += len(p.tagcode) + n += sizeRawBytes(data) + continue + } +@@ -1039,10 +1065,32 @@ func size_slice_struct_group(p *Properties, base structPointer) (n int) { + + // Encode an extension map. + func (o *Buffer) enc_map(p *Properties, base structPointer) error { +- v := *structPointer_ExtMap(base, p.field) +- if err := encodeExtensionMap(v); err != nil { ++ exts := structPointer_ExtMap(base, p.field) ++ if err := encodeExtensionsMap(*exts); err != nil { ++ return err ++ } ++ ++ return o.enc_map_body(*exts) ++} ++ ++func (o *Buffer) enc_exts(p *Properties, base structPointer) error { ++ exts := structPointer_Extensions(base, p.field) ++ ++ v, mu := exts.extensionsRead() ++ if v == nil { ++ return nil ++ } ++ ++ mu.Lock() ++ defer mu.Unlock() ++ if err := encodeExtensionsMap(v); err != nil { + return err + } ++ ++ return o.enc_map_body(v) ++} ++ ++func (o *Buffer) enc_map_body(v map[int32]Extension) error { + // Fast-path for common cases: zero or one extensions. + if len(v) <= 1 { + for _, e := range v { +@@ -1065,8 +1113,13 @@ func (o *Buffer) enc_map(p *Properties, base structPointer) error { + } + + func size_map(p *Properties, base structPointer) int { +- v := *structPointer_ExtMap(base, p.field) +- return sizeExtensionMap(v) ++ v := structPointer_ExtMap(base, p.field) ++ return extensionsMapSize(*v) ++} ++ ++func size_exts(p *Properties, base structPointer) int { ++ v := structPointer_Extensions(base, p.field) ++ return extensionsSize(v) + } + + // Encode a map field. +@@ -1084,7 +1137,7 @@ func (o *Buffer) enc_new_map(p *Properties, base structPointer) error { + repeated MapFieldEntry map_field = N; + */ + +- v := structPointer_Map(base, p.field, p.mtype).Elem() // map[K]V ++ v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V + if v.Len() == 0 { + return nil + } +@@ -1095,15 +1148,14 @@ func (o *Buffer) enc_new_map(p *Properties, base structPointer) error { + if err := p.mkeyprop.enc(o, p.mkeyprop, keybase); err != nil { + return err + } +- if err := p.mvalprop.enc(o, p.mvalprop, valbase); err != nil { ++ if err := p.mvalprop.enc(o, p.mvalprop, valbase); err != nil && err != ErrNil { + return err + } + return nil + } + +- keys := v.MapKeys() +- sort.Sort(mapKeys(keys)) +- for _, key := range keys { ++ // Don't sort map keys. It is not required by the spec, and C++ doesn't do it. ++ for _, key := range v.MapKeys() { + val := v.MapIndex(key) + + keycopy.Set(key) +@@ -1118,7 +1170,7 @@ func (o *Buffer) enc_new_map(p *Properties, base structPointer) error { + } + + func size_new_map(p *Properties, base structPointer) int { +- v := structPointer_Map(base, p.field, p.mtype).Elem() // map[K]V ++ v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V + + keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype) + +@@ -1128,10 +1180,12 @@ func size_new_map(p *Properties, base structPointer) int { + keycopy.Set(key) + valcopy.Set(val) + +- // Tag codes are two bytes per map entry. +- n += 2 +- n += p.mkeyprop.size(p.mkeyprop, keybase) +- n += p.mvalprop.size(p.mvalprop, valbase) ++ // Tag codes for key and val are the responsibility of the sub-sizer. ++ keysize := p.mkeyprop.size(p.mkeyprop, keybase) ++ valsize := p.mvalprop.size(p.mvalprop, valbase) ++ entry := keysize + valsize ++ // Add on tag code and length of map entry itself. ++ n += len(p.tagcode) + sizeVarint(uint64(entry)) + entry + } + return n + } +@@ -1191,12 +1245,28 @@ func (o *Buffer) enc_struct(prop *StructProperties, base structPointer) error { + return err + } + } ++ if len(o.buf) > maxMarshalSize { ++ return ErrTooLarge ++ } ++ } ++ } ++ ++ // Do oneof fields. ++ if prop.oneofMarshaler != nil { ++ m := structPointer_Interface(base, prop.stype).(Message) ++ if err := prop.oneofMarshaler(m, o); err == ErrNil { ++ return errOneofHasNil ++ } else if err != nil { ++ return err + } + } + + // Add unrecognized fields at the end. + if prop.unrecField.IsValid() { + v := *structPointer_Bytes(base, prop.unrecField) ++ if len(o.buf)+len(v) > maxMarshalSize { ++ return ErrTooLarge ++ } + if len(v) > 0 { + o.buf = append(o.buf, v...) + } +@@ -1219,6 +1289,12 @@ func size_struct(prop *StructProperties, base structPointer) (n int) { + n += len(v) + } + ++ // Factor in any oneof fields. ++ if prop.oneofSizer != nil { ++ m := structPointer_Interface(base, prop.stype).(Message) ++ n += prop.oneofSizer(m) ++ } ++ + return + } + +diff --git a/vendor/github.com/golang/protobuf/proto/equal.go b/vendor/github.com/golang/protobuf/proto/equal.go +index d8673a3..2ed1cf5 100644 +--- a/vendor/github.com/golang/protobuf/proto/equal.go ++++ b/vendor/github.com/golang/protobuf/proto/equal.go +@@ -30,7 +30,6 @@ + // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + // Protocol buffer comparison. +-// TODO: MessageSet. + + package proto + +@@ -51,15 +50,21 @@ Equality is defined in this way: + are equal, and extensions sets are equal. + - Two set scalar fields are equal iff their values are equal. + If the fields are of a floating-point type, remember that +- NaN != x for all x, including NaN. ++ NaN != x for all x, including NaN. If the message is defined ++ in a proto3 .proto file, fields are not "set"; specifically, ++ zero length proto3 "bytes" fields are equal (nil == {}). + - Two repeated fields are equal iff their lengths are the same, +- and their corresponding elements are equal (a "bytes" field, +- although represented by []byte, is not a repeated field) ++ and their corresponding elements are equal. Note a "bytes" field, ++ although represented by []byte, is not a repeated field and the ++ rule for the scalar fields described above applies. + - Two unset fields are equal. + - Two unknown field sets are equal if their current + encoded state is equal. + - Two extension sets are equal iff they have corresponding + elements that are pairwise equal. ++ - Two map fields are equal iff their lengths are the same, ++ and they contain the same set of elements. Zero-length map ++ fields are equal. + - Every other combination of things are not equal. + + The return value is undefined if a and b are not protocol buffers. +@@ -89,6 +94,7 @@ func Equal(a, b Message) bool { + + // v1 and v2 are known to have the same type. + func equalStruct(v1, v2 reflect.Value) bool { ++ sprop := GetProperties(v1.Type()) + for i := 0; i < v1.NumField(); i++ { + f := v1.Type().Field(i) + if strings.HasPrefix(f.Name, "XXX_") { +@@ -114,14 +120,21 @@ func equalStruct(v1, v2 reflect.Value) bool { + } + f1, f2 = f1.Elem(), f2.Elem() + } +- if !equalAny(f1, f2) { ++ if !equalAny(f1, f2, sprop.Prop[i]) { ++ return false ++ } ++ } ++ ++ if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() { ++ em2 := v2.FieldByName("XXX_InternalExtensions") ++ if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) { + return false + } + } + + if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() { + em2 := v2.FieldByName("XXX_extensions") +- if !equalExtensions(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) { ++ if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) { + return false + } + } +@@ -141,7 +154,8 @@ func equalStruct(v1, v2 reflect.Value) bool { + } + + // v1 and v2 are known to have the same type. +-func equalAny(v1, v2 reflect.Value) bool { ++// prop may be nil. ++func equalAny(v1, v2 reflect.Value, prop *Properties) bool { + if v1.Type() == protoMessageType { + m1, _ := v1.Interface().(Message) + m2, _ := v2.Interface().(Message) +@@ -154,6 +168,17 @@ func equalAny(v1, v2 reflect.Value) bool { + return v1.Float() == v2.Float() + case reflect.Int32, reflect.Int64: + return v1.Int() == v2.Int() ++ case reflect.Interface: ++ // Probably a oneof field; compare the inner values. ++ n1, n2 := v1.IsNil(), v2.IsNil() ++ if n1 || n2 { ++ return n1 == n2 ++ } ++ e1, e2 := v1.Elem(), v2.Elem() ++ if e1.Type() != e2.Type() { ++ return false ++ } ++ return equalAny(e1, e2, nil) + case reflect.Map: + if v1.Len() != v2.Len() { + return false +@@ -164,16 +189,29 @@ func equalAny(v1, v2 reflect.Value) bool { + // This key was not found in the second map. + return false + } +- if !equalAny(v1.MapIndex(key), val2) { ++ if !equalAny(v1.MapIndex(key), val2, nil) { + return false + } + } + return true + case reflect.Ptr: +- return equalAny(v1.Elem(), v2.Elem()) ++ // Maps may have nil values in them, so check for nil. ++ if v1.IsNil() && v2.IsNil() { ++ return true ++ } ++ if v1.IsNil() != v2.IsNil() { ++ return false ++ } ++ return equalAny(v1.Elem(), v2.Elem(), prop) + case reflect.Slice: + if v1.Type().Elem().Kind() == reflect.Uint8 { + // short circuit: []byte ++ ++ // Edge case: if this is in a proto3 message, a zero length ++ // bytes field is considered the zero value. ++ if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 { ++ return true ++ } + if v1.IsNil() != v2.IsNil() { + return false + } +@@ -184,7 +222,7 @@ func equalAny(v1, v2 reflect.Value) bool { + return false + } + for i := 0; i < v1.Len(); i++ { +- if !equalAny(v1.Index(i), v2.Index(i)) { ++ if !equalAny(v1.Index(i), v2.Index(i), prop) { + return false + } + } +@@ -203,8 +241,14 @@ func equalAny(v1, v2 reflect.Value) bool { + } + + // base is the struct type that the extensions are based on. +-// em1 and em2 are extension maps. +-func equalExtensions(base reflect.Type, em1, em2 map[int32]Extension) bool { ++// x1 and x2 are InternalExtensions. ++func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool { ++ em1, _ := x1.extensionsRead() ++ em2, _ := x2.extensionsRead() ++ return equalExtMap(base, em1, em2) ++} ++ ++func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool { + if len(em1) != len(em2) { + return false + } +@@ -219,7 +263,7 @@ func equalExtensions(base reflect.Type, em1, em2 map[int32]Extension) bool { + + if m1 != nil && m2 != nil { + // Both are unencoded. +- if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2)) { ++ if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) { + return false + } + continue +@@ -247,7 +291,7 @@ func equalExtensions(base reflect.Type, em1, em2 map[int32]Extension) bool { + log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err) + return false + } +- if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2)) { ++ if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) { + return false + } + } +diff --git a/vendor/github.com/golang/protobuf/proto/extensions.go b/vendor/github.com/golang/protobuf/proto/extensions.go +index 5f62dff..eaad218 100644 +--- a/vendor/github.com/golang/protobuf/proto/extensions.go ++++ b/vendor/github.com/golang/protobuf/proto/extensions.go +@@ -52,14 +52,99 @@ type ExtensionRange struct { + Start, End int32 // both inclusive + } + +-// extendableProto is an interface implemented by any protocol buffer that may be extended. ++// extendableProto is an interface implemented by any protocol buffer generated by the current ++// proto compiler that may be extended. + type extendableProto interface { ++ Message ++ ExtensionRangeArray() []ExtensionRange ++ extensionsWrite() map[int32]Extension ++ extensionsRead() (map[int32]Extension, sync.Locker) ++} ++ ++// extendableProtoV1 is an interface implemented by a protocol buffer generated by the previous ++// version of the proto compiler that may be extended. ++type extendableProtoV1 interface { + Message + ExtensionRangeArray() []ExtensionRange + ExtensionMap() map[int32]Extension + } + ++// extensionAdapter is a wrapper around extendableProtoV1 that implements extendableProto. ++type extensionAdapter struct { ++ extendableProtoV1 ++} ++ ++func (e extensionAdapter) extensionsWrite() map[int32]Extension { ++ return e.ExtensionMap() ++} ++ ++func (e extensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) { ++ return e.ExtensionMap(), notLocker{} ++} ++ ++// notLocker is a sync.Locker whose Lock and Unlock methods are nops. ++type notLocker struct{} ++ ++func (n notLocker) Lock() {} ++func (n notLocker) Unlock() {} ++ ++// extendable returns the extendableProto interface for the given generated proto message. ++// If the proto message has the old extension format, it returns a wrapper that implements ++// the extendableProto interface. ++func extendable(p interface{}) (extendableProto, bool) { ++ if ep, ok := p.(extendableProto); ok { ++ return ep, ok ++ } ++ if ep, ok := p.(extendableProtoV1); ok { ++ return extensionAdapter{ep}, ok ++ } ++ return nil, false ++} ++ ++// XXX_InternalExtensions is an internal representation of proto extensions. ++// ++// Each generated message struct type embeds an anonymous XXX_InternalExtensions field, ++// thus gaining the unexported 'extensions' method, which can be called only from the proto package. ++// ++// The methods of XXX_InternalExtensions are not concurrency safe in general, ++// but calls to logically read-only methods such as has and get may be executed concurrently. ++type XXX_InternalExtensions struct { ++ // The struct must be indirect so that if a user inadvertently copies a ++ // generated message and its embedded XXX_InternalExtensions, they ++ // avoid the mayhem of a copied mutex. ++ // ++ // The mutex serializes all logically read-only operations to p.extensionMap. ++ // It is up to the client to ensure that write operations to p.extensionMap are ++ // mutually exclusive with other accesses. ++ p *struct { ++ mu sync.Mutex ++ extensionMap map[int32]Extension ++ } ++} ++ ++// extensionsWrite returns the extension map, creating it on first use. ++func (e *XXX_InternalExtensions) extensionsWrite() map[int32]Extension { ++ if e.p == nil { ++ e.p = new(struct { ++ mu sync.Mutex ++ extensionMap map[int32]Extension ++ }) ++ e.p.extensionMap = make(map[int32]Extension) ++ } ++ return e.p.extensionMap ++} ++ ++// extensionsRead returns the extensions map for read-only use. It may be nil. ++// The caller must hold the returned mutex's lock when accessing Elements within the map. ++func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locker) { ++ if e.p == nil { ++ return nil, nil ++ } ++ return e.p.extensionMap, &e.p.mu ++} ++ + var extendableProtoType = reflect.TypeOf((*extendableProto)(nil)).Elem() ++var extendableProtoV1Type = reflect.TypeOf((*extendableProtoV1)(nil)).Elem() + + // ExtensionDesc represents an extension specification. + // Used in generated code from the protocol compiler. +@@ -69,6 +154,7 @@ type ExtensionDesc struct { + Field int32 // field number + Name string // fully-qualified name of extension, for text formatting + Tag string // protobuf tag style ++ Filename string // name of the file in which the extension is defined + } + + func (ed *ExtensionDesc) repeated() bool { +@@ -92,8 +178,13 @@ type Extension struct { + } + + // SetRawExtension is for testing only. +-func SetRawExtension(base extendableProto, id int32, b []byte) { +- base.ExtensionMap()[id] = Extension{enc: b} ++func SetRawExtension(base Message, id int32, b []byte) { ++ epb, ok := extendable(base) ++ if !ok { ++ return ++ } ++ extmap := epb.extensionsWrite() ++ extmap[id] = Extension{enc: b} + } + + // isExtensionField returns true iff the given field number is in an extension range. +@@ -108,8 +199,12 @@ func isExtensionField(pb extendableProto, field int32) bool { + + // checkExtensionTypes checks that the given extension is valid for pb. + func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error { ++ var pbi interface{} = pb + // Check the extended type. +- if a, b := reflect.TypeOf(pb), reflect.TypeOf(extension.ExtendedType); a != b { ++ if ea, ok := pbi.(extensionAdapter); ok { ++ pbi = ea.extendableProtoV1 ++ } ++ if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b { + return errors.New("proto: bad extended type; " + b.String() + " does not extend " + a.String()) + } + // Check the range. +@@ -155,8 +250,19 @@ func extensionProperties(ed *ExtensionDesc) *Properties { + return prop + } + +-// encodeExtensionMap encodes any unmarshaled (unencoded) extensions in m. +-func encodeExtensionMap(m map[int32]Extension) error { ++// encode encodes any unmarshaled (unencoded) extensions in e. ++func encodeExtensions(e *XXX_InternalExtensions) error { ++ m, mu := e.extensionsRead() ++ if m == nil { ++ return nil // fast path ++ } ++ mu.Lock() ++ defer mu.Unlock() ++ return encodeExtensionsMap(m) ++} ++ ++// encode encodes any unmarshaled (unencoded) extensions in e. ++func encodeExtensionsMap(m map[int32]Extension) error { + for k, e := range m { + if e.value == nil || e.desc == nil { + // Extension is only in its encoded form. +@@ -184,7 +290,17 @@ func encodeExtensionMap(m map[int32]Extension) error { + return nil + } + +-func sizeExtensionMap(m map[int32]Extension) (n int) { ++func extensionsSize(e *XXX_InternalExtensions) (n int) { ++ m, mu := e.extensionsRead() ++ if m == nil { ++ return 0 ++ } ++ mu.Lock() ++ defer mu.Unlock() ++ return extensionsMapSize(m) ++} ++ ++func extensionsMapSize(m map[int32]Extension) (n int) { + for _, e := range m { + if e.value == nil || e.desc == nil { + // Extension is only in its encoded form. +@@ -209,30 +325,58 @@ func sizeExtensionMap(m map[int32]Extension) (n int) { + } + + // HasExtension returns whether the given extension is present in pb. +-func HasExtension(pb extendableProto, extension *ExtensionDesc) bool { ++func HasExtension(pb Message, extension *ExtensionDesc) bool { + // TODO: Check types, field numbers, etc.? +- _, ok := pb.ExtensionMap()[extension.Field] ++ epb, ok := extendable(pb) ++ if !ok { ++ return false ++ } ++ extmap, mu := epb.extensionsRead() ++ if extmap == nil { ++ return false ++ } ++ mu.Lock() ++ _, ok = extmap[extension.Field] ++ mu.Unlock() + return ok + } + + // ClearExtension removes the given extension from pb. +-func ClearExtension(pb extendableProto, extension *ExtensionDesc) { ++func ClearExtension(pb Message, extension *ExtensionDesc) { ++ epb, ok := extendable(pb) ++ if !ok { ++ return ++ } + // TODO: Check types, field numbers, etc.? +- delete(pb.ExtensionMap(), extension.Field) ++ extmap := epb.extensionsWrite() ++ delete(extmap, extension.Field) + } + + // GetExtension parses and returns the given extension of pb. +-// If the extension is not present it returns ErrMissingExtension. +-func GetExtension(pb extendableProto, extension *ExtensionDesc) (interface{}, error) { +- if err := checkExtensionTypes(pb, extension); err != nil { ++// If the extension is not present and has no default value it returns ErrMissingExtension. ++func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) { ++ epb, ok := extendable(pb) ++ if !ok { ++ return nil, errors.New("proto: not an extendable proto") ++ } ++ ++ if err := checkExtensionTypes(epb, extension); err != nil { + return nil, err + } + +- emap := pb.ExtensionMap() ++ emap, mu := epb.extensionsRead() ++ if emap == nil { ++ return defaultExtensionValue(extension) ++ } ++ mu.Lock() ++ defer mu.Unlock() + e, ok := emap[extension.Field] + if !ok { +- return nil, ErrMissingExtension ++ // defaultExtensionValue returns the default value or ++ // ErrMissingExtension if there is no default. ++ return defaultExtensionValue(extension) + } ++ + if e.value != nil { + // Already decoded. Check the descriptor, though. + if e.desc != extension { +@@ -258,12 +402,46 @@ func GetExtension(pb extendableProto, extension *ExtensionDesc) (interface{}, er + return e.value, nil + } + ++// defaultExtensionValue returns the default value for extension. ++// If no default for an extension is defined ErrMissingExtension is returned. ++func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) { ++ t := reflect.TypeOf(extension.ExtensionType) ++ props := extensionProperties(extension) ++ ++ sf, _, err := fieldDefault(t, props) ++ if err != nil { ++ return nil, err ++ } ++ ++ if sf == nil || sf.value == nil { ++ // There is no default value. ++ return nil, ErrMissingExtension ++ } ++ ++ if t.Kind() != reflect.Ptr { ++ // We do not need to return a Ptr, we can directly return sf.value. ++ return sf.value, nil ++ } ++ ++ // We need to return an interface{} that is a pointer to sf.value. ++ value := reflect.New(t).Elem() ++ value.Set(reflect.New(value.Type().Elem())) ++ if sf.kind == reflect.Int32 { ++ // We may have an int32 or an enum, but the underlying data is int32. ++ // Since we can't set an int32 into a non int32 reflect.value directly ++ // set it as a int32. ++ value.Elem().SetInt(int64(sf.value.(int32))) ++ } else { ++ value.Elem().Set(reflect.ValueOf(sf.value)) ++ } ++ return value.Interface(), nil ++} ++ + // decodeExtension decodes an extension encoded in b. + func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) { + o := NewBuffer(b) + + t := reflect.TypeOf(extension.ExtensionType) +- rep := extension.repeated() + + props := extensionProperties(extension) + +@@ -285,7 +463,7 @@ func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) { + return nil, err + } + +- if !rep || o.index >= len(o.buf) { ++ if o.index >= len(o.buf) { + break + } + } +@@ -295,10 +473,9 @@ func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) { + // GetExtensions returns a slice of the extensions present in pb that are also listed in es. + // The returned slice has the same length as es; missing extensions will appear as nil elements. + func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) { +- epb, ok := pb.(extendableProto) ++ epb, ok := extendable(pb) + if !ok { +- err = errors.New("proto: not an extendable proto") +- return ++ return nil, errors.New("proto: not an extendable proto") + } + extensions = make([]interface{}, len(es)) + for i, e := range es { +@@ -313,9 +490,44 @@ func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, e + return + } + ++// ExtensionDescs returns a new slice containing pb's extension descriptors, in undefined order. ++// For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing ++// just the Field field, which defines the extension's field number. ++func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) { ++ epb, ok := extendable(pb) ++ if !ok { ++ return nil, fmt.Errorf("proto: %T is not an extendable proto.Message", pb) ++ } ++ registeredExtensions := RegisteredExtensions(pb) ++ ++ emap, mu := epb.extensionsRead() ++ if emap == nil { ++ return nil, nil ++ } ++ mu.Lock() ++ defer mu.Unlock() ++ extensions := make([]*ExtensionDesc, 0, len(emap)) ++ for extid, e := range emap { ++ desc := e.desc ++ if desc == nil { ++ desc = registeredExtensions[extid] ++ if desc == nil { ++ desc = &ExtensionDesc{Field: extid} ++ } ++ } ++ ++ extensions = append(extensions, desc) ++ } ++ return extensions, nil ++} ++ + // SetExtension sets the specified extension of pb to the specified value. +-func SetExtension(pb extendableProto, extension *ExtensionDesc, value interface{}) error { +- if err := checkExtensionTypes(pb, extension); err != nil { ++func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error { ++ epb, ok := extendable(pb) ++ if !ok { ++ return errors.New("proto: not an extendable proto") ++ } ++ if err := checkExtensionTypes(epb, extension); err != nil { + return err + } + typ := reflect.TypeOf(extension.ExtensionType) +@@ -331,10 +543,23 @@ func SetExtension(pb extendableProto, extension *ExtensionDesc, value interface{ + return fmt.Errorf("proto: SetExtension called with nil value of type %T", value) + } + +- pb.ExtensionMap()[extension.Field] = Extension{desc: extension, value: value} ++ extmap := epb.extensionsWrite() ++ extmap[extension.Field] = Extension{desc: extension, value: value} + return nil + } + ++// ClearAllExtensions clears all extensions from pb. ++func ClearAllExtensions(pb Message) { ++ epb, ok := extendable(pb) ++ if !ok { ++ return ++ } ++ m := epb.extensionsWrite() ++ for k := range m { ++ delete(m, k) ++ } ++} ++ + // A global registry of extensions. + // The generated code will register the generated descriptors by calling RegisterExtension. + +diff --git a/vendor/github.com/golang/protobuf/proto/lib.go b/vendor/github.com/golang/protobuf/proto/lib.go +index f81052f..ac4ddbc 100644 +--- a/vendor/github.com/golang/protobuf/proto/lib.go ++++ b/vendor/github.com/golang/protobuf/proto/lib.go +@@ -30,179 +30,237 @@ + // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + /* +- Package proto converts data structures to and from the wire format of +- protocol buffers. It works in concert with the Go source code generated +- for .proto files by the protocol compiler. +- +- A summary of the properties of the protocol buffer interface +- for a protocol buffer variable v: +- +- - Names are turned from camel_case to CamelCase for export. +- - There are no methods on v to set fields; just treat +- them as structure fields. +- - There are getters that return a field's value if set, +- and return the field's default value if unset. +- The getters work even if the receiver is a nil message. +- - The zero value for a struct is its correct initialization state. +- All desired fields must be set before marshaling. +- - A Reset() method will restore a protobuf struct to its zero state. +- - Non-repeated fields are pointers to the values; nil means unset. +- That is, optional or required field int32 f becomes F *int32. +- - Repeated fields are slices. +- - Helper functions are available to aid the setting of fields. +- msg.Foo = proto.String("hello") // set field +- - Constants are defined to hold the default values of all fields that +- have them. They have the form Default_StructName_FieldName. +- Because the getter methods handle defaulted values, +- direct use of these constants should be rare. +- - Enums are given type names and maps from names to values. +- Enum values are prefixed by the enclosing message's name, or by the +- enum's type name if it is a top-level enum. Enum types have a String +- method, and a Enum method to assist in message construction. +- - Nested messages, groups and enums have type names prefixed with the name of +- the surrounding message type. +- - Extensions are given descriptor names that start with E_, +- followed by an underscore-delimited list of the nested messages +- that contain it (if any) followed by the CamelCased name of the +- extension field itself. HasExtension, ClearExtension, GetExtension +- and SetExtension are functions for manipulating extensions. +- - Marshal and Unmarshal are functions to encode and decode the wire format. +- +- The simplest way to describe this is to see an example. +- Given file test.proto, containing +- +- package example; +- +- enum FOO { X = 17; } +- +- message Test { +- required string label = 1; +- optional int32 type = 2 [default=77]; +- repeated int64 reps = 3; +- optional group OptionalGroup = 4 { +- required string RequiredField = 5; +- } +- } +- +- The resulting file, test.pb.go, is: +- +- package example +- +- import proto "github.com/golang/protobuf/proto" +- import math "math" +- +- type FOO int32 +- const ( +- FOO_X FOO = 17 +- ) +- var FOO_name = map[int32]string{ +- 17: "X", +- } +- var FOO_value = map[string]int32{ +- "X": 17, +- } +- +- func (x FOO) Enum() *FOO { +- p := new(FOO) +- *p = x +- return p +- } +- func (x FOO) String() string { +- return proto.EnumName(FOO_name, int32(x)) +- } +- func (x *FOO) UnmarshalJSON(data []byte) error { +- value, err := proto.UnmarshalJSONEnum(FOO_value, data) +- if err != nil { +- return err +- } +- *x = FOO(value) +- return nil ++Package proto converts data structures to and from the wire format of ++protocol buffers. It works in concert with the Go source code generated ++for .proto files by the protocol compiler. ++ ++A summary of the properties of the protocol buffer interface ++for a protocol buffer variable v: ++ ++ - Names are turned from camel_case to CamelCase for export. ++ - There are no methods on v to set fields; just treat ++ them as structure fields. ++ - There are getters that return a field's value if set, ++ and return the field's default value if unset. ++ The getters work even if the receiver is a nil message. ++ - The zero value for a struct is its correct initialization state. ++ All desired fields must be set before marshaling. ++ - A Reset() method will restore a protobuf struct to its zero state. ++ - Non-repeated fields are pointers to the values; nil means unset. ++ That is, optional or required field int32 f becomes F *int32. ++ - Repeated fields are slices. ++ - Helper functions are available to aid the setting of fields. ++ msg.Foo = proto.String("hello") // set field ++ - Constants are defined to hold the default values of all fields that ++ have them. They have the form Default_StructName_FieldName. ++ Because the getter methods handle defaulted values, ++ direct use of these constants should be rare. ++ - Enums are given type names and maps from names to values. ++ Enum values are prefixed by the enclosing message's name, or by the ++ enum's type name if it is a top-level enum. Enum types have a String ++ method, and a Enum method to assist in message construction. ++ - Nested messages, groups and enums have type names prefixed with the name of ++ the surrounding message type. ++ - Extensions are given descriptor names that start with E_, ++ followed by an underscore-delimited list of the nested messages ++ that contain it (if any) followed by the CamelCased name of the ++ extension field itself. HasExtension, ClearExtension, GetExtension ++ and SetExtension are functions for manipulating extensions. ++ - Oneof field sets are given a single field in their message, ++ with distinguished wrapper types for each possible field value. ++ - Marshal and Unmarshal are functions to encode and decode the wire format. ++ ++When the .proto file specifies `syntax="proto3"`, there are some differences: ++ ++ - Non-repeated fields of non-message type are values instead of pointers. ++ - Getters are only generated for message and oneof fields. ++ - Enum types do not get an Enum method. ++ ++The simplest way to describe this is to see an example. ++Given file test.proto, containing ++ ++ package example; ++ ++ enum FOO { X = 17; } ++ ++ message Test { ++ required string label = 1; ++ optional int32 type = 2 [default=77]; ++ repeated int64 reps = 3; ++ optional group OptionalGroup = 4 { ++ required string RequiredField = 5; ++ } ++ oneof union { ++ int32 number = 6; ++ string name = 7; ++ } ++ } ++ ++The resulting file, test.pb.go, is: ++ ++ package example ++ ++ import proto "github.com/golang/protobuf/proto" ++ import math "math" ++ ++ type FOO int32 ++ const ( ++ FOO_X FOO = 17 ++ ) ++ var FOO_name = map[int32]string{ ++ 17: "X", ++ } ++ var FOO_value = map[string]int32{ ++ "X": 17, ++ } ++ ++ func (x FOO) Enum() *FOO { ++ p := new(FOO) ++ *p = x ++ return p ++ } ++ func (x FOO) String() string { ++ return proto.EnumName(FOO_name, int32(x)) ++ } ++ func (x *FOO) UnmarshalJSON(data []byte) error { ++ value, err := proto.UnmarshalJSONEnum(FOO_value, data) ++ if err != nil { ++ return err + } ++ *x = FOO(value) ++ return nil ++ } + +- type Test struct { +- Label *string `protobuf:"bytes,1,req,name=label" json:"label,omitempty"` +- Type *int32 `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"` +- Reps []int64 `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"` +- Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"` +- XXX_unrecognized []byte `json:"-"` ++ type Test struct { ++ Label *string `protobuf:"bytes,1,req,name=label" json:"label,omitempty"` ++ Type *int32 `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"` ++ Reps []int64 `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"` ++ Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"` ++ // Types that are valid to be assigned to Union: ++ // *Test_Number ++ // *Test_Name ++ Union isTest_Union `protobuf_oneof:"union"` ++ XXX_unrecognized []byte `json:"-"` ++ } ++ func (m *Test) Reset() { *m = Test{} } ++ func (m *Test) String() string { return proto.CompactTextString(m) } ++ func (*Test) ProtoMessage() {} ++ ++ type isTest_Union interface { ++ isTest_Union() ++ } ++ ++ type Test_Number struct { ++ Number int32 `protobuf:"varint,6,opt,name=number"` ++ } ++ type Test_Name struct { ++ Name string `protobuf:"bytes,7,opt,name=name"` ++ } ++ ++ func (*Test_Number) isTest_Union() {} ++ func (*Test_Name) isTest_Union() {} ++ ++ func (m *Test) GetUnion() isTest_Union { ++ if m != nil { ++ return m.Union + } +- func (m *Test) Reset() { *m = Test{} } +- func (m *Test) String() string { return proto.CompactTextString(m) } +- func (*Test) ProtoMessage() {} +- const Default_Test_Type int32 = 77 ++ return nil ++ } ++ const Default_Test_Type int32 = 77 + +- func (m *Test) GetLabel() string { +- if m != nil && m.Label != nil { +- return *m.Label +- } +- return "" ++ func (m *Test) GetLabel() string { ++ if m != nil && m.Label != nil { ++ return *m.Label + } ++ return "" ++ } + +- func (m *Test) GetType() int32 { +- if m != nil && m.Type != nil { +- return *m.Type +- } +- return Default_Test_Type ++ func (m *Test) GetType() int32 { ++ if m != nil && m.Type != nil { ++ return *m.Type + } ++ return Default_Test_Type ++ } + +- func (m *Test) GetOptionalgroup() *Test_OptionalGroup { +- if m != nil { +- return m.Optionalgroup +- } +- return nil ++ func (m *Test) GetOptionalgroup() *Test_OptionalGroup { ++ if m != nil { ++ return m.Optionalgroup + } ++ return nil ++ } ++ ++ type Test_OptionalGroup struct { ++ RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"` ++ } ++ func (m *Test_OptionalGroup) Reset() { *m = Test_OptionalGroup{} } ++ func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) } + +- type Test_OptionalGroup struct { +- RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"` ++ func (m *Test_OptionalGroup) GetRequiredField() string { ++ if m != nil && m.RequiredField != nil { ++ return *m.RequiredField + } +- func (m *Test_OptionalGroup) Reset() { *m = Test_OptionalGroup{} } +- func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) } ++ return "" ++ } + +- func (m *Test_OptionalGroup) GetRequiredField() string { +- if m != nil && m.RequiredField != nil { +- return *m.RequiredField +- } +- return "" ++ func (m *Test) GetNumber() int32 { ++ if x, ok := m.GetUnion().(*Test_Number); ok { ++ return x.Number + } ++ return 0 ++ } + +- func init() { +- proto.RegisterEnum("example.FOO", FOO_name, FOO_value) ++ func (m *Test) GetName() string { ++ if x, ok := m.GetUnion().(*Test_Name); ok { ++ return x.Name + } ++ return "" ++ } + +- To create and play with a Test object: ++ func init() { ++ proto.RegisterEnum("example.FOO", FOO_name, FOO_value) ++ } + +- package main ++To create and play with a Test object: + +- import ( +- "log" ++ package main + +- "github.com/golang/protobuf/proto" +- pb "./example.pb" +- ) ++ import ( ++ "log" + +- func main() { +- test := &pb.Test{ +- Label: proto.String("hello"), +- Type: proto.Int32(17), +- Optionalgroup: &pb.Test_OptionalGroup{ +- RequiredField: proto.String("good bye"), +- }, +- } +- data, err := proto.Marshal(test) +- if err != nil { +- log.Fatal("marshaling error: ", err) +- } +- newTest := &pb.Test{} +- err = proto.Unmarshal(data, newTest) +- if err != nil { +- log.Fatal("unmarshaling error: ", err) +- } +- // Now test and newTest contain the same data. +- if test.GetLabel() != newTest.GetLabel() { +- log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel()) +- } +- // etc. ++ "github.com/golang/protobuf/proto" ++ pb "./example.pb" ++ ) ++ ++ func main() { ++ test := &pb.Test{ ++ Label: proto.String("hello"), ++ Type: proto.Int32(17), ++ Reps: []int64{1, 2, 3}, ++ Optionalgroup: &pb.Test_OptionalGroup{ ++ RequiredField: proto.String("good bye"), ++ }, ++ Union: &pb.Test_Name{"fred"}, ++ } ++ data, err := proto.Marshal(test) ++ if err != nil { ++ log.Fatal("marshaling error: ", err) ++ } ++ newTest := &pb.Test{} ++ err = proto.Unmarshal(data, newTest) ++ if err != nil { ++ log.Fatal("unmarshaling error: ", err) + } ++ // Now test and newTest contain the same data. ++ if test.GetLabel() != newTest.GetLabel() { ++ log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel()) ++ } ++ // Use a type switch to determine which oneof was set. ++ switch u := test.Union.(type) { ++ case *pb.Test_Number: // u.Number contains the number. ++ case *pb.Test_Name: // u.Name contains the string. ++ } ++ // etc. ++ } + */ + package proto + +@@ -211,6 +269,7 @@ import ( + "fmt" + "log" + "reflect" ++ "sort" + "strconv" + "sync" + ) +@@ -249,7 +308,7 @@ func GetStats() Stats { return stats } + // temporary Buffer and are fine for most applications. + type Buffer struct { + buf []byte // encode/decode byte stream +- index int // write point ++ index int // read point + + // pools of basic types to amortize allocation. + bools []bool +@@ -385,13 +444,13 @@ func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, + + // DebugPrint dumps the encoded data in b in a debugging format with a header + // including the string s. Used in testing but made available for general debugging. +-func (o *Buffer) DebugPrint(s string, b []byte) { ++func (p *Buffer) DebugPrint(s string, b []byte) { + var u uint64 + +- obuf := o.buf +- index := o.index +- o.buf = b +- o.index = 0 ++ obuf := p.buf ++ index := p.index ++ p.buf = b ++ p.index = 0 + depth := 0 + + fmt.Printf("\n--- %s ---\n", s) +@@ -402,12 +461,12 @@ out: + fmt.Print(" ") + } + +- index := o.index +- if index == len(o.buf) { ++ index := p.index ++ if index == len(p.buf) { + break + } + +- op, err := o.DecodeVarint() ++ op, err := p.DecodeVarint() + if err != nil { + fmt.Printf("%3d: fetching op err %v\n", index, err) + break out +@@ -424,7 +483,7 @@ out: + case WireBytes: + var r []byte + +- r, err = o.DecodeRawBytes(false) ++ r, err = p.DecodeRawBytes(false) + if err != nil { + break out + } +@@ -445,7 +504,7 @@ out: + fmt.Printf("\n") + + case WireFixed32: +- u, err = o.DecodeFixed32() ++ u, err = p.DecodeFixed32() + if err != nil { + fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err) + break out +@@ -453,16 +512,15 @@ out: + fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u) + + case WireFixed64: +- u, err = o.DecodeFixed64() ++ u, err = p.DecodeFixed64() + if err != nil { + fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err) + break out + } + fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u) +- break + + case WireVarint: +- u, err = o.DecodeVarint() ++ u, err = p.DecodeVarint() + if err != nil { + fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err) + break out +@@ -470,30 +528,22 @@ out: + fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u) + + case WireStartGroup: +- if err != nil { +- fmt.Printf("%3d: t=%3d start err %v\n", index, tag, err) +- break out +- } + fmt.Printf("%3d: t=%3d start\n", index, tag) + depth++ + + case WireEndGroup: + depth-- +- if err != nil { +- fmt.Printf("%3d: t=%3d end err %v\n", index, tag, err) +- break out +- } + fmt.Printf("%3d: t=%3d end\n", index, tag) + } + } + + if depth != 0 { +- fmt.Printf("%3d: start-end not balanced %d\n", o.index, depth) ++ fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth) + } + fmt.Printf("\n") + +- o.buf = obuf +- o.index = index ++ p.buf = obuf ++ p.index = index + } + + // SetDefaults sets unset protocol buffer fields to their default values. +@@ -607,13 +657,15 @@ func setDefaults(v reflect.Value, recur, zeros bool) { + + for _, ni := range dm.nested { + f := v.Field(ni) +- if f.IsNil() { +- continue +- } +- // f is *T or []*T +- if f.Kind() == reflect.Ptr { ++ // f is *T or []*T or map[T]*T ++ switch f.Kind() { ++ case reflect.Ptr: ++ if f.IsNil() { ++ continue ++ } + setDefaults(f, recur, zeros) +- } else { ++ ++ case reflect.Slice: + for i := 0; i < f.Len(); i++ { + e := f.Index(i) + if e.IsNil() { +@@ -621,6 +673,15 @@ func setDefaults(v reflect.Value, recur, zeros bool) { + } + setDefaults(e, recur, zeros) + } ++ ++ case reflect.Map: ++ for _, k := range f.MapKeys() { ++ e := f.MapIndex(k) ++ if e.IsNil() { ++ continue ++ } ++ setDefaults(e, recur, zeros) ++ } + } + } + } +@@ -646,10 +707,6 @@ type scalarField struct { + value interface{} // the proto-declared default value, or nil + } + +-func ptrToStruct(t reflect.Type) bool { +- return t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Struct +-} +- + // t is a struct type. + func buildDefaultMessage(t reflect.Type) (dm defaultMessage) { + sprop := GetProperties(t) +@@ -661,88 +718,118 @@ func buildDefaultMessage(t reflect.Type) (dm defaultMessage) { + } + ft := t.Field(fi).Type + +- // nested messages +- if ptrToStruct(ft) || (ft.Kind() == reflect.Slice && ptrToStruct(ft.Elem())) { ++ sf, nested, err := fieldDefault(ft, prop) ++ switch { ++ case err != nil: ++ log.Print(err) ++ case nested: + dm.nested = append(dm.nested, fi) +- continue ++ case sf != nil: ++ sf.index = fi ++ dm.scalars = append(dm.scalars, *sf) + } ++ } + +- sf := scalarField{ +- index: fi, +- kind: ft.Elem().Kind(), +- } ++ return dm ++} + +- // scalar fields without defaults +- if !prop.HasDefault { +- dm.scalars = append(dm.scalars, sf) +- continue ++// fieldDefault returns the scalarField for field type ft. ++// sf will be nil if the field can not have a default. ++// nestedMessage will be true if this is a nested message. ++// Note that sf.index is not set on return. ++func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) { ++ var canHaveDefault bool ++ switch ft.Kind() { ++ case reflect.Ptr: ++ if ft.Elem().Kind() == reflect.Struct { ++ nestedMessage = true ++ } else { ++ canHaveDefault = true // proto2 scalar field + } + +- // a scalar field: either *T or []byte ++ case reflect.Slice: + switch ft.Elem().Kind() { +- case reflect.Bool: +- x, err := strconv.ParseBool(prop.Default) +- if err != nil { +- log.Printf("proto: bad default bool %q: %v", prop.Default, err) +- continue +- } +- sf.value = x +- case reflect.Float32: +- x, err := strconv.ParseFloat(prop.Default, 32) +- if err != nil { +- log.Printf("proto: bad default float32 %q: %v", prop.Default, err) +- continue +- } +- sf.value = float32(x) +- case reflect.Float64: +- x, err := strconv.ParseFloat(prop.Default, 64) +- if err != nil { +- log.Printf("proto: bad default float64 %q: %v", prop.Default, err) +- continue +- } +- sf.value = x +- case reflect.Int32: +- x, err := strconv.ParseInt(prop.Default, 10, 32) +- if err != nil { +- log.Printf("proto: bad default int32 %q: %v", prop.Default, err) +- continue +- } +- sf.value = int32(x) +- case reflect.Int64: +- x, err := strconv.ParseInt(prop.Default, 10, 64) +- if err != nil { +- log.Printf("proto: bad default int64 %q: %v", prop.Default, err) +- continue +- } +- sf.value = x +- case reflect.String: +- sf.value = prop.Default ++ case reflect.Ptr: ++ nestedMessage = true // repeated message + case reflect.Uint8: +- // []byte (not *uint8) +- sf.value = []byte(prop.Default) +- case reflect.Uint32: +- x, err := strconv.ParseUint(prop.Default, 10, 32) +- if err != nil { +- log.Printf("proto: bad default uint32 %q: %v", prop.Default, err) +- continue +- } +- sf.value = uint32(x) +- case reflect.Uint64: +- x, err := strconv.ParseUint(prop.Default, 10, 64) +- if err != nil { +- log.Printf("proto: bad default uint64 %q: %v", prop.Default, err) +- continue +- } +- sf.value = x +- default: +- log.Printf("proto: unhandled def kind %v", ft.Elem().Kind()) +- continue ++ canHaveDefault = true // bytes field ++ } ++ ++ case reflect.Map: ++ if ft.Elem().Kind() == reflect.Ptr { ++ nestedMessage = true // map with message values + } ++ } + +- dm.scalars = append(dm.scalars, sf) ++ if !canHaveDefault { ++ if nestedMessage { ++ return nil, true, nil ++ } ++ return nil, false, nil + } + +- return dm ++ // We now know that ft is a pointer or slice. ++ sf = &scalarField{kind: ft.Elem().Kind()} ++ ++ // scalar fields without defaults ++ if !prop.HasDefault { ++ return sf, false, nil ++ } ++ ++ // a scalar field: either *T or []byte ++ switch ft.Elem().Kind() { ++ case reflect.Bool: ++ x, err := strconv.ParseBool(prop.Default) ++ if err != nil { ++ return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err) ++ } ++ sf.value = x ++ case reflect.Float32: ++ x, err := strconv.ParseFloat(prop.Default, 32) ++ if err != nil { ++ return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err) ++ } ++ sf.value = float32(x) ++ case reflect.Float64: ++ x, err := strconv.ParseFloat(prop.Default, 64) ++ if err != nil { ++ return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err) ++ } ++ sf.value = x ++ case reflect.Int32: ++ x, err := strconv.ParseInt(prop.Default, 10, 32) ++ if err != nil { ++ return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err) ++ } ++ sf.value = int32(x) ++ case reflect.Int64: ++ x, err := strconv.ParseInt(prop.Default, 10, 64) ++ if err != nil { ++ return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err) ++ } ++ sf.value = x ++ case reflect.String: ++ sf.value = prop.Default ++ case reflect.Uint8: ++ // []byte (not *uint8) ++ sf.value = []byte(prop.Default) ++ case reflect.Uint32: ++ x, err := strconv.ParseUint(prop.Default, 10, 32) ++ if err != nil { ++ return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err) ++ } ++ sf.value = uint32(x) ++ case reflect.Uint64: ++ x, err := strconv.ParseUint(prop.Default, 10, 64) ++ if err != nil { ++ return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err) ++ } ++ sf.value = x ++ default: ++ return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind()) ++ } ++ ++ return sf, false, nil + } + + // Map fields may have key types of non-float scalars, strings and enums. +@@ -750,10 +837,62 @@ func buildDefaultMessage(t reflect.Type) (dm defaultMessage) { + // If this turns out to be inefficient we can always consider other options, + // such as doing a Schwartzian transform. + +-type mapKeys []reflect.Value ++func mapKeys(vs []reflect.Value) sort.Interface { ++ s := mapKeySorter{ ++ vs: vs, ++ // default Less function: textual comparison ++ less: func(a, b reflect.Value) bool { ++ return fmt.Sprint(a.Interface()) < fmt.Sprint(b.Interface()) ++ }, ++ } ++ ++ // Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps; ++ // numeric keys are sorted numerically. ++ if len(vs) == 0 { ++ return s ++ } ++ switch vs[0].Kind() { ++ case reflect.Int32, reflect.Int64: ++ s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() } ++ case reflect.Uint32, reflect.Uint64: ++ s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() } ++ } ++ ++ return s ++} + +-func (s mapKeys) Len() int { return len(s) } +-func (s mapKeys) Swap(i, j int) { s[i], s[j] = s[j], s[i] } +-func (s mapKeys) Less(i, j int) bool { +- return fmt.Sprint(s[i].Interface()) < fmt.Sprint(s[j].Interface()) ++type mapKeySorter struct { ++ vs []reflect.Value ++ less func(a, b reflect.Value) bool + } ++ ++func (s mapKeySorter) Len() int { return len(s.vs) } ++func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] } ++func (s mapKeySorter) Less(i, j int) bool { ++ return s.less(s.vs[i], s.vs[j]) ++} ++ ++// isProto3Zero reports whether v is a zero proto3 value. ++func isProto3Zero(v reflect.Value) bool { ++ switch v.Kind() { ++ case reflect.Bool: ++ return !v.Bool() ++ case reflect.Int32, reflect.Int64: ++ return v.Int() == 0 ++ case reflect.Uint32, reflect.Uint64: ++ return v.Uint() == 0 ++ case reflect.Float32, reflect.Float64: ++ return v.Float() == 0 ++ case reflect.String: ++ return v.String() == "" ++ } ++ return false ++} ++ ++// ProtoPackageIsVersion2 is referenced from generated protocol buffer files ++// to assert that that code is compatible with this version of the proto package. ++const ProtoPackageIsVersion2 = true ++ ++// ProtoPackageIsVersion1 is referenced from generated protocol buffer files ++// to assert that that code is compatible with this version of the proto package. ++const ProtoPackageIsVersion1 = true +diff --git a/vendor/github.com/golang/protobuf/proto/message_set.go b/vendor/github.com/golang/protobuf/proto/message_set.go +index 9d912bc..fd982de 100644 +--- a/vendor/github.com/golang/protobuf/proto/message_set.go ++++ b/vendor/github.com/golang/protobuf/proto/message_set.go +@@ -44,11 +44,11 @@ import ( + "sort" + ) + +-// ErrNoMessageTypeId occurs when a protocol buffer does not have a message type ID. ++// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID. + // A message type ID is required for storing a protocol buffer in a message set. +-var ErrNoMessageTypeId = errors.New("proto does not have a message type ID") ++var errNoMessageTypeID = errors.New("proto does not have a message type ID") + +-// The first two types (_MessageSet_Item and MessageSet) ++// The first two types (_MessageSet_Item and messageSet) + // model what the protocol compiler produces for the following protocol message: + // message MessageSet { + // repeated group Item = 1 { +@@ -58,27 +58,20 @@ var ErrNoMessageTypeId = errors.New("proto does not have a message type ID") + // } + // That is the MessageSet wire format. We can't use a proto to generate these + // because that would introduce a circular dependency between it and this package. +-// +-// When a proto1 proto has a field that looks like: +-// optional message info = 3; +-// the protocol compiler produces a field in the generated struct that looks like: +-// Info *_proto_.MessageSet `protobuf:"bytes,3,opt,name=info"` +-// The package is automatically inserted so there is no need for that proto file to +-// import this package. + + type _MessageSet_Item struct { + TypeId *int32 `protobuf:"varint,2,req,name=type_id"` + Message []byte `protobuf:"bytes,3,req,name=message"` + } + +-type MessageSet struct { ++type messageSet struct { + Item []*_MessageSet_Item `protobuf:"group,1,rep"` + XXX_unrecognized []byte + // TODO: caching? + } + +-// Make sure MessageSet is a Message. +-var _ Message = (*MessageSet)(nil) ++// Make sure messageSet is a Message. ++var _ Message = (*messageSet)(nil) + + // messageTypeIder is an interface satisfied by a protocol buffer type + // that may be stored in a MessageSet. +@@ -86,7 +79,7 @@ type messageTypeIder interface { + MessageTypeId() int32 + } + +-func (ms *MessageSet) find(pb Message) *_MessageSet_Item { ++func (ms *messageSet) find(pb Message) *_MessageSet_Item { + mti, ok := pb.(messageTypeIder) + if !ok { + return nil +@@ -100,24 +93,24 @@ func (ms *MessageSet) find(pb Message) *_MessageSet_Item { + return nil + } + +-func (ms *MessageSet) Has(pb Message) bool { ++func (ms *messageSet) Has(pb Message) bool { + if ms.find(pb) != nil { + return true + } + return false + } + +-func (ms *MessageSet) Unmarshal(pb Message) error { ++func (ms *messageSet) Unmarshal(pb Message) error { + if item := ms.find(pb); item != nil { + return Unmarshal(item.Message, pb) + } + if _, ok := pb.(messageTypeIder); !ok { +- return ErrNoMessageTypeId ++ return errNoMessageTypeID + } + return nil // TODO: return error instead? + } + +-func (ms *MessageSet) Marshal(pb Message) error { ++func (ms *messageSet) Marshal(pb Message) error { + msg, err := Marshal(pb) + if err != nil { + return err +@@ -130,7 +123,7 @@ func (ms *MessageSet) Marshal(pb Message) error { + + mti, ok := pb.(messageTypeIder) + if !ok { +- return ErrNoMessageTypeId ++ return errNoMessageTypeID + } + + mtid := mti.MessageTypeId() +@@ -141,9 +134,9 @@ func (ms *MessageSet) Marshal(pb Message) error { + return nil + } + +-func (ms *MessageSet) Reset() { *ms = MessageSet{} } +-func (ms *MessageSet) String() string { return CompactTextString(ms) } +-func (*MessageSet) ProtoMessage() {} ++func (ms *messageSet) Reset() { *ms = messageSet{} } ++func (ms *messageSet) String() string { return CompactTextString(ms) } ++func (*messageSet) ProtoMessage() {} + + // Support for the message_set_wire_format message option. + +@@ -156,9 +149,21 @@ func skipVarint(buf []byte) []byte { + + // MarshalMessageSet encodes the extension map represented by m in the message set wire format. + // It is called by generated Marshal methods on protocol buffer messages with the message_set_wire_format option. +-func MarshalMessageSet(m map[int32]Extension) ([]byte, error) { +- if err := encodeExtensionMap(m); err != nil { +- return nil, err ++func MarshalMessageSet(exts interface{}) ([]byte, error) { ++ var m map[int32]Extension ++ switch exts := exts.(type) { ++ case *XXX_InternalExtensions: ++ if err := encodeExtensions(exts); err != nil { ++ return nil, err ++ } ++ m, _ = exts.extensionsRead() ++ case map[int32]Extension: ++ if err := encodeExtensionsMap(exts); err != nil { ++ return nil, err ++ } ++ m = exts ++ default: ++ return nil, errors.New("proto: not an extension map") + } + + // Sort extension IDs to provide a deterministic encoding. +@@ -169,7 +174,7 @@ func MarshalMessageSet(m map[int32]Extension) ([]byte, error) { + } + sort.Ints(ids) + +- ms := &MessageSet{Item: make([]*_MessageSet_Item, 0, len(m))} ++ ms := &messageSet{Item: make([]*_MessageSet_Item, 0, len(m))} + for _, id := range ids { + e := m[int32(id)] + // Remove the wire type and field number varint, as well as the length varint. +@@ -185,8 +190,18 @@ func MarshalMessageSet(m map[int32]Extension) ([]byte, error) { + + // UnmarshalMessageSet decodes the extension map encoded in buf in the message set wire format. + // It is called by generated Unmarshal methods on protocol buffer messages with the message_set_wire_format option. +-func UnmarshalMessageSet(buf []byte, m map[int32]Extension) error { +- ms := new(MessageSet) ++func UnmarshalMessageSet(buf []byte, exts interface{}) error { ++ var m map[int32]Extension ++ switch exts := exts.(type) { ++ case *XXX_InternalExtensions: ++ m = exts.extensionsWrite() ++ case map[int32]Extension: ++ m = exts ++ default: ++ return errors.New("proto: not an extension map") ++ } ++ ++ ms := new(messageSet) + if err := Unmarshal(buf, ms); err != nil { + return err + } +@@ -216,7 +231,16 @@ func UnmarshalMessageSet(buf []byte, m map[int32]Extension) error { + + // MarshalMessageSetJSON encodes the extension map represented by m in JSON format. + // It is called by generated MarshalJSON methods on protocol buffer messages with the message_set_wire_format option. +-func MarshalMessageSetJSON(m map[int32]Extension) ([]byte, error) { ++func MarshalMessageSetJSON(exts interface{}) ([]byte, error) { ++ var m map[int32]Extension ++ switch exts := exts.(type) { ++ case *XXX_InternalExtensions: ++ m, _ = exts.extensionsRead() ++ case map[int32]Extension: ++ m = exts ++ default: ++ return nil, errors.New("proto: not an extension map") ++ } + var b bytes.Buffer + b.WriteByte('{') + +@@ -259,7 +283,7 @@ func MarshalMessageSetJSON(m map[int32]Extension) ([]byte, error) { + + // UnmarshalMessageSetJSON decodes the extension map encoded in buf in JSON format. + // It is called by generated UnmarshalJSON methods on protocol buffer messages with the message_set_wire_format option. +-func UnmarshalMessageSetJSON(buf []byte, m map[int32]Extension) error { ++func UnmarshalMessageSetJSON(buf []byte, exts interface{}) error { + // Common-case fast path. + if len(buf) == 0 || bytes.Equal(buf, []byte("{}")) { + return nil +diff --git a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go +index c68b125..fb512e2 100644 +--- a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go ++++ b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go +@@ -29,7 +29,7 @@ + // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +-// +build appengine ++// +build appengine js + + // This file contains an implementation of proto field accesses using package reflect. + // It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can +@@ -139,13 +139,18 @@ func structPointer_StringSlice(p structPointer, f field) *[]string { + return structPointer_ifield(p, f).(*[]string) + } + ++// Extensions returns the address of an extension map field in the struct. ++func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions { ++ return structPointer_ifield(p, f).(*XXX_InternalExtensions) ++} ++ + // ExtMap returns the address of an extension map field in the struct. + func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension { + return structPointer_ifield(p, f).(*map[int32]Extension) + } + +-// Map returns the reflect.Value for the address of a map field in the struct. +-func structPointer_Map(p structPointer, f field, typ reflect.Type) reflect.Value { ++// NewAt returns the reflect.Value for a pointer to a field in the struct. ++func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value { + return structPointer_field(p, f).Addr() + } + +diff --git a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go +index 48bc0fa..6b5567d 100644 +--- a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go ++++ b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go +@@ -29,7 +29,7 @@ + // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +-// +build !appengine ++// +build !appengine,!js + + // This file contains the implementation of the proto field accesses using package unsafe. + +@@ -126,12 +126,16 @@ func structPointer_StringSlice(p structPointer, f field) *[]string { + } + + // ExtMap returns the address of an extension map field in the struct. ++func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions { ++ return (*XXX_InternalExtensions)(unsafe.Pointer(uintptr(p) + uintptr(f))) ++} ++ + func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension { + return (*map[int32]Extension)(unsafe.Pointer(uintptr(p) + uintptr(f))) + } + +-// Map returns the reflect.Value for the address of a map field in the struct. +-func structPointer_Map(p structPointer, f field, typ reflect.Type) reflect.Value { ++// NewAt returns the reflect.Value for a pointer to a field in the struct. ++func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value { + return reflect.NewAt(typ, unsafe.Pointer(uintptr(p)+uintptr(f))) + } + +diff --git a/vendor/github.com/golang/protobuf/proto/properties.go b/vendor/github.com/golang/protobuf/proto/properties.go +index 7216544..ec2289c 100644 +--- a/vendor/github.com/golang/protobuf/proto/properties.go ++++ b/vendor/github.com/golang/protobuf/proto/properties.go +@@ -37,6 +37,7 @@ package proto + + import ( + "fmt" ++ "log" + "os" + "reflect" + "sort" +@@ -84,6 +85,15 @@ type decoder func(p *Buffer, prop *Properties, base structPointer) error + // A valueDecoder decodes a single integer in a particular encoding. + type valueDecoder func(o *Buffer) (x uint64, err error) + ++// A oneofMarshaler does the marshaling for all oneof fields in a message. ++type oneofMarshaler func(Message, *Buffer) error ++ ++// A oneofUnmarshaler does the unmarshaling for a oneof field in a message. ++type oneofUnmarshaler func(Message, int, int, *Buffer) (bool, error) ++ ++// A oneofSizer does the sizing for all oneof fields in a message. ++type oneofSizer func(Message) int ++ + // tagMap is an optimization over map[int]int for typical protocol buffer + // use-cases. Encoded protocol buffers are often in tag order with small tag + // numbers. +@@ -132,6 +142,22 @@ type StructProperties struct { + order []int // list of struct field numbers in tag order + unrecField field // field id of the XXX_unrecognized []byte field + extendable bool // is this an extendable proto ++ ++ oneofMarshaler oneofMarshaler ++ oneofUnmarshaler oneofUnmarshaler ++ oneofSizer oneofSizer ++ stype reflect.Type ++ ++ // OneofTypes contains information about the oneof fields in this message. ++ // It is keyed by the original name of a field. ++ OneofTypes map[string]*OneofProperties ++} ++ ++// OneofProperties represents information about a specific field in a oneof. ++type OneofProperties struct { ++ Type reflect.Type // pointer to generated struct type for this oneof field ++ Field int // struct field number of the containing oneof in the message ++ Prop *Properties + } + + // Implement the sorting interface so we can sort the fields in tag order, as recommended by the spec. +@@ -147,6 +173,7 @@ func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order + type Properties struct { + Name string // name of the field, for error messages + OrigName string // original name before protocol compiler (always set) ++ JSONName string // name to use for JSON; determined by protoc + Wire string + WireType int + Tag int +@@ -156,6 +183,7 @@ type Properties struct { + Packed bool // relevant for repeated primitives only + Enum string // set for enum types only + proto3 bool // whether this is known to be a proto3 field; set for []byte only ++ oneof bool // whether this is a oneof field + + Default string // default value + HasDefault bool // whether an explicit default was provided +@@ -202,12 +230,16 @@ func (p *Properties) String() string { + if p.Packed { + s += ",packed" + } +- if p.OrigName != p.Name { +- s += ",name=" + p.OrigName ++ s += ",name=" + p.OrigName ++ if p.JSONName != p.OrigName { ++ s += ",json=" + p.JSONName + } + if p.proto3 { + s += ",proto3" + } ++ if p.oneof { ++ s += ",oneof" ++ } + if len(p.Enum) > 0 { + s += ",enum=" + p.Enum + } +@@ -280,10 +312,14 @@ func (p *Properties) Parse(s string) { + p.Packed = true + case strings.HasPrefix(f, "name="): + p.OrigName = f[5:] ++ case strings.HasPrefix(f, "json="): ++ p.JSONName = f[5:] + case strings.HasPrefix(f, "enum="): + p.Enum = f[5:] + case f == "proto3": + p.proto3 = true ++ case f == "oneof": ++ p.oneof = true + case strings.HasPrefix(f, "def="): + p.HasDefault = true + p.Default = f[4:] // rest of string +@@ -437,12 +473,13 @@ func (p *Properties) setEncAndDec(typ reflect.Type, f *reflect.StructField, lock + p.dec = (*Buffer).dec_slice_int64 + p.packedDec = (*Buffer).dec_slice_packed_int64 + case reflect.Uint8: +- p.enc = (*Buffer).enc_slice_byte + p.dec = (*Buffer).dec_slice_byte +- p.size = size_slice_byte + if p.proto3 { + p.enc = (*Buffer).enc_proto3_slice_byte + p.size = size_proto3_slice_byte ++ } else { ++ p.enc = (*Buffer).enc_slice_byte ++ p.size = size_slice_byte + } + case reflect.Float32, reflect.Float64: + switch t2.Bits() { +@@ -641,7 +678,8 @@ func getPropertiesLocked(t reflect.Type) *StructProperties { + propertiesMap[t] = prop + + // build properties +- prop.extendable = reflect.PtrTo(t).Implements(extendableProtoType) ++ prop.extendable = reflect.PtrTo(t).Implements(extendableProtoType) || ++ reflect.PtrTo(t).Implements(extendableProtoV1Type) + prop.unrecField = invalidField + prop.Prop = make([]*Properties, t.NumField()) + prop.order = make([]int, t.NumField()) +@@ -652,14 +690,22 @@ func getPropertiesLocked(t reflect.Type) *StructProperties { + name := f.Name + p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false) + +- if f.Name == "XXX_extensions" { // special case ++ if f.Name == "XXX_InternalExtensions" { // special case ++ p.enc = (*Buffer).enc_exts ++ p.dec = nil // not needed ++ p.size = size_exts ++ } else if f.Name == "XXX_extensions" { // special case + p.enc = (*Buffer).enc_map + p.dec = nil // not needed + p.size = size_map +- } +- if f.Name == "XXX_unrecognized" { // special case ++ } else if f.Name == "XXX_unrecognized" { // special case + prop.unrecField = toField(&f) + } ++ oneof := f.Tag.Get("protobuf_oneof") // special case ++ if oneof != "" { ++ // Oneof fields don't use the traditional protobuf tag. ++ p.OrigName = oneof ++ } + prop.Prop[i] = p + prop.order[i] = i + if debug { +@@ -669,7 +715,7 @@ func getPropertiesLocked(t reflect.Type) *StructProperties { + } + print("\n") + } +- if p.enc == nil && !strings.HasPrefix(f.Name, "XXX_") { ++ if p.enc == nil && !strings.HasPrefix(f.Name, "XXX_") && oneof == "" { + fmt.Fprintln(os.Stderr, "proto: no encoder for", f.Name, f.Type.String(), "[GetProperties]") + } + } +@@ -677,6 +723,41 @@ func getPropertiesLocked(t reflect.Type) *StructProperties { + // Re-order prop.order. + sort.Sort(prop) + ++ type oneofMessage interface { ++ XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{}) ++ } ++ if om, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok { ++ var oots []interface{} ++ prop.oneofMarshaler, prop.oneofUnmarshaler, prop.oneofSizer, oots = om.XXX_OneofFuncs() ++ prop.stype = t ++ ++ // Interpret oneof metadata. ++ prop.OneofTypes = make(map[string]*OneofProperties) ++ for _, oot := range oots { ++ oop := &OneofProperties{ ++ Type: reflect.ValueOf(oot).Type(), // *T ++ Prop: new(Properties), ++ } ++ sft := oop.Type.Elem().Field(0) ++ oop.Prop.Name = sft.Name ++ oop.Prop.Parse(sft.Tag.Get("protobuf")) ++ // There will be exactly one interface field that ++ // this new value is assignable to. ++ for i := 0; i < t.NumField(); i++ { ++ f := t.Field(i) ++ if f.Type.Kind() != reflect.Interface { ++ continue ++ } ++ if !oop.Type.AssignableTo(f.Type) { ++ continue ++ } ++ oop.Field = i ++ break ++ } ++ prop.OneofTypes[oop.Prop.OrigName] = oop ++ } ++ } ++ + // build required counts + // build tags + reqCount := 0 +@@ -735,3 +816,57 @@ func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[ + } + enumValueMaps[typeName] = valueMap + } ++ ++// EnumValueMap returns the mapping from names to integers of the ++// enum type enumType, or a nil if not found. ++func EnumValueMap(enumType string) map[string]int32 { ++ return enumValueMaps[enumType] ++} ++ ++// A registry of all linked message types. ++// The string is a fully-qualified proto name ("pkg.Message"). ++var ( ++ protoTypes = make(map[string]reflect.Type) ++ revProtoTypes = make(map[reflect.Type]string) ++) ++ ++// RegisterType is called from generated code and maps from the fully qualified ++// proto name to the type (pointer to struct) of the protocol buffer. ++func RegisterType(x Message, name string) { ++ if _, ok := protoTypes[name]; ok { ++ // TODO: Some day, make this a panic. ++ log.Printf("proto: duplicate proto type registered: %s", name) ++ return ++ } ++ t := reflect.TypeOf(x) ++ protoTypes[name] = t ++ revProtoTypes[t] = name ++} ++ ++// MessageName returns the fully-qualified proto name for the given message type. ++func MessageName(x Message) string { ++ type xname interface { ++ XXX_MessageName() string ++ } ++ if m, ok := x.(xname); ok { ++ return m.XXX_MessageName() ++ } ++ return revProtoTypes[reflect.TypeOf(x)] ++} ++ ++// MessageType returns the message type (pointer to struct) for a named message. ++func MessageType(name string) reflect.Type { return protoTypes[name] } ++ ++// A registry of all linked proto files. ++var ( ++ protoFiles = make(map[string][]byte) // file name => fileDescriptor ++) ++ ++// RegisterFile is called from generated code and maps from the ++// full file name of a .proto file to its compressed FileDescriptorProto. ++func RegisterFile(filename string, fileDescriptor []byte) { ++ protoFiles[filename] = fileDescriptor ++} ++ ++// FileDescriptor returns the compressed FileDescriptorProto for a .proto file. ++func FileDescriptor(filename string) []byte { return protoFiles[filename] } +diff --git a/vendor/github.com/golang/protobuf/proto/proto3_proto/proto3.pb.go b/vendor/github.com/golang/protobuf/proto/proto3_proto/proto3.pb.go +new file mode 100644 +index 0000000..cc4d048 +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/proto/proto3_proto/proto3.pb.go +@@ -0,0 +1,347 @@ ++// Code generated by protoc-gen-go. ++// source: proto3_proto/proto3.proto ++// DO NOT EDIT! ++ ++/* ++Package proto3_proto is a generated protocol buffer package. ++ ++It is generated from these files: ++ proto3_proto/proto3.proto ++ ++It has these top-level messages: ++ Message ++ Nested ++ MessageWithMap ++ IntMap ++ IntMaps ++*/ ++package proto3_proto ++ ++import proto "github.com/golang/protobuf/proto" ++import fmt "fmt" ++import math "math" ++import google_protobuf "github.com/golang/protobuf/ptypes/any" ++import testdata "github.com/golang/protobuf/proto/testdata" ++ ++// Reference imports to suppress errors if they are not otherwise used. ++var _ = proto.Marshal ++var _ = fmt.Errorf ++var _ = math.Inf ++ ++// This is a compile-time assertion to ensure that this generated file ++// is compatible with the proto package it is being compiled against. ++// A compilation error at this line likely means your copy of the ++// proto package needs to be updated. ++const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package ++ ++type Message_Humour int32 ++ ++const ( ++ Message_UNKNOWN Message_Humour = 0 ++ Message_PUNS Message_Humour = 1 ++ Message_SLAPSTICK Message_Humour = 2 ++ Message_BILL_BAILEY Message_Humour = 3 ++) ++ ++var Message_Humour_name = map[int32]string{ ++ 0: "UNKNOWN", ++ 1: "PUNS", ++ 2: "SLAPSTICK", ++ 3: "BILL_BAILEY", ++} ++var Message_Humour_value = map[string]int32{ ++ "UNKNOWN": 0, ++ "PUNS": 1, ++ "SLAPSTICK": 2, ++ "BILL_BAILEY": 3, ++} ++ ++func (x Message_Humour) String() string { ++ return proto.EnumName(Message_Humour_name, int32(x)) ++} ++func (Message_Humour) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 0} } ++ ++type Message struct { ++ Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` ++ Hilarity Message_Humour `protobuf:"varint,2,opt,name=hilarity,enum=proto3_proto.Message_Humour" json:"hilarity,omitempty"` ++ HeightInCm uint32 `protobuf:"varint,3,opt,name=height_in_cm,json=heightInCm" json:"height_in_cm,omitempty"` ++ Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` ++ ResultCount int64 `protobuf:"varint,7,opt,name=result_count,json=resultCount" json:"result_count,omitempty"` ++ TrueScotsman bool `protobuf:"varint,8,opt,name=true_scotsman,json=trueScotsman" json:"true_scotsman,omitempty"` ++ Score float32 `protobuf:"fixed32,9,opt,name=score" json:"score,omitempty"` ++ Key []uint64 `protobuf:"varint,5,rep,packed,name=key" json:"key,omitempty"` ++ ShortKey []int32 `protobuf:"varint,19,rep,packed,name=short_key,json=shortKey" json:"short_key,omitempty"` ++ Nested *Nested `protobuf:"bytes,6,opt,name=nested" json:"nested,omitempty"` ++ RFunny []Message_Humour `protobuf:"varint,16,rep,packed,name=r_funny,json=rFunny,enum=proto3_proto.Message_Humour" json:"r_funny,omitempty"` ++ Terrain map[string]*Nested `protobuf:"bytes,10,rep,name=terrain" json:"terrain,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` ++ Proto2Field *testdata.SubDefaults `protobuf:"bytes,11,opt,name=proto2_field,json=proto2Field" json:"proto2_field,omitempty"` ++ Proto2Value map[string]*testdata.SubDefaults `protobuf:"bytes,13,rep,name=proto2_value,json=proto2Value" json:"proto2_value,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` ++ Anything *google_protobuf.Any `protobuf:"bytes,14,opt,name=anything" json:"anything,omitempty"` ++ ManyThings []*google_protobuf.Any `protobuf:"bytes,15,rep,name=many_things,json=manyThings" json:"many_things,omitempty"` ++ Submessage *Message `protobuf:"bytes,17,opt,name=submessage" json:"submessage,omitempty"` ++ Children []*Message `protobuf:"bytes,18,rep,name=children" json:"children,omitempty"` ++} ++ ++func (m *Message) Reset() { *m = Message{} } ++func (m *Message) String() string { return proto.CompactTextString(m) } ++func (*Message) ProtoMessage() {} ++func (*Message) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } ++ ++func (m *Message) GetName() string { ++ if m != nil { ++ return m.Name ++ } ++ return "" ++} ++ ++func (m *Message) GetHilarity() Message_Humour { ++ if m != nil { ++ return m.Hilarity ++ } ++ return Message_UNKNOWN ++} ++ ++func (m *Message) GetHeightInCm() uint32 { ++ if m != nil { ++ return m.HeightInCm ++ } ++ return 0 ++} ++ ++func (m *Message) GetData() []byte { ++ if m != nil { ++ return m.Data ++ } ++ return nil ++} ++ ++func (m *Message) GetResultCount() int64 { ++ if m != nil { ++ return m.ResultCount ++ } ++ return 0 ++} ++ ++func (m *Message) GetTrueScotsman() bool { ++ if m != nil { ++ return m.TrueScotsman ++ } ++ return false ++} ++ ++func (m *Message) GetScore() float32 { ++ if m != nil { ++ return m.Score ++ } ++ return 0 ++} ++ ++func (m *Message) GetKey() []uint64 { ++ if m != nil { ++ return m.Key ++ } ++ return nil ++} ++ ++func (m *Message) GetShortKey() []int32 { ++ if m != nil { ++ return m.ShortKey ++ } ++ return nil ++} ++ ++func (m *Message) GetNested() *Nested { ++ if m != nil { ++ return m.Nested ++ } ++ return nil ++} ++ ++func (m *Message) GetRFunny() []Message_Humour { ++ if m != nil { ++ return m.RFunny ++ } ++ return nil ++} ++ ++func (m *Message) GetTerrain() map[string]*Nested { ++ if m != nil { ++ return m.Terrain ++ } ++ return nil ++} ++ ++func (m *Message) GetProto2Field() *testdata.SubDefaults { ++ if m != nil { ++ return m.Proto2Field ++ } ++ return nil ++} ++ ++func (m *Message) GetProto2Value() map[string]*testdata.SubDefaults { ++ if m != nil { ++ return m.Proto2Value ++ } ++ return nil ++} ++ ++func (m *Message) GetAnything() *google_protobuf.Any { ++ if m != nil { ++ return m.Anything ++ } ++ return nil ++} ++ ++func (m *Message) GetManyThings() []*google_protobuf.Any { ++ if m != nil { ++ return m.ManyThings ++ } ++ return nil ++} ++ ++func (m *Message) GetSubmessage() *Message { ++ if m != nil { ++ return m.Submessage ++ } ++ return nil ++} ++ ++func (m *Message) GetChildren() []*Message { ++ if m != nil { ++ return m.Children ++ } ++ return nil ++} ++ ++type Nested struct { ++ Bunny string `protobuf:"bytes,1,opt,name=bunny" json:"bunny,omitempty"` ++ Cute bool `protobuf:"varint,2,opt,name=cute" json:"cute,omitempty"` ++} ++ ++func (m *Nested) Reset() { *m = Nested{} } ++func (m *Nested) String() string { return proto.CompactTextString(m) } ++func (*Nested) ProtoMessage() {} ++func (*Nested) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } ++ ++func (m *Nested) GetBunny() string { ++ if m != nil { ++ return m.Bunny ++ } ++ return "" ++} ++ ++func (m *Nested) GetCute() bool { ++ if m != nil { ++ return m.Cute ++ } ++ return false ++} ++ ++type MessageWithMap struct { ++ ByteMapping map[bool][]byte `protobuf:"bytes,1,rep,name=byte_mapping,json=byteMapping" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value,proto3"` ++} ++ ++func (m *MessageWithMap) Reset() { *m = MessageWithMap{} } ++func (m *MessageWithMap) String() string { return proto.CompactTextString(m) } ++func (*MessageWithMap) ProtoMessage() {} ++func (*MessageWithMap) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } ++ ++func (m *MessageWithMap) GetByteMapping() map[bool][]byte { ++ if m != nil { ++ return m.ByteMapping ++ } ++ return nil ++} ++ ++type IntMap struct { ++ Rtt map[int32]int32 `protobuf:"bytes,1,rep,name=rtt" json:"rtt,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` ++} ++ ++func (m *IntMap) Reset() { *m = IntMap{} } ++func (m *IntMap) String() string { return proto.CompactTextString(m) } ++func (*IntMap) ProtoMessage() {} ++func (*IntMap) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } ++ ++func (m *IntMap) GetRtt() map[int32]int32 { ++ if m != nil { ++ return m.Rtt ++ } ++ return nil ++} ++ ++type IntMaps struct { ++ Maps []*IntMap `protobuf:"bytes,1,rep,name=maps" json:"maps,omitempty"` ++} ++ ++func (m *IntMaps) Reset() { *m = IntMaps{} } ++func (m *IntMaps) String() string { return proto.CompactTextString(m) } ++func (*IntMaps) ProtoMessage() {} ++func (*IntMaps) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } ++ ++func (m *IntMaps) GetMaps() []*IntMap { ++ if m != nil { ++ return m.Maps ++ } ++ return nil ++} ++ ++func init() { ++ proto.RegisterType((*Message)(nil), "proto3_proto.Message") ++ proto.RegisterType((*Nested)(nil), "proto3_proto.Nested") ++ proto.RegisterType((*MessageWithMap)(nil), "proto3_proto.MessageWithMap") ++ proto.RegisterType((*IntMap)(nil), "proto3_proto.IntMap") ++ proto.RegisterType((*IntMaps)(nil), "proto3_proto.IntMaps") ++ proto.RegisterEnum("proto3_proto.Message_Humour", Message_Humour_name, Message_Humour_value) ++} ++ ++func init() { proto.RegisterFile("proto3_proto/proto3.proto", fileDescriptor0) } ++ ++var fileDescriptor0 = []byte{ ++ // 733 bytes of a gzipped FileDescriptorProto ++ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x53, 0x6d, 0x6f, 0xf3, 0x34, ++ 0x14, 0x25, 0x4d, 0x5f, 0xd2, 0x9b, 0x74, 0x0b, 0x5e, 0x91, 0xbc, 0x02, 0x52, 0x28, 0x12, 0x8a, ++ 0x78, 0x49, 0xa1, 0xd3, 0xd0, 0x84, 0x10, 0x68, 0x1b, 0x9b, 0xa8, 0xd6, 0x95, 0xca, 0xdd, 0x98, ++ 0xf8, 0x14, 0xa5, 0xad, 0xdb, 0x46, 0x34, 0x4e, 0x49, 0x1c, 0xa4, 0xfc, 0x1d, 0xfe, 0x28, 0x8f, ++ 0x6c, 0xa7, 0x5d, 0x36, 0x65, 0xcf, 0xf3, 0x29, 0xf6, 0xf1, 0xb9, 0xf7, 0x9c, 0x1c, 0x5f, 0xc3, ++ 0xe9, 0x2e, 0x89, 0x79, 0x7c, 0xe6, 0xcb, 0xcf, 0x40, 0x6d, 0x3c, 0xf9, 0x41, 0x56, 0xf9, 0xa8, ++ 0x77, 0xba, 0x8e, 0xe3, 0xf5, 0x96, 0x2a, 0xca, 0x3c, 0x5b, 0x0d, 0x02, 0x96, 0x2b, 0x62, 0xef, ++ 0x84, 0xd3, 0x94, 0x2f, 0x03, 0x1e, 0x0c, 0xc4, 0x42, 0x81, 0xfd, 0xff, 0x5b, 0xd0, 0xba, 0xa7, ++ 0x69, 0x1a, 0xac, 0x29, 0x42, 0x50, 0x67, 0x41, 0x44, 0xb1, 0xe6, 0x68, 0x6e, 0x9b, 0xc8, 0x35, ++ 0xba, 0x00, 0x63, 0x13, 0x6e, 0x83, 0x24, 0xe4, 0x39, 0xae, 0x39, 0x9a, 0x7b, 0x34, 0xfc, 0xcc, ++ 0x2b, 0x0b, 0x7a, 0x45, 0xb1, 0xf7, 0x7b, 0x16, 0xc5, 0x59, 0x42, 0x0e, 0x6c, 0xe4, 0x80, 0xb5, ++ 0xa1, 0xe1, 0x7a, 0xc3, 0xfd, 0x90, 0xf9, 0x8b, 0x08, 0xeb, 0x8e, 0xe6, 0x76, 0x08, 0x28, 0x6c, ++ 0xc4, 0xae, 0x23, 0xa1, 0x27, 0xec, 0xe0, 0xba, 0xa3, 0xb9, 0x16, 0x91, 0x6b, 0xf4, 0x05, 0x58, ++ 0x09, 0x4d, 0xb3, 0x2d, 0xf7, 0x17, 0x71, 0xc6, 0x38, 0x6e, 0x39, 0x9a, 0xab, 0x13, 0x53, 0x61, ++ 0xd7, 0x02, 0x42, 0x5f, 0x42, 0x87, 0x27, 0x19, 0xf5, 0xd3, 0x45, 0xcc, 0xd3, 0x28, 0x60, 0xd8, ++ 0x70, 0x34, 0xd7, 0x20, 0x96, 0x00, 0x67, 0x05, 0x86, 0xba, 0xd0, 0x48, 0x17, 0x71, 0x42, 0x71, ++ 0xdb, 0xd1, 0xdc, 0x1a, 0x51, 0x1b, 0x64, 0x83, 0xfe, 0x37, 0xcd, 0x71, 0xc3, 0xd1, 0xdd, 0x3a, ++ 0x11, 0x4b, 0xf4, 0x29, 0xb4, 0xd3, 0x4d, 0x9c, 0x70, 0x5f, 0xe0, 0x27, 0x8e, 0xee, 0x36, 0x88, ++ 0x21, 0x81, 0x3b, 0x9a, 0xa3, 0x6f, 0xa1, 0xc9, 0x68, 0xca, 0xe9, 0x12, 0x37, 0x1d, 0xcd, 0x35, ++ 0x87, 0xdd, 0x97, 0xbf, 0x3e, 0x91, 0x67, 0xa4, 0xe0, 0xa0, 0x73, 0x68, 0x25, 0xfe, 0x2a, 0x63, ++ 0x2c, 0xc7, 0xb6, 0xa3, 0x7f, 0x30, 0xa9, 0x66, 0x72, 0x2b, 0xb8, 0xe8, 0x67, 0x68, 0x71, 0x9a, ++ 0x24, 0x41, 0xc8, 0x30, 0x38, 0xba, 0x6b, 0x0e, 0xfb, 0xd5, 0x65, 0x0f, 0x8a, 0x74, 0xc3, 0x78, ++ 0x92, 0x93, 0x7d, 0x09, 0xba, 0x00, 0x75, 0xff, 0x43, 0x7f, 0x15, 0xd2, 0xed, 0x12, 0x9b, 0xd2, ++ 0xe8, 0x27, 0xde, 0xfe, 0xae, 0xbd, 0x59, 0x36, 0xff, 0x8d, 0xae, 0x82, 0x6c, 0xcb, 0x53, 0x62, ++ 0x2a, 0xea, 0xad, 0x60, 0xa2, 0xd1, 0xa1, 0xf2, 0xdf, 0x60, 0x9b, 0x51, 0xdc, 0x91, 0xe2, 0x5f, ++ 0x55, 0x8b, 0x4f, 0x25, 0xf3, 0x4f, 0x41, 0x54, 0x06, 0x8a, 0x56, 0x12, 0x41, 0xdf, 0x83, 0x11, ++ 0xb0, 0x9c, 0x6f, 0x42, 0xb6, 0xc6, 0x47, 0x45, 0x52, 0x6a, 0x0e, 0xbd, 0xfd, 0x1c, 0x7a, 0x97, ++ 0x2c, 0x27, 0x07, 0x16, 0x3a, 0x07, 0x33, 0x0a, 0x58, 0xee, 0xcb, 0x5d, 0x8a, 0x8f, 0xa5, 0x76, ++ 0x75, 0x11, 0x08, 0xe2, 0x83, 0xe4, 0xa1, 0x73, 0x80, 0x34, 0x9b, 0x47, 0xca, 0x14, 0xfe, 0xb8, ++ 0xf8, 0xd7, 0x2a, 0xc7, 0xa4, 0x44, 0x44, 0x3f, 0x80, 0xb1, 0xd8, 0x84, 0xdb, 0x65, 0x42, 0x19, ++ 0x46, 0x52, 0xea, 0x8d, 0xa2, 0x03, 0xad, 0x37, 0x05, 0xab, 0x1c, 0xf8, 0x7e, 0x72, 0xd4, 0xd3, ++ 0x90, 0x93, 0xf3, 0x35, 0x34, 0x54, 0x70, 0xb5, 0xf7, 0xcc, 0x86, 0xa2, 0xfc, 0x54, 0xbb, 0xd0, ++ 0x7a, 0x8f, 0x60, 0xbf, 0x4e, 0xb1, 0xa2, 0xeb, 0x37, 0x2f, 0xbb, 0xbe, 0x71, 0x91, 0xcf, 0x6d, ++ 0xfb, 0xbf, 0x42, 0x53, 0x0d, 0x14, 0x32, 0xa1, 0xf5, 0x38, 0xb9, 0x9b, 0xfc, 0xf1, 0x34, 0xb1, ++ 0x3f, 0x42, 0x06, 0xd4, 0xa7, 0x8f, 0x93, 0x99, 0xad, 0xa1, 0x0e, 0xb4, 0x67, 0xe3, 0xcb, 0xe9, ++ 0xec, 0x61, 0x74, 0x7d, 0x67, 0xd7, 0xd0, 0x31, 0x98, 0x57, 0xa3, 0xf1, 0xd8, 0xbf, 0xba, 0x1c, ++ 0x8d, 0x6f, 0xfe, 0xb2, 0xf5, 0xfe, 0x10, 0x9a, 0xca, 0xac, 0x78, 0x33, 0x73, 0x39, 0xbe, 0xca, ++ 0x8f, 0xda, 0x88, 0x57, 0xba, 0xc8, 0xb8, 0x32, 0x64, 0x10, 0xb9, 0xee, 0xff, 0xa7, 0xc1, 0x51, ++ 0x91, 0xd9, 0x53, 0xc8, 0x37, 0xf7, 0xc1, 0x0e, 0x4d, 0xc1, 0x9a, 0xe7, 0x9c, 0xfa, 0x51, 0xb0, ++ 0xdb, 0x89, 0x39, 0xd0, 0x64, 0xce, 0xdf, 0x55, 0xe6, 0x5c, 0xd4, 0x78, 0x57, 0x39, 0xa7, 0xf7, ++ 0x8a, 0x5f, 0x4c, 0xd5, 0xfc, 0x19, 0xe9, 0xfd, 0x02, 0xf6, 0x6b, 0x42, 0x39, 0x30, 0x43, 0x05, ++ 0xd6, 0x2d, 0x07, 0x66, 0x95, 0x93, 0xf9, 0x07, 0x9a, 0x23, 0xc6, 0x85, 0xb7, 0x01, 0xe8, 0x09, ++ 0xe7, 0x85, 0xa5, 0xcf, 0x5f, 0x5a, 0x52, 0x14, 0x8f, 0x70, 0xae, 0x2c, 0x08, 0x66, 0xef, 0x47, ++ 0x30, 0xf6, 0x40, 0x59, 0xb2, 0x51, 0x21, 0xd9, 0x28, 0x4b, 0x9e, 0x41, 0x4b, 0xf5, 0x4b, 0x91, ++ 0x0b, 0xf5, 0x28, 0xd8, 0xa5, 0x85, 0x68, 0xb7, 0x4a, 0x94, 0x48, 0xc6, 0xbc, 0xa9, 0x8e, 0xde, ++ 0x05, 0x00, 0x00, 0xff, 0xff, 0x75, 0x38, 0xad, 0x84, 0xe4, 0x05, 0x00, 0x00, ++} +diff --git a/vendor/github.com/golang/protobuf/proto/proto3_proto/proto3.proto b/vendor/github.com/golang/protobuf/proto/proto3_proto/proto3.proto +new file mode 100644 +index 0000000..2048655 +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/proto/proto3_proto/proto3.proto +@@ -0,0 +1,87 @@ ++// Go support for Protocol Buffers - Google's data interchange format ++// ++// Copyright 2014 The Go Authors. All rights reserved. ++// https://github.com/golang/protobuf ++// ++// Redistribution and use in source and binary forms, with or without ++// modification, are permitted provided that the following conditions are ++// met: ++// ++// * Redistributions of source code must retain the above copyright ++// notice, this list of conditions and the following disclaimer. ++// * Redistributions in binary form must reproduce the above ++// copyright notice, this list of conditions and the following disclaimer ++// in the documentation and/or other materials provided with the ++// distribution. ++// * Neither the name of Google Inc. nor the names of its ++// contributors may be used to endorse or promote products derived from ++// this software without specific prior written permission. ++// ++// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++syntax = "proto3"; ++ ++import "google/protobuf/any.proto"; ++import "testdata/test.proto"; ++ ++package proto3_proto; ++ ++message Message { ++ enum Humour { ++ UNKNOWN = 0; ++ PUNS = 1; ++ SLAPSTICK = 2; ++ BILL_BAILEY = 3; ++ } ++ ++ string name = 1; ++ Humour hilarity = 2; ++ uint32 height_in_cm = 3; ++ bytes data = 4; ++ int64 result_count = 7; ++ bool true_scotsman = 8; ++ float score = 9; ++ ++ repeated uint64 key = 5; ++ repeated int32 short_key = 19; ++ Nested nested = 6; ++ repeated Humour r_funny = 16; ++ ++ map terrain = 10; ++ testdata.SubDefaults proto2_field = 11; ++ map proto2_value = 13; ++ ++ google.protobuf.Any anything = 14; ++ repeated google.protobuf.Any many_things = 15; ++ ++ Message submessage = 17; ++ repeated Message children = 18; ++} ++ ++message Nested { ++ string bunny = 1; ++ bool cute = 2; ++} ++ ++message MessageWithMap { ++ map byte_mapping = 1; ++} ++ ++ ++message IntMap { ++ map rtt = 1; ++} ++ ++message IntMaps { ++ repeated IntMap maps = 1; ++} +diff --git a/vendor/github.com/golang/protobuf/proto/text.go b/vendor/github.com/golang/protobuf/proto/text.go +index 720eac4..965876b 100644 +--- a/vendor/github.com/golang/protobuf/proto/text.go ++++ b/vendor/github.com/golang/protobuf/proto/text.go +@@ -37,11 +37,11 @@ import ( + "bufio" + "bytes" + "encoding" ++ "errors" + "fmt" + "io" + "log" + "math" +- "os" + "reflect" + "sort" + "strings" +@@ -154,7 +154,7 @@ func (w *textWriter) indent() { w.ind++ } + + func (w *textWriter) unindent() { + if w.ind == 0 { +- log.Printf("proto: textWriter unindented too far") ++ log.Print("proto: textWriter unindented too far") + return + } + w.ind-- +@@ -170,20 +170,98 @@ func writeName(w *textWriter, props *Properties) error { + return nil + } + +-var ( +- messageSetType = reflect.TypeOf((*MessageSet)(nil)).Elem() +-) +- + // raw is the interface satisfied by RawMessage. + type raw interface { + Bytes() []byte + } + +-func writeStruct(w *textWriter, sv reflect.Value) error { +- if sv.Type() == messageSetType { +- return writeMessageSet(w, sv.Addr().Interface().(*MessageSet)) ++func requiresQuotes(u string) bool { ++ // When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted. ++ for _, ch := range u { ++ switch { ++ case ch == '.' || ch == '/' || ch == '_': ++ continue ++ case '0' <= ch && ch <= '9': ++ continue ++ case 'A' <= ch && ch <= 'Z': ++ continue ++ case 'a' <= ch && ch <= 'z': ++ continue ++ default: ++ return true ++ } ++ } ++ return false ++} ++ ++// isAny reports whether sv is a google.protobuf.Any message ++func isAny(sv reflect.Value) bool { ++ type wkt interface { ++ XXX_WellKnownType() string ++ } ++ t, ok := sv.Addr().Interface().(wkt) ++ return ok && t.XXX_WellKnownType() == "Any" ++} ++ ++// writeProto3Any writes an expanded google.protobuf.Any message. ++// ++// It returns (false, nil) if sv value can't be unmarshaled (e.g. because ++// required messages are not linked in). ++// ++// It returns (true, error) when sv was written in expanded format or an error ++// was encountered. ++func (tm *TextMarshaler) writeProto3Any(w *textWriter, sv reflect.Value) (bool, error) { ++ turl := sv.FieldByName("TypeUrl") ++ val := sv.FieldByName("Value") ++ if !turl.IsValid() || !val.IsValid() { ++ return true, errors.New("proto: invalid google.protobuf.Any message") ++ } ++ ++ b, ok := val.Interface().([]byte) ++ if !ok { ++ return true, errors.New("proto: invalid google.protobuf.Any message") + } + ++ parts := strings.Split(turl.String(), "/") ++ mt := MessageType(parts[len(parts)-1]) ++ if mt == nil { ++ return false, nil ++ } ++ m := reflect.New(mt.Elem()) ++ if err := Unmarshal(b, m.Interface().(Message)); err != nil { ++ return false, nil ++ } ++ w.Write([]byte("[")) ++ u := turl.String() ++ if requiresQuotes(u) { ++ writeString(w, u) ++ } else { ++ w.Write([]byte(u)) ++ } ++ if w.compact { ++ w.Write([]byte("]:<")) ++ } else { ++ w.Write([]byte("]: <\n")) ++ w.ind++ ++ } ++ if err := tm.writeStruct(w, m.Elem()); err != nil { ++ return true, err ++ } ++ if w.compact { ++ w.Write([]byte("> ")) ++ } else { ++ w.ind-- ++ w.Write([]byte(">\n")) ++ } ++ return true, nil ++} ++ ++func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error { ++ if tm.ExpandAny && isAny(sv) { ++ if canExpand, err := tm.writeProto3Any(w, sv); canExpand { ++ return err ++ } ++ } + st := sv.Type() + sprops := GetProperties(st) + for i := 0; i < sv.NumField(); i++ { +@@ -235,7 +313,7 @@ func writeStruct(w *textWriter, sv reflect.Value) error { + } + continue + } +- if err := writeAny(w, v, props); err != nil { ++ if err := tm.writeAny(w, v, props); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { +@@ -246,7 +324,7 @@ func writeStruct(w *textWriter, sv reflect.Value) error { + } + if fv.Kind() == reflect.Map { + // Map fields are rendered as a repeated struct with key/value fields. +- keys := fv.MapKeys() // TODO: should we sort these for deterministic output? ++ keys := fv.MapKeys() + sort.Sort(mapKeys(keys)) + for _, key := range keys { + val := fv.MapIndex(key) +@@ -277,26 +355,29 @@ func writeStruct(w *textWriter, sv reflect.Value) error { + return err + } + } +- if err := writeAny(w, key, props.mkeyprop); err != nil { ++ if err := tm.writeAny(w, key, props.mkeyprop); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } +- // value +- if _, err := w.WriteString("value:"); err != nil { +- return err +- } +- if !w.compact { +- if err := w.WriteByte(' '); err != nil { ++ // nil values aren't legal, but we can avoid panicking because of them. ++ if val.Kind() != reflect.Ptr || !val.IsNil() { ++ // value ++ if _, err := w.WriteString("value:"); err != nil { ++ return err ++ } ++ if !w.compact { ++ if err := w.WriteByte(' '); err != nil { ++ return err ++ } ++ } ++ if err := tm.writeAny(w, val, props.mvalprop); err != nil { ++ return err ++ } ++ if err := w.WriteByte('\n'); err != nil { + return err + } +- } +- if err := writeAny(w, val, props.mvalprop); err != nil { +- return err +- } +- if err := w.WriteByte('\n'); err != nil { +- return err + } + // close struct + w.unindent() +@@ -315,26 +396,34 @@ func writeStruct(w *textWriter, sv reflect.Value) error { + } + if fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice { + // proto3 non-repeated scalar field; skip if zero value +- switch fv.Kind() { +- case reflect.Bool: +- if !fv.Bool() { +- continue +- } +- case reflect.Int32, reflect.Int64: +- if fv.Int() == 0 { +- continue +- } +- case reflect.Uint32, reflect.Uint64: +- if fv.Uint() == 0 { +- continue +- } +- case reflect.Float32, reflect.Float64: +- if fv.Float() == 0 { ++ if isProto3Zero(fv) { ++ continue ++ } ++ } ++ ++ if fv.Kind() == reflect.Interface { ++ // Check if it is a oneof. ++ if st.Field(i).Tag.Get("protobuf_oneof") != "" { ++ // fv is nil, or holds a pointer to generated struct. ++ // That generated struct has exactly one field, ++ // which has a protobuf struct tag. ++ if fv.IsNil() { + continue + } +- case reflect.String: +- if fv.String() == "" { +- continue ++ inner := fv.Elem().Elem() // interface -> *T -> T ++ tag := inner.Type().Field(0).Tag.Get("protobuf") ++ props = new(Properties) // Overwrite the outer props var, but not its pointee. ++ props.Parse(tag) ++ // Write the value in the oneof, not the oneof itself. ++ fv = inner.Field(0) ++ ++ // Special case to cope with malformed messages gracefully: ++ // If the value in the oneof is a nil pointer, don't panic ++ // in writeAny. ++ if fv.Kind() == reflect.Ptr && fv.IsNil() { ++ // Use errors.New so writeAny won't render quotes. ++ msg := errors.New("/* nil */") ++ fv = reflect.ValueOf(&msg).Elem() + } + } + } +@@ -355,7 +444,7 @@ func writeStruct(w *textWriter, sv reflect.Value) error { + } + + // Enums have a String method, so writeAny will work fine. +- if err := writeAny(w, fv, props); err != nil { ++ if err := tm.writeAny(w, fv, props); err != nil { + return err + } + +@@ -366,8 +455,8 @@ func writeStruct(w *textWriter, sv reflect.Value) error { + + // Extensions (the XXX_extensions field). + pv := sv.Addr() +- if pv.Type().Implements(extendableProtoType) { +- if err := writeExtensions(w, pv); err != nil { ++ if _, ok := extendable(pv.Interface()); ok { ++ if err := tm.writeExtensions(w, pv); err != nil { + return err + } + } +@@ -397,7 +486,7 @@ func writeRaw(w *textWriter, b []byte) error { + } + + // writeAny writes an arbitrary field. +-func writeAny(w *textWriter, v reflect.Value, props *Properties) error { ++func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error { + v = reflect.Indirect(v) + + // Floats have special cases. +@@ -424,7 +513,7 @@ func writeAny(w *textWriter, v reflect.Value, props *Properties) error { + switch v.Kind() { + case reflect.Slice: + // Should only be a []byte; repeated fields are handled in writeStruct. +- if err := writeString(w, string(v.Interface().([]byte))); err != nil { ++ if err := writeString(w, string(v.Bytes())); err != nil { + return err + } + case reflect.String: +@@ -446,15 +535,15 @@ func writeAny(w *textWriter, v reflect.Value, props *Properties) error { + } + } + w.indent() +- if tm, ok := v.Interface().(encoding.TextMarshaler); ok { +- text, err := tm.MarshalText() ++ if etm, ok := v.Interface().(encoding.TextMarshaler); ok { ++ text, err := etm.MarshalText() + if err != nil { + return err + } + if _, err = w.Write(text); err != nil { + return err + } +- } else if err := writeStruct(w, v); err != nil { ++ } else if err := tm.writeStruct(w, v); err != nil { + return err + } + w.unindent() +@@ -514,44 +603,6 @@ func writeString(w *textWriter, s string) error { + return w.WriteByte('"') + } + +-func writeMessageSet(w *textWriter, ms *MessageSet) error { +- for _, item := range ms.Item { +- id := *item.TypeId +- if msd, ok := messageSetMap[id]; ok { +- // Known message set type. +- if _, err := fmt.Fprintf(w, "[%s]: <\n", msd.name); err != nil { +- return err +- } +- w.indent() +- +- pb := reflect.New(msd.t.Elem()) +- if err := Unmarshal(item.Message, pb.Interface().(Message)); err != nil { +- if _, err := fmt.Fprintf(w, "/* bad message: %v */\n", err); err != nil { +- return err +- } +- } else { +- if err := writeStruct(w, pb.Elem()); err != nil { +- return err +- } +- } +- } else { +- // Unknown type. +- if _, err := fmt.Fprintf(w, "[%d]: <\n", id); err != nil { +- return err +- } +- w.indent() +- if err := writeUnknownStruct(w, item.Message); err != nil { +- return err +- } +- } +- w.unindent() +- if _, err := w.Write(gtNewline); err != nil { +- return err +- } +- } +- return nil +-} +- + func writeUnknownStruct(w *textWriter, data []byte) (err error) { + if !w.compact { + if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil { +@@ -636,19 +687,24 @@ func (s int32Slice) Swap(i, j int) { s[i], s[j] = s[j], s[i] } + + // writeExtensions writes all the extensions in pv. + // pv is assumed to be a pointer to a protocol message struct that is extendable. +-func writeExtensions(w *textWriter, pv reflect.Value) error { ++func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error { + emap := extensionMaps[pv.Type().Elem()] +- ep := pv.Interface().(extendableProto) ++ ep, _ := extendable(pv.Interface()) + + // Order the extensions by ID. + // This isn't strictly necessary, but it will give us + // canonical output, which will also make testing easier. +- m := ep.ExtensionMap() ++ m, mu := ep.extensionsRead() ++ if m == nil { ++ return nil ++ } ++ mu.Lock() + ids := make([]int32, 0, len(m)) + for id := range m { + ids = append(ids, id) + } + sort.Sort(int32Slice(ids)) ++ mu.Unlock() + + for _, extNum := range ids { + ext := m[extNum] +@@ -666,21 +722,18 @@ func writeExtensions(w *textWriter, pv reflect.Value) error { + + pb, err := GetExtension(ep, desc) + if err != nil { +- if _, err := fmt.Fprintln(os.Stderr, "proto: failed getting extension: ", err); err != nil { +- return err +- } +- continue ++ return fmt.Errorf("failed getting extension: %v", err) + } + + // Repeated extensions will appear as a slice. + if !desc.repeated() { +- if err := writeExtension(w, desc.Name, pb); err != nil { ++ if err := tm.writeExtension(w, desc.Name, pb); err != nil { + return err + } + } else { + v := reflect.ValueOf(pb) + for i := 0; i < v.Len(); i++ { +- if err := writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil { ++ if err := tm.writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil { + return err + } + } +@@ -689,7 +742,7 @@ func writeExtensions(w *textWriter, pv reflect.Value) error { + return nil + } + +-func writeExtension(w *textWriter, name string, pb interface{}) error { ++func (tm *TextMarshaler) writeExtension(w *textWriter, name string, pb interface{}) error { + if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil { + return err + } +@@ -698,7 +751,7 @@ func writeExtension(w *textWriter, name string, pb interface{}) error { + return err + } + } +- if err := writeAny(w, reflect.ValueOf(pb), nil); err != nil { ++ if err := tm.writeAny(w, reflect.ValueOf(pb), nil); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { +@@ -723,7 +776,15 @@ func (w *textWriter) writeIndent() { + w.complete = false + } + +-func marshalText(w io.Writer, pb Message, compact bool) error { ++// TextMarshaler is a configurable text format marshaler. ++type TextMarshaler struct { ++ Compact bool // use compact text format (one line). ++ ExpandAny bool // expand google.protobuf.Any messages of known types ++} ++ ++// Marshal writes a given protocol buffer in text format. ++// The only errors returned are from w. ++func (tm *TextMarshaler) Marshal(w io.Writer, pb Message) error { + val := reflect.ValueOf(pb) + if pb == nil || val.IsNil() { + w.Write([]byte("")) +@@ -738,11 +799,11 @@ func marshalText(w io.Writer, pb Message, compact bool) error { + aw := &textWriter{ + w: ww, + complete: true, +- compact: compact, ++ compact: tm.Compact, + } + +- if tm, ok := pb.(encoding.TextMarshaler); ok { +- text, err := tm.MarshalText() ++ if etm, ok := pb.(encoding.TextMarshaler); ok { ++ text, err := etm.MarshalText() + if err != nil { + return err + } +@@ -756,7 +817,7 @@ func marshalText(w io.Writer, pb Message, compact bool) error { + } + // Dereference the received pointer so we don't have outer < and >. + v := reflect.Indirect(val) +- if err := writeStruct(aw, v); err != nil { ++ if err := tm.writeStruct(aw, v); err != nil { + return err + } + if bw != nil { +@@ -765,25 +826,29 @@ func marshalText(w io.Writer, pb Message, compact bool) error { + return nil + } + ++// Text is the same as Marshal, but returns the string directly. ++func (tm *TextMarshaler) Text(pb Message) string { ++ var buf bytes.Buffer ++ tm.Marshal(&buf, pb) ++ return buf.String() ++} ++ ++var ( ++ defaultTextMarshaler = TextMarshaler{} ++ compactTextMarshaler = TextMarshaler{Compact: true} ++) ++ ++// TODO: consider removing some of the Marshal functions below. ++ + // MarshalText writes a given protocol buffer in text format. + // The only errors returned are from w. +-func MarshalText(w io.Writer, pb Message) error { +- return marshalText(w, pb, false) +-} ++func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) } + + // MarshalTextString is the same as MarshalText, but returns the string directly. +-func MarshalTextString(pb Message) string { +- var buf bytes.Buffer +- marshalText(&buf, pb, false) +- return buf.String() +-} ++func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) } + + // CompactText writes a given protocol buffer in compact text format (one line). +-func CompactText(w io.Writer, pb Message) error { return marshalText(w, pb, true) } ++func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) } + + // CompactTextString is the same as CompactText, but returns the string directly. +-func CompactTextString(pb Message) string { +- var buf bytes.Buffer +- marshalText(&buf, pb, true) +- return buf.String() +-} ++func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) } +diff --git a/vendor/github.com/golang/protobuf/proto/text_parser.go b/vendor/github.com/golang/protobuf/proto/text_parser.go +index d1caeff..61f83c1 100644 +--- a/vendor/github.com/golang/protobuf/proto/text_parser.go ++++ b/vendor/github.com/golang/protobuf/proto/text_parser.go +@@ -44,6 +44,9 @@ import ( + "unicode/utf8" + ) + ++// Error string emitted when deserializing Any and fields are already set ++const anyRepeatedlyUnpacked = "Any message unpacked multiple times, or %q already set" ++ + type ParseError struct { + Message string + Line int // 1-based line number +@@ -119,6 +122,14 @@ func isWhitespace(c byte) bool { + return false + } + ++func isQuote(c byte) bool { ++ switch c { ++ case '"', '\'': ++ return true ++ } ++ return false ++} ++ + func (p *textParser) skipWhitespace() { + i := 0 + for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') { +@@ -155,7 +166,7 @@ func (p *textParser) advance() { + p.cur.offset, p.cur.line = p.offset, p.line + p.cur.unquoted = "" + switch p.s[0] { +- case '<', '>', '{', '}', ':', '[', ']', ';', ',': ++ case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/': + // Single symbol + p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)] + case '"', '\'': +@@ -174,7 +185,7 @@ func (p *textParser) advance() { + } + unq, err := unquoteC(p.s[1:i], rune(p.s[0])) + if err != nil { +- p.errorf("invalid quoted string %v", p.s[0:i+1]) ++ p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err) + return + } + p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)] +@@ -333,13 +344,13 @@ func (p *textParser) next() *token { + p.advance() + if p.done { + p.cur.value = "" +- } else if len(p.cur.value) > 0 && p.cur.value[0] == '"' { ++ } else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) { + // Look for multiple quoted strings separated by whitespace, + // and concatenate them. + cat := p.cur + for { + p.skipWhitespace() +- if p.done || p.s[0] != '"' { ++ if p.done || !isQuote(p.s[0]) { + break + } + p.advance() +@@ -385,8 +396,7 @@ func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSet + } + + // Returns the index in the struct for the named field, as well as the parsed tag properties. +-func structFieldByName(st reflect.Type, name string) (int, *Properties, bool) { +- sprops := GetProperties(st) ++func structFieldByName(sprops *StructProperties, name string) (int, *Properties, bool) { + i, ok := sprops.decoderOrigNames[name] + if ok { + return i, sprops.Prop[i], true +@@ -438,12 +448,16 @@ func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseEr + + func (p *textParser) readStruct(sv reflect.Value, terminator string) error { + st := sv.Type() +- reqCount := GetProperties(st).reqCount ++ sprops := GetProperties(st) ++ reqCount := sprops.reqCount + var reqFieldErr error + fieldSet := make(map[string]bool) + // A struct is a sequence of "name: value", terminated by one of + // '>' or '}', or the end of the input. A name may also be +- // "[extension]". ++ // "[extension]" or "[type/url]". ++ // ++ // The whole struct can also be an expanded Any message, like: ++ // [type/url] < ... struct contents ... > + for { + tok := p.next() + if tok.err != nil { +@@ -453,33 +467,74 @@ func (p *textParser) readStruct(sv reflect.Value, terminator string) error { + break + } + if tok.value == "[" { +- // Looks like an extension. ++ // Looks like an extension or an Any. + // + // TODO: Check whether we need to handle + // namespace rooted names (e.g. ".something.Foo"). +- tok = p.next() +- if tok.err != nil { +- return tok.err ++ extName, err := p.consumeExtName() ++ if err != nil { ++ return err + } ++ ++ if s := strings.LastIndex(extName, "/"); s >= 0 { ++ // If it contains a slash, it's an Any type URL. ++ messageName := extName[s+1:] ++ mt := MessageType(messageName) ++ if mt == nil { ++ return p.errorf("unrecognized message %q in google.protobuf.Any", messageName) ++ } ++ tok = p.next() ++ if tok.err != nil { ++ return tok.err ++ } ++ // consume an optional colon ++ if tok.value == ":" { ++ tok = p.next() ++ if tok.err != nil { ++ return tok.err ++ } ++ } ++ var terminator string ++ switch tok.value { ++ case "<": ++ terminator = ">" ++ case "{": ++ terminator = "}" ++ default: ++ return p.errorf("expected '{' or '<', found %q", tok.value) ++ } ++ v := reflect.New(mt.Elem()) ++ if pe := p.readStruct(v.Elem(), terminator); pe != nil { ++ return pe ++ } ++ b, err := Marshal(v.Interface().(Message)) ++ if err != nil { ++ return p.errorf("failed to marshal message of type %q: %v", messageName, err) ++ } ++ if fieldSet["type_url"] { ++ return p.errorf(anyRepeatedlyUnpacked, "type_url") ++ } ++ if fieldSet["value"] { ++ return p.errorf(anyRepeatedlyUnpacked, "value") ++ } ++ sv.FieldByName("TypeUrl").SetString(extName) ++ sv.FieldByName("Value").SetBytes(b) ++ fieldSet["type_url"] = true ++ fieldSet["value"] = true ++ continue ++ } ++ + var desc *ExtensionDesc + // This could be faster, but it's functional. + // TODO: Do something smarter than a linear scan. + for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) { +- if d.Name == tok.value { ++ if d.Name == extName { + desc = d + break + } + } + if desc == nil { +- return p.errorf("unrecognized extension %q", tok.value) +- } +- // Check the extension terminator. +- tok = p.next() +- if tok.err != nil { +- return tok.err +- } +- if tok.value != "]" { +- return p.errorf("unrecognized extension terminator %q", tok.value) ++ return p.errorf("unrecognized extension %q", extName) + } + + props := &Properties{} +@@ -506,7 +561,7 @@ func (p *textParser) readStruct(sv reflect.Value, terminator string) error { + } + reqFieldErr = err + } +- ep := sv.Addr().Interface().(extendableProto) ++ ep := sv.Addr().Interface().(Message) + if !rep { + SetExtension(ep, desc, ext.Interface()) + } else { +@@ -520,99 +575,126 @@ func (p *textParser) readStruct(sv reflect.Value, terminator string) error { + sl = reflect.Append(sl, ext) + SetExtension(ep, desc, sl.Interface()) + } +- } else { +- // This is a normal, non-extension field. +- name := tok.value +- fi, props, ok := structFieldByName(st, name) +- if !ok { +- return p.errorf("unknown field name %q in %v", name, st) ++ if err := p.consumeOptionalSeparator(); err != nil { ++ return err + } ++ continue ++ } + +- dst := sv.Field(fi) +- +- if dst.Kind() == reflect.Map { +- // Consume any colon. +- if err := p.checkForColon(props, dst.Type()); err != nil { +- return err +- } +- +- // Construct the map if it doesn't already exist. +- if dst.IsNil() { +- dst.Set(reflect.MakeMap(dst.Type())) +- } +- key := reflect.New(dst.Type().Key()).Elem() +- val := reflect.New(dst.Type().Elem()).Elem() ++ // This is a normal, non-extension field. ++ name := tok.value ++ var dst reflect.Value ++ fi, props, ok := structFieldByName(sprops, name) ++ if ok { ++ dst = sv.Field(fi) ++ } else if oop, ok := sprops.OneofTypes[name]; ok { ++ // It is a oneof. ++ props = oop.Prop ++ nv := reflect.New(oop.Type.Elem()) ++ dst = nv.Elem().Field(0) ++ field := sv.Field(oop.Field) ++ if !field.IsNil() { ++ return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, sv.Type().Field(oop.Field).Name) ++ } ++ field.Set(nv) ++ } ++ if !dst.IsValid() { ++ return p.errorf("unknown field name %q in %v", name, st) ++ } + +- // The map entry should be this sequence of tokens: +- // < key : KEY value : VALUE > +- // Technically the "key" and "value" could come in any order, +- // but in practice they won't. ++ if dst.Kind() == reflect.Map { ++ // Consume any colon. ++ if err := p.checkForColon(props, dst.Type()); err != nil { ++ return err ++ } + ++ // Construct the map if it doesn't already exist. ++ if dst.IsNil() { ++ dst.Set(reflect.MakeMap(dst.Type())) ++ } ++ key := reflect.New(dst.Type().Key()).Elem() ++ val := reflect.New(dst.Type().Elem()).Elem() ++ ++ // The map entry should be this sequence of tokens: ++ // < key : KEY value : VALUE > ++ // However, implementations may omit key or value, and technically ++ // we should support them in any order. See b/28924776 for a time ++ // this went wrong. ++ ++ tok := p.next() ++ var terminator string ++ switch tok.value { ++ case "<": ++ terminator = ">" ++ case "{": ++ terminator = "}" ++ default: ++ return p.errorf("expected '{' or '<', found %q", tok.value) ++ } ++ for { + tok := p.next() +- var terminator string +- switch tok.value { +- case "<": +- terminator = ">" +- case "{": +- terminator = "}" +- default: +- return p.errorf("expected '{' or '<', found %q", tok.value) +- } +- if err := p.consumeToken("key"); err != nil { +- return err +- } +- if err := p.consumeToken(":"); err != nil { +- return err +- } +- if err := p.readAny(key, props.mkeyprop); err != nil { +- return err +- } +- if err := p.consumeToken("value"); err != nil { +- return err ++ if tok.err != nil { ++ return tok.err + } +- if err := p.checkForColon(props.mvalprop, dst.Type().Elem()); err != nil { +- return err +- } +- if err := p.readAny(val, props.mvalprop); err != nil { +- return err ++ if tok.value == terminator { ++ break + } +- if err := p.consumeToken(terminator); err != nil { +- return err ++ switch tok.value { ++ case "key": ++ if err := p.consumeToken(":"); err != nil { ++ return err ++ } ++ if err := p.readAny(key, props.mkeyprop); err != nil { ++ return err ++ } ++ if err := p.consumeOptionalSeparator(); err != nil { ++ return err ++ } ++ case "value": ++ if err := p.checkForColon(props.mvalprop, dst.Type().Elem()); err != nil { ++ return err ++ } ++ if err := p.readAny(val, props.mvalprop); err != nil { ++ return err ++ } ++ if err := p.consumeOptionalSeparator(); err != nil { ++ return err ++ } ++ default: ++ p.back() ++ return p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value) + } +- +- dst.SetMapIndex(key, val) +- continue + } + +- // Check that it's not already set if it's not a repeated field. +- if !props.Repeated && fieldSet[name] { +- return p.errorf("non-repeated field %q was repeated", name) +- } ++ dst.SetMapIndex(key, val) ++ continue ++ } + +- if err := p.checkForColon(props, st.Field(fi).Type); err != nil { +- return err +- } ++ // Check that it's not already set if it's not a repeated field. ++ if !props.Repeated && fieldSet[name] { ++ return p.errorf("non-repeated field %q was repeated", name) ++ } + +- // Parse into the field. +- fieldSet[name] = true +- if err := p.readAny(dst, props); err != nil { +- if _, ok := err.(*RequiredNotSetError); !ok { +- return err +- } +- reqFieldErr = err +- } else if props.Required { +- reqCount-- +- } ++ if err := p.checkForColon(props, dst.Type()); err != nil { ++ return err + } + +- // For backward compatibility, permit a semicolon or comma after a field. +- tok = p.next() +- if tok.err != nil { +- return tok.err ++ // Parse into the field. ++ fieldSet[name] = true ++ if err := p.readAny(dst, props); err != nil { ++ if _, ok := err.(*RequiredNotSetError); !ok { ++ return err ++ } ++ reqFieldErr = err ++ } ++ if props.Required { ++ reqCount-- + } +- if tok.value != ";" && tok.value != "," { +- p.back() ++ ++ if err := p.consumeOptionalSeparator(); err != nil { ++ return err + } ++ + } + + if reqCount > 0 { +@@ -621,6 +703,48 @@ func (p *textParser) readStruct(sv reflect.Value, terminator string) error { + return reqFieldErr + } + ++// consumeExtName consumes extension name or expanded Any type URL and the ++// following ']'. It returns the name or URL consumed. ++func (p *textParser) consumeExtName() (string, error) { ++ tok := p.next() ++ if tok.err != nil { ++ return "", tok.err ++ } ++ ++ // If extension name or type url is quoted, it's a single token. ++ if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] { ++ name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0])) ++ if err != nil { ++ return "", err ++ } ++ return name, p.consumeToken("]") ++ } ++ ++ // Consume everything up to "]" ++ var parts []string ++ for tok.value != "]" { ++ parts = append(parts, tok.value) ++ tok = p.next() ++ if tok.err != nil { ++ return "", p.errorf("unrecognized type_url or extension name: %s", tok.err) ++ } ++ } ++ return strings.Join(parts, ""), nil ++} ++ ++// consumeOptionalSeparator consumes an optional semicolon or comma. ++// It is used in readStruct to provide backward compatibility. ++func (p *textParser) consumeOptionalSeparator() error { ++ tok := p.next() ++ if tok.err != nil { ++ return tok.err ++ } ++ if tok.value != ";" && tok.value != "," { ++ p.back() ++ } ++ return nil ++} ++ + func (p *textParser) readAny(v reflect.Value, props *Properties) error { + tok := p.next() + if tok.err != nil { +@@ -645,25 +769,39 @@ func (p *textParser) readAny(v reflect.Value, props *Properties) error { + fv.Set(reflect.ValueOf(bytes)) + return nil + } +- // Repeated field. May already exist. +- flen := fv.Len() +- if flen == fv.Cap() { +- nav := reflect.MakeSlice(at, flen, 2*flen+1) +- reflect.Copy(nav, fv) +- fv.Set(nav) ++ // Repeated field. ++ if tok.value == "[" { ++ // Repeated field with list notation, like [1,2,3]. ++ for { ++ fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem())) ++ err := p.readAny(fv.Index(fv.Len()-1), props) ++ if err != nil { ++ return err ++ } ++ tok := p.next() ++ if tok.err != nil { ++ return tok.err ++ } ++ if tok.value == "]" { ++ break ++ } ++ if tok.value != "," { ++ return p.errorf("Expected ']' or ',' found %q", tok.value) ++ } ++ } ++ return nil + } +- fv.SetLen(flen + 1) +- +- // Read one. ++ // One value of the repeated field. + p.back() +- return p.readAny(fv.Index(flen), props) ++ fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem())) ++ return p.readAny(fv.Index(fv.Len()-1), props) + case reflect.Bool: +- // Either "true", "false", 1 or 0. ++ // true/1/t/True or false/f/0/False. + switch tok.value { +- case "true", "1": ++ case "true", "1", "t", "True": + fv.SetBool(true) + return nil +- case "false", "0": ++ case "false", "0", "f", "False": + fv.SetBool(false) + return nil + } +diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go +new file mode 100644 +index 0000000..a1d8a76 +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go +@@ -0,0 +1,2065 @@ ++// Code generated by protoc-gen-go. ++// source: google/protobuf/descriptor.proto ++// DO NOT EDIT! ++ ++/* ++Package descriptor is a generated protocol buffer package. ++ ++It is generated from these files: ++ google/protobuf/descriptor.proto ++ ++It has these top-level messages: ++ FileDescriptorSet ++ FileDescriptorProto ++ DescriptorProto ++ FieldDescriptorProto ++ OneofDescriptorProto ++ EnumDescriptorProto ++ EnumValueDescriptorProto ++ ServiceDescriptorProto ++ MethodDescriptorProto ++ FileOptions ++ MessageOptions ++ FieldOptions ++ OneofOptions ++ EnumOptions ++ EnumValueOptions ++ ServiceOptions ++ MethodOptions ++ UninterpretedOption ++ SourceCodeInfo ++ GeneratedCodeInfo ++*/ ++package descriptor ++ ++import proto "github.com/golang/protobuf/proto" ++import fmt "fmt" ++import math "math" ++ ++// Reference imports to suppress errors if they are not otherwise used. ++var _ = proto.Marshal ++var _ = fmt.Errorf ++var _ = math.Inf ++ ++// This is a compile-time assertion to ensure that this generated file ++// is compatible with the proto package it is being compiled against. ++// A compilation error at this line likely means your copy of the ++// proto package needs to be updated. ++const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package ++ ++type FieldDescriptorProto_Type int32 ++ ++const ( ++ // 0 is reserved for errors. ++ // Order is weird for historical reasons. ++ FieldDescriptorProto_TYPE_DOUBLE FieldDescriptorProto_Type = 1 ++ FieldDescriptorProto_TYPE_FLOAT FieldDescriptorProto_Type = 2 ++ // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if ++ // negative values are likely. ++ FieldDescriptorProto_TYPE_INT64 FieldDescriptorProto_Type = 3 ++ FieldDescriptorProto_TYPE_UINT64 FieldDescriptorProto_Type = 4 ++ // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if ++ // negative values are likely. ++ FieldDescriptorProto_TYPE_INT32 FieldDescriptorProto_Type = 5 ++ FieldDescriptorProto_TYPE_FIXED64 FieldDescriptorProto_Type = 6 ++ FieldDescriptorProto_TYPE_FIXED32 FieldDescriptorProto_Type = 7 ++ FieldDescriptorProto_TYPE_BOOL FieldDescriptorProto_Type = 8 ++ FieldDescriptorProto_TYPE_STRING FieldDescriptorProto_Type = 9 ++ FieldDescriptorProto_TYPE_GROUP FieldDescriptorProto_Type = 10 ++ FieldDescriptorProto_TYPE_MESSAGE FieldDescriptorProto_Type = 11 ++ // New in version 2. ++ FieldDescriptorProto_TYPE_BYTES FieldDescriptorProto_Type = 12 ++ FieldDescriptorProto_TYPE_UINT32 FieldDescriptorProto_Type = 13 ++ FieldDescriptorProto_TYPE_ENUM FieldDescriptorProto_Type = 14 ++ FieldDescriptorProto_TYPE_SFIXED32 FieldDescriptorProto_Type = 15 ++ FieldDescriptorProto_TYPE_SFIXED64 FieldDescriptorProto_Type = 16 ++ FieldDescriptorProto_TYPE_SINT32 FieldDescriptorProto_Type = 17 ++ FieldDescriptorProto_TYPE_SINT64 FieldDescriptorProto_Type = 18 ++) ++ ++var FieldDescriptorProto_Type_name = map[int32]string{ ++ 1: "TYPE_DOUBLE", ++ 2: "TYPE_FLOAT", ++ 3: "TYPE_INT64", ++ 4: "TYPE_UINT64", ++ 5: "TYPE_INT32", ++ 6: "TYPE_FIXED64", ++ 7: "TYPE_FIXED32", ++ 8: "TYPE_BOOL", ++ 9: "TYPE_STRING", ++ 10: "TYPE_GROUP", ++ 11: "TYPE_MESSAGE", ++ 12: "TYPE_BYTES", ++ 13: "TYPE_UINT32", ++ 14: "TYPE_ENUM", ++ 15: "TYPE_SFIXED32", ++ 16: "TYPE_SFIXED64", ++ 17: "TYPE_SINT32", ++ 18: "TYPE_SINT64", ++} ++var FieldDescriptorProto_Type_value = map[string]int32{ ++ "TYPE_DOUBLE": 1, ++ "TYPE_FLOAT": 2, ++ "TYPE_INT64": 3, ++ "TYPE_UINT64": 4, ++ "TYPE_INT32": 5, ++ "TYPE_FIXED64": 6, ++ "TYPE_FIXED32": 7, ++ "TYPE_BOOL": 8, ++ "TYPE_STRING": 9, ++ "TYPE_GROUP": 10, ++ "TYPE_MESSAGE": 11, ++ "TYPE_BYTES": 12, ++ "TYPE_UINT32": 13, ++ "TYPE_ENUM": 14, ++ "TYPE_SFIXED32": 15, ++ "TYPE_SFIXED64": 16, ++ "TYPE_SINT32": 17, ++ "TYPE_SINT64": 18, ++} ++ ++func (x FieldDescriptorProto_Type) Enum() *FieldDescriptorProto_Type { ++ p := new(FieldDescriptorProto_Type) ++ *p = x ++ return p ++} ++func (x FieldDescriptorProto_Type) String() string { ++ return proto.EnumName(FieldDescriptorProto_Type_name, int32(x)) ++} ++func (x *FieldDescriptorProto_Type) UnmarshalJSON(data []byte) error { ++ value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Type_value, data, "FieldDescriptorProto_Type") ++ if err != nil { ++ return err ++ } ++ *x = FieldDescriptorProto_Type(value) ++ return nil ++} ++func (FieldDescriptorProto_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{3, 0} } ++ ++type FieldDescriptorProto_Label int32 ++ ++const ( ++ // 0 is reserved for errors ++ FieldDescriptorProto_LABEL_OPTIONAL FieldDescriptorProto_Label = 1 ++ FieldDescriptorProto_LABEL_REQUIRED FieldDescriptorProto_Label = 2 ++ FieldDescriptorProto_LABEL_REPEATED FieldDescriptorProto_Label = 3 ++) ++ ++var FieldDescriptorProto_Label_name = map[int32]string{ ++ 1: "LABEL_OPTIONAL", ++ 2: "LABEL_REQUIRED", ++ 3: "LABEL_REPEATED", ++} ++var FieldDescriptorProto_Label_value = map[string]int32{ ++ "LABEL_OPTIONAL": 1, ++ "LABEL_REQUIRED": 2, ++ "LABEL_REPEATED": 3, ++} ++ ++func (x FieldDescriptorProto_Label) Enum() *FieldDescriptorProto_Label { ++ p := new(FieldDescriptorProto_Label) ++ *p = x ++ return p ++} ++func (x FieldDescriptorProto_Label) String() string { ++ return proto.EnumName(FieldDescriptorProto_Label_name, int32(x)) ++} ++func (x *FieldDescriptorProto_Label) UnmarshalJSON(data []byte) error { ++ value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Label_value, data, "FieldDescriptorProto_Label") ++ if err != nil { ++ return err ++ } ++ *x = FieldDescriptorProto_Label(value) ++ return nil ++} ++func (FieldDescriptorProto_Label) EnumDescriptor() ([]byte, []int) { ++ return fileDescriptor0, []int{3, 1} ++} ++ ++// Generated classes can be optimized for speed or code size. ++type FileOptions_OptimizeMode int32 ++ ++const ( ++ FileOptions_SPEED FileOptions_OptimizeMode = 1 ++ // etc. ++ FileOptions_CODE_SIZE FileOptions_OptimizeMode = 2 ++ FileOptions_LITE_RUNTIME FileOptions_OptimizeMode = 3 ++) ++ ++var FileOptions_OptimizeMode_name = map[int32]string{ ++ 1: "SPEED", ++ 2: "CODE_SIZE", ++ 3: "LITE_RUNTIME", ++} ++var FileOptions_OptimizeMode_value = map[string]int32{ ++ "SPEED": 1, ++ "CODE_SIZE": 2, ++ "LITE_RUNTIME": 3, ++} ++ ++func (x FileOptions_OptimizeMode) Enum() *FileOptions_OptimizeMode { ++ p := new(FileOptions_OptimizeMode) ++ *p = x ++ return p ++} ++func (x FileOptions_OptimizeMode) String() string { ++ return proto.EnumName(FileOptions_OptimizeMode_name, int32(x)) ++} ++func (x *FileOptions_OptimizeMode) UnmarshalJSON(data []byte) error { ++ value, err := proto.UnmarshalJSONEnum(FileOptions_OptimizeMode_value, data, "FileOptions_OptimizeMode") ++ if err != nil { ++ return err ++ } ++ *x = FileOptions_OptimizeMode(value) ++ return nil ++} ++func (FileOptions_OptimizeMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{9, 0} } ++ ++type FieldOptions_CType int32 ++ ++const ( ++ // Default mode. ++ FieldOptions_STRING FieldOptions_CType = 0 ++ FieldOptions_CORD FieldOptions_CType = 1 ++ FieldOptions_STRING_PIECE FieldOptions_CType = 2 ++) ++ ++var FieldOptions_CType_name = map[int32]string{ ++ 0: "STRING", ++ 1: "CORD", ++ 2: "STRING_PIECE", ++} ++var FieldOptions_CType_value = map[string]int32{ ++ "STRING": 0, ++ "CORD": 1, ++ "STRING_PIECE": 2, ++} ++ ++func (x FieldOptions_CType) Enum() *FieldOptions_CType { ++ p := new(FieldOptions_CType) ++ *p = x ++ return p ++} ++func (x FieldOptions_CType) String() string { ++ return proto.EnumName(FieldOptions_CType_name, int32(x)) ++} ++func (x *FieldOptions_CType) UnmarshalJSON(data []byte) error { ++ value, err := proto.UnmarshalJSONEnum(FieldOptions_CType_value, data, "FieldOptions_CType") ++ if err != nil { ++ return err ++ } ++ *x = FieldOptions_CType(value) ++ return nil ++} ++func (FieldOptions_CType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{11, 0} } ++ ++type FieldOptions_JSType int32 ++ ++const ( ++ // Use the default type. ++ FieldOptions_JS_NORMAL FieldOptions_JSType = 0 ++ // Use JavaScript strings. ++ FieldOptions_JS_STRING FieldOptions_JSType = 1 ++ // Use JavaScript numbers. ++ FieldOptions_JS_NUMBER FieldOptions_JSType = 2 ++) ++ ++var FieldOptions_JSType_name = map[int32]string{ ++ 0: "JS_NORMAL", ++ 1: "JS_STRING", ++ 2: "JS_NUMBER", ++} ++var FieldOptions_JSType_value = map[string]int32{ ++ "JS_NORMAL": 0, ++ "JS_STRING": 1, ++ "JS_NUMBER": 2, ++} ++ ++func (x FieldOptions_JSType) Enum() *FieldOptions_JSType { ++ p := new(FieldOptions_JSType) ++ *p = x ++ return p ++} ++func (x FieldOptions_JSType) String() string { ++ return proto.EnumName(FieldOptions_JSType_name, int32(x)) ++} ++func (x *FieldOptions_JSType) UnmarshalJSON(data []byte) error { ++ value, err := proto.UnmarshalJSONEnum(FieldOptions_JSType_value, data, "FieldOptions_JSType") ++ if err != nil { ++ return err ++ } ++ *x = FieldOptions_JSType(value) ++ return nil ++} ++func (FieldOptions_JSType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{11, 1} } ++ ++// The protocol compiler can output a FileDescriptorSet containing the .proto ++// files it parses. ++type FileDescriptorSet struct { ++ File []*FileDescriptorProto `protobuf:"bytes,1,rep,name=file" json:"file,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *FileDescriptorSet) Reset() { *m = FileDescriptorSet{} } ++func (m *FileDescriptorSet) String() string { return proto.CompactTextString(m) } ++func (*FileDescriptorSet) ProtoMessage() {} ++func (*FileDescriptorSet) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } ++ ++func (m *FileDescriptorSet) GetFile() []*FileDescriptorProto { ++ if m != nil { ++ return m.File ++ } ++ return nil ++} ++ ++// Describes a complete .proto file. ++type FileDescriptorProto struct { ++ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` ++ Package *string `protobuf:"bytes,2,opt,name=package" json:"package,omitempty"` ++ // Names of files imported by this file. ++ Dependency []string `protobuf:"bytes,3,rep,name=dependency" json:"dependency,omitempty"` ++ // Indexes of the public imported files in the dependency list above. ++ PublicDependency []int32 `protobuf:"varint,10,rep,name=public_dependency,json=publicDependency" json:"public_dependency,omitempty"` ++ // Indexes of the weak imported files in the dependency list. ++ // For Google-internal migration only. Do not use. ++ WeakDependency []int32 `protobuf:"varint,11,rep,name=weak_dependency,json=weakDependency" json:"weak_dependency,omitempty"` ++ // All top-level definitions in this file. ++ MessageType []*DescriptorProto `protobuf:"bytes,4,rep,name=message_type,json=messageType" json:"message_type,omitempty"` ++ EnumType []*EnumDescriptorProto `protobuf:"bytes,5,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"` ++ Service []*ServiceDescriptorProto `protobuf:"bytes,6,rep,name=service" json:"service,omitempty"` ++ Extension []*FieldDescriptorProto `protobuf:"bytes,7,rep,name=extension" json:"extension,omitempty"` ++ Options *FileOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"` ++ // This field contains optional information about the original source code. ++ // You may safely remove this entire field without harming runtime ++ // functionality of the descriptors -- the information is needed only by ++ // development tools. ++ SourceCodeInfo *SourceCodeInfo `protobuf:"bytes,9,opt,name=source_code_info,json=sourceCodeInfo" json:"source_code_info,omitempty"` ++ // The syntax of the proto file. ++ // The supported values are "proto2" and "proto3". ++ Syntax *string `protobuf:"bytes,12,opt,name=syntax" json:"syntax,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *FileDescriptorProto) Reset() { *m = FileDescriptorProto{} } ++func (m *FileDescriptorProto) String() string { return proto.CompactTextString(m) } ++func (*FileDescriptorProto) ProtoMessage() {} ++func (*FileDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } ++ ++func (m *FileDescriptorProto) GetName() string { ++ if m != nil && m.Name != nil { ++ return *m.Name ++ } ++ return "" ++} ++ ++func (m *FileDescriptorProto) GetPackage() string { ++ if m != nil && m.Package != nil { ++ return *m.Package ++ } ++ return "" ++} ++ ++func (m *FileDescriptorProto) GetDependency() []string { ++ if m != nil { ++ return m.Dependency ++ } ++ return nil ++} ++ ++func (m *FileDescriptorProto) GetPublicDependency() []int32 { ++ if m != nil { ++ return m.PublicDependency ++ } ++ return nil ++} ++ ++func (m *FileDescriptorProto) GetWeakDependency() []int32 { ++ if m != nil { ++ return m.WeakDependency ++ } ++ return nil ++} ++ ++func (m *FileDescriptorProto) GetMessageType() []*DescriptorProto { ++ if m != nil { ++ return m.MessageType ++ } ++ return nil ++} ++ ++func (m *FileDescriptorProto) GetEnumType() []*EnumDescriptorProto { ++ if m != nil { ++ return m.EnumType ++ } ++ return nil ++} ++ ++func (m *FileDescriptorProto) GetService() []*ServiceDescriptorProto { ++ if m != nil { ++ return m.Service ++ } ++ return nil ++} ++ ++func (m *FileDescriptorProto) GetExtension() []*FieldDescriptorProto { ++ if m != nil { ++ return m.Extension ++ } ++ return nil ++} ++ ++func (m *FileDescriptorProto) GetOptions() *FileOptions { ++ if m != nil { ++ return m.Options ++ } ++ return nil ++} ++ ++func (m *FileDescriptorProto) GetSourceCodeInfo() *SourceCodeInfo { ++ if m != nil { ++ return m.SourceCodeInfo ++ } ++ return nil ++} ++ ++func (m *FileDescriptorProto) GetSyntax() string { ++ if m != nil && m.Syntax != nil { ++ return *m.Syntax ++ } ++ return "" ++} ++ ++// Describes a message type. ++type DescriptorProto struct { ++ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` ++ Field []*FieldDescriptorProto `protobuf:"bytes,2,rep,name=field" json:"field,omitempty"` ++ Extension []*FieldDescriptorProto `protobuf:"bytes,6,rep,name=extension" json:"extension,omitempty"` ++ NestedType []*DescriptorProto `protobuf:"bytes,3,rep,name=nested_type,json=nestedType" json:"nested_type,omitempty"` ++ EnumType []*EnumDescriptorProto `protobuf:"bytes,4,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"` ++ ExtensionRange []*DescriptorProto_ExtensionRange `protobuf:"bytes,5,rep,name=extension_range,json=extensionRange" json:"extension_range,omitempty"` ++ OneofDecl []*OneofDescriptorProto `protobuf:"bytes,8,rep,name=oneof_decl,json=oneofDecl" json:"oneof_decl,omitempty"` ++ Options *MessageOptions `protobuf:"bytes,7,opt,name=options" json:"options,omitempty"` ++ ReservedRange []*DescriptorProto_ReservedRange `protobuf:"bytes,9,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"` ++ // Reserved field names, which may not be used by fields in the same message. ++ // A given name may only be reserved once. ++ ReservedName []string `protobuf:"bytes,10,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *DescriptorProto) Reset() { *m = DescriptorProto{} } ++func (m *DescriptorProto) String() string { return proto.CompactTextString(m) } ++func (*DescriptorProto) ProtoMessage() {} ++func (*DescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } ++ ++func (m *DescriptorProto) GetName() string { ++ if m != nil && m.Name != nil { ++ return *m.Name ++ } ++ return "" ++} ++ ++func (m *DescriptorProto) GetField() []*FieldDescriptorProto { ++ if m != nil { ++ return m.Field ++ } ++ return nil ++} ++ ++func (m *DescriptorProto) GetExtension() []*FieldDescriptorProto { ++ if m != nil { ++ return m.Extension ++ } ++ return nil ++} ++ ++func (m *DescriptorProto) GetNestedType() []*DescriptorProto { ++ if m != nil { ++ return m.NestedType ++ } ++ return nil ++} ++ ++func (m *DescriptorProto) GetEnumType() []*EnumDescriptorProto { ++ if m != nil { ++ return m.EnumType ++ } ++ return nil ++} ++ ++func (m *DescriptorProto) GetExtensionRange() []*DescriptorProto_ExtensionRange { ++ if m != nil { ++ return m.ExtensionRange ++ } ++ return nil ++} ++ ++func (m *DescriptorProto) GetOneofDecl() []*OneofDescriptorProto { ++ if m != nil { ++ return m.OneofDecl ++ } ++ return nil ++} ++ ++func (m *DescriptorProto) GetOptions() *MessageOptions { ++ if m != nil { ++ return m.Options ++ } ++ return nil ++} ++ ++func (m *DescriptorProto) GetReservedRange() []*DescriptorProto_ReservedRange { ++ if m != nil { ++ return m.ReservedRange ++ } ++ return nil ++} ++ ++func (m *DescriptorProto) GetReservedName() []string { ++ if m != nil { ++ return m.ReservedName ++ } ++ return nil ++} ++ ++type DescriptorProto_ExtensionRange struct { ++ Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` ++ End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *DescriptorProto_ExtensionRange) Reset() { *m = DescriptorProto_ExtensionRange{} } ++func (m *DescriptorProto_ExtensionRange) String() string { return proto.CompactTextString(m) } ++func (*DescriptorProto_ExtensionRange) ProtoMessage() {} ++func (*DescriptorProto_ExtensionRange) Descriptor() ([]byte, []int) { ++ return fileDescriptor0, []int{2, 0} ++} ++ ++func (m *DescriptorProto_ExtensionRange) GetStart() int32 { ++ if m != nil && m.Start != nil { ++ return *m.Start ++ } ++ return 0 ++} ++ ++func (m *DescriptorProto_ExtensionRange) GetEnd() int32 { ++ if m != nil && m.End != nil { ++ return *m.End ++ } ++ return 0 ++} ++ ++// Range of reserved tag numbers. Reserved tag numbers may not be used by ++// fields or extension ranges in the same message. Reserved ranges may ++// not overlap. ++type DescriptorProto_ReservedRange struct { ++ Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` ++ End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *DescriptorProto_ReservedRange) Reset() { *m = DescriptorProto_ReservedRange{} } ++func (m *DescriptorProto_ReservedRange) String() string { return proto.CompactTextString(m) } ++func (*DescriptorProto_ReservedRange) ProtoMessage() {} ++func (*DescriptorProto_ReservedRange) Descriptor() ([]byte, []int) { ++ return fileDescriptor0, []int{2, 1} ++} ++ ++func (m *DescriptorProto_ReservedRange) GetStart() int32 { ++ if m != nil && m.Start != nil { ++ return *m.Start ++ } ++ return 0 ++} ++ ++func (m *DescriptorProto_ReservedRange) GetEnd() int32 { ++ if m != nil && m.End != nil { ++ return *m.End ++ } ++ return 0 ++} ++ ++// Describes a field within a message. ++type FieldDescriptorProto struct { ++ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` ++ Number *int32 `protobuf:"varint,3,opt,name=number" json:"number,omitempty"` ++ Label *FieldDescriptorProto_Label `protobuf:"varint,4,opt,name=label,enum=google.protobuf.FieldDescriptorProto_Label" json:"label,omitempty"` ++ // If type_name is set, this need not be set. If both this and type_name ++ // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. ++ Type *FieldDescriptorProto_Type `protobuf:"varint,5,opt,name=type,enum=google.protobuf.FieldDescriptorProto_Type" json:"type,omitempty"` ++ // For message and enum types, this is the name of the type. If the name ++ // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping ++ // rules are used to find the type (i.e. first the nested types within this ++ // message are searched, then within the parent, on up to the root ++ // namespace). ++ TypeName *string `protobuf:"bytes,6,opt,name=type_name,json=typeName" json:"type_name,omitempty"` ++ // For extensions, this is the name of the type being extended. It is ++ // resolved in the same manner as type_name. ++ Extendee *string `protobuf:"bytes,2,opt,name=extendee" json:"extendee,omitempty"` ++ // For numeric types, contains the original text representation of the value. ++ // For booleans, "true" or "false". ++ // For strings, contains the default text contents (not escaped in any way). ++ // For bytes, contains the C escaped value. All bytes >= 128 are escaped. ++ // TODO(kenton): Base-64 encode? ++ DefaultValue *string `protobuf:"bytes,7,opt,name=default_value,json=defaultValue" json:"default_value,omitempty"` ++ // If set, gives the index of a oneof in the containing type's oneof_decl ++ // list. This field is a member of that oneof. ++ OneofIndex *int32 `protobuf:"varint,9,opt,name=oneof_index,json=oneofIndex" json:"oneof_index,omitempty"` ++ // JSON name of this field. The value is set by protocol compiler. If the ++ // user has set a "json_name" option on this field, that option's value ++ // will be used. Otherwise, it's deduced from the field's name by converting ++ // it to camelCase. ++ JsonName *string `protobuf:"bytes,10,opt,name=json_name,json=jsonName" json:"json_name,omitempty"` ++ Options *FieldOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *FieldDescriptorProto) Reset() { *m = FieldDescriptorProto{} } ++func (m *FieldDescriptorProto) String() string { return proto.CompactTextString(m) } ++func (*FieldDescriptorProto) ProtoMessage() {} ++func (*FieldDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } ++ ++func (m *FieldDescriptorProto) GetName() string { ++ if m != nil && m.Name != nil { ++ return *m.Name ++ } ++ return "" ++} ++ ++func (m *FieldDescriptorProto) GetNumber() int32 { ++ if m != nil && m.Number != nil { ++ return *m.Number ++ } ++ return 0 ++} ++ ++func (m *FieldDescriptorProto) GetLabel() FieldDescriptorProto_Label { ++ if m != nil && m.Label != nil { ++ return *m.Label ++ } ++ return FieldDescriptorProto_LABEL_OPTIONAL ++} ++ ++func (m *FieldDescriptorProto) GetType() FieldDescriptorProto_Type { ++ if m != nil && m.Type != nil { ++ return *m.Type ++ } ++ return FieldDescriptorProto_TYPE_DOUBLE ++} ++ ++func (m *FieldDescriptorProto) GetTypeName() string { ++ if m != nil && m.TypeName != nil { ++ return *m.TypeName ++ } ++ return "" ++} ++ ++func (m *FieldDescriptorProto) GetExtendee() string { ++ if m != nil && m.Extendee != nil { ++ return *m.Extendee ++ } ++ return "" ++} ++ ++func (m *FieldDescriptorProto) GetDefaultValue() string { ++ if m != nil && m.DefaultValue != nil { ++ return *m.DefaultValue ++ } ++ return "" ++} ++ ++func (m *FieldDescriptorProto) GetOneofIndex() int32 { ++ if m != nil && m.OneofIndex != nil { ++ return *m.OneofIndex ++ } ++ return 0 ++} ++ ++func (m *FieldDescriptorProto) GetJsonName() string { ++ if m != nil && m.JsonName != nil { ++ return *m.JsonName ++ } ++ return "" ++} ++ ++func (m *FieldDescriptorProto) GetOptions() *FieldOptions { ++ if m != nil { ++ return m.Options ++ } ++ return nil ++} ++ ++// Describes a oneof. ++type OneofDescriptorProto struct { ++ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` ++ Options *OneofOptions `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *OneofDescriptorProto) Reset() { *m = OneofDescriptorProto{} } ++func (m *OneofDescriptorProto) String() string { return proto.CompactTextString(m) } ++func (*OneofDescriptorProto) ProtoMessage() {} ++func (*OneofDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } ++ ++func (m *OneofDescriptorProto) GetName() string { ++ if m != nil && m.Name != nil { ++ return *m.Name ++ } ++ return "" ++} ++ ++func (m *OneofDescriptorProto) GetOptions() *OneofOptions { ++ if m != nil { ++ return m.Options ++ } ++ return nil ++} ++ ++// Describes an enum type. ++type EnumDescriptorProto struct { ++ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` ++ Value []*EnumValueDescriptorProto `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"` ++ Options *EnumOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *EnumDescriptorProto) Reset() { *m = EnumDescriptorProto{} } ++func (m *EnumDescriptorProto) String() string { return proto.CompactTextString(m) } ++func (*EnumDescriptorProto) ProtoMessage() {} ++func (*EnumDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } ++ ++func (m *EnumDescriptorProto) GetName() string { ++ if m != nil && m.Name != nil { ++ return *m.Name ++ } ++ return "" ++} ++ ++func (m *EnumDescriptorProto) GetValue() []*EnumValueDescriptorProto { ++ if m != nil { ++ return m.Value ++ } ++ return nil ++} ++ ++func (m *EnumDescriptorProto) GetOptions() *EnumOptions { ++ if m != nil { ++ return m.Options ++ } ++ return nil ++} ++ ++// Describes a value within an enum. ++type EnumValueDescriptorProto struct { ++ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` ++ Number *int32 `protobuf:"varint,2,opt,name=number" json:"number,omitempty"` ++ Options *EnumValueOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *EnumValueDescriptorProto) Reset() { *m = EnumValueDescriptorProto{} } ++func (m *EnumValueDescriptorProto) String() string { return proto.CompactTextString(m) } ++func (*EnumValueDescriptorProto) ProtoMessage() {} ++func (*EnumValueDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } ++ ++func (m *EnumValueDescriptorProto) GetName() string { ++ if m != nil && m.Name != nil { ++ return *m.Name ++ } ++ return "" ++} ++ ++func (m *EnumValueDescriptorProto) GetNumber() int32 { ++ if m != nil && m.Number != nil { ++ return *m.Number ++ } ++ return 0 ++} ++ ++func (m *EnumValueDescriptorProto) GetOptions() *EnumValueOptions { ++ if m != nil { ++ return m.Options ++ } ++ return nil ++} ++ ++// Describes a service. ++type ServiceDescriptorProto struct { ++ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` ++ Method []*MethodDescriptorProto `protobuf:"bytes,2,rep,name=method" json:"method,omitempty"` ++ Options *ServiceOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *ServiceDescriptorProto) Reset() { *m = ServiceDescriptorProto{} } ++func (m *ServiceDescriptorProto) String() string { return proto.CompactTextString(m) } ++func (*ServiceDescriptorProto) ProtoMessage() {} ++func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } ++ ++func (m *ServiceDescriptorProto) GetName() string { ++ if m != nil && m.Name != nil { ++ return *m.Name ++ } ++ return "" ++} ++ ++func (m *ServiceDescriptorProto) GetMethod() []*MethodDescriptorProto { ++ if m != nil { ++ return m.Method ++ } ++ return nil ++} ++ ++func (m *ServiceDescriptorProto) GetOptions() *ServiceOptions { ++ if m != nil { ++ return m.Options ++ } ++ return nil ++} ++ ++// Describes a method of a service. ++type MethodDescriptorProto struct { ++ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` ++ // Input and output type names. These are resolved in the same way as ++ // FieldDescriptorProto.type_name, but must refer to a message type. ++ InputType *string `protobuf:"bytes,2,opt,name=input_type,json=inputType" json:"input_type,omitempty"` ++ OutputType *string `protobuf:"bytes,3,opt,name=output_type,json=outputType" json:"output_type,omitempty"` ++ Options *MethodOptions `protobuf:"bytes,4,opt,name=options" json:"options,omitempty"` ++ // Identifies if client streams multiple client messages ++ ClientStreaming *bool `protobuf:"varint,5,opt,name=client_streaming,json=clientStreaming,def=0" json:"client_streaming,omitempty"` ++ // Identifies if server streams multiple server messages ++ ServerStreaming *bool `protobuf:"varint,6,opt,name=server_streaming,json=serverStreaming,def=0" json:"server_streaming,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *MethodDescriptorProto) Reset() { *m = MethodDescriptorProto{} } ++func (m *MethodDescriptorProto) String() string { return proto.CompactTextString(m) } ++func (*MethodDescriptorProto) ProtoMessage() {} ++func (*MethodDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } ++ ++const Default_MethodDescriptorProto_ClientStreaming bool = false ++const Default_MethodDescriptorProto_ServerStreaming bool = false ++ ++func (m *MethodDescriptorProto) GetName() string { ++ if m != nil && m.Name != nil { ++ return *m.Name ++ } ++ return "" ++} ++ ++func (m *MethodDescriptorProto) GetInputType() string { ++ if m != nil && m.InputType != nil { ++ return *m.InputType ++ } ++ return "" ++} ++ ++func (m *MethodDescriptorProto) GetOutputType() string { ++ if m != nil && m.OutputType != nil { ++ return *m.OutputType ++ } ++ return "" ++} ++ ++func (m *MethodDescriptorProto) GetOptions() *MethodOptions { ++ if m != nil { ++ return m.Options ++ } ++ return nil ++} ++ ++func (m *MethodDescriptorProto) GetClientStreaming() bool { ++ if m != nil && m.ClientStreaming != nil { ++ return *m.ClientStreaming ++ } ++ return Default_MethodDescriptorProto_ClientStreaming ++} ++ ++func (m *MethodDescriptorProto) GetServerStreaming() bool { ++ if m != nil && m.ServerStreaming != nil { ++ return *m.ServerStreaming ++ } ++ return Default_MethodDescriptorProto_ServerStreaming ++} ++ ++type FileOptions struct { ++ // Sets the Java package where classes generated from this .proto will be ++ // placed. By default, the proto package is used, but this is often ++ // inappropriate because proto packages do not normally start with backwards ++ // domain names. ++ JavaPackage *string `protobuf:"bytes,1,opt,name=java_package,json=javaPackage" json:"java_package,omitempty"` ++ // If set, all the classes from the .proto file are wrapped in a single ++ // outer class with the given name. This applies to both Proto1 ++ // (equivalent to the old "--one_java_file" option) and Proto2 (where ++ // a .proto always translates to a single class, but you may want to ++ // explicitly choose the class name). ++ JavaOuterClassname *string `protobuf:"bytes,8,opt,name=java_outer_classname,json=javaOuterClassname" json:"java_outer_classname,omitempty"` ++ // If set true, then the Java code generator will generate a separate .java ++ // file for each top-level message, enum, and service defined in the .proto ++ // file. Thus, these types will *not* be nested inside the outer class ++ // named by java_outer_classname. However, the outer class will still be ++ // generated to contain the file's getDescriptor() method as well as any ++ // top-level extensions defined in the file. ++ JavaMultipleFiles *bool `protobuf:"varint,10,opt,name=java_multiple_files,json=javaMultipleFiles,def=0" json:"java_multiple_files,omitempty"` ++ // This option does nothing. ++ JavaGenerateEqualsAndHash *bool `protobuf:"varint,20,opt,name=java_generate_equals_and_hash,json=javaGenerateEqualsAndHash" json:"java_generate_equals_and_hash,omitempty"` ++ // If set true, then the Java2 code generator will generate code that ++ // throws an exception whenever an attempt is made to assign a non-UTF-8 ++ // byte sequence to a string field. ++ // Message reflection will do the same. ++ // However, an extension field still accepts non-UTF-8 byte sequences. ++ // This option has no effect on when used with the lite runtime. ++ JavaStringCheckUtf8 *bool `protobuf:"varint,27,opt,name=java_string_check_utf8,json=javaStringCheckUtf8,def=0" json:"java_string_check_utf8,omitempty"` ++ OptimizeFor *FileOptions_OptimizeMode `protobuf:"varint,9,opt,name=optimize_for,json=optimizeFor,enum=google.protobuf.FileOptions_OptimizeMode,def=1" json:"optimize_for,omitempty"` ++ // Sets the Go package where structs generated from this .proto will be ++ // placed. If omitted, the Go package will be derived from the following: ++ // - The basename of the package import path, if provided. ++ // - Otherwise, the package statement in the .proto file, if present. ++ // - Otherwise, the basename of the .proto file, without extension. ++ GoPackage *string `protobuf:"bytes,11,opt,name=go_package,json=goPackage" json:"go_package,omitempty"` ++ // Should generic services be generated in each language? "Generic" services ++ // are not specific to any particular RPC system. They are generated by the ++ // main code generators in each language (without additional plugins). ++ // Generic services were the only kind of service generation supported by ++ // early versions of google.protobuf. ++ // ++ // Generic services are now considered deprecated in favor of using plugins ++ // that generate code specific to your particular RPC system. Therefore, ++ // these default to false. Old code which depends on generic services should ++ // explicitly set them to true. ++ CcGenericServices *bool `protobuf:"varint,16,opt,name=cc_generic_services,json=ccGenericServices,def=0" json:"cc_generic_services,omitempty"` ++ JavaGenericServices *bool `protobuf:"varint,17,opt,name=java_generic_services,json=javaGenericServices,def=0" json:"java_generic_services,omitempty"` ++ PyGenericServices *bool `protobuf:"varint,18,opt,name=py_generic_services,json=pyGenericServices,def=0" json:"py_generic_services,omitempty"` ++ // Is this file deprecated? ++ // Depending on the target platform, this can emit Deprecated annotations ++ // for everything in the file, or it will be completely ignored; in the very ++ // least, this is a formalization for deprecating files. ++ Deprecated *bool `protobuf:"varint,23,opt,name=deprecated,def=0" json:"deprecated,omitempty"` ++ // Enables the use of arenas for the proto messages in this file. This applies ++ // only to generated classes for C++. ++ CcEnableArenas *bool `protobuf:"varint,31,opt,name=cc_enable_arenas,json=ccEnableArenas,def=0" json:"cc_enable_arenas,omitempty"` ++ // Sets the objective c class prefix which is prepended to all objective c ++ // generated classes from this .proto. There is no default. ++ ObjcClassPrefix *string `protobuf:"bytes,36,opt,name=objc_class_prefix,json=objcClassPrefix" json:"objc_class_prefix,omitempty"` ++ // Namespace for generated classes; defaults to the package. ++ CsharpNamespace *string `protobuf:"bytes,37,opt,name=csharp_namespace,json=csharpNamespace" json:"csharp_namespace,omitempty"` ++ // The parser stores options it doesn't recognize here. See above. ++ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` ++ proto.XXX_InternalExtensions `json:"-"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *FileOptions) Reset() { *m = FileOptions{} } ++func (m *FileOptions) String() string { return proto.CompactTextString(m) } ++func (*FileOptions) ProtoMessage() {} ++func (*FileOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } ++ ++var extRange_FileOptions = []proto.ExtensionRange{ ++ {1000, 536870911}, ++} ++ ++func (*FileOptions) ExtensionRangeArray() []proto.ExtensionRange { ++ return extRange_FileOptions ++} ++ ++const Default_FileOptions_JavaMultipleFiles bool = false ++const Default_FileOptions_JavaStringCheckUtf8 bool = false ++const Default_FileOptions_OptimizeFor FileOptions_OptimizeMode = FileOptions_SPEED ++const Default_FileOptions_CcGenericServices bool = false ++const Default_FileOptions_JavaGenericServices bool = false ++const Default_FileOptions_PyGenericServices bool = false ++const Default_FileOptions_Deprecated bool = false ++const Default_FileOptions_CcEnableArenas bool = false ++ ++func (m *FileOptions) GetJavaPackage() string { ++ if m != nil && m.JavaPackage != nil { ++ return *m.JavaPackage ++ } ++ return "" ++} ++ ++func (m *FileOptions) GetJavaOuterClassname() string { ++ if m != nil && m.JavaOuterClassname != nil { ++ return *m.JavaOuterClassname ++ } ++ return "" ++} ++ ++func (m *FileOptions) GetJavaMultipleFiles() bool { ++ if m != nil && m.JavaMultipleFiles != nil { ++ return *m.JavaMultipleFiles ++ } ++ return Default_FileOptions_JavaMultipleFiles ++} ++ ++func (m *FileOptions) GetJavaGenerateEqualsAndHash() bool { ++ if m != nil && m.JavaGenerateEqualsAndHash != nil { ++ return *m.JavaGenerateEqualsAndHash ++ } ++ return false ++} ++ ++func (m *FileOptions) GetJavaStringCheckUtf8() bool { ++ if m != nil && m.JavaStringCheckUtf8 != nil { ++ return *m.JavaStringCheckUtf8 ++ } ++ return Default_FileOptions_JavaStringCheckUtf8 ++} ++ ++func (m *FileOptions) GetOptimizeFor() FileOptions_OptimizeMode { ++ if m != nil && m.OptimizeFor != nil { ++ return *m.OptimizeFor ++ } ++ return Default_FileOptions_OptimizeFor ++} ++ ++func (m *FileOptions) GetGoPackage() string { ++ if m != nil && m.GoPackage != nil { ++ return *m.GoPackage ++ } ++ return "" ++} ++ ++func (m *FileOptions) GetCcGenericServices() bool { ++ if m != nil && m.CcGenericServices != nil { ++ return *m.CcGenericServices ++ } ++ return Default_FileOptions_CcGenericServices ++} ++ ++func (m *FileOptions) GetJavaGenericServices() bool { ++ if m != nil && m.JavaGenericServices != nil { ++ return *m.JavaGenericServices ++ } ++ return Default_FileOptions_JavaGenericServices ++} ++ ++func (m *FileOptions) GetPyGenericServices() bool { ++ if m != nil && m.PyGenericServices != nil { ++ return *m.PyGenericServices ++ } ++ return Default_FileOptions_PyGenericServices ++} ++ ++func (m *FileOptions) GetDeprecated() bool { ++ if m != nil && m.Deprecated != nil { ++ return *m.Deprecated ++ } ++ return Default_FileOptions_Deprecated ++} ++ ++func (m *FileOptions) GetCcEnableArenas() bool { ++ if m != nil && m.CcEnableArenas != nil { ++ return *m.CcEnableArenas ++ } ++ return Default_FileOptions_CcEnableArenas ++} ++ ++func (m *FileOptions) GetObjcClassPrefix() string { ++ if m != nil && m.ObjcClassPrefix != nil { ++ return *m.ObjcClassPrefix ++ } ++ return "" ++} ++ ++func (m *FileOptions) GetCsharpNamespace() string { ++ if m != nil && m.CsharpNamespace != nil { ++ return *m.CsharpNamespace ++ } ++ return "" ++} ++ ++func (m *FileOptions) GetUninterpretedOption() []*UninterpretedOption { ++ if m != nil { ++ return m.UninterpretedOption ++ } ++ return nil ++} ++ ++type MessageOptions struct { ++ // Set true to use the old proto1 MessageSet wire format for extensions. ++ // This is provided for backwards-compatibility with the MessageSet wire ++ // format. You should not use this for any other reason: It's less ++ // efficient, has fewer features, and is more complicated. ++ // ++ // The message must be defined exactly as follows: ++ // message Foo { ++ // option message_set_wire_format = true; ++ // extensions 4 to max; ++ // } ++ // Note that the message cannot have any defined fields; MessageSets only ++ // have extensions. ++ // ++ // All extensions of your type must be singular messages; e.g. they cannot ++ // be int32s, enums, or repeated messages. ++ // ++ // Because this is an option, the above two restrictions are not enforced by ++ // the protocol compiler. ++ MessageSetWireFormat *bool `protobuf:"varint,1,opt,name=message_set_wire_format,json=messageSetWireFormat,def=0" json:"message_set_wire_format,omitempty"` ++ // Disables the generation of the standard "descriptor()" accessor, which can ++ // conflict with a field of the same name. This is meant to make migration ++ // from proto1 easier; new code should avoid fields named "descriptor". ++ NoStandardDescriptorAccessor *bool `protobuf:"varint,2,opt,name=no_standard_descriptor_accessor,json=noStandardDescriptorAccessor,def=0" json:"no_standard_descriptor_accessor,omitempty"` ++ // Is this message deprecated? ++ // Depending on the target platform, this can emit Deprecated annotations ++ // for the message, or it will be completely ignored; in the very least, ++ // this is a formalization for deprecating messages. ++ Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` ++ // Whether the message is an automatically generated map entry type for the ++ // maps field. ++ // ++ // For maps fields: ++ // map map_field = 1; ++ // The parsed descriptor looks like: ++ // message MapFieldEntry { ++ // option map_entry = true; ++ // optional KeyType key = 1; ++ // optional ValueType value = 2; ++ // } ++ // repeated MapFieldEntry map_field = 1; ++ // ++ // Implementations may choose not to generate the map_entry=true message, but ++ // use a native map in the target language to hold the keys and values. ++ // The reflection APIs in such implementions still need to work as ++ // if the field is a repeated message field. ++ // ++ // NOTE: Do not set the option in .proto files. Always use the maps syntax ++ // instead. The option should only be implicitly set by the proto compiler ++ // parser. ++ MapEntry *bool `protobuf:"varint,7,opt,name=map_entry,json=mapEntry" json:"map_entry,omitempty"` ++ // The parser stores options it doesn't recognize here. See above. ++ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` ++ proto.XXX_InternalExtensions `json:"-"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *MessageOptions) Reset() { *m = MessageOptions{} } ++func (m *MessageOptions) String() string { return proto.CompactTextString(m) } ++func (*MessageOptions) ProtoMessage() {} ++func (*MessageOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } ++ ++var extRange_MessageOptions = []proto.ExtensionRange{ ++ {1000, 536870911}, ++} ++ ++func (*MessageOptions) ExtensionRangeArray() []proto.ExtensionRange { ++ return extRange_MessageOptions ++} ++ ++const Default_MessageOptions_MessageSetWireFormat bool = false ++const Default_MessageOptions_NoStandardDescriptorAccessor bool = false ++const Default_MessageOptions_Deprecated bool = false ++ ++func (m *MessageOptions) GetMessageSetWireFormat() bool { ++ if m != nil && m.MessageSetWireFormat != nil { ++ return *m.MessageSetWireFormat ++ } ++ return Default_MessageOptions_MessageSetWireFormat ++} ++ ++func (m *MessageOptions) GetNoStandardDescriptorAccessor() bool { ++ if m != nil && m.NoStandardDescriptorAccessor != nil { ++ return *m.NoStandardDescriptorAccessor ++ } ++ return Default_MessageOptions_NoStandardDescriptorAccessor ++} ++ ++func (m *MessageOptions) GetDeprecated() bool { ++ if m != nil && m.Deprecated != nil { ++ return *m.Deprecated ++ } ++ return Default_MessageOptions_Deprecated ++} ++ ++func (m *MessageOptions) GetMapEntry() bool { ++ if m != nil && m.MapEntry != nil { ++ return *m.MapEntry ++ } ++ return false ++} ++ ++func (m *MessageOptions) GetUninterpretedOption() []*UninterpretedOption { ++ if m != nil { ++ return m.UninterpretedOption ++ } ++ return nil ++} ++ ++type FieldOptions struct { ++ // The ctype option instructs the C++ code generator to use a different ++ // representation of the field than it normally would. See the specific ++ // options below. This option is not yet implemented in the open source ++ // release -- sorry, we'll try to include it in a future version! ++ Ctype *FieldOptions_CType `protobuf:"varint,1,opt,name=ctype,enum=google.protobuf.FieldOptions_CType,def=0" json:"ctype,omitempty"` ++ // The packed option can be enabled for repeated primitive fields to enable ++ // a more efficient representation on the wire. Rather than repeatedly ++ // writing the tag and type for each element, the entire array is encoded as ++ // a single length-delimited blob. In proto3, only explicit setting it to ++ // false will avoid using packed encoding. ++ Packed *bool `protobuf:"varint,2,opt,name=packed" json:"packed,omitempty"` ++ // The jstype option determines the JavaScript type used for values of the ++ // field. The option is permitted only for 64 bit integral and fixed types ++ // (int64, uint64, sint64, fixed64, sfixed64). By default these types are ++ // represented as JavaScript strings. This avoids loss of precision that can ++ // happen when a large value is converted to a floating point JavaScript ++ // numbers. Specifying JS_NUMBER for the jstype causes the generated ++ // JavaScript code to use the JavaScript "number" type instead of strings. ++ // This option is an enum to permit additional types to be added, ++ // e.g. goog.math.Integer. ++ Jstype *FieldOptions_JSType `protobuf:"varint,6,opt,name=jstype,enum=google.protobuf.FieldOptions_JSType,def=0" json:"jstype,omitempty"` ++ // Should this field be parsed lazily? Lazy applies only to message-type ++ // fields. It means that when the outer message is initially parsed, the ++ // inner message's contents will not be parsed but instead stored in encoded ++ // form. The inner message will actually be parsed when it is first accessed. ++ // ++ // This is only a hint. Implementations are free to choose whether to use ++ // eager or lazy parsing regardless of the value of this option. However, ++ // setting this option true suggests that the protocol author believes that ++ // using lazy parsing on this field is worth the additional bookkeeping ++ // overhead typically needed to implement it. ++ // ++ // This option does not affect the public interface of any generated code; ++ // all method signatures remain the same. Furthermore, thread-safety of the ++ // interface is not affected by this option; const methods remain safe to ++ // call from multiple threads concurrently, while non-const methods continue ++ // to require exclusive access. ++ // ++ // ++ // Note that implementations may choose not to check required fields within ++ // a lazy sub-message. That is, calling IsInitialized() on the outer message ++ // may return true even if the inner message has missing required fields. ++ // This is necessary because otherwise the inner message would have to be ++ // parsed in order to perform the check, defeating the purpose of lazy ++ // parsing. An implementation which chooses not to check required fields ++ // must be consistent about it. That is, for any particular sub-message, the ++ // implementation must either *always* check its required fields, or *never* ++ // check its required fields, regardless of whether or not the message has ++ // been parsed. ++ Lazy *bool `protobuf:"varint,5,opt,name=lazy,def=0" json:"lazy,omitempty"` ++ // Is this field deprecated? ++ // Depending on the target platform, this can emit Deprecated annotations ++ // for accessors, or it will be completely ignored; in the very least, this ++ // is a formalization for deprecating fields. ++ Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` ++ // For Google-internal migration only. Do not use. ++ Weak *bool `protobuf:"varint,10,opt,name=weak,def=0" json:"weak,omitempty"` ++ // The parser stores options it doesn't recognize here. See above. ++ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` ++ proto.XXX_InternalExtensions `json:"-"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *FieldOptions) Reset() { *m = FieldOptions{} } ++func (m *FieldOptions) String() string { return proto.CompactTextString(m) } ++func (*FieldOptions) ProtoMessage() {} ++func (*FieldOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } ++ ++var extRange_FieldOptions = []proto.ExtensionRange{ ++ {1000, 536870911}, ++} ++ ++func (*FieldOptions) ExtensionRangeArray() []proto.ExtensionRange { ++ return extRange_FieldOptions ++} ++ ++const Default_FieldOptions_Ctype FieldOptions_CType = FieldOptions_STRING ++const Default_FieldOptions_Jstype FieldOptions_JSType = FieldOptions_JS_NORMAL ++const Default_FieldOptions_Lazy bool = false ++const Default_FieldOptions_Deprecated bool = false ++const Default_FieldOptions_Weak bool = false ++ ++func (m *FieldOptions) GetCtype() FieldOptions_CType { ++ if m != nil && m.Ctype != nil { ++ return *m.Ctype ++ } ++ return Default_FieldOptions_Ctype ++} ++ ++func (m *FieldOptions) GetPacked() bool { ++ if m != nil && m.Packed != nil { ++ return *m.Packed ++ } ++ return false ++} ++ ++func (m *FieldOptions) GetJstype() FieldOptions_JSType { ++ if m != nil && m.Jstype != nil { ++ return *m.Jstype ++ } ++ return Default_FieldOptions_Jstype ++} ++ ++func (m *FieldOptions) GetLazy() bool { ++ if m != nil && m.Lazy != nil { ++ return *m.Lazy ++ } ++ return Default_FieldOptions_Lazy ++} ++ ++func (m *FieldOptions) GetDeprecated() bool { ++ if m != nil && m.Deprecated != nil { ++ return *m.Deprecated ++ } ++ return Default_FieldOptions_Deprecated ++} ++ ++func (m *FieldOptions) GetWeak() bool { ++ if m != nil && m.Weak != nil { ++ return *m.Weak ++ } ++ return Default_FieldOptions_Weak ++} ++ ++func (m *FieldOptions) GetUninterpretedOption() []*UninterpretedOption { ++ if m != nil { ++ return m.UninterpretedOption ++ } ++ return nil ++} ++ ++type OneofOptions struct { ++ // The parser stores options it doesn't recognize here. See above. ++ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` ++ proto.XXX_InternalExtensions `json:"-"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *OneofOptions) Reset() { *m = OneofOptions{} } ++func (m *OneofOptions) String() string { return proto.CompactTextString(m) } ++func (*OneofOptions) ProtoMessage() {} ++func (*OneofOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } ++ ++var extRange_OneofOptions = []proto.ExtensionRange{ ++ {1000, 536870911}, ++} ++ ++func (*OneofOptions) ExtensionRangeArray() []proto.ExtensionRange { ++ return extRange_OneofOptions ++} ++ ++func (m *OneofOptions) GetUninterpretedOption() []*UninterpretedOption { ++ if m != nil { ++ return m.UninterpretedOption ++ } ++ return nil ++} ++ ++type EnumOptions struct { ++ // Set this option to true to allow mapping different tag names to the same ++ // value. ++ AllowAlias *bool `protobuf:"varint,2,opt,name=allow_alias,json=allowAlias" json:"allow_alias,omitempty"` ++ // Is this enum deprecated? ++ // Depending on the target platform, this can emit Deprecated annotations ++ // for the enum, or it will be completely ignored; in the very least, this ++ // is a formalization for deprecating enums. ++ Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` ++ // The parser stores options it doesn't recognize here. See above. ++ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` ++ proto.XXX_InternalExtensions `json:"-"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *EnumOptions) Reset() { *m = EnumOptions{} } ++func (m *EnumOptions) String() string { return proto.CompactTextString(m) } ++func (*EnumOptions) ProtoMessage() {} ++func (*EnumOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } ++ ++var extRange_EnumOptions = []proto.ExtensionRange{ ++ {1000, 536870911}, ++} ++ ++func (*EnumOptions) ExtensionRangeArray() []proto.ExtensionRange { ++ return extRange_EnumOptions ++} ++ ++const Default_EnumOptions_Deprecated bool = false ++ ++func (m *EnumOptions) GetAllowAlias() bool { ++ if m != nil && m.AllowAlias != nil { ++ return *m.AllowAlias ++ } ++ return false ++} ++ ++func (m *EnumOptions) GetDeprecated() bool { ++ if m != nil && m.Deprecated != nil { ++ return *m.Deprecated ++ } ++ return Default_EnumOptions_Deprecated ++} ++ ++func (m *EnumOptions) GetUninterpretedOption() []*UninterpretedOption { ++ if m != nil { ++ return m.UninterpretedOption ++ } ++ return nil ++} ++ ++type EnumValueOptions struct { ++ // Is this enum value deprecated? ++ // Depending on the target platform, this can emit Deprecated annotations ++ // for the enum value, or it will be completely ignored; in the very least, ++ // this is a formalization for deprecating enum values. ++ Deprecated *bool `protobuf:"varint,1,opt,name=deprecated,def=0" json:"deprecated,omitempty"` ++ // The parser stores options it doesn't recognize here. See above. ++ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` ++ proto.XXX_InternalExtensions `json:"-"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *EnumValueOptions) Reset() { *m = EnumValueOptions{} } ++func (m *EnumValueOptions) String() string { return proto.CompactTextString(m) } ++func (*EnumValueOptions) ProtoMessage() {} ++func (*EnumValueOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} } ++ ++var extRange_EnumValueOptions = []proto.ExtensionRange{ ++ {1000, 536870911}, ++} ++ ++func (*EnumValueOptions) ExtensionRangeArray() []proto.ExtensionRange { ++ return extRange_EnumValueOptions ++} ++ ++const Default_EnumValueOptions_Deprecated bool = false ++ ++func (m *EnumValueOptions) GetDeprecated() bool { ++ if m != nil && m.Deprecated != nil { ++ return *m.Deprecated ++ } ++ return Default_EnumValueOptions_Deprecated ++} ++ ++func (m *EnumValueOptions) GetUninterpretedOption() []*UninterpretedOption { ++ if m != nil { ++ return m.UninterpretedOption ++ } ++ return nil ++} ++ ++type ServiceOptions struct { ++ // Is this service deprecated? ++ // Depending on the target platform, this can emit Deprecated annotations ++ // for the service, or it will be completely ignored; in the very least, ++ // this is a formalization for deprecating services. ++ Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"` ++ // The parser stores options it doesn't recognize here. See above. ++ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` ++ proto.XXX_InternalExtensions `json:"-"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *ServiceOptions) Reset() { *m = ServiceOptions{} } ++func (m *ServiceOptions) String() string { return proto.CompactTextString(m) } ++func (*ServiceOptions) ProtoMessage() {} ++func (*ServiceOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } ++ ++var extRange_ServiceOptions = []proto.ExtensionRange{ ++ {1000, 536870911}, ++} ++ ++func (*ServiceOptions) ExtensionRangeArray() []proto.ExtensionRange { ++ return extRange_ServiceOptions ++} ++ ++const Default_ServiceOptions_Deprecated bool = false ++ ++func (m *ServiceOptions) GetDeprecated() bool { ++ if m != nil && m.Deprecated != nil { ++ return *m.Deprecated ++ } ++ return Default_ServiceOptions_Deprecated ++} ++ ++func (m *ServiceOptions) GetUninterpretedOption() []*UninterpretedOption { ++ if m != nil { ++ return m.UninterpretedOption ++ } ++ return nil ++} ++ ++type MethodOptions struct { ++ // Is this method deprecated? ++ // Depending on the target platform, this can emit Deprecated annotations ++ // for the method, or it will be completely ignored; in the very least, ++ // this is a formalization for deprecating methods. ++ Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"` ++ // The parser stores options it doesn't recognize here. See above. ++ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` ++ proto.XXX_InternalExtensions `json:"-"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *MethodOptions) Reset() { *m = MethodOptions{} } ++func (m *MethodOptions) String() string { return proto.CompactTextString(m) } ++func (*MethodOptions) ProtoMessage() {} ++func (*MethodOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } ++ ++var extRange_MethodOptions = []proto.ExtensionRange{ ++ {1000, 536870911}, ++} ++ ++func (*MethodOptions) ExtensionRangeArray() []proto.ExtensionRange { ++ return extRange_MethodOptions ++} ++ ++const Default_MethodOptions_Deprecated bool = false ++ ++func (m *MethodOptions) GetDeprecated() bool { ++ if m != nil && m.Deprecated != nil { ++ return *m.Deprecated ++ } ++ return Default_MethodOptions_Deprecated ++} ++ ++func (m *MethodOptions) GetUninterpretedOption() []*UninterpretedOption { ++ if m != nil { ++ return m.UninterpretedOption ++ } ++ return nil ++} ++ ++// A message representing a option the parser does not recognize. This only ++// appears in options protos created by the compiler::Parser class. ++// DescriptorPool resolves these when building Descriptor objects. Therefore, ++// options protos in descriptor objects (e.g. returned by Descriptor::options(), ++// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions ++// in them. ++type UninterpretedOption struct { ++ Name []*UninterpretedOption_NamePart `protobuf:"bytes,2,rep,name=name" json:"name,omitempty"` ++ // The value of the uninterpreted option, in whatever type the tokenizer ++ // identified it as during parsing. Exactly one of these should be set. ++ IdentifierValue *string `protobuf:"bytes,3,opt,name=identifier_value,json=identifierValue" json:"identifier_value,omitempty"` ++ PositiveIntValue *uint64 `protobuf:"varint,4,opt,name=positive_int_value,json=positiveIntValue" json:"positive_int_value,omitempty"` ++ NegativeIntValue *int64 `protobuf:"varint,5,opt,name=negative_int_value,json=negativeIntValue" json:"negative_int_value,omitempty"` ++ DoubleValue *float64 `protobuf:"fixed64,6,opt,name=double_value,json=doubleValue" json:"double_value,omitempty"` ++ StringValue []byte `protobuf:"bytes,7,opt,name=string_value,json=stringValue" json:"string_value,omitempty"` ++ AggregateValue *string `protobuf:"bytes,8,opt,name=aggregate_value,json=aggregateValue" json:"aggregate_value,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *UninterpretedOption) Reset() { *m = UninterpretedOption{} } ++func (m *UninterpretedOption) String() string { return proto.CompactTextString(m) } ++func (*UninterpretedOption) ProtoMessage() {} ++func (*UninterpretedOption) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } ++ ++func (m *UninterpretedOption) GetName() []*UninterpretedOption_NamePart { ++ if m != nil { ++ return m.Name ++ } ++ return nil ++} ++ ++func (m *UninterpretedOption) GetIdentifierValue() string { ++ if m != nil && m.IdentifierValue != nil { ++ return *m.IdentifierValue ++ } ++ return "" ++} ++ ++func (m *UninterpretedOption) GetPositiveIntValue() uint64 { ++ if m != nil && m.PositiveIntValue != nil { ++ return *m.PositiveIntValue ++ } ++ return 0 ++} ++ ++func (m *UninterpretedOption) GetNegativeIntValue() int64 { ++ if m != nil && m.NegativeIntValue != nil { ++ return *m.NegativeIntValue ++ } ++ return 0 ++} ++ ++func (m *UninterpretedOption) GetDoubleValue() float64 { ++ if m != nil && m.DoubleValue != nil { ++ return *m.DoubleValue ++ } ++ return 0 ++} ++ ++func (m *UninterpretedOption) GetStringValue() []byte { ++ if m != nil { ++ return m.StringValue ++ } ++ return nil ++} ++ ++func (m *UninterpretedOption) GetAggregateValue() string { ++ if m != nil && m.AggregateValue != nil { ++ return *m.AggregateValue ++ } ++ return "" ++} ++ ++// The name of the uninterpreted option. Each string represents a segment in ++// a dot-separated name. is_extension is true iff a segment represents an ++// extension (denoted with parentheses in options specs in .proto files). ++// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents ++// "foo.(bar.baz).qux". ++type UninterpretedOption_NamePart struct { ++ NamePart *string `protobuf:"bytes,1,req,name=name_part,json=namePart" json:"name_part,omitempty"` ++ IsExtension *bool `protobuf:"varint,2,req,name=is_extension,json=isExtension" json:"is_extension,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *UninterpretedOption_NamePart) Reset() { *m = UninterpretedOption_NamePart{} } ++func (m *UninterpretedOption_NamePart) String() string { return proto.CompactTextString(m) } ++func (*UninterpretedOption_NamePart) ProtoMessage() {} ++func (*UninterpretedOption_NamePart) Descriptor() ([]byte, []int) { ++ return fileDescriptor0, []int{17, 0} ++} ++ ++func (m *UninterpretedOption_NamePart) GetNamePart() string { ++ if m != nil && m.NamePart != nil { ++ return *m.NamePart ++ } ++ return "" ++} ++ ++func (m *UninterpretedOption_NamePart) GetIsExtension() bool { ++ if m != nil && m.IsExtension != nil { ++ return *m.IsExtension ++ } ++ return false ++} ++ ++// Encapsulates information about the original source file from which a ++// FileDescriptorProto was generated. ++type SourceCodeInfo struct { ++ // A Location identifies a piece of source code in a .proto file which ++ // corresponds to a particular definition. This information is intended ++ // to be useful to IDEs, code indexers, documentation generators, and similar ++ // tools. ++ // ++ // For example, say we have a file like: ++ // message Foo { ++ // optional string foo = 1; ++ // } ++ // Let's look at just the field definition: ++ // optional string foo = 1; ++ // ^ ^^ ^^ ^ ^^^ ++ // a bc de f ghi ++ // We have the following locations: ++ // span path represents ++ // [a,i) [ 4, 0, 2, 0 ] The whole field definition. ++ // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). ++ // [c,d) [ 4, 0, 2, 0, 5 ] The type (string). ++ // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). ++ // [g,h) [ 4, 0, 2, 0, 3 ] The number (1). ++ // ++ // Notes: ++ // - A location may refer to a repeated field itself (i.e. not to any ++ // particular index within it). This is used whenever a set of elements are ++ // logically enclosed in a single code segment. For example, an entire ++ // extend block (possibly containing multiple extension definitions) will ++ // have an outer location whose path refers to the "extensions" repeated ++ // field without an index. ++ // - Multiple locations may have the same path. This happens when a single ++ // logical declaration is spread out across multiple places. The most ++ // obvious example is the "extend" block again -- there may be multiple ++ // extend blocks in the same scope, each of which will have the same path. ++ // - A location's span is not always a subset of its parent's span. For ++ // example, the "extendee" of an extension declaration appears at the ++ // beginning of the "extend" block and is shared by all extensions within ++ // the block. ++ // - Just because a location's span is a subset of some other location's span ++ // does not mean that it is a descendent. For example, a "group" defines ++ // both a type and a field in a single declaration. Thus, the locations ++ // corresponding to the type and field and their components will overlap. ++ // - Code which tries to interpret locations should probably be designed to ++ // ignore those that it doesn't understand, as more types of locations could ++ // be recorded in the future. ++ Location []*SourceCodeInfo_Location `protobuf:"bytes,1,rep,name=location" json:"location,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *SourceCodeInfo) Reset() { *m = SourceCodeInfo{} } ++func (m *SourceCodeInfo) String() string { return proto.CompactTextString(m) } ++func (*SourceCodeInfo) ProtoMessage() {} ++func (*SourceCodeInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } ++ ++func (m *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location { ++ if m != nil { ++ return m.Location ++ } ++ return nil ++} ++ ++type SourceCodeInfo_Location struct { ++ // Identifies which part of the FileDescriptorProto was defined at this ++ // location. ++ // ++ // Each element is a field number or an index. They form a path from ++ // the root FileDescriptorProto to the place where the definition. For ++ // example, this path: ++ // [ 4, 3, 2, 7, 1 ] ++ // refers to: ++ // file.message_type(3) // 4, 3 ++ // .field(7) // 2, 7 ++ // .name() // 1 ++ // This is because FileDescriptorProto.message_type has field number 4: ++ // repeated DescriptorProto message_type = 4; ++ // and DescriptorProto.field has field number 2: ++ // repeated FieldDescriptorProto field = 2; ++ // and FieldDescriptorProto.name has field number 1: ++ // optional string name = 1; ++ // ++ // Thus, the above path gives the location of a field name. If we removed ++ // the last element: ++ // [ 4, 3, 2, 7 ] ++ // this path refers to the whole field declaration (from the beginning ++ // of the label to the terminating semicolon). ++ Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"` ++ // Always has exactly three or four elements: start line, start column, ++ // end line (optional, otherwise assumed same as start line), end column. ++ // These are packed into a single field for efficiency. Note that line ++ // and column numbers are zero-based -- typically you will want to add ++ // 1 to each before displaying to a user. ++ Span []int32 `protobuf:"varint,2,rep,packed,name=span" json:"span,omitempty"` ++ // If this SourceCodeInfo represents a complete declaration, these are any ++ // comments appearing before and after the declaration which appear to be ++ // attached to the declaration. ++ // ++ // A series of line comments appearing on consecutive lines, with no other ++ // tokens appearing on those lines, will be treated as a single comment. ++ // ++ // leading_detached_comments will keep paragraphs of comments that appear ++ // before (but not connected to) the current element. Each paragraph, ++ // separated by empty lines, will be one comment element in the repeated ++ // field. ++ // ++ // Only the comment content is provided; comment markers (e.g. //) are ++ // stripped out. For block comments, leading whitespace and an asterisk ++ // will be stripped from the beginning of each line other than the first. ++ // Newlines are included in the output. ++ // ++ // Examples: ++ // ++ // optional int32 foo = 1; // Comment attached to foo. ++ // // Comment attached to bar. ++ // optional int32 bar = 2; ++ // ++ // optional string baz = 3; ++ // // Comment attached to baz. ++ // // Another line attached to baz. ++ // ++ // // Comment attached to qux. ++ // // ++ // // Another line attached to qux. ++ // optional double qux = 4; ++ // ++ // // Detached comment for corge. This is not leading or trailing comments ++ // // to qux or corge because there are blank lines separating it from ++ // // both. ++ // ++ // // Detached comment for corge paragraph 2. ++ // ++ // optional string corge = 5; ++ // /* Block comment attached ++ // * to corge. Leading asterisks ++ // * will be removed. */ ++ // /* Block comment attached to ++ // * grault. */ ++ // optional int32 grault = 6; ++ // ++ // // ignored detached comments. ++ LeadingComments *string `protobuf:"bytes,3,opt,name=leading_comments,json=leadingComments" json:"leading_comments,omitempty"` ++ TrailingComments *string `protobuf:"bytes,4,opt,name=trailing_comments,json=trailingComments" json:"trailing_comments,omitempty"` ++ LeadingDetachedComments []string `protobuf:"bytes,6,rep,name=leading_detached_comments,json=leadingDetachedComments" json:"leading_detached_comments,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *SourceCodeInfo_Location) Reset() { *m = SourceCodeInfo_Location{} } ++func (m *SourceCodeInfo_Location) String() string { return proto.CompactTextString(m) } ++func (*SourceCodeInfo_Location) ProtoMessage() {} ++func (*SourceCodeInfo_Location) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18, 0} } ++ ++func (m *SourceCodeInfo_Location) GetPath() []int32 { ++ if m != nil { ++ return m.Path ++ } ++ return nil ++} ++ ++func (m *SourceCodeInfo_Location) GetSpan() []int32 { ++ if m != nil { ++ return m.Span ++ } ++ return nil ++} ++ ++func (m *SourceCodeInfo_Location) GetLeadingComments() string { ++ if m != nil && m.LeadingComments != nil { ++ return *m.LeadingComments ++ } ++ return "" ++} ++ ++func (m *SourceCodeInfo_Location) GetTrailingComments() string { ++ if m != nil && m.TrailingComments != nil { ++ return *m.TrailingComments ++ } ++ return "" ++} ++ ++func (m *SourceCodeInfo_Location) GetLeadingDetachedComments() []string { ++ if m != nil { ++ return m.LeadingDetachedComments ++ } ++ return nil ++} ++ ++// Describes the relationship between generated code and its original source ++// file. A GeneratedCodeInfo message is associated with only one generated ++// source file, but may contain references to different source .proto files. ++type GeneratedCodeInfo struct { ++ // An Annotation connects some span of text in generated code to an element ++ // of its generating .proto file. ++ Annotation []*GeneratedCodeInfo_Annotation `protobuf:"bytes,1,rep,name=annotation" json:"annotation,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *GeneratedCodeInfo) Reset() { *m = GeneratedCodeInfo{} } ++func (m *GeneratedCodeInfo) String() string { return proto.CompactTextString(m) } ++func (*GeneratedCodeInfo) ProtoMessage() {} ++func (*GeneratedCodeInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } ++ ++func (m *GeneratedCodeInfo) GetAnnotation() []*GeneratedCodeInfo_Annotation { ++ if m != nil { ++ return m.Annotation ++ } ++ return nil ++} ++ ++type GeneratedCodeInfo_Annotation struct { ++ // Identifies the element in the original source .proto file. This field ++ // is formatted the same as SourceCodeInfo.Location.path. ++ Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"` ++ // Identifies the filesystem path to the original source .proto. ++ SourceFile *string `protobuf:"bytes,2,opt,name=source_file,json=sourceFile" json:"source_file,omitempty"` ++ // Identifies the starting offset in bytes in the generated code ++ // that relates to the identified object. ++ Begin *int32 `protobuf:"varint,3,opt,name=begin" json:"begin,omitempty"` ++ // Identifies the ending offset in bytes in the generated code that ++ // relates to the identified offset. The end offset should be one past ++ // the last relevant byte (so the length of the text = end - begin). ++ End *int32 `protobuf:"varint,4,opt,name=end" json:"end,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *GeneratedCodeInfo_Annotation) Reset() { *m = GeneratedCodeInfo_Annotation{} } ++func (m *GeneratedCodeInfo_Annotation) String() string { return proto.CompactTextString(m) } ++func (*GeneratedCodeInfo_Annotation) ProtoMessage() {} ++func (*GeneratedCodeInfo_Annotation) Descriptor() ([]byte, []int) { ++ return fileDescriptor0, []int{19, 0} ++} ++ ++func (m *GeneratedCodeInfo_Annotation) GetPath() []int32 { ++ if m != nil { ++ return m.Path ++ } ++ return nil ++} ++ ++func (m *GeneratedCodeInfo_Annotation) GetSourceFile() string { ++ if m != nil && m.SourceFile != nil { ++ return *m.SourceFile ++ } ++ return "" ++} ++ ++func (m *GeneratedCodeInfo_Annotation) GetBegin() int32 { ++ if m != nil && m.Begin != nil { ++ return *m.Begin ++ } ++ return 0 ++} ++ ++func (m *GeneratedCodeInfo_Annotation) GetEnd() int32 { ++ if m != nil && m.End != nil { ++ return *m.End ++ } ++ return 0 ++} ++ ++func init() { ++ proto.RegisterType((*FileDescriptorSet)(nil), "google.protobuf.FileDescriptorSet") ++ proto.RegisterType((*FileDescriptorProto)(nil), "google.protobuf.FileDescriptorProto") ++ proto.RegisterType((*DescriptorProto)(nil), "google.protobuf.DescriptorProto") ++ proto.RegisterType((*DescriptorProto_ExtensionRange)(nil), "google.protobuf.DescriptorProto.ExtensionRange") ++ proto.RegisterType((*DescriptorProto_ReservedRange)(nil), "google.protobuf.DescriptorProto.ReservedRange") ++ proto.RegisterType((*FieldDescriptorProto)(nil), "google.protobuf.FieldDescriptorProto") ++ proto.RegisterType((*OneofDescriptorProto)(nil), "google.protobuf.OneofDescriptorProto") ++ proto.RegisterType((*EnumDescriptorProto)(nil), "google.protobuf.EnumDescriptorProto") ++ proto.RegisterType((*EnumValueDescriptorProto)(nil), "google.protobuf.EnumValueDescriptorProto") ++ proto.RegisterType((*ServiceDescriptorProto)(nil), "google.protobuf.ServiceDescriptorProto") ++ proto.RegisterType((*MethodDescriptorProto)(nil), "google.protobuf.MethodDescriptorProto") ++ proto.RegisterType((*FileOptions)(nil), "google.protobuf.FileOptions") ++ proto.RegisterType((*MessageOptions)(nil), "google.protobuf.MessageOptions") ++ proto.RegisterType((*FieldOptions)(nil), "google.protobuf.FieldOptions") ++ proto.RegisterType((*OneofOptions)(nil), "google.protobuf.OneofOptions") ++ proto.RegisterType((*EnumOptions)(nil), "google.protobuf.EnumOptions") ++ proto.RegisterType((*EnumValueOptions)(nil), "google.protobuf.EnumValueOptions") ++ proto.RegisterType((*ServiceOptions)(nil), "google.protobuf.ServiceOptions") ++ proto.RegisterType((*MethodOptions)(nil), "google.protobuf.MethodOptions") ++ proto.RegisterType((*UninterpretedOption)(nil), "google.protobuf.UninterpretedOption") ++ proto.RegisterType((*UninterpretedOption_NamePart)(nil), "google.protobuf.UninterpretedOption.NamePart") ++ proto.RegisterType((*SourceCodeInfo)(nil), "google.protobuf.SourceCodeInfo") ++ proto.RegisterType((*SourceCodeInfo_Location)(nil), "google.protobuf.SourceCodeInfo.Location") ++ proto.RegisterType((*GeneratedCodeInfo)(nil), "google.protobuf.GeneratedCodeInfo") ++ proto.RegisterType((*GeneratedCodeInfo_Annotation)(nil), "google.protobuf.GeneratedCodeInfo.Annotation") ++ proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Type", FieldDescriptorProto_Type_name, FieldDescriptorProto_Type_value) ++ proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Label", FieldDescriptorProto_Label_name, FieldDescriptorProto_Label_value) ++ proto.RegisterEnum("google.protobuf.FileOptions_OptimizeMode", FileOptions_OptimizeMode_name, FileOptions_OptimizeMode_value) ++ proto.RegisterEnum("google.protobuf.FieldOptions_CType", FieldOptions_CType_name, FieldOptions_CType_value) ++ proto.RegisterEnum("google.protobuf.FieldOptions_JSType", FieldOptions_JSType_name, FieldOptions_JSType_value) ++} ++ ++func init() { proto.RegisterFile("google/protobuf/descriptor.proto", fileDescriptor0) } ++ ++var fileDescriptor0 = []byte{ ++ // 2295 bytes of a gzipped FileDescriptorProto ++ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x59, 0x4f, 0x6f, 0x1b, 0xc7, ++ 0x15, 0xcf, 0xf2, 0x9f, 0xc8, 0x47, 0x8a, 0x1a, 0x8d, 0x14, 0x67, 0xad, 0xfc, 0xb1, 0xcc, 0xd8, ++ 0xb1, 0x6c, 0xb7, 0x74, 0x20, 0xff, 0x89, 0xa3, 0x14, 0x29, 0x28, 0x71, 0xad, 0xd0, 0x90, 0x44, ++ 0x76, 0x29, 0xb5, 0x4e, 0x2e, 0x8b, 0xd1, 0xee, 0x90, 0x5a, 0x7b, 0x39, 0xbb, 0xdd, 0x5d, 0xda, ++ 0x56, 0x4e, 0x06, 0x7a, 0xea, 0xa5, 0xe7, 0xa2, 0x2d, 0x7a, 0xc8, 0x25, 0x40, 0x3f, 0x40, 0x0f, ++ 0xfd, 0x0a, 0x05, 0x0a, 0xf4, 0x2b, 0x14, 0x05, 0xda, 0x6f, 0xd0, 0x6b, 0x31, 0x33, 0xbb, 0xcb, ++ 0x5d, 0xfe, 0x89, 0xd5, 0x00, 0x49, 0x7a, 0x12, 0xe7, 0xf7, 0x7e, 0xef, 0xcd, 0x9b, 0x37, 0x6f, ++ 0xde, 0xbc, 0x1d, 0xc1, 0xe6, 0xd0, 0x75, 0x87, 0x0e, 0xbd, 0xe3, 0xf9, 0x6e, 0xe8, 0x9e, 0x8e, ++ 0x07, 0x77, 0x2c, 0x1a, 0x98, 0xbe, 0xed, 0x85, 0xae, 0xdf, 0x14, 0x18, 0x5e, 0x91, 0x8c, 0x66, ++ 0xcc, 0x68, 0x1c, 0xc2, 0xea, 0x23, 0xdb, 0xa1, 0xed, 0x84, 0xd8, 0xa7, 0x21, 0x7e, 0x08, 0x85, ++ 0x81, 0xed, 0x50, 0x55, 0xd9, 0xcc, 0x6f, 0x55, 0xb7, 0xaf, 0x35, 0xa7, 0x94, 0x9a, 0x59, 0x8d, ++ 0x1e, 0x87, 0x75, 0xa1, 0xd1, 0xf8, 0x67, 0x01, 0xd6, 0xe6, 0x48, 0x31, 0x86, 0x02, 0x23, 0x23, ++ 0x6e, 0x51, 0xd9, 0xaa, 0xe8, 0xe2, 0x37, 0x56, 0x61, 0xc9, 0x23, 0xe6, 0x33, 0x32, 0xa4, 0x6a, ++ 0x4e, 0xc0, 0xf1, 0x10, 0xbf, 0x07, 0x60, 0x51, 0x8f, 0x32, 0x8b, 0x32, 0xf3, 0x5c, 0xcd, 0x6f, ++ 0xe6, 0xb7, 0x2a, 0x7a, 0x0a, 0xc1, 0xb7, 0x61, 0xd5, 0x1b, 0x9f, 0x3a, 0xb6, 0x69, 0xa4, 0x68, ++ 0xb0, 0x99, 0xdf, 0x2a, 0xea, 0x48, 0x0a, 0xda, 0x13, 0xf2, 0x0d, 0x58, 0x79, 0x41, 0xc9, 0xb3, ++ 0x34, 0xb5, 0x2a, 0xa8, 0x75, 0x0e, 0xa7, 0x88, 0x7b, 0x50, 0x1b, 0xd1, 0x20, 0x20, 0x43, 0x6a, ++ 0x84, 0xe7, 0x1e, 0x55, 0x0b, 0x62, 0xf5, 0x9b, 0x33, 0xab, 0x9f, 0x5e, 0x79, 0x35, 0xd2, 0x3a, ++ 0x3e, 0xf7, 0x28, 0x6e, 0x41, 0x85, 0xb2, 0xf1, 0x48, 0x5a, 0x28, 0x2e, 0x88, 0x9f, 0xc6, 0xc6, ++ 0xa3, 0x69, 0x2b, 0x65, 0xae, 0x16, 0x99, 0x58, 0x0a, 0xa8, 0xff, 0xdc, 0x36, 0xa9, 0x5a, 0x12, ++ 0x06, 0x6e, 0xcc, 0x18, 0xe8, 0x4b, 0xf9, 0xb4, 0x8d, 0x58, 0x0f, 0xef, 0x41, 0x85, 0xbe, 0x0c, ++ 0x29, 0x0b, 0x6c, 0x97, 0xa9, 0x4b, 0xc2, 0xc8, 0xf5, 0x39, 0xbb, 0x48, 0x1d, 0x6b, 0xda, 0xc4, ++ 0x44, 0x0f, 0x3f, 0x80, 0x25, 0xd7, 0x0b, 0x6d, 0x97, 0x05, 0x6a, 0x79, 0x53, 0xd9, 0xaa, 0x6e, ++ 0xbf, 0x33, 0x37, 0x11, 0xba, 0x92, 0xa3, 0xc7, 0x64, 0xdc, 0x01, 0x14, 0xb8, 0x63, 0xdf, 0xa4, ++ 0x86, 0xe9, 0x5a, 0xd4, 0xb0, 0xd9, 0xc0, 0x55, 0x2b, 0xc2, 0xc0, 0x95, 0xd9, 0x85, 0x08, 0xe2, ++ 0x9e, 0x6b, 0xd1, 0x0e, 0x1b, 0xb8, 0x7a, 0x3d, 0xc8, 0x8c, 0xf1, 0x25, 0x28, 0x05, 0xe7, 0x2c, ++ 0x24, 0x2f, 0xd5, 0x9a, 0xc8, 0x90, 0x68, 0xd4, 0xf8, 0x4f, 0x11, 0x56, 0x2e, 0x92, 0x62, 0x9f, ++ 0x40, 0x71, 0xc0, 0x57, 0xa9, 0xe6, 0xfe, 0x97, 0x18, 0x48, 0x9d, 0x6c, 0x10, 0x4b, 0xdf, 0x32, ++ 0x88, 0x2d, 0xa8, 0x32, 0x1a, 0x84, 0xd4, 0x92, 0x19, 0x91, 0xbf, 0x60, 0x4e, 0x81, 0x54, 0x9a, ++ 0x4d, 0xa9, 0xc2, 0xb7, 0x4a, 0xa9, 0x27, 0xb0, 0x92, 0xb8, 0x64, 0xf8, 0x84, 0x0d, 0xe3, 0xdc, ++ 0xbc, 0xf3, 0x3a, 0x4f, 0x9a, 0x5a, 0xac, 0xa7, 0x73, 0x35, 0xbd, 0x4e, 0x33, 0x63, 0xdc, 0x06, ++ 0x70, 0x19, 0x75, 0x07, 0x86, 0x45, 0x4d, 0x47, 0x2d, 0x2f, 0x88, 0x52, 0x97, 0x53, 0x66, 0xa2, ++ 0xe4, 0x4a, 0xd4, 0x74, 0xf0, 0xc7, 0x93, 0x54, 0x5b, 0x5a, 0x90, 0x29, 0x87, 0xf2, 0x90, 0xcd, ++ 0x64, 0xdb, 0x09, 0xd4, 0x7d, 0xca, 0xf3, 0x9e, 0x5a, 0xd1, 0xca, 0x2a, 0xc2, 0x89, 0xe6, 0x6b, ++ 0x57, 0xa6, 0x47, 0x6a, 0x72, 0x61, 0xcb, 0x7e, 0x7a, 0x88, 0xdf, 0x87, 0x04, 0x30, 0x44, 0x5a, ++ 0x81, 0xa8, 0x42, 0xb5, 0x18, 0x3c, 0x22, 0x23, 0xba, 0xf1, 0x10, 0xea, 0xd9, 0xf0, 0xe0, 0x75, ++ 0x28, 0x06, 0x21, 0xf1, 0x43, 0x91, 0x85, 0x45, 0x5d, 0x0e, 0x30, 0x82, 0x3c, 0x65, 0x96, 0xa8, ++ 0x72, 0x45, 0x9d, 0xff, 0xdc, 0xf8, 0x08, 0x96, 0x33, 0xd3, 0x5f, 0x54, 0xb1, 0xf1, 0xdb, 0x12, ++ 0xac, 0xcf, 0xcb, 0xb9, 0xb9, 0xe9, 0x7f, 0x09, 0x4a, 0x6c, 0x3c, 0x3a, 0xa5, 0xbe, 0x9a, 0x17, ++ 0x16, 0xa2, 0x11, 0x6e, 0x41, 0xd1, 0x21, 0xa7, 0xd4, 0x51, 0x0b, 0x9b, 0xca, 0x56, 0x7d, 0xfb, ++ 0xf6, 0x85, 0xb2, 0xba, 0x79, 0xc0, 0x55, 0x74, 0xa9, 0x89, 0x3f, 0x85, 0x42, 0x54, 0xe2, 0xb8, ++ 0x85, 0x5b, 0x17, 0xb3, 0xc0, 0x73, 0x51, 0x17, 0x7a, 0xf8, 0x6d, 0xa8, 0xf0, 0xbf, 0x32, 0xb6, ++ 0x25, 0xe1, 0x73, 0x99, 0x03, 0x3c, 0xae, 0x78, 0x03, 0xca, 0x22, 0xcd, 0x2c, 0x1a, 0x5f, 0x0d, ++ 0xc9, 0x98, 0x6f, 0x8c, 0x45, 0x07, 0x64, 0xec, 0x84, 0xc6, 0x73, 0xe2, 0x8c, 0xa9, 0x48, 0x98, ++ 0x8a, 0x5e, 0x8b, 0xc0, 0x9f, 0x73, 0x0c, 0x5f, 0x81, 0xaa, 0xcc, 0x4a, 0x9b, 0x59, 0xf4, 0xa5, ++ 0xa8, 0x3e, 0x45, 0x5d, 0x26, 0x6a, 0x87, 0x23, 0x7c, 0xfa, 0xa7, 0x81, 0xcb, 0xe2, 0xad, 0x15, ++ 0x53, 0x70, 0x40, 0x4c, 0xff, 0xd1, 0x74, 0xe1, 0x7b, 0x77, 0xfe, 0xf2, 0xa6, 0x73, 0xb1, 0xf1, ++ 0xe7, 0x1c, 0x14, 0xc4, 0x79, 0x5b, 0x81, 0xea, 0xf1, 0xe7, 0x3d, 0xcd, 0x68, 0x77, 0x4f, 0x76, ++ 0x0f, 0x34, 0xa4, 0xe0, 0x3a, 0x80, 0x00, 0x1e, 0x1d, 0x74, 0x5b, 0xc7, 0x28, 0x97, 0x8c, 0x3b, ++ 0x47, 0xc7, 0x0f, 0xee, 0xa1, 0x7c, 0xa2, 0x70, 0x22, 0x81, 0x42, 0x9a, 0x70, 0x77, 0x1b, 0x15, ++ 0x31, 0x82, 0x9a, 0x34, 0xd0, 0x79, 0xa2, 0xb5, 0x1f, 0xdc, 0x43, 0xa5, 0x2c, 0x72, 0x77, 0x1b, ++ 0x2d, 0xe1, 0x65, 0xa8, 0x08, 0x64, 0xb7, 0xdb, 0x3d, 0x40, 0xe5, 0xc4, 0x66, 0xff, 0x58, 0xef, ++ 0x1c, 0xed, 0xa3, 0x4a, 0x62, 0x73, 0x5f, 0xef, 0x9e, 0xf4, 0x10, 0x24, 0x16, 0x0e, 0xb5, 0x7e, ++ 0xbf, 0xb5, 0xaf, 0xa1, 0x6a, 0xc2, 0xd8, 0xfd, 0xfc, 0x58, 0xeb, 0xa3, 0x5a, 0xc6, 0xad, 0xbb, ++ 0xdb, 0x68, 0x39, 0x99, 0x42, 0x3b, 0x3a, 0x39, 0x44, 0x75, 0xbc, 0x0a, 0xcb, 0x72, 0x8a, 0xd8, ++ 0x89, 0x95, 0x29, 0xe8, 0xc1, 0x3d, 0x84, 0x26, 0x8e, 0x48, 0x2b, 0xab, 0x19, 0xe0, 0xc1, 0x3d, ++ 0x84, 0x1b, 0x7b, 0x50, 0x14, 0xd9, 0x85, 0x31, 0xd4, 0x0f, 0x5a, 0xbb, 0xda, 0x81, 0xd1, 0xed, ++ 0x1d, 0x77, 0xba, 0x47, 0xad, 0x03, 0xa4, 0x4c, 0x30, 0x5d, 0xfb, 0xd9, 0x49, 0x47, 0xd7, 0xda, ++ 0x28, 0x97, 0xc6, 0x7a, 0x5a, 0xeb, 0x58, 0x6b, 0xa3, 0x7c, 0xc3, 0x84, 0xf5, 0x79, 0x75, 0x66, ++ 0xee, 0xc9, 0x48, 0x6d, 0x71, 0x6e, 0xc1, 0x16, 0x0b, 0x5b, 0x33, 0x5b, 0xfc, 0x95, 0x02, 0x6b, ++ 0x73, 0x6a, 0xed, 0xdc, 0x49, 0x7e, 0x0a, 0x45, 0x99, 0xa2, 0xf2, 0xf6, 0xb9, 0x39, 0xb7, 0x68, ++ 0x8b, 0x84, 0x9d, 0xb9, 0x81, 0x84, 0x5e, 0xfa, 0x06, 0xce, 0x2f, 0xb8, 0x81, 0xb9, 0x89, 0x19, ++ 0x27, 0x7f, 0xa5, 0x80, 0xba, 0xc8, 0xf6, 0x6b, 0x0a, 0x45, 0x2e, 0x53, 0x28, 0x3e, 0x99, 0x76, ++ 0xe0, 0xea, 0xe2, 0x35, 0xcc, 0x78, 0xf1, 0xb5, 0x02, 0x97, 0xe6, 0x37, 0x2a, 0x73, 0x7d, 0xf8, ++ 0x14, 0x4a, 0x23, 0x1a, 0x9e, 0xb9, 0xf1, 0x65, 0xfd, 0xc1, 0x9c, 0x2b, 0x80, 0x8b, 0xa7, 0x63, ++ 0x15, 0x69, 0xa5, 0xef, 0x90, 0xfc, 0xa2, 0x6e, 0x43, 0x7a, 0x33, 0xe3, 0xe9, 0xaf, 0x73, 0xf0, ++ 0xe6, 0x5c, 0xe3, 0x73, 0x1d, 0x7d, 0x17, 0xc0, 0x66, 0xde, 0x38, 0x94, 0x17, 0xb2, 0xac, 0x4f, ++ 0x15, 0x81, 0x88, 0xb3, 0xcf, 0x6b, 0xcf, 0x38, 0x4c, 0xe4, 0x79, 0x21, 0x07, 0x09, 0x09, 0xc2, ++ 0xc3, 0x89, 0xa3, 0x05, 0xe1, 0xe8, 0x7b, 0x0b, 0x56, 0x3a, 0x73, 0xd7, 0x7d, 0x08, 0xc8, 0x74, ++ 0x6c, 0xca, 0x42, 0x23, 0x08, 0x7d, 0x4a, 0x46, 0x36, 0x1b, 0x8a, 0x02, 0x5c, 0xde, 0x29, 0x0e, ++ 0x88, 0x13, 0x50, 0x7d, 0x45, 0x8a, 0xfb, 0xb1, 0x94, 0x6b, 0x88, 0x5b, 0xc6, 0x4f, 0x69, 0x94, ++ 0x32, 0x1a, 0x52, 0x9c, 0x68, 0x34, 0x7e, 0xb3, 0x04, 0xd5, 0x54, 0x5b, 0x87, 0xaf, 0x42, 0xed, ++ 0x29, 0x79, 0x4e, 0x8c, 0xb8, 0x55, 0x97, 0x91, 0xa8, 0x72, 0xac, 0x17, 0xb5, 0xeb, 0x1f, 0xc2, ++ 0xba, 0xa0, 0xb8, 0xe3, 0x90, 0xfa, 0x86, 0xe9, 0x90, 0x20, 0x10, 0x41, 0x2b, 0x0b, 0x2a, 0xe6, ++ 0xb2, 0x2e, 0x17, 0xed, 0xc5, 0x12, 0x7c, 0x1f, 0xd6, 0x84, 0xc6, 0x68, 0xec, 0x84, 0xb6, 0xe7, ++ 0x50, 0x83, 0x7f, 0x3c, 0x04, 0xa2, 0x10, 0x27, 0x9e, 0xad, 0x72, 0xc6, 0x61, 0x44, 0xe0, 0x1e, ++ 0x05, 0xb8, 0x0d, 0xef, 0x0a, 0xb5, 0x21, 0x65, 0xd4, 0x27, 0x21, 0x35, 0xe8, 0x2f, 0xc7, 0xc4, ++ 0x09, 0x0c, 0xc2, 0x2c, 0xe3, 0x8c, 0x04, 0x67, 0xea, 0x3a, 0x37, 0xb0, 0x9b, 0x53, 0x15, 0xfd, ++ 0x32, 0x27, 0xee, 0x47, 0x3c, 0x4d, 0xd0, 0x5a, 0xcc, 0xfa, 0x8c, 0x04, 0x67, 0x78, 0x07, 0x2e, ++ 0x09, 0x2b, 0x41, 0xe8, 0xdb, 0x6c, 0x68, 0x98, 0x67, 0xd4, 0x7c, 0x66, 0x8c, 0xc3, 0xc1, 0x43, ++ 0xf5, 0xed, 0xf4, 0xfc, 0xc2, 0xc3, 0xbe, 0xe0, 0xec, 0x71, 0xca, 0x49, 0x38, 0x78, 0x88, 0xfb, ++ 0x50, 0xe3, 0x9b, 0x31, 0xb2, 0xbf, 0xa4, 0xc6, 0xc0, 0xf5, 0xc5, 0xcd, 0x52, 0x9f, 0x73, 0xb2, ++ 0x53, 0x11, 0x6c, 0x76, 0x23, 0x85, 0x43, 0xd7, 0xa2, 0x3b, 0xc5, 0x7e, 0x4f, 0xd3, 0xda, 0x7a, ++ 0x35, 0xb6, 0xf2, 0xc8, 0xf5, 0x79, 0x42, 0x0d, 0xdd, 0x24, 0xc0, 0x55, 0x99, 0x50, 0x43, 0x37, ++ 0x0e, 0xef, 0x7d, 0x58, 0x33, 0x4d, 0xb9, 0x66, 0xdb, 0x34, 0xa2, 0x16, 0x3f, 0x50, 0x51, 0x26, ++ 0x58, 0xa6, 0xb9, 0x2f, 0x09, 0x51, 0x8e, 0x07, 0xf8, 0x63, 0x78, 0x73, 0x12, 0xac, 0xb4, 0xe2, ++ 0xea, 0xcc, 0x2a, 0xa7, 0x55, 0xef, 0xc3, 0x9a, 0x77, 0x3e, 0xab, 0x88, 0x33, 0x33, 0x7a, 0xe7, ++ 0xd3, 0x6a, 0xd7, 0xc5, 0x67, 0x9b, 0x4f, 0x4d, 0x12, 0x52, 0x4b, 0x7d, 0x2b, 0xcd, 0x4e, 0x09, ++ 0xf0, 0x1d, 0x40, 0xa6, 0x69, 0x50, 0x46, 0x4e, 0x1d, 0x6a, 0x10, 0x9f, 0x32, 0x12, 0xa8, 0x57, ++ 0xd2, 0xe4, 0xba, 0x69, 0x6a, 0x42, 0xda, 0x12, 0x42, 0x7c, 0x0b, 0x56, 0xdd, 0xd3, 0xa7, 0xa6, ++ 0xcc, 0x2c, 0xc3, 0xf3, 0xe9, 0xc0, 0x7e, 0xa9, 0x5e, 0x13, 0x61, 0x5a, 0xe1, 0x02, 0x91, 0x57, ++ 0x3d, 0x01, 0xe3, 0x9b, 0x80, 0xcc, 0xe0, 0x8c, 0xf8, 0x9e, 0xb8, 0xda, 0x03, 0x8f, 0x98, 0x54, ++ 0xbd, 0x2e, 0xa9, 0x12, 0x3f, 0x8a, 0x61, 0xfc, 0x04, 0xd6, 0xc7, 0xcc, 0x66, 0x21, 0xf5, 0x3d, ++ 0x9f, 0xf2, 0x0e, 0x5d, 0x1e, 0x33, 0xf5, 0x5f, 0x4b, 0x0b, 0x7a, 0xec, 0x93, 0x34, 0x5b, 0xee, ++ 0xae, 0xbe, 0x36, 0x9e, 0x05, 0x1b, 0x3b, 0x50, 0x4b, 0x6f, 0x3a, 0xae, 0x80, 0xdc, 0x76, 0xa4, ++ 0xf0, 0x0b, 0x74, 0xaf, 0xdb, 0xe6, 0x57, 0xdf, 0x17, 0x1a, 0xca, 0xf1, 0x2b, 0xf8, 0xa0, 0x73, ++ 0xac, 0x19, 0xfa, 0xc9, 0xd1, 0x71, 0xe7, 0x50, 0x43, 0xf9, 0x5b, 0x95, 0xf2, 0xbf, 0x97, 0xd0, ++ 0xab, 0x57, 0xaf, 0x5e, 0xe5, 0x1e, 0x17, 0xca, 0x1f, 0xa0, 0x1b, 0x8d, 0xbf, 0xe6, 0xa0, 0x9e, ++ 0x6d, 0x7e, 0xf1, 0x4f, 0xe0, 0xad, 0xf8, 0x4b, 0x35, 0xa0, 0xa1, 0xf1, 0xc2, 0xf6, 0x45, 0x36, ++ 0x8e, 0x88, 0x6c, 0x1f, 0x93, 0x40, 0xae, 0x47, 0xac, 0x3e, 0x0d, 0x7f, 0x61, 0xfb, 0x3c, 0xd7, ++ 0x46, 0x24, 0xc4, 0x07, 0x70, 0x85, 0xb9, 0x46, 0x10, 0x12, 0x66, 0x11, 0xdf, 0x32, 0x26, 0x6f, ++ 0x04, 0x06, 0x31, 0x4d, 0x1a, 0x04, 0xae, 0xbc, 0x05, 0x12, 0x2b, 0xef, 0x30, 0xb7, 0x1f, 0x91, ++ 0x27, 0xe5, 0xb1, 0x15, 0x51, 0xa7, 0x36, 0x3d, 0xbf, 0x68, 0xd3, 0xdf, 0x86, 0xca, 0x88, 0x78, ++ 0x06, 0x65, 0xa1, 0x7f, 0x2e, 0x5a, 0xb6, 0xb2, 0x5e, 0x1e, 0x11, 0x4f, 0xe3, 0xe3, 0xef, 0x6e, ++ 0x27, 0xb2, 0xd1, 0x2c, 0xa3, 0x4a, 0xe3, 0x1f, 0x79, 0xa8, 0xa5, 0x9b, 0x37, 0xde, 0x0b, 0x9b, ++ 0xa2, 0x50, 0x2b, 0xe2, 0x28, 0xbf, 0xff, 0x8d, 0xad, 0x5e, 0x73, 0x8f, 0x57, 0xf0, 0x9d, 0x92, ++ 0x6c, 0xa9, 0x74, 0xa9, 0xc9, 0x6f, 0x4f, 0x7e, 0x78, 0xa9, 0x6c, 0xd4, 0xcb, 0x7a, 0x34, 0xc2, ++ 0xfb, 0x50, 0x7a, 0x1a, 0x08, 0xdb, 0x25, 0x61, 0xfb, 0xda, 0x37, 0xdb, 0x7e, 0xdc, 0x17, 0xc6, ++ 0x2b, 0x8f, 0xfb, 0xc6, 0x51, 0x57, 0x3f, 0x6c, 0x1d, 0xe8, 0x91, 0x3a, 0xbe, 0x0c, 0x05, 0x87, ++ 0x7c, 0x79, 0x9e, 0xad, 0xf5, 0x02, 0xba, 0x68, 0xf8, 0x2f, 0x43, 0xe1, 0x05, 0x25, 0xcf, 0xb2, ++ 0x15, 0x56, 0x40, 0xdf, 0xe1, 0x31, 0xb8, 0x03, 0x45, 0x11, 0x2f, 0x0c, 0x10, 0x45, 0x0c, 0xbd, ++ 0x81, 0xcb, 0x50, 0xd8, 0xeb, 0xea, 0xfc, 0x28, 0x20, 0xa8, 0x49, 0xd4, 0xe8, 0x75, 0xb4, 0x3d, ++ 0x0d, 0xe5, 0x1a, 0xf7, 0xa1, 0x24, 0x83, 0xc0, 0x8f, 0x49, 0x12, 0x06, 0xf4, 0x46, 0x34, 0x8c, ++ 0x6c, 0x28, 0xb1, 0xf4, 0xe4, 0x70, 0x57, 0xd3, 0x51, 0x2e, 0xbb, 0xc9, 0x05, 0x54, 0x6c, 0x04, ++ 0x50, 0x4b, 0x77, 0x6f, 0xdf, 0x4b, 0x7e, 0x35, 0xfe, 0xa2, 0x40, 0x35, 0xd5, 0x8d, 0xf1, 0x3e, ++ 0x80, 0x38, 0x8e, 0xfb, 0xc2, 0x20, 0x8e, 0x4d, 0x82, 0x28, 0x35, 0x40, 0x40, 0x2d, 0x8e, 0x5c, ++ 0x74, 0xeb, 0xbe, 0x17, 0xe7, 0xff, 0xa8, 0x00, 0x9a, 0xee, 0xe4, 0xa6, 0x1c, 0x54, 0x7e, 0x50, ++ 0x07, 0xff, 0xa0, 0x40, 0x3d, 0xdb, 0xbe, 0x4d, 0xb9, 0x77, 0xf5, 0x07, 0x75, 0xef, 0xf7, 0x0a, ++ 0x2c, 0x67, 0x9a, 0xb6, 0xff, 0x2b, 0xef, 0x7e, 0x97, 0x87, 0xb5, 0x39, 0x7a, 0xb8, 0x15, 0x75, ++ 0xb7, 0xb2, 0xe1, 0xfe, 0xf1, 0x45, 0xe6, 0x6a, 0xf2, 0xfb, 0xb3, 0x47, 0xfc, 0x30, 0x6a, 0x86, ++ 0x6f, 0x02, 0xb2, 0x2d, 0xca, 0x42, 0x7b, 0x60, 0x53, 0x3f, 0xfa, 0x22, 0x97, 0x2d, 0xef, 0xca, ++ 0x04, 0x97, 0x1f, 0xe5, 0x3f, 0x02, 0xec, 0xb9, 0x81, 0x1d, 0xda, 0xcf, 0xa9, 0x61, 0xb3, 0xf8, ++ 0xf3, 0x9d, 0xb7, 0xc0, 0x05, 0x1d, 0xc5, 0x92, 0x0e, 0x0b, 0x13, 0x36, 0xa3, 0x43, 0x32, 0xc5, ++ 0xe6, 0x15, 0x30, 0xaf, 0xa3, 0x58, 0x92, 0xb0, 0xaf, 0x42, 0xcd, 0x72, 0xc7, 0xbc, 0xa1, 0x90, ++ 0x3c, 0x5e, 0x70, 0x15, 0xbd, 0x2a, 0xb1, 0x84, 0x12, 0x75, 0x7c, 0x93, 0x77, 0x83, 0x9a, 0x5e, ++ 0x95, 0x98, 0xa4, 0xdc, 0x80, 0x15, 0x32, 0x1c, 0xfa, 0xdc, 0x78, 0x6c, 0x48, 0xf6, 0xb0, 0xf5, ++ 0x04, 0x16, 0xc4, 0x8d, 0xc7, 0x50, 0x8e, 0xe3, 0xc0, 0x6f, 0x36, 0x1e, 0x09, 0xc3, 0x93, 0xaf, ++ 0x37, 0xb9, 0xad, 0x8a, 0x5e, 0x66, 0xb1, 0xf0, 0x2a, 0xd4, 0xec, 0xc0, 0x98, 0x3c, 0x23, 0xe6, ++ 0x36, 0x73, 0x5b, 0x65, 0xbd, 0x6a, 0x07, 0xc9, 0xbb, 0x51, 0xe3, 0xeb, 0x1c, 0xd4, 0xb3, 0xcf, ++ 0xa0, 0xb8, 0x0d, 0x65, 0xc7, 0x35, 0x89, 0x48, 0x04, 0xf9, 0x06, 0xbf, 0xf5, 0x9a, 0x97, 0xd3, ++ 0xe6, 0x41, 0xc4, 0xd7, 0x13, 0xcd, 0x8d, 0xbf, 0x29, 0x50, 0x8e, 0x61, 0x7c, 0x09, 0x0a, 0x1e, ++ 0x09, 0xcf, 0x84, 0xb9, 0xe2, 0x6e, 0x0e, 0x29, 0xba, 0x18, 0x73, 0x3c, 0xf0, 0x08, 0x13, 0x29, ++ 0x10, 0xe1, 0x7c, 0xcc, 0xf7, 0xd5, 0xa1, 0xc4, 0x12, 0x0d, 0xb2, 0x3b, 0x1a, 0x51, 0x16, 0x06, ++ 0xf1, 0xbe, 0x46, 0xf8, 0x5e, 0x04, 0xe3, 0xdb, 0xb0, 0x1a, 0xfa, 0xc4, 0x76, 0x32, 0xdc, 0x82, ++ 0xe0, 0xa2, 0x58, 0x90, 0x90, 0x77, 0xe0, 0x72, 0x6c, 0xd7, 0xa2, 0x21, 0x31, 0xcf, 0xa8, 0x35, ++ 0x51, 0x2a, 0x89, 0x37, 0xb6, 0xb7, 0x22, 0x42, 0x3b, 0x92, 0xc7, 0xba, 0x8d, 0xbf, 0x2b, 0xb0, ++ 0x1a, 0xb7, 0xf4, 0x56, 0x12, 0xac, 0x43, 0x00, 0xc2, 0x98, 0x1b, 0xa6, 0xc3, 0x35, 0x9b, 0xca, ++ 0x33, 0x7a, 0xcd, 0x56, 0xa2, 0xa4, 0xa7, 0x0c, 0x6c, 0x8c, 0x00, 0x26, 0x92, 0x85, 0x61, 0xbb, ++ 0x02, 0xd5, 0xe8, 0x8d, 0x5b, 0xfc, 0xa3, 0x44, 0x7e, 0x04, 0x82, 0x84, 0x78, 0xef, 0x8f, 0xd7, ++ 0xa1, 0x78, 0x4a, 0x87, 0x36, 0x8b, 0x5e, 0xde, 0xe4, 0x20, 0x7e, 0xcf, 0x2b, 0x24, 0xef, 0x79, ++ 0xbb, 0x4f, 0x60, 0xcd, 0x74, 0x47, 0xd3, 0xee, 0xee, 0xa2, 0xa9, 0x0f, 0xd1, 0xe0, 0x33, 0xe5, ++ 0x0b, 0x98, 0x74, 0x6a, 0x5f, 0xe5, 0xf2, 0xfb, 0xbd, 0xdd, 0x3f, 0xe5, 0x36, 0xf6, 0xa5, 0x5e, ++ 0x2f, 0x5e, 0xa6, 0x4e, 0x07, 0x0e, 0x35, 0xb9, 0xeb, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x5f, ++ 0x1c, 0x48, 0x4f, 0x0d, 0x1a, 0x00, 0x00, ++} +diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/generator/generator.go b/vendor/github.com/golang/protobuf/protoc-gen-go/generator/generator.go +new file mode 100644 +index 0000000..a5879fe +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/protoc-gen-go/generator/generator.go +@@ -0,0 +1,2806 @@ ++// Go support for Protocol Buffers - Google's data interchange format ++// ++// Copyright 2010 The Go Authors. All rights reserved. ++// https://github.com/golang/protobuf ++// ++// Redistribution and use in source and binary forms, with or without ++// modification, are permitted provided that the following conditions are ++// met: ++// ++// * Redistributions of source code must retain the above copyright ++// notice, this list of conditions and the following disclaimer. ++// * Redistributions in binary form must reproduce the above ++// copyright notice, this list of conditions and the following disclaimer ++// in the documentation and/or other materials provided with the ++// distribution. ++// * Neither the name of Google Inc. nor the names of its ++// contributors may be used to endorse or promote products derived from ++// this software without specific prior written permission. ++// ++// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++/* ++ The code generator for the plugin for the Google protocol buffer compiler. ++ It generates Go code from the protocol buffer description files read by the ++ main routine. ++*/ ++package generator ++ ++import ( ++ "bufio" ++ "bytes" ++ "compress/gzip" ++ "fmt" ++ "go/parser" ++ "go/printer" ++ "go/token" ++ "log" ++ "os" ++ "path" ++ "strconv" ++ "strings" ++ "unicode" ++ "unicode/utf8" ++ ++ "github.com/golang/protobuf/proto" ++ ++ "github.com/golang/protobuf/protoc-gen-go/descriptor" ++ plugin "github.com/golang/protobuf/protoc-gen-go/plugin" ++) ++ ++// generatedCodeVersion indicates a version of the generated code. ++// It is incremented whenever an incompatibility between the generated code and ++// proto package is introduced; the generated code references ++// a constant, proto.ProtoPackageIsVersionN (where N is generatedCodeVersion). ++const generatedCodeVersion = 2 ++ ++// A Plugin provides functionality to add to the output during Go code generation, ++// such as to produce RPC stubs. ++type Plugin interface { ++ // Name identifies the plugin. ++ Name() string ++ // Init is called once after data structures are built but before ++ // code generation begins. ++ Init(g *Generator) ++ // Generate produces the code generated by the plugin for this file, ++ // except for the imports, by calling the generator's methods P, In, and Out. ++ Generate(file *FileDescriptor) ++ // GenerateImports produces the import declarations for this file. ++ // It is called after Generate. ++ GenerateImports(file *FileDescriptor) ++} ++ ++var plugins []Plugin ++ ++// RegisterPlugin installs a (second-order) plugin to be run when the Go output is generated. ++// It is typically called during initialization. ++func RegisterPlugin(p Plugin) { ++ plugins = append(plugins, p) ++} ++ ++// Each type we import as a protocol buffer (other than FileDescriptorProto) needs ++// a pointer to the FileDescriptorProto that represents it. These types achieve that ++// wrapping by placing each Proto inside a struct with the pointer to its File. The ++// structs have the same names as their contents, with "Proto" removed. ++// FileDescriptor is used to store the things that it points to. ++ ++// The file and package name method are common to messages and enums. ++type common struct { ++ file *descriptor.FileDescriptorProto // File this object comes from. ++} ++ ++// PackageName is name in the package clause in the generated file. ++func (c *common) PackageName() string { return uniquePackageOf(c.file) } ++ ++func (c *common) File() *descriptor.FileDescriptorProto { return c.file } ++ ++func fileIsProto3(file *descriptor.FileDescriptorProto) bool { ++ return file.GetSyntax() == "proto3" ++} ++ ++func (c *common) proto3() bool { return fileIsProto3(c.file) } ++ ++// Descriptor represents a protocol buffer message. ++type Descriptor struct { ++ common ++ *descriptor.DescriptorProto ++ parent *Descriptor // The containing message, if any. ++ nested []*Descriptor // Inner messages, if any. ++ enums []*EnumDescriptor // Inner enums, if any. ++ ext []*ExtensionDescriptor // Extensions, if any. ++ typename []string // Cached typename vector. ++ index int // The index into the container, whether the file or another message. ++ path string // The SourceCodeInfo path as comma-separated integers. ++ group bool ++} ++ ++// TypeName returns the elements of the dotted type name. ++// The package name is not part of this name. ++func (d *Descriptor) TypeName() []string { ++ if d.typename != nil { ++ return d.typename ++ } ++ n := 0 ++ for parent := d; parent != nil; parent = parent.parent { ++ n++ ++ } ++ s := make([]string, n, n) ++ for parent := d; parent != nil; parent = parent.parent { ++ n-- ++ s[n] = parent.GetName() ++ } ++ d.typename = s ++ return s ++} ++ ++// EnumDescriptor describes an enum. If it's at top level, its parent will be nil. ++// Otherwise it will be the descriptor of the message in which it is defined. ++type EnumDescriptor struct { ++ common ++ *descriptor.EnumDescriptorProto ++ parent *Descriptor // The containing message, if any. ++ typename []string // Cached typename vector. ++ index int // The index into the container, whether the file or a message. ++ path string // The SourceCodeInfo path as comma-separated integers. ++} ++ ++// TypeName returns the elements of the dotted type name. ++// The package name is not part of this name. ++func (e *EnumDescriptor) TypeName() (s []string) { ++ if e.typename != nil { ++ return e.typename ++ } ++ name := e.GetName() ++ if e.parent == nil { ++ s = make([]string, 1) ++ } else { ++ pname := e.parent.TypeName() ++ s = make([]string, len(pname)+1) ++ copy(s, pname) ++ } ++ s[len(s)-1] = name ++ e.typename = s ++ return s ++} ++ ++// Everything but the last element of the full type name, CamelCased. ++// The values of type Foo.Bar are call Foo_value1... not Foo_Bar_value1... . ++func (e *EnumDescriptor) prefix() string { ++ if e.parent == nil { ++ // If the enum is not part of a message, the prefix is just the type name. ++ return CamelCase(*e.Name) + "_" ++ } ++ typeName := e.TypeName() ++ return CamelCaseSlice(typeName[0:len(typeName)-1]) + "_" ++} ++ ++// The integer value of the named constant in this enumerated type. ++func (e *EnumDescriptor) integerValueAsString(name string) string { ++ for _, c := range e.Value { ++ if c.GetName() == name { ++ return fmt.Sprint(c.GetNumber()) ++ } ++ } ++ log.Fatal("cannot find value for enum constant") ++ return "" ++} ++ ++// ExtensionDescriptor describes an extension. If it's at top level, its parent will be nil. ++// Otherwise it will be the descriptor of the message in which it is defined. ++type ExtensionDescriptor struct { ++ common ++ *descriptor.FieldDescriptorProto ++ parent *Descriptor // The containing message, if any. ++} ++ ++// TypeName returns the elements of the dotted type name. ++// The package name is not part of this name. ++func (e *ExtensionDescriptor) TypeName() (s []string) { ++ name := e.GetName() ++ if e.parent == nil { ++ // top-level extension ++ s = make([]string, 1) ++ } else { ++ pname := e.parent.TypeName() ++ s = make([]string, len(pname)+1) ++ copy(s, pname) ++ } ++ s[len(s)-1] = name ++ return s ++} ++ ++// DescName returns the variable name used for the generated descriptor. ++func (e *ExtensionDescriptor) DescName() string { ++ // The full type name. ++ typeName := e.TypeName() ++ // Each scope of the extension is individually CamelCased, and all are joined with "_" with an "E_" prefix. ++ for i, s := range typeName { ++ typeName[i] = CamelCase(s) ++ } ++ return "E_" + strings.Join(typeName, "_") ++} ++ ++// ImportedDescriptor describes a type that has been publicly imported from another file. ++type ImportedDescriptor struct { ++ common ++ o Object ++} ++ ++func (id *ImportedDescriptor) TypeName() []string { return id.o.TypeName() } ++ ++// FileDescriptor describes an protocol buffer descriptor file (.proto). ++// It includes slices of all the messages and enums defined within it. ++// Those slices are constructed by WrapTypes. ++type FileDescriptor struct { ++ *descriptor.FileDescriptorProto ++ desc []*Descriptor // All the messages defined in this file. ++ enum []*EnumDescriptor // All the enums defined in this file. ++ ext []*ExtensionDescriptor // All the top-level extensions defined in this file. ++ imp []*ImportedDescriptor // All types defined in files publicly imported by this file. ++ ++ // Comments, stored as a map of path (comma-separated integers) to the comment. ++ comments map[string]*descriptor.SourceCodeInfo_Location ++ ++ // The full list of symbols that are exported, ++ // as a map from the exported object to its symbols. ++ // This is used for supporting public imports. ++ exported map[Object][]symbol ++ ++ index int // The index of this file in the list of files to generate code for ++ ++ proto3 bool // whether to generate proto3 code for this file ++} ++ ++// PackageName is the package name we'll use in the generated code to refer to this file. ++func (d *FileDescriptor) PackageName() string { return uniquePackageOf(d.FileDescriptorProto) } ++ ++// VarName is the variable name we'll use in the generated code to refer ++// to the compressed bytes of this descriptor. It is not exported, so ++// it is only valid inside the generated package. ++func (d *FileDescriptor) VarName() string { return fmt.Sprintf("fileDescriptor%d", d.index) } ++ ++// goPackageOption interprets the file's go_package option. ++// If there is no go_package, it returns ("", "", false). ++// If there's a simple name, it returns ("", pkg, true). ++// If the option implies an import path, it returns (impPath, pkg, true). ++func (d *FileDescriptor) goPackageOption() (impPath, pkg string, ok bool) { ++ pkg = d.GetOptions().GetGoPackage() ++ if pkg == "" { ++ return ++ } ++ ok = true ++ // The presence of a slash implies there's an import path. ++ slash := strings.LastIndex(pkg, "/") ++ if slash < 0 { ++ return ++ } ++ impPath, pkg = pkg, pkg[slash+1:] ++ // A semicolon-delimited suffix overrides the package name. ++ sc := strings.IndexByte(impPath, ';') ++ if sc < 0 { ++ return ++ } ++ impPath, pkg = impPath[:sc], impPath[sc+1:] ++ return ++} ++ ++// goPackageName returns the Go package name to use in the ++// generated Go file. The result explicit reports whether the name ++// came from an option go_package statement. If explicit is false, ++// the name was derived from the protocol buffer's package statement ++// or the input file name. ++func (d *FileDescriptor) goPackageName() (name string, explicit bool) { ++ // Does the file have a "go_package" option? ++ if _, pkg, ok := d.goPackageOption(); ok { ++ return pkg, true ++ } ++ ++ // Does the file have a package clause? ++ if pkg := d.GetPackage(); pkg != "" { ++ return pkg, false ++ } ++ // Use the file base name. ++ return baseName(d.GetName()), false ++} ++ ++// goFileName returns the output name for the generated Go file. ++func (d *FileDescriptor) goFileName() string { ++ name := *d.Name ++ if ext := path.Ext(name); ext == ".proto" || ext == ".protodevel" { ++ name = name[:len(name)-len(ext)] ++ } ++ name += ".pb.go" ++ ++ // Does the file have a "go_package" option? ++ // If it does, it may override the filename. ++ if impPath, _, ok := d.goPackageOption(); ok && impPath != "" { ++ // Replace the existing dirname with the declared import path. ++ _, name = path.Split(name) ++ name = path.Join(impPath, name) ++ return name ++ } ++ ++ return name ++} ++ ++func (d *FileDescriptor) addExport(obj Object, sym symbol) { ++ d.exported[obj] = append(d.exported[obj], sym) ++} ++ ++// symbol is an interface representing an exported Go symbol. ++type symbol interface { ++ // GenerateAlias should generate an appropriate alias ++ // for the symbol from the named package. ++ GenerateAlias(g *Generator, pkg string) ++} ++ ++type messageSymbol struct { ++ sym string ++ hasExtensions, isMessageSet bool ++ hasOneof bool ++ getters []getterSymbol ++} ++ ++type getterSymbol struct { ++ name string ++ typ string ++ typeName string // canonical name in proto world; empty for proto.Message and similar ++ genType bool // whether typ contains a generated type (message/group/enum) ++} ++ ++func (ms *messageSymbol) GenerateAlias(g *Generator, pkg string) { ++ remoteSym := pkg + "." + ms.sym ++ ++ g.P("type ", ms.sym, " ", remoteSym) ++ g.P("func (m *", ms.sym, ") Reset() { (*", remoteSym, ")(m).Reset() }") ++ g.P("func (m *", ms.sym, ") String() string { return (*", remoteSym, ")(m).String() }") ++ g.P("func (*", ms.sym, ") ProtoMessage() {}") ++ if ms.hasExtensions { ++ g.P("func (*", ms.sym, ") ExtensionRangeArray() []", g.Pkg["proto"], ".ExtensionRange ", ++ "{ return (*", remoteSym, ")(nil).ExtensionRangeArray() }") ++ if ms.isMessageSet { ++ g.P("func (m *", ms.sym, ") Marshal() ([]byte, error) ", ++ "{ return (*", remoteSym, ")(m).Marshal() }") ++ g.P("func (m *", ms.sym, ") Unmarshal(buf []byte) error ", ++ "{ return (*", remoteSym, ")(m).Unmarshal(buf) }") ++ } ++ } ++ if ms.hasOneof { ++ // Oneofs and public imports do not mix well. ++ // We can make them work okay for the binary format, ++ // but they're going to break weirdly for text/JSON. ++ enc := "_" + ms.sym + "_OneofMarshaler" ++ dec := "_" + ms.sym + "_OneofUnmarshaler" ++ size := "_" + ms.sym + "_OneofSizer" ++ encSig := "(msg " + g.Pkg["proto"] + ".Message, b *" + g.Pkg["proto"] + ".Buffer) error" ++ decSig := "(msg " + g.Pkg["proto"] + ".Message, tag, wire int, b *" + g.Pkg["proto"] + ".Buffer) (bool, error)" ++ sizeSig := "(msg " + g.Pkg["proto"] + ".Message) int" ++ g.P("func (m *", ms.sym, ") XXX_OneofFuncs() (func", encSig, ", func", decSig, ", func", sizeSig, ", []interface{}) {") ++ g.P("return ", enc, ", ", dec, ", ", size, ", nil") ++ g.P("}") ++ ++ g.P("func ", enc, encSig, " {") ++ g.P("m := msg.(*", ms.sym, ")") ++ g.P("m0 := (*", remoteSym, ")(m)") ++ g.P("enc, _, _, _ := m0.XXX_OneofFuncs()") ++ g.P("return enc(m0, b)") ++ g.P("}") ++ ++ g.P("func ", dec, decSig, " {") ++ g.P("m := msg.(*", ms.sym, ")") ++ g.P("m0 := (*", remoteSym, ")(m)") ++ g.P("_, dec, _, _ := m0.XXX_OneofFuncs()") ++ g.P("return dec(m0, tag, wire, b)") ++ g.P("}") ++ ++ g.P("func ", size, sizeSig, " {") ++ g.P("m := msg.(*", ms.sym, ")") ++ g.P("m0 := (*", remoteSym, ")(m)") ++ g.P("_, _, size, _ := m0.XXX_OneofFuncs()") ++ g.P("return size(m0)") ++ g.P("}") ++ } ++ for _, get := range ms.getters { ++ ++ if get.typeName != "" { ++ g.RecordTypeUse(get.typeName) ++ } ++ typ := get.typ ++ val := "(*" + remoteSym + ")(m)." + get.name + "()" ++ if get.genType { ++ // typ will be "*pkg.T" (message/group) or "pkg.T" (enum) ++ // or "map[t]*pkg.T" (map to message/enum). ++ // The first two of those might have a "[]" prefix if it is repeated. ++ // Drop any package qualifier since we have hoisted the type into this package. ++ rep := strings.HasPrefix(typ, "[]") ++ if rep { ++ typ = typ[2:] ++ } ++ isMap := strings.HasPrefix(typ, "map[") ++ star := typ[0] == '*' ++ if !isMap { // map types handled lower down ++ typ = typ[strings.Index(typ, ".")+1:] ++ } ++ if star { ++ typ = "*" + typ ++ } ++ if rep { ++ // Go does not permit conversion between slice types where both ++ // element types are named. That means we need to generate a bit ++ // of code in this situation. ++ // typ is the element type. ++ // val is the expression to get the slice from the imported type. ++ ++ ctyp := typ // conversion type expression; "Foo" or "(*Foo)" ++ if star { ++ ctyp = "(" + typ + ")" ++ } ++ ++ g.P("func (m *", ms.sym, ") ", get.name, "() []", typ, " {") ++ g.In() ++ g.P("o := ", val) ++ g.P("if o == nil {") ++ g.In() ++ g.P("return nil") ++ g.Out() ++ g.P("}") ++ g.P("s := make([]", typ, ", len(o))") ++ g.P("for i, x := range o {") ++ g.In() ++ g.P("s[i] = ", ctyp, "(x)") ++ g.Out() ++ g.P("}") ++ g.P("return s") ++ g.Out() ++ g.P("}") ++ continue ++ } ++ if isMap { ++ // Split map[keyTyp]valTyp. ++ bra, ket := strings.Index(typ, "["), strings.Index(typ, "]") ++ keyTyp, valTyp := typ[bra+1:ket], typ[ket+1:] ++ // Drop any package qualifier. ++ // Only the value type may be foreign. ++ star := valTyp[0] == '*' ++ valTyp = valTyp[strings.Index(valTyp, ".")+1:] ++ if star { ++ valTyp = "*" + valTyp ++ } ++ ++ typ := "map[" + keyTyp + "]" + valTyp ++ g.P("func (m *", ms.sym, ") ", get.name, "() ", typ, " {") ++ g.P("o := ", val) ++ g.P("if o == nil { return nil }") ++ g.P("s := make(", typ, ", len(o))") ++ g.P("for k, v := range o {") ++ g.P("s[k] = (", valTyp, ")(v)") ++ g.P("}") ++ g.P("return s") ++ g.P("}") ++ continue ++ } ++ // Convert imported type into the forwarding type. ++ val = "(" + typ + ")(" + val + ")" ++ } ++ ++ g.P("func (m *", ms.sym, ") ", get.name, "() ", typ, " { return ", val, " }") ++ } ++ ++} ++ ++type enumSymbol struct { ++ name string ++ proto3 bool // Whether this came from a proto3 file. ++} ++ ++func (es enumSymbol) GenerateAlias(g *Generator, pkg string) { ++ s := es.name ++ g.P("type ", s, " ", pkg, ".", s) ++ g.P("var ", s, "_name = ", pkg, ".", s, "_name") ++ g.P("var ", s, "_value = ", pkg, ".", s, "_value") ++ g.P("func (x ", s, ") String() string { return (", pkg, ".", s, ")(x).String() }") ++ if !es.proto3 { ++ g.P("func (x ", s, ") Enum() *", s, "{ return (*", s, ")((", pkg, ".", s, ")(x).Enum()) }") ++ g.P("func (x *", s, ") UnmarshalJSON(data []byte) error { return (*", pkg, ".", s, ")(x).UnmarshalJSON(data) }") ++ } ++} ++ ++type constOrVarSymbol struct { ++ sym string ++ typ string // either "const" or "var" ++ cast string // if non-empty, a type cast is required (used for enums) ++} ++ ++func (cs constOrVarSymbol) GenerateAlias(g *Generator, pkg string) { ++ v := pkg + "." + cs.sym ++ if cs.cast != "" { ++ v = cs.cast + "(" + v + ")" ++ } ++ g.P(cs.typ, " ", cs.sym, " = ", v) ++} ++ ++// Object is an interface abstracting the abilities shared by enums, messages, extensions and imported objects. ++type Object interface { ++ PackageName() string // The name we use in our output (a_b_c), possibly renamed for uniqueness. ++ TypeName() []string ++ File() *descriptor.FileDescriptorProto ++} ++ ++// Each package name we generate must be unique. The package we're generating ++// gets its own name but every other package must have a unique name that does ++// not conflict in the code we generate. These names are chosen globally (although ++// they don't have to be, it simplifies things to do them globally). ++func uniquePackageOf(fd *descriptor.FileDescriptorProto) string { ++ s, ok := uniquePackageName[fd] ++ if !ok { ++ log.Fatal("internal error: no package name defined for " + fd.GetName()) ++ } ++ return s ++} ++ ++// Generator is the type whose methods generate the output, stored in the associated response structure. ++type Generator struct { ++ *bytes.Buffer ++ ++ Request *plugin.CodeGeneratorRequest // The input. ++ Response *plugin.CodeGeneratorResponse // The output. ++ ++ Param map[string]string // Command-line parameters. ++ PackageImportPath string // Go import path of the package we're generating code for ++ ImportPrefix string // String to prefix to imported package file names. ++ ImportMap map[string]string // Mapping from .proto file name to import path ++ ++ Pkg map[string]string // The names under which we import support packages ++ ++ packageName string // What we're calling ourselves. ++ allFiles []*FileDescriptor // All files in the tree ++ allFilesByName map[string]*FileDescriptor // All files by filename. ++ genFiles []*FileDescriptor // Those files we will generate output for. ++ file *FileDescriptor // The file we are compiling now. ++ usedPackages map[string]bool // Names of packages used in current file. ++ typeNameToObject map[string]Object // Key is a fully-qualified name in input syntax. ++ init []string // Lines to emit in the init function. ++ indent string ++ writeOutput bool ++} ++ ++// New creates a new generator and allocates the request and response protobufs. ++func New() *Generator { ++ g := new(Generator) ++ g.Buffer = new(bytes.Buffer) ++ g.Request = new(plugin.CodeGeneratorRequest) ++ g.Response = new(plugin.CodeGeneratorResponse) ++ return g ++} ++ ++// Error reports a problem, including an error, and exits the program. ++func (g *Generator) Error(err error, msgs ...string) { ++ s := strings.Join(msgs, " ") + ":" + err.Error() ++ log.Print("protoc-gen-go: error:", s) ++ os.Exit(1) ++} ++ ++// Fail reports a problem and exits the program. ++func (g *Generator) Fail(msgs ...string) { ++ s := strings.Join(msgs, " ") ++ log.Print("protoc-gen-go: error:", s) ++ os.Exit(1) ++} ++ ++// CommandLineParameters breaks the comma-separated list of key=value pairs ++// in the parameter (a member of the request protobuf) into a key/value map. ++// It then sets file name mappings defined by those entries. ++func (g *Generator) CommandLineParameters(parameter string) { ++ g.Param = make(map[string]string) ++ for _, p := range strings.Split(parameter, ",") { ++ if i := strings.Index(p, "="); i < 0 { ++ g.Param[p] = "" ++ } else { ++ g.Param[p[0:i]] = p[i+1:] ++ } ++ } ++ ++ g.ImportMap = make(map[string]string) ++ pluginList := "none" // Default list of plugin names to enable (empty means all). ++ for k, v := range g.Param { ++ switch k { ++ case "import_prefix": ++ g.ImportPrefix = v ++ case "import_path": ++ g.PackageImportPath = v ++ case "plugins": ++ pluginList = v ++ default: ++ if len(k) > 0 && k[0] == 'M' { ++ g.ImportMap[k[1:]] = v ++ } ++ } ++ } ++ if pluginList != "" { ++ // Amend the set of plugins. ++ enabled := make(map[string]bool) ++ for _, name := range strings.Split(pluginList, "+") { ++ enabled[name] = true ++ } ++ var nplugins []Plugin ++ for _, p := range plugins { ++ if enabled[p.Name()] { ++ nplugins = append(nplugins, p) ++ } ++ } ++ plugins = nplugins ++ } ++} ++ ++// DefaultPackageName returns the package name printed for the object. ++// If its file is in a different package, it returns the package name we're using for this file, plus ".". ++// Otherwise it returns the empty string. ++func (g *Generator) DefaultPackageName(obj Object) string { ++ pkg := obj.PackageName() ++ if pkg == g.packageName { ++ return "" ++ } ++ return pkg + "." ++} ++ ++// For each input file, the unique package name to use, underscored. ++var uniquePackageName = make(map[*descriptor.FileDescriptorProto]string) ++ ++// Package names already registered. Key is the name from the .proto file; ++// value is the name that appears in the generated code. ++var pkgNamesInUse = make(map[string]bool) ++ ++// Create and remember a guaranteed unique package name for this file descriptor. ++// Pkg is the candidate name. If f is nil, it's a builtin package like "proto" and ++// has no file descriptor. ++func RegisterUniquePackageName(pkg string, f *FileDescriptor) string { ++ // Convert dots to underscores before finding a unique alias. ++ pkg = strings.Map(badToUnderscore, pkg) ++ ++ for i, orig := 1, pkg; pkgNamesInUse[pkg]; i++ { ++ // It's a duplicate; must rename. ++ pkg = orig + strconv.Itoa(i) ++ } ++ // Install it. ++ pkgNamesInUse[pkg] = true ++ if f != nil { ++ uniquePackageName[f.FileDescriptorProto] = pkg ++ } ++ return pkg ++} ++ ++var isGoKeyword = map[string]bool{ ++ "break": true, ++ "case": true, ++ "chan": true, ++ "const": true, ++ "continue": true, ++ "default": true, ++ "else": true, ++ "defer": true, ++ "fallthrough": true, ++ "for": true, ++ "func": true, ++ "go": true, ++ "goto": true, ++ "if": true, ++ "import": true, ++ "interface": true, ++ "map": true, ++ "package": true, ++ "range": true, ++ "return": true, ++ "select": true, ++ "struct": true, ++ "switch": true, ++ "type": true, ++ "var": true, ++} ++ ++// defaultGoPackage returns the package name to use, ++// derived from the import path of the package we're building code for. ++func (g *Generator) defaultGoPackage() string { ++ p := g.PackageImportPath ++ if i := strings.LastIndex(p, "/"); i >= 0 { ++ p = p[i+1:] ++ } ++ if p == "" { ++ return "" ++ } ++ ++ p = strings.Map(badToUnderscore, p) ++ // Identifier must not be keyword: insert _. ++ if isGoKeyword[p] { ++ p = "_" + p ++ } ++ // Identifier must not begin with digit: insert _. ++ if r, _ := utf8.DecodeRuneInString(p); unicode.IsDigit(r) { ++ p = "_" + p ++ } ++ return p ++} ++ ++// SetPackageNames sets the package name for this run. ++// The package name must agree across all files being generated. ++// It also defines unique package names for all imported files. ++func (g *Generator) SetPackageNames() { ++ // Register the name for this package. It will be the first name ++ // registered so is guaranteed to be unmodified. ++ pkg, explicit := g.genFiles[0].goPackageName() ++ ++ // Check all files for an explicit go_package option. ++ for _, f := range g.genFiles { ++ thisPkg, thisExplicit := f.goPackageName() ++ if thisExplicit { ++ if !explicit { ++ // Let this file's go_package option serve for all input files. ++ pkg, explicit = thisPkg, true ++ } else if thisPkg != pkg { ++ g.Fail("inconsistent package names:", thisPkg, pkg) ++ } ++ } ++ } ++ ++ // If we don't have an explicit go_package option but we have an ++ // import path, use that. ++ if !explicit { ++ p := g.defaultGoPackage() ++ if p != "" { ++ pkg, explicit = p, true ++ } ++ } ++ ++ // If there was no go_package and no import path to use, ++ // double-check that all the inputs have the same implicit ++ // Go package name. ++ if !explicit { ++ for _, f := range g.genFiles { ++ thisPkg, _ := f.goPackageName() ++ if thisPkg != pkg { ++ g.Fail("inconsistent package names:", thisPkg, pkg) ++ } ++ } ++ } ++ ++ g.packageName = RegisterUniquePackageName(pkg, g.genFiles[0]) ++ ++ // Register the support package names. They might collide with the ++ // name of a package we import. ++ g.Pkg = map[string]string{ ++ "fmt": RegisterUniquePackageName("fmt", nil), ++ "math": RegisterUniquePackageName("math", nil), ++ "proto": RegisterUniquePackageName("proto", nil), ++ } ++ ++AllFiles: ++ for _, f := range g.allFiles { ++ for _, genf := range g.genFiles { ++ if f == genf { ++ // In this package already. ++ uniquePackageName[f.FileDescriptorProto] = g.packageName ++ continue AllFiles ++ } ++ } ++ // The file is a dependency, so we want to ignore its go_package option ++ // because that is only relevant for its specific generated output. ++ pkg := f.GetPackage() ++ if pkg == "" { ++ pkg = baseName(*f.Name) ++ } ++ RegisterUniquePackageName(pkg, f) ++ } ++} ++ ++// WrapTypes walks the incoming data, wrapping DescriptorProtos, EnumDescriptorProtos ++// and FileDescriptorProtos into file-referenced objects within the Generator. ++// It also creates the list of files to generate and so should be called before GenerateAllFiles. ++func (g *Generator) WrapTypes() { ++ g.allFiles = make([]*FileDescriptor, 0, len(g.Request.ProtoFile)) ++ g.allFilesByName = make(map[string]*FileDescriptor, len(g.allFiles)) ++ for _, f := range g.Request.ProtoFile { ++ // We must wrap the descriptors before we wrap the enums ++ descs := wrapDescriptors(f) ++ g.buildNestedDescriptors(descs) ++ enums := wrapEnumDescriptors(f, descs) ++ g.buildNestedEnums(descs, enums) ++ exts := wrapExtensions(f) ++ fd := &FileDescriptor{ ++ FileDescriptorProto: f, ++ desc: descs, ++ enum: enums, ++ ext: exts, ++ exported: make(map[Object][]symbol), ++ proto3: fileIsProto3(f), ++ } ++ extractComments(fd) ++ g.allFiles = append(g.allFiles, fd) ++ g.allFilesByName[f.GetName()] = fd ++ } ++ for _, fd := range g.allFiles { ++ fd.imp = wrapImported(fd.FileDescriptorProto, g) ++ } ++ ++ g.genFiles = make([]*FileDescriptor, 0, len(g.Request.FileToGenerate)) ++ for _, fileName := range g.Request.FileToGenerate { ++ fd := g.allFilesByName[fileName] ++ if fd == nil { ++ g.Fail("could not find file named", fileName) ++ } ++ fd.index = len(g.genFiles) ++ g.genFiles = append(g.genFiles, fd) ++ } ++} ++ ++// Scan the descriptors in this file. For each one, build the slice of nested descriptors ++func (g *Generator) buildNestedDescriptors(descs []*Descriptor) { ++ for _, desc := range descs { ++ if len(desc.NestedType) != 0 { ++ for _, nest := range descs { ++ if nest.parent == desc { ++ desc.nested = append(desc.nested, nest) ++ } ++ } ++ if len(desc.nested) != len(desc.NestedType) { ++ g.Fail("internal error: nesting failure for", desc.GetName()) ++ } ++ } ++ } ++} ++ ++func (g *Generator) buildNestedEnums(descs []*Descriptor, enums []*EnumDescriptor) { ++ for _, desc := range descs { ++ if len(desc.EnumType) != 0 { ++ for _, enum := range enums { ++ if enum.parent == desc { ++ desc.enums = append(desc.enums, enum) ++ } ++ } ++ if len(desc.enums) != len(desc.EnumType) { ++ g.Fail("internal error: enum nesting failure for", desc.GetName()) ++ } ++ } ++ } ++} ++ ++// Construct the Descriptor ++func newDescriptor(desc *descriptor.DescriptorProto, parent *Descriptor, file *descriptor.FileDescriptorProto, index int) *Descriptor { ++ d := &Descriptor{ ++ common: common{file}, ++ DescriptorProto: desc, ++ parent: parent, ++ index: index, ++ } ++ if parent == nil { ++ d.path = fmt.Sprintf("%d,%d", messagePath, index) ++ } else { ++ d.path = fmt.Sprintf("%s,%d,%d", parent.path, messageMessagePath, index) ++ } ++ ++ // The only way to distinguish a group from a message is whether ++ // the containing message has a TYPE_GROUP field that matches. ++ if parent != nil { ++ parts := d.TypeName() ++ if file.Package != nil { ++ parts = append([]string{*file.Package}, parts...) ++ } ++ exp := "." + strings.Join(parts, ".") ++ for _, field := range parent.Field { ++ if field.GetType() == descriptor.FieldDescriptorProto_TYPE_GROUP && field.GetTypeName() == exp { ++ d.group = true ++ break ++ } ++ } ++ } ++ ++ for _, field := range desc.Extension { ++ d.ext = append(d.ext, &ExtensionDescriptor{common{file}, field, d}) ++ } ++ ++ return d ++} ++ ++// Return a slice of all the Descriptors defined within this file ++func wrapDescriptors(file *descriptor.FileDescriptorProto) []*Descriptor { ++ sl := make([]*Descriptor, 0, len(file.MessageType)+10) ++ for i, desc := range file.MessageType { ++ sl = wrapThisDescriptor(sl, desc, nil, file, i) ++ } ++ return sl ++} ++ ++// Wrap this Descriptor, recursively ++func wrapThisDescriptor(sl []*Descriptor, desc *descriptor.DescriptorProto, parent *Descriptor, file *descriptor.FileDescriptorProto, index int) []*Descriptor { ++ sl = append(sl, newDescriptor(desc, parent, file, index)) ++ me := sl[len(sl)-1] ++ for i, nested := range desc.NestedType { ++ sl = wrapThisDescriptor(sl, nested, me, file, i) ++ } ++ return sl ++} ++ ++// Construct the EnumDescriptor ++func newEnumDescriptor(desc *descriptor.EnumDescriptorProto, parent *Descriptor, file *descriptor.FileDescriptorProto, index int) *EnumDescriptor { ++ ed := &EnumDescriptor{ ++ common: common{file}, ++ EnumDescriptorProto: desc, ++ parent: parent, ++ index: index, ++ } ++ if parent == nil { ++ ed.path = fmt.Sprintf("%d,%d", enumPath, index) ++ } else { ++ ed.path = fmt.Sprintf("%s,%d,%d", parent.path, messageEnumPath, index) ++ } ++ return ed ++} ++ ++// Return a slice of all the EnumDescriptors defined within this file ++func wrapEnumDescriptors(file *descriptor.FileDescriptorProto, descs []*Descriptor) []*EnumDescriptor { ++ sl := make([]*EnumDescriptor, 0, len(file.EnumType)+10) ++ // Top-level enums. ++ for i, enum := range file.EnumType { ++ sl = append(sl, newEnumDescriptor(enum, nil, file, i)) ++ } ++ // Enums within messages. Enums within embedded messages appear in the outer-most message. ++ for _, nested := range descs { ++ for i, enum := range nested.EnumType { ++ sl = append(sl, newEnumDescriptor(enum, nested, file, i)) ++ } ++ } ++ return sl ++} ++ ++// Return a slice of all the top-level ExtensionDescriptors defined within this file. ++func wrapExtensions(file *descriptor.FileDescriptorProto) []*ExtensionDescriptor { ++ var sl []*ExtensionDescriptor ++ for _, field := range file.Extension { ++ sl = append(sl, &ExtensionDescriptor{common{file}, field, nil}) ++ } ++ return sl ++} ++ ++// Return a slice of all the types that are publicly imported into this file. ++func wrapImported(file *descriptor.FileDescriptorProto, g *Generator) (sl []*ImportedDescriptor) { ++ for _, index := range file.PublicDependency { ++ df := g.fileByName(file.Dependency[index]) ++ for _, d := range df.desc { ++ if d.GetOptions().GetMapEntry() { ++ continue ++ } ++ sl = append(sl, &ImportedDescriptor{common{file}, d}) ++ } ++ for _, e := range df.enum { ++ sl = append(sl, &ImportedDescriptor{common{file}, e}) ++ } ++ for _, ext := range df.ext { ++ sl = append(sl, &ImportedDescriptor{common{file}, ext}) ++ } ++ } ++ return ++} ++ ++func extractComments(file *FileDescriptor) { ++ file.comments = make(map[string]*descriptor.SourceCodeInfo_Location) ++ for _, loc := range file.GetSourceCodeInfo().GetLocation() { ++ if loc.LeadingComments == nil { ++ continue ++ } ++ var p []string ++ for _, n := range loc.Path { ++ p = append(p, strconv.Itoa(int(n))) ++ } ++ file.comments[strings.Join(p, ",")] = loc ++ } ++} ++ ++// BuildTypeNameMap builds the map from fully qualified type names to objects. ++// The key names for the map come from the input data, which puts a period at the beginning. ++// It should be called after SetPackageNames and before GenerateAllFiles. ++func (g *Generator) BuildTypeNameMap() { ++ g.typeNameToObject = make(map[string]Object) ++ for _, f := range g.allFiles { ++ // The names in this loop are defined by the proto world, not us, so the ++ // package name may be empty. If so, the dotted package name of X will ++ // be ".X"; otherwise it will be ".pkg.X". ++ dottedPkg := "." + f.GetPackage() ++ if dottedPkg != "." { ++ dottedPkg += "." ++ } ++ for _, enum := range f.enum { ++ name := dottedPkg + dottedSlice(enum.TypeName()) ++ g.typeNameToObject[name] = enum ++ } ++ for _, desc := range f.desc { ++ name := dottedPkg + dottedSlice(desc.TypeName()) ++ g.typeNameToObject[name] = desc ++ } ++ } ++} ++ ++// ObjectNamed, given a fully-qualified input type name as it appears in the input data, ++// returns the descriptor for the message or enum with that name. ++func (g *Generator) ObjectNamed(typeName string) Object { ++ o, ok := g.typeNameToObject[typeName] ++ if !ok { ++ g.Fail("can't find object with type", typeName) ++ } ++ ++ // If the file of this object isn't a direct dependency of the current file, ++ // or in the current file, then this object has been publicly imported into ++ // a dependency of the current file. ++ // We should return the ImportedDescriptor object for it instead. ++ direct := *o.File().Name == *g.file.Name ++ if !direct { ++ for _, dep := range g.file.Dependency { ++ if *g.fileByName(dep).Name == *o.File().Name { ++ direct = true ++ break ++ } ++ } ++ } ++ if !direct { ++ found := false ++ Loop: ++ for _, dep := range g.file.Dependency { ++ df := g.fileByName(*g.fileByName(dep).Name) ++ for _, td := range df.imp { ++ if td.o == o { ++ // Found it! ++ o = td ++ found = true ++ break Loop ++ } ++ } ++ } ++ if !found { ++ log.Printf("protoc-gen-go: WARNING: failed finding publicly imported dependency for %v, used in %v", typeName, *g.file.Name) ++ } ++ } ++ ++ return o ++} ++ ++// P prints the arguments to the generated output. It handles strings and int32s, plus ++// handling indirections because they may be *string, etc. ++func (g *Generator) P(str ...interface{}) { ++ if !g.writeOutput { ++ return ++ } ++ g.WriteString(g.indent) ++ for _, v := range str { ++ switch s := v.(type) { ++ case string: ++ g.WriteString(s) ++ case *string: ++ g.WriteString(*s) ++ case bool: ++ fmt.Fprintf(g, "%t", s) ++ case *bool: ++ fmt.Fprintf(g, "%t", *s) ++ case int: ++ fmt.Fprintf(g, "%d", s) ++ case *int32: ++ fmt.Fprintf(g, "%d", *s) ++ case *int64: ++ fmt.Fprintf(g, "%d", *s) ++ case float64: ++ fmt.Fprintf(g, "%g", s) ++ case *float64: ++ fmt.Fprintf(g, "%g", *s) ++ default: ++ g.Fail(fmt.Sprintf("unknown type in printer: %T", v)) ++ } ++ } ++ g.WriteByte('\n') ++} ++ ++// addInitf stores the given statement to be printed inside the file's init function. ++// The statement is given as a format specifier and arguments. ++func (g *Generator) addInitf(stmt string, a ...interface{}) { ++ g.init = append(g.init, fmt.Sprintf(stmt, a...)) ++} ++ ++// In Indents the output one tab stop. ++func (g *Generator) In() { g.indent += "\t" } ++ ++// Out unindents the output one tab stop. ++func (g *Generator) Out() { ++ if len(g.indent) > 0 { ++ g.indent = g.indent[1:] ++ } ++} ++ ++// GenerateAllFiles generates the output for all the files we're outputting. ++func (g *Generator) GenerateAllFiles() { ++ // Initialize the plugins ++ for _, p := range plugins { ++ p.Init(g) ++ } ++ // Generate the output. The generator runs for every file, even the files ++ // that we don't generate output for, so that we can collate the full list ++ // of exported symbols to support public imports. ++ genFileMap := make(map[*FileDescriptor]bool, len(g.genFiles)) ++ for _, file := range g.genFiles { ++ genFileMap[file] = true ++ } ++ for _, file := range g.allFiles { ++ g.Reset() ++ g.writeOutput = genFileMap[file] ++ g.generate(file) ++ if !g.writeOutput { ++ continue ++ } ++ g.Response.File = append(g.Response.File, &plugin.CodeGeneratorResponse_File{ ++ Name: proto.String(file.goFileName()), ++ Content: proto.String(g.String()), ++ }) ++ } ++} ++ ++// Run all the plugins associated with the file. ++func (g *Generator) runPlugins(file *FileDescriptor) { ++ for _, p := range plugins { ++ p.Generate(file) ++ } ++} ++ ++// FileOf return the FileDescriptor for this FileDescriptorProto. ++func (g *Generator) FileOf(fd *descriptor.FileDescriptorProto) *FileDescriptor { ++ for _, file := range g.allFiles { ++ if file.FileDescriptorProto == fd { ++ return file ++ } ++ } ++ g.Fail("could not find file in table:", fd.GetName()) ++ return nil ++} ++ ++// Fill the response protocol buffer with the generated output for all the files we're ++// supposed to generate. ++func (g *Generator) generate(file *FileDescriptor) { ++ g.file = g.FileOf(file.FileDescriptorProto) ++ g.usedPackages = make(map[string]bool) ++ ++ if g.file.index == 0 { ++ // For one file in the package, assert version compatibility. ++ g.P("// This is a compile-time assertion to ensure that this generated file") ++ g.P("// is compatible with the proto package it is being compiled against.") ++ g.P("// A compilation error at this line likely means your copy of the") ++ g.P("// proto package needs to be updated.") ++ g.P("const _ = ", g.Pkg["proto"], ".ProtoPackageIsVersion", generatedCodeVersion, " // please upgrade the proto package") ++ g.P() ++ } ++ for _, td := range g.file.imp { ++ g.generateImported(td) ++ } ++ for _, enum := range g.file.enum { ++ g.generateEnum(enum) ++ } ++ for _, desc := range g.file.desc { ++ // Don't generate virtual messages for maps. ++ if desc.GetOptions().GetMapEntry() { ++ continue ++ } ++ g.generateMessage(desc) ++ } ++ for _, ext := range g.file.ext { ++ g.generateExtension(ext) ++ } ++ g.generateInitFunction() ++ ++ // Run the plugins before the imports so we know which imports are necessary. ++ g.runPlugins(file) ++ ++ g.generateFileDescriptor(file) ++ ++ // Generate header and imports last, though they appear first in the output. ++ rem := g.Buffer ++ g.Buffer = new(bytes.Buffer) ++ g.generateHeader() ++ g.generateImports() ++ if !g.writeOutput { ++ return ++ } ++ g.Write(rem.Bytes()) ++ ++ // Reformat generated code. ++ fset := token.NewFileSet() ++ raw := g.Bytes() ++ ast, err := parser.ParseFile(fset, "", g, parser.ParseComments) ++ if err != nil { ++ // Print out the bad code with line numbers. ++ // This should never happen in practice, but it can while changing generated code, ++ // so consider this a debugging aid. ++ var src bytes.Buffer ++ s := bufio.NewScanner(bytes.NewReader(raw)) ++ for line := 1; s.Scan(); line++ { ++ fmt.Fprintf(&src, "%5d\t%s\n", line, s.Bytes()) ++ } ++ g.Fail("bad Go source code was generated:", err.Error(), "\n"+src.String()) ++ } ++ g.Reset() ++ err = (&printer.Config{Mode: printer.TabIndent | printer.UseSpaces, Tabwidth: 8}).Fprint(g, fset, ast) ++ if err != nil { ++ g.Fail("generated Go source code could not be reformatted:", err.Error()) ++ } ++} ++ ++// Generate the header, including package definition ++func (g *Generator) generateHeader() { ++ g.P("// Code generated by protoc-gen-go.") ++ g.P("// source: ", g.file.Name) ++ g.P("// DO NOT EDIT!") ++ g.P() ++ ++ name := g.file.PackageName() ++ ++ if g.file.index == 0 { ++ // Generate package docs for the first file in the package. ++ g.P("/*") ++ g.P("Package ", name, " is a generated protocol buffer package.") ++ g.P() ++ if loc, ok := g.file.comments[strconv.Itoa(packagePath)]; ok { ++ // not using g.PrintComments because this is a /* */ comment block. ++ text := strings.TrimSuffix(loc.GetLeadingComments(), "\n") ++ for _, line := range strings.Split(text, "\n") { ++ line = strings.TrimPrefix(line, " ") ++ // ensure we don't escape from the block comment ++ line = strings.Replace(line, "*/", "* /", -1) ++ g.P(line) ++ } ++ g.P() ++ } ++ var topMsgs []string ++ g.P("It is generated from these files:") ++ for _, f := range g.genFiles { ++ g.P("\t", f.Name) ++ for _, msg := range f.desc { ++ if msg.parent != nil { ++ continue ++ } ++ topMsgs = append(topMsgs, CamelCaseSlice(msg.TypeName())) ++ } ++ } ++ g.P() ++ g.P("It has these top-level messages:") ++ for _, msg := range topMsgs { ++ g.P("\t", msg) ++ } ++ g.P("*/") ++ } ++ ++ g.P("package ", name) ++ g.P() ++} ++ ++// PrintComments prints any comments from the source .proto file. ++// The path is a comma-separated list of integers. ++// It returns an indication of whether any comments were printed. ++// See descriptor.proto for its format. ++func (g *Generator) PrintComments(path string) bool { ++ if !g.writeOutput { ++ return false ++ } ++ if loc, ok := g.file.comments[path]; ok { ++ text := strings.TrimSuffix(loc.GetLeadingComments(), "\n") ++ for _, line := range strings.Split(text, "\n") { ++ g.P("// ", strings.TrimPrefix(line, " ")) ++ } ++ return true ++ } ++ return false ++} ++ ++func (g *Generator) fileByName(filename string) *FileDescriptor { ++ return g.allFilesByName[filename] ++} ++ ++// weak returns whether the ith import of the current file is a weak import. ++func (g *Generator) weak(i int32) bool { ++ for _, j := range g.file.WeakDependency { ++ if j == i { ++ return true ++ } ++ } ++ return false ++} ++ ++// Generate the imports ++func (g *Generator) generateImports() { ++ // We almost always need a proto import. Rather than computing when we ++ // do, which is tricky when there's a plugin, just import it and ++ // reference it later. The same argument applies to the fmt and math packages. ++ g.P("import " + g.Pkg["proto"] + " " + strconv.Quote(g.ImportPrefix+"github.com/golang/protobuf/proto")) ++ g.P("import " + g.Pkg["fmt"] + ` "fmt"`) ++ g.P("import " + g.Pkg["math"] + ` "math"`) ++ for i, s := range g.file.Dependency { ++ fd := g.fileByName(s) ++ // Do not import our own package. ++ if fd.PackageName() == g.packageName { ++ continue ++ } ++ filename := fd.goFileName() ++ // By default, import path is the dirname of the Go filename. ++ importPath := path.Dir(filename) ++ if substitution, ok := g.ImportMap[s]; ok { ++ importPath = substitution ++ } ++ importPath = g.ImportPrefix + importPath ++ // Skip weak imports. ++ if g.weak(int32(i)) { ++ g.P("// skipping weak import ", fd.PackageName(), " ", strconv.Quote(importPath)) ++ continue ++ } ++ // We need to import all the dependencies, even if we don't reference them, ++ // because other code and tools depend on having the full transitive closure ++ // of protocol buffer types in the binary. ++ pname := fd.PackageName() ++ if _, ok := g.usedPackages[pname]; !ok { ++ pname = "_" ++ } ++ g.P("import ", pname, " ", strconv.Quote(importPath)) ++ } ++ g.P() ++ // TODO: may need to worry about uniqueness across plugins ++ for _, p := range plugins { ++ p.GenerateImports(g.file) ++ g.P() ++ } ++ g.P("// Reference imports to suppress errors if they are not otherwise used.") ++ g.P("var _ = ", g.Pkg["proto"], ".Marshal") ++ g.P("var _ = ", g.Pkg["fmt"], ".Errorf") ++ g.P("var _ = ", g.Pkg["math"], ".Inf") ++ g.P() ++} ++ ++func (g *Generator) generateImported(id *ImportedDescriptor) { ++ // Don't generate public import symbols for files that we are generating ++ // code for, since those symbols will already be in this package. ++ // We can't simply avoid creating the ImportedDescriptor objects, ++ // because g.genFiles isn't populated at that stage. ++ tn := id.TypeName() ++ sn := tn[len(tn)-1] ++ df := g.FileOf(id.o.File()) ++ filename := *df.Name ++ for _, fd := range g.genFiles { ++ if *fd.Name == filename { ++ g.P("// Ignoring public import of ", sn, " from ", filename) ++ g.P() ++ return ++ } ++ } ++ g.P("// ", sn, " from public import ", filename) ++ g.usedPackages[df.PackageName()] = true ++ ++ for _, sym := range df.exported[id.o] { ++ sym.GenerateAlias(g, df.PackageName()) ++ } ++ ++ g.P() ++} ++ ++// Generate the enum definitions for this EnumDescriptor. ++func (g *Generator) generateEnum(enum *EnumDescriptor) { ++ // The full type name ++ typeName := enum.TypeName() ++ // The full type name, CamelCased. ++ ccTypeName := CamelCaseSlice(typeName) ++ ccPrefix := enum.prefix() ++ ++ g.PrintComments(enum.path) ++ g.P("type ", ccTypeName, " int32") ++ g.file.addExport(enum, enumSymbol{ccTypeName, enum.proto3()}) ++ g.P("const (") ++ g.In() ++ for i, e := range enum.Value { ++ g.PrintComments(fmt.Sprintf("%s,%d,%d", enum.path, enumValuePath, i)) ++ ++ name := ccPrefix + *e.Name ++ g.P(name, " ", ccTypeName, " = ", e.Number) ++ g.file.addExport(enum, constOrVarSymbol{name, "const", ccTypeName}) ++ } ++ g.Out() ++ g.P(")") ++ g.P("var ", ccTypeName, "_name = map[int32]string{") ++ g.In() ++ generated := make(map[int32]bool) // avoid duplicate values ++ for _, e := range enum.Value { ++ duplicate := "" ++ if _, present := generated[*e.Number]; present { ++ duplicate = "// Duplicate value: " ++ } ++ g.P(duplicate, e.Number, ": ", strconv.Quote(*e.Name), ",") ++ generated[*e.Number] = true ++ } ++ g.Out() ++ g.P("}") ++ g.P("var ", ccTypeName, "_value = map[string]int32{") ++ g.In() ++ for _, e := range enum.Value { ++ g.P(strconv.Quote(*e.Name), ": ", e.Number, ",") ++ } ++ g.Out() ++ g.P("}") ++ ++ if !enum.proto3() { ++ g.P("func (x ", ccTypeName, ") Enum() *", ccTypeName, " {") ++ g.In() ++ g.P("p := new(", ccTypeName, ")") ++ g.P("*p = x") ++ g.P("return p") ++ g.Out() ++ g.P("}") ++ } ++ ++ g.P("func (x ", ccTypeName, ") String() string {") ++ g.In() ++ g.P("return ", g.Pkg["proto"], ".EnumName(", ccTypeName, "_name, int32(x))") ++ g.Out() ++ g.P("}") ++ ++ if !enum.proto3() { ++ g.P("func (x *", ccTypeName, ") UnmarshalJSON(data []byte) error {") ++ g.In() ++ g.P("value, err := ", g.Pkg["proto"], ".UnmarshalJSONEnum(", ccTypeName, `_value, data, "`, ccTypeName, `")`) ++ g.P("if err != nil {") ++ g.In() ++ g.P("return err") ++ g.Out() ++ g.P("}") ++ g.P("*x = ", ccTypeName, "(value)") ++ g.P("return nil") ++ g.Out() ++ g.P("}") ++ } ++ ++ var indexes []string ++ for m := enum.parent; m != nil; m = m.parent { ++ // XXX: skip groups? ++ indexes = append([]string{strconv.Itoa(m.index)}, indexes...) ++ } ++ indexes = append(indexes, strconv.Itoa(enum.index)) ++ g.P("func (", ccTypeName, ") EnumDescriptor() ([]byte, []int) { return ", g.file.VarName(), ", []int{", strings.Join(indexes, ", "), "} }") ++ if enum.file.GetPackage() == "google.protobuf" && enum.GetName() == "NullValue" { ++ g.P("func (", ccTypeName, `) XXX_WellKnownType() string { return "`, enum.GetName(), `" }`) ++ } ++ ++ g.P() ++} ++ ++// The tag is a string like "varint,2,opt,name=fieldname,def=7" that ++// identifies details of the field for the protocol buffer marshaling and unmarshaling ++// code. The fields are: ++// wire encoding ++// protocol tag number ++// opt,req,rep for optional, required, or repeated ++// packed whether the encoding is "packed" (optional; repeated primitives only) ++// name= the original declared name ++// enum= the name of the enum type if it is an enum-typed field. ++// proto3 if this field is in a proto3 message ++// def= string representation of the default value, if any. ++// The default value must be in a representation that can be used at run-time ++// to generate the default value. Thus bools become 0 and 1, for instance. ++func (g *Generator) goTag(message *Descriptor, field *descriptor.FieldDescriptorProto, wiretype string) string { ++ optrepreq := "" ++ switch { ++ case isOptional(field): ++ optrepreq = "opt" ++ case isRequired(field): ++ optrepreq = "req" ++ case isRepeated(field): ++ optrepreq = "rep" ++ } ++ var defaultValue string ++ if dv := field.DefaultValue; dv != nil { // set means an explicit default ++ defaultValue = *dv ++ // Some types need tweaking. ++ switch *field.Type { ++ case descriptor.FieldDescriptorProto_TYPE_BOOL: ++ if defaultValue == "true" { ++ defaultValue = "1" ++ } else { ++ defaultValue = "0" ++ } ++ case descriptor.FieldDescriptorProto_TYPE_STRING, ++ descriptor.FieldDescriptorProto_TYPE_BYTES: ++ // Nothing to do. Quoting is done for the whole tag. ++ case descriptor.FieldDescriptorProto_TYPE_ENUM: ++ // For enums we need to provide the integer constant. ++ obj := g.ObjectNamed(field.GetTypeName()) ++ if id, ok := obj.(*ImportedDescriptor); ok { ++ // It is an enum that was publicly imported. ++ // We need the underlying type. ++ obj = id.o ++ } ++ enum, ok := obj.(*EnumDescriptor) ++ if !ok { ++ log.Printf("obj is a %T", obj) ++ if id, ok := obj.(*ImportedDescriptor); ok { ++ log.Printf("id.o is a %T", id.o) ++ } ++ g.Fail("unknown enum type", CamelCaseSlice(obj.TypeName())) ++ } ++ defaultValue = enum.integerValueAsString(defaultValue) ++ } ++ defaultValue = ",def=" + defaultValue ++ } ++ enum := "" ++ if *field.Type == descriptor.FieldDescriptorProto_TYPE_ENUM { ++ // We avoid using obj.PackageName(), because we want to use the ++ // original (proto-world) package name. ++ obj := g.ObjectNamed(field.GetTypeName()) ++ if id, ok := obj.(*ImportedDescriptor); ok { ++ obj = id.o ++ } ++ enum = ",enum=" ++ if pkg := obj.File().GetPackage(); pkg != "" { ++ enum += pkg + "." ++ } ++ enum += CamelCaseSlice(obj.TypeName()) ++ } ++ packed := "" ++ if (field.Options != nil && field.Options.GetPacked()) || ++ // Per https://developers.google.com/protocol-buffers/docs/proto3#simple: ++ // "In proto3, repeated fields of scalar numeric types use packed encoding by default." ++ (message.proto3() && (field.Options == nil || field.Options.Packed == nil) && ++ isRepeated(field) && isScalar(field)) { ++ packed = ",packed" ++ } ++ fieldName := field.GetName() ++ name := fieldName ++ if *field.Type == descriptor.FieldDescriptorProto_TYPE_GROUP { ++ // We must use the type name for groups instead of ++ // the field name to preserve capitalization. ++ // type_name in FieldDescriptorProto is fully-qualified, ++ // but we only want the local part. ++ name = *field.TypeName ++ if i := strings.LastIndex(name, "."); i >= 0 { ++ name = name[i+1:] ++ } ++ } ++ if json := field.GetJsonName(); json != "" && json != name { ++ // TODO: escaping might be needed, in which case ++ // perhaps this should be in its own "json" tag. ++ name += ",json=" + json ++ } ++ name = ",name=" + name ++ if message.proto3() { ++ // We only need the extra tag for []byte fields; ++ // no need to add noise for the others. ++ if *field.Type == descriptor.FieldDescriptorProto_TYPE_BYTES { ++ name += ",proto3" ++ } ++ ++ } ++ oneof := "" ++ if field.OneofIndex != nil { ++ oneof = ",oneof" ++ } ++ return strconv.Quote(fmt.Sprintf("%s,%d,%s%s%s%s%s%s", ++ wiretype, ++ field.GetNumber(), ++ optrepreq, ++ packed, ++ name, ++ enum, ++ oneof, ++ defaultValue)) ++} ++ ++func needsStar(typ descriptor.FieldDescriptorProto_Type) bool { ++ switch typ { ++ case descriptor.FieldDescriptorProto_TYPE_GROUP: ++ return false ++ case descriptor.FieldDescriptorProto_TYPE_MESSAGE: ++ return false ++ case descriptor.FieldDescriptorProto_TYPE_BYTES: ++ return false ++ } ++ return true ++} ++ ++// TypeName is the printed name appropriate for an item. If the object is in the current file, ++// TypeName drops the package name and underscores the rest. ++// Otherwise the object is from another package; and the result is the underscored ++// package name followed by the item name. ++// The result always has an initial capital. ++func (g *Generator) TypeName(obj Object) string { ++ return g.DefaultPackageName(obj) + CamelCaseSlice(obj.TypeName()) ++} ++ ++// TypeNameWithPackage is like TypeName, but always includes the package ++// name even if the object is in our own package. ++func (g *Generator) TypeNameWithPackage(obj Object) string { ++ return obj.PackageName() + CamelCaseSlice(obj.TypeName()) ++} ++ ++// GoType returns a string representing the type name, and the wire type ++func (g *Generator) GoType(message *Descriptor, field *descriptor.FieldDescriptorProto) (typ string, wire string) { ++ // TODO: Options. ++ switch *field.Type { ++ case descriptor.FieldDescriptorProto_TYPE_DOUBLE: ++ typ, wire = "float64", "fixed64" ++ case descriptor.FieldDescriptorProto_TYPE_FLOAT: ++ typ, wire = "float32", "fixed32" ++ case descriptor.FieldDescriptorProto_TYPE_INT64: ++ typ, wire = "int64", "varint" ++ case descriptor.FieldDescriptorProto_TYPE_UINT64: ++ typ, wire = "uint64", "varint" ++ case descriptor.FieldDescriptorProto_TYPE_INT32: ++ typ, wire = "int32", "varint" ++ case descriptor.FieldDescriptorProto_TYPE_UINT32: ++ typ, wire = "uint32", "varint" ++ case descriptor.FieldDescriptorProto_TYPE_FIXED64: ++ typ, wire = "uint64", "fixed64" ++ case descriptor.FieldDescriptorProto_TYPE_FIXED32: ++ typ, wire = "uint32", "fixed32" ++ case descriptor.FieldDescriptorProto_TYPE_BOOL: ++ typ, wire = "bool", "varint" ++ case descriptor.FieldDescriptorProto_TYPE_STRING: ++ typ, wire = "string", "bytes" ++ case descriptor.FieldDescriptorProto_TYPE_GROUP: ++ desc := g.ObjectNamed(field.GetTypeName()) ++ typ, wire = "*"+g.TypeName(desc), "group" ++ case descriptor.FieldDescriptorProto_TYPE_MESSAGE: ++ desc := g.ObjectNamed(field.GetTypeName()) ++ typ, wire = "*"+g.TypeName(desc), "bytes" ++ case descriptor.FieldDescriptorProto_TYPE_BYTES: ++ typ, wire = "[]byte", "bytes" ++ case descriptor.FieldDescriptorProto_TYPE_ENUM: ++ desc := g.ObjectNamed(field.GetTypeName()) ++ typ, wire = g.TypeName(desc), "varint" ++ case descriptor.FieldDescriptorProto_TYPE_SFIXED32: ++ typ, wire = "int32", "fixed32" ++ case descriptor.FieldDescriptorProto_TYPE_SFIXED64: ++ typ, wire = "int64", "fixed64" ++ case descriptor.FieldDescriptorProto_TYPE_SINT32: ++ typ, wire = "int32", "zigzag32" ++ case descriptor.FieldDescriptorProto_TYPE_SINT64: ++ typ, wire = "int64", "zigzag64" ++ default: ++ g.Fail("unknown type for", field.GetName()) ++ } ++ if isRepeated(field) { ++ typ = "[]" + typ ++ } else if message != nil && message.proto3() { ++ return ++ } else if field.OneofIndex != nil && message != nil { ++ return ++ } else if needsStar(*field.Type) { ++ typ = "*" + typ ++ } ++ return ++} ++ ++func (g *Generator) RecordTypeUse(t string) { ++ if obj, ok := g.typeNameToObject[t]; ok { ++ // Call ObjectNamed to get the true object to record the use. ++ obj = g.ObjectNamed(t) ++ g.usedPackages[obj.PackageName()] = true ++ } ++} ++ ++// Method names that may be generated. Fields with these names get an ++// underscore appended. Any change to this set is a potential incompatible ++// API change because it changes generated field names. ++var methodNames = [...]string{ ++ "Reset", ++ "String", ++ "ProtoMessage", ++ "Marshal", ++ "Unmarshal", ++ "ExtensionRangeArray", ++ "ExtensionMap", ++ "Descriptor", ++} ++ ++// Names of messages in the `google.protobuf` package for which ++// we will generate XXX_WellKnownType methods. ++var wellKnownTypes = map[string]bool{ ++ "Any": true, ++ "Duration": true, ++ "Empty": true, ++ "Struct": true, ++ "Timestamp": true, ++ ++ "Value": true, ++ "ListValue": true, ++ "DoubleValue": true, ++ "FloatValue": true, ++ "Int64Value": true, ++ "UInt64Value": true, ++ "Int32Value": true, ++ "UInt32Value": true, ++ "BoolValue": true, ++ "StringValue": true, ++ "BytesValue": true, ++} ++ ++// Generate the type and default constant definitions for this Descriptor. ++func (g *Generator) generateMessage(message *Descriptor) { ++ // The full type name ++ typeName := message.TypeName() ++ // The full type name, CamelCased. ++ ccTypeName := CamelCaseSlice(typeName) ++ ++ usedNames := make(map[string]bool) ++ for _, n := range methodNames { ++ usedNames[n] = true ++ } ++ fieldNames := make(map[*descriptor.FieldDescriptorProto]string) ++ fieldGetterNames := make(map[*descriptor.FieldDescriptorProto]string) ++ fieldTypes := make(map[*descriptor.FieldDescriptorProto]string) ++ mapFieldTypes := make(map[*descriptor.FieldDescriptorProto]string) ++ ++ oneofFieldName := make(map[int32]string) // indexed by oneof_index field of FieldDescriptorProto ++ oneofDisc := make(map[int32]string) // name of discriminator method ++ oneofTypeName := make(map[*descriptor.FieldDescriptorProto]string) // without star ++ oneofInsertPoints := make(map[int32]int) // oneof_index => offset of g.Buffer ++ ++ g.PrintComments(message.path) ++ g.P("type ", ccTypeName, " struct {") ++ g.In() ++ ++ // allocNames finds a conflict-free variation of the given strings, ++ // consistently mutating their suffixes. ++ // It returns the same number of strings. ++ allocNames := func(ns ...string) []string { ++ Loop: ++ for { ++ for _, n := range ns { ++ if usedNames[n] { ++ for i := range ns { ++ ns[i] += "_" ++ } ++ continue Loop ++ } ++ } ++ for _, n := range ns { ++ usedNames[n] = true ++ } ++ return ns ++ } ++ } ++ ++ for i, field := range message.Field { ++ // Allocate the getter and the field at the same time so name ++ // collisions create field/method consistent names. ++ // TODO: This allocation occurs based on the order of the fields ++ // in the proto file, meaning that a change in the field ++ // ordering can change generated Method/Field names. ++ base := CamelCase(*field.Name) ++ ns := allocNames(base, "Get"+base) ++ fieldName, fieldGetterName := ns[0], ns[1] ++ typename, wiretype := g.GoType(message, field) ++ jsonName := *field.Name ++ tag := fmt.Sprintf("protobuf:%s json:%q", g.goTag(message, field, wiretype), jsonName+",omitempty") ++ ++ fieldNames[field] = fieldName ++ fieldGetterNames[field] = fieldGetterName ++ ++ oneof := field.OneofIndex != nil ++ if oneof && oneofFieldName[*field.OneofIndex] == "" { ++ odp := message.OneofDecl[int(*field.OneofIndex)] ++ fname := allocNames(CamelCase(odp.GetName()))[0] ++ ++ // This is the first field of a oneof we haven't seen before. ++ // Generate the union field. ++ com := g.PrintComments(fmt.Sprintf("%s,%d,%d", message.path, messageOneofPath, *field.OneofIndex)) ++ if com { ++ g.P("//") ++ } ++ g.P("// Types that are valid to be assigned to ", fname, ":") ++ // Generate the rest of this comment later, ++ // when we've computed any disambiguation. ++ oneofInsertPoints[*field.OneofIndex] = g.Buffer.Len() ++ ++ dname := "is" + ccTypeName + "_" + fname ++ oneofFieldName[*field.OneofIndex] = fname ++ oneofDisc[*field.OneofIndex] = dname ++ tag := `protobuf_oneof:"` + odp.GetName() + `"` ++ g.P(fname, " ", dname, " `", tag, "`") ++ } ++ ++ if *field.Type == descriptor.FieldDescriptorProto_TYPE_MESSAGE { ++ desc := g.ObjectNamed(field.GetTypeName()) ++ if d, ok := desc.(*Descriptor); ok && d.GetOptions().GetMapEntry() { ++ // Figure out the Go types and tags for the key and value types. ++ keyField, valField := d.Field[0], d.Field[1] ++ keyType, keyWire := g.GoType(d, keyField) ++ valType, valWire := g.GoType(d, valField) ++ keyTag, valTag := g.goTag(d, keyField, keyWire), g.goTag(d, valField, valWire) ++ ++ // We don't use stars, except for message-typed values. ++ // Message and enum types are the only two possibly foreign types used in maps, ++ // so record their use. They are not permitted as map keys. ++ keyType = strings.TrimPrefix(keyType, "*") ++ switch *valField.Type { ++ case descriptor.FieldDescriptorProto_TYPE_ENUM: ++ valType = strings.TrimPrefix(valType, "*") ++ g.RecordTypeUse(valField.GetTypeName()) ++ case descriptor.FieldDescriptorProto_TYPE_MESSAGE: ++ g.RecordTypeUse(valField.GetTypeName()) ++ default: ++ valType = strings.TrimPrefix(valType, "*") ++ } ++ ++ typename = fmt.Sprintf("map[%s]%s", keyType, valType) ++ mapFieldTypes[field] = typename // record for the getter generation ++ ++ tag += fmt.Sprintf(" protobuf_key:%s protobuf_val:%s", keyTag, valTag) ++ } ++ } ++ ++ fieldTypes[field] = typename ++ ++ if oneof { ++ tname := ccTypeName + "_" + fieldName ++ // It is possible for this to collide with a message or enum ++ // nested in this message. Check for collisions. ++ for { ++ ok := true ++ for _, desc := range message.nested { ++ if CamelCaseSlice(desc.TypeName()) == tname { ++ ok = false ++ break ++ } ++ } ++ for _, enum := range message.enums { ++ if CamelCaseSlice(enum.TypeName()) == tname { ++ ok = false ++ break ++ } ++ } ++ if !ok { ++ tname += "_" ++ continue ++ } ++ break ++ } ++ ++ oneofTypeName[field] = tname ++ continue ++ } ++ ++ g.PrintComments(fmt.Sprintf("%s,%d,%d", message.path, messageFieldPath, i)) ++ g.P(fieldName, "\t", typename, "\t`", tag, "`") ++ g.RecordTypeUse(field.GetTypeName()) ++ } ++ if len(message.ExtensionRange) > 0 { ++ g.P(g.Pkg["proto"], ".XXX_InternalExtensions `json:\"-\"`") ++ } ++ if !message.proto3() { ++ g.P("XXX_unrecognized\t[]byte `json:\"-\"`") ++ } ++ g.Out() ++ g.P("}") ++ ++ // Update g.Buffer to list valid oneof types. ++ // We do this down here, after we've disambiguated the oneof type names. ++ // We go in reverse order of insertion point to avoid invalidating offsets. ++ for oi := int32(len(message.OneofDecl)); oi >= 0; oi-- { ++ ip := oneofInsertPoints[oi] ++ all := g.Buffer.Bytes() ++ rem := all[ip:] ++ g.Buffer = bytes.NewBuffer(all[:ip:ip]) // set cap so we don't scribble on rem ++ for _, field := range message.Field { ++ if field.OneofIndex == nil || *field.OneofIndex != oi { ++ continue ++ } ++ g.P("//\t*", oneofTypeName[field]) ++ } ++ g.Buffer.Write(rem) ++ } ++ ++ // Reset, String and ProtoMessage methods. ++ g.P("func (m *", ccTypeName, ") Reset() { *m = ", ccTypeName, "{} }") ++ g.P("func (m *", ccTypeName, ") String() string { return ", g.Pkg["proto"], ".CompactTextString(m) }") ++ g.P("func (*", ccTypeName, ") ProtoMessage() {}") ++ var indexes []string ++ for m := message; m != nil; m = m.parent { ++ indexes = append([]string{strconv.Itoa(m.index)}, indexes...) ++ } ++ g.P("func (*", ccTypeName, ") Descriptor() ([]byte, []int) { return ", g.file.VarName(), ", []int{", strings.Join(indexes, ", "), "} }") ++ // TODO: Revisit the decision to use a XXX_WellKnownType method ++ // if we change proto.MessageName to work with multiple equivalents. ++ if message.file.GetPackage() == "google.protobuf" && wellKnownTypes[message.GetName()] { ++ g.P("func (*", ccTypeName, `) XXX_WellKnownType() string { return "`, message.GetName(), `" }`) ++ } ++ ++ // Extension support methods ++ var hasExtensions, isMessageSet bool ++ if len(message.ExtensionRange) > 0 { ++ hasExtensions = true ++ // message_set_wire_format only makes sense when extensions are defined. ++ if opts := message.Options; opts != nil && opts.GetMessageSetWireFormat() { ++ isMessageSet = true ++ g.P() ++ g.P("func (m *", ccTypeName, ") Marshal() ([]byte, error) {") ++ g.In() ++ g.P("return ", g.Pkg["proto"], ".MarshalMessageSet(&m.XXX_InternalExtensions)") ++ g.Out() ++ g.P("}") ++ g.P("func (m *", ccTypeName, ") Unmarshal(buf []byte) error {") ++ g.In() ++ g.P("return ", g.Pkg["proto"], ".UnmarshalMessageSet(buf, &m.XXX_InternalExtensions)") ++ g.Out() ++ g.P("}") ++ g.P("func (m *", ccTypeName, ") MarshalJSON() ([]byte, error) {") ++ g.In() ++ g.P("return ", g.Pkg["proto"], ".MarshalMessageSetJSON(&m.XXX_InternalExtensions)") ++ g.Out() ++ g.P("}") ++ g.P("func (m *", ccTypeName, ") UnmarshalJSON(buf []byte) error {") ++ g.In() ++ g.P("return ", g.Pkg["proto"], ".UnmarshalMessageSetJSON(buf, &m.XXX_InternalExtensions)") ++ g.Out() ++ g.P("}") ++ g.P("// ensure ", ccTypeName, " satisfies proto.Marshaler and proto.Unmarshaler") ++ g.P("var _ ", g.Pkg["proto"], ".Marshaler = (*", ccTypeName, ")(nil)") ++ g.P("var _ ", g.Pkg["proto"], ".Unmarshaler = (*", ccTypeName, ")(nil)") ++ } ++ ++ g.P() ++ g.P("var extRange_", ccTypeName, " = []", g.Pkg["proto"], ".ExtensionRange{") ++ g.In() ++ for _, r := range message.ExtensionRange { ++ end := fmt.Sprint(*r.End - 1) // make range inclusive on both ends ++ g.P("{", r.Start, ", ", end, "},") ++ } ++ g.Out() ++ g.P("}") ++ g.P("func (*", ccTypeName, ") ExtensionRangeArray() []", g.Pkg["proto"], ".ExtensionRange {") ++ g.In() ++ g.P("return extRange_", ccTypeName) ++ g.Out() ++ g.P("}") ++ } ++ ++ // Default constants ++ defNames := make(map[*descriptor.FieldDescriptorProto]string) ++ for _, field := range message.Field { ++ def := field.GetDefaultValue() ++ if def == "" { ++ continue ++ } ++ fieldname := "Default_" + ccTypeName + "_" + CamelCase(*field.Name) ++ defNames[field] = fieldname ++ typename, _ := g.GoType(message, field) ++ if typename[0] == '*' { ++ typename = typename[1:] ++ } ++ kind := "const " ++ switch { ++ case typename == "bool": ++ case typename == "string": ++ def = strconv.Quote(def) ++ case typename == "[]byte": ++ def = "[]byte(" + strconv.Quote(def) + ")" ++ kind = "var " ++ case def == "inf", def == "-inf", def == "nan": ++ // These names are known to, and defined by, the protocol language. ++ switch def { ++ case "inf": ++ def = "math.Inf(1)" ++ case "-inf": ++ def = "math.Inf(-1)" ++ case "nan": ++ def = "math.NaN()" ++ } ++ if *field.Type == descriptor.FieldDescriptorProto_TYPE_FLOAT { ++ def = "float32(" + def + ")" ++ } ++ kind = "var " ++ case *field.Type == descriptor.FieldDescriptorProto_TYPE_ENUM: ++ // Must be an enum. Need to construct the prefixed name. ++ obj := g.ObjectNamed(field.GetTypeName()) ++ var enum *EnumDescriptor ++ if id, ok := obj.(*ImportedDescriptor); ok { ++ // The enum type has been publicly imported. ++ enum, _ = id.o.(*EnumDescriptor) ++ } else { ++ enum, _ = obj.(*EnumDescriptor) ++ } ++ if enum == nil { ++ log.Printf("don't know how to generate constant for %s", fieldname) ++ continue ++ } ++ def = g.DefaultPackageName(obj) + enum.prefix() + def ++ } ++ g.P(kind, fieldname, " ", typename, " = ", def) ++ g.file.addExport(message, constOrVarSymbol{fieldname, kind, ""}) ++ } ++ g.P() ++ ++ // Oneof per-field types, discriminants and getters. ++ // ++ // Generate unexported named types for the discriminant interfaces. ++ // We shouldn't have to do this, but there was (~19 Aug 2015) a compiler/linker bug ++ // that was triggered by using anonymous interfaces here. ++ // TODO: Revisit this and consider reverting back to anonymous interfaces. ++ for oi := range message.OneofDecl { ++ dname := oneofDisc[int32(oi)] ++ g.P("type ", dname, " interface { ", dname, "() }") ++ } ++ g.P() ++ for _, field := range message.Field { ++ if field.OneofIndex == nil { ++ continue ++ } ++ _, wiretype := g.GoType(message, field) ++ tag := "protobuf:" + g.goTag(message, field, wiretype) ++ g.P("type ", oneofTypeName[field], " struct{ ", fieldNames[field], " ", fieldTypes[field], " `", tag, "` }") ++ g.RecordTypeUse(field.GetTypeName()) ++ } ++ g.P() ++ for _, field := range message.Field { ++ if field.OneofIndex == nil { ++ continue ++ } ++ g.P("func (*", oneofTypeName[field], ") ", oneofDisc[*field.OneofIndex], "() {}") ++ } ++ g.P() ++ for oi := range message.OneofDecl { ++ fname := oneofFieldName[int32(oi)] ++ g.P("func (m *", ccTypeName, ") Get", fname, "() ", oneofDisc[int32(oi)], " {") ++ g.P("if m != nil { return m.", fname, " }") ++ g.P("return nil") ++ g.P("}") ++ } ++ g.P() ++ ++ // Field getters ++ var getters []getterSymbol ++ for _, field := range message.Field { ++ oneof := field.OneofIndex != nil ++ ++ fname := fieldNames[field] ++ typename, _ := g.GoType(message, field) ++ if t, ok := mapFieldTypes[field]; ok { ++ typename = t ++ } ++ mname := fieldGetterNames[field] ++ star := "" ++ if needsStar(*field.Type) && typename[0] == '*' { ++ typename = typename[1:] ++ star = "*" ++ } ++ ++ // Only export getter symbols for basic types, ++ // and for messages and enums in the same package. ++ // Groups are not exported. ++ // Foreign types can't be hoisted through a public import because ++ // the importer may not already be importing the defining .proto. ++ // As an example, imagine we have an import tree like this: ++ // A.proto -> B.proto -> C.proto ++ // If A publicly imports B, we need to generate the getters from B in A's output, ++ // but if one such getter returns something from C then we cannot do that ++ // because A is not importing C already. ++ var getter, genType bool ++ switch *field.Type { ++ case descriptor.FieldDescriptorProto_TYPE_GROUP: ++ getter = false ++ case descriptor.FieldDescriptorProto_TYPE_MESSAGE, descriptor.FieldDescriptorProto_TYPE_ENUM: ++ // Only export getter if its return type is in this package. ++ getter = g.ObjectNamed(field.GetTypeName()).PackageName() == message.PackageName() ++ genType = true ++ default: ++ getter = true ++ } ++ if getter { ++ getters = append(getters, getterSymbol{ ++ name: mname, ++ typ: typename, ++ typeName: field.GetTypeName(), ++ genType: genType, ++ }) ++ } ++ ++ g.P("func (m *", ccTypeName, ") "+mname+"() "+typename+" {") ++ g.In() ++ def, hasDef := defNames[field] ++ typeDefaultIsNil := false // whether this field type's default value is a literal nil unless specified ++ switch *field.Type { ++ case descriptor.FieldDescriptorProto_TYPE_BYTES: ++ typeDefaultIsNil = !hasDef ++ case descriptor.FieldDescriptorProto_TYPE_GROUP, descriptor.FieldDescriptorProto_TYPE_MESSAGE: ++ typeDefaultIsNil = true ++ } ++ if isRepeated(field) { ++ typeDefaultIsNil = true ++ } ++ if typeDefaultIsNil && !oneof { ++ // A bytes field with no explicit default needs less generated code, ++ // as does a message or group field, or a repeated field. ++ g.P("if m != nil {") ++ g.In() ++ g.P("return m." + fname) ++ g.Out() ++ g.P("}") ++ g.P("return nil") ++ g.Out() ++ g.P("}") ++ g.P() ++ continue ++ } ++ if !oneof { ++ if message.proto3() { ++ g.P("if m != nil {") ++ } else { ++ g.P("if m != nil && m." + fname + " != nil {") ++ } ++ g.In() ++ g.P("return " + star + "m." + fname) ++ g.Out() ++ g.P("}") ++ } else { ++ uname := oneofFieldName[*field.OneofIndex] ++ tname := oneofTypeName[field] ++ g.P("if x, ok := m.Get", uname, "().(*", tname, "); ok {") ++ g.P("return x.", fname) ++ g.P("}") ++ } ++ if hasDef { ++ if *field.Type != descriptor.FieldDescriptorProto_TYPE_BYTES { ++ g.P("return " + def) ++ } else { ++ // The default is a []byte var. ++ // Make a copy when returning it to be safe. ++ g.P("return append([]byte(nil), ", def, "...)") ++ } ++ } else { ++ switch *field.Type { ++ case descriptor.FieldDescriptorProto_TYPE_BOOL: ++ g.P("return false") ++ case descriptor.FieldDescriptorProto_TYPE_STRING: ++ g.P(`return ""`) ++ case descriptor.FieldDescriptorProto_TYPE_GROUP, ++ descriptor.FieldDescriptorProto_TYPE_MESSAGE, ++ descriptor.FieldDescriptorProto_TYPE_BYTES: ++ // This is only possible for oneof fields. ++ g.P("return nil") ++ case descriptor.FieldDescriptorProto_TYPE_ENUM: ++ // The default default for an enum is the first value in the enum, ++ // not zero. ++ obj := g.ObjectNamed(field.GetTypeName()) ++ var enum *EnumDescriptor ++ if id, ok := obj.(*ImportedDescriptor); ok { ++ // The enum type has been publicly imported. ++ enum, _ = id.o.(*EnumDescriptor) ++ } else { ++ enum, _ = obj.(*EnumDescriptor) ++ } ++ if enum == nil { ++ log.Printf("don't know how to generate getter for %s", field.GetName()) ++ continue ++ } ++ if len(enum.Value) == 0 { ++ g.P("return 0 // empty enum") ++ } else { ++ first := enum.Value[0].GetName() ++ g.P("return ", g.DefaultPackageName(obj)+enum.prefix()+first) ++ } ++ default: ++ g.P("return 0") ++ } ++ } ++ g.Out() ++ g.P("}") ++ g.P() ++ } ++ ++ if !message.group { ++ ms := &messageSymbol{ ++ sym: ccTypeName, ++ hasExtensions: hasExtensions, ++ isMessageSet: isMessageSet, ++ hasOneof: len(message.OneofDecl) > 0, ++ getters: getters, ++ } ++ g.file.addExport(message, ms) ++ } ++ ++ // Oneof functions ++ if len(message.OneofDecl) > 0 { ++ fieldWire := make(map[*descriptor.FieldDescriptorProto]string) ++ ++ // method ++ enc := "_" + ccTypeName + "_OneofMarshaler" ++ dec := "_" + ccTypeName + "_OneofUnmarshaler" ++ size := "_" + ccTypeName + "_OneofSizer" ++ encSig := "(msg " + g.Pkg["proto"] + ".Message, b *" + g.Pkg["proto"] + ".Buffer) error" ++ decSig := "(msg " + g.Pkg["proto"] + ".Message, tag, wire int, b *" + g.Pkg["proto"] + ".Buffer) (bool, error)" ++ sizeSig := "(msg " + g.Pkg["proto"] + ".Message) (n int)" ++ ++ g.P("// XXX_OneofFuncs is for the internal use of the proto package.") ++ g.P("func (*", ccTypeName, ") XXX_OneofFuncs() (func", encSig, ", func", decSig, ", func", sizeSig, ", []interface{}) {") ++ g.P("return ", enc, ", ", dec, ", ", size, ", []interface{}{") ++ for _, field := range message.Field { ++ if field.OneofIndex == nil { ++ continue ++ } ++ g.P("(*", oneofTypeName[field], ")(nil),") ++ } ++ g.P("}") ++ g.P("}") ++ g.P() ++ ++ // marshaler ++ g.P("func ", enc, encSig, " {") ++ g.P("m := msg.(*", ccTypeName, ")") ++ for oi, odp := range message.OneofDecl { ++ g.P("// ", odp.GetName()) ++ fname := oneofFieldName[int32(oi)] ++ g.P("switch x := m.", fname, ".(type) {") ++ for _, field := range message.Field { ++ if field.OneofIndex == nil || int(*field.OneofIndex) != oi { ++ continue ++ } ++ g.P("case *", oneofTypeName[field], ":") ++ var wire, pre, post string ++ val := "x." + fieldNames[field] // overridden for TYPE_BOOL ++ canFail := false // only TYPE_MESSAGE and TYPE_GROUP can fail ++ switch *field.Type { ++ case descriptor.FieldDescriptorProto_TYPE_DOUBLE: ++ wire = "WireFixed64" ++ pre = "b.EncodeFixed64(" + g.Pkg["math"] + ".Float64bits(" ++ post = "))" ++ case descriptor.FieldDescriptorProto_TYPE_FLOAT: ++ wire = "WireFixed32" ++ pre = "b.EncodeFixed32(uint64(" + g.Pkg["math"] + ".Float32bits(" ++ post = ")))" ++ case descriptor.FieldDescriptorProto_TYPE_INT64, ++ descriptor.FieldDescriptorProto_TYPE_UINT64: ++ wire = "WireVarint" ++ pre, post = "b.EncodeVarint(uint64(", "))" ++ case descriptor.FieldDescriptorProto_TYPE_INT32, ++ descriptor.FieldDescriptorProto_TYPE_UINT32, ++ descriptor.FieldDescriptorProto_TYPE_ENUM: ++ wire = "WireVarint" ++ pre, post = "b.EncodeVarint(uint64(", "))" ++ case descriptor.FieldDescriptorProto_TYPE_FIXED64, ++ descriptor.FieldDescriptorProto_TYPE_SFIXED64: ++ wire = "WireFixed64" ++ pre, post = "b.EncodeFixed64(uint64(", "))" ++ case descriptor.FieldDescriptorProto_TYPE_FIXED32, ++ descriptor.FieldDescriptorProto_TYPE_SFIXED32: ++ wire = "WireFixed32" ++ pre, post = "b.EncodeFixed32(uint64(", "))" ++ case descriptor.FieldDescriptorProto_TYPE_BOOL: ++ // bool needs special handling. ++ g.P("t := uint64(0)") ++ g.P("if ", val, " { t = 1 }") ++ val = "t" ++ wire = "WireVarint" ++ pre, post = "b.EncodeVarint(", ")" ++ case descriptor.FieldDescriptorProto_TYPE_STRING: ++ wire = "WireBytes" ++ pre, post = "b.EncodeStringBytes(", ")" ++ case descriptor.FieldDescriptorProto_TYPE_GROUP: ++ wire = "WireStartGroup" ++ pre, post = "b.Marshal(", ")" ++ canFail = true ++ case descriptor.FieldDescriptorProto_TYPE_MESSAGE: ++ wire = "WireBytes" ++ pre, post = "b.EncodeMessage(", ")" ++ canFail = true ++ case descriptor.FieldDescriptorProto_TYPE_BYTES: ++ wire = "WireBytes" ++ pre, post = "b.EncodeRawBytes(", ")" ++ case descriptor.FieldDescriptorProto_TYPE_SINT32: ++ wire = "WireVarint" ++ pre, post = "b.EncodeZigzag32(uint64(", "))" ++ case descriptor.FieldDescriptorProto_TYPE_SINT64: ++ wire = "WireVarint" ++ pre, post = "b.EncodeZigzag64(uint64(", "))" ++ default: ++ g.Fail("unhandled oneof field type ", field.Type.String()) ++ } ++ fieldWire[field] = wire ++ g.P("b.EncodeVarint(", field.Number, "<<3|", g.Pkg["proto"], ".", wire, ")") ++ if !canFail { ++ g.P(pre, val, post) ++ } else { ++ g.P("if err := ", pre, val, post, "; err != nil {") ++ g.P("return err") ++ g.P("}") ++ } ++ if *field.Type == descriptor.FieldDescriptorProto_TYPE_GROUP { ++ g.P("b.EncodeVarint(", field.Number, "<<3|", g.Pkg["proto"], ".WireEndGroup)") ++ } ++ } ++ g.P("case nil:") ++ g.P("default: return ", g.Pkg["fmt"], `.Errorf("`, ccTypeName, ".", fname, ` has unexpected type %T", x)`) ++ g.P("}") ++ } ++ g.P("return nil") ++ g.P("}") ++ g.P() ++ ++ // unmarshaler ++ g.P("func ", dec, decSig, " {") ++ g.P("m := msg.(*", ccTypeName, ")") ++ g.P("switch tag {") ++ for _, field := range message.Field { ++ if field.OneofIndex == nil { ++ continue ++ } ++ odp := message.OneofDecl[int(*field.OneofIndex)] ++ g.P("case ", field.Number, ": // ", odp.GetName(), ".", *field.Name) ++ g.P("if wire != ", g.Pkg["proto"], ".", fieldWire[field], " {") ++ g.P("return true, ", g.Pkg["proto"], ".ErrInternalBadWireType") ++ g.P("}") ++ lhs := "x, err" // overridden for TYPE_MESSAGE and TYPE_GROUP ++ var dec, cast, cast2 string ++ switch *field.Type { ++ case descriptor.FieldDescriptorProto_TYPE_DOUBLE: ++ dec, cast = "b.DecodeFixed64()", g.Pkg["math"]+".Float64frombits" ++ case descriptor.FieldDescriptorProto_TYPE_FLOAT: ++ dec, cast, cast2 = "b.DecodeFixed32()", "uint32", g.Pkg["math"]+".Float32frombits" ++ case descriptor.FieldDescriptorProto_TYPE_INT64: ++ dec, cast = "b.DecodeVarint()", "int64" ++ case descriptor.FieldDescriptorProto_TYPE_UINT64: ++ dec = "b.DecodeVarint()" ++ case descriptor.FieldDescriptorProto_TYPE_INT32: ++ dec, cast = "b.DecodeVarint()", "int32" ++ case descriptor.FieldDescriptorProto_TYPE_FIXED64: ++ dec = "b.DecodeFixed64()" ++ case descriptor.FieldDescriptorProto_TYPE_FIXED32: ++ dec, cast = "b.DecodeFixed32()", "uint32" ++ case descriptor.FieldDescriptorProto_TYPE_BOOL: ++ dec = "b.DecodeVarint()" ++ // handled specially below ++ case descriptor.FieldDescriptorProto_TYPE_STRING: ++ dec = "b.DecodeStringBytes()" ++ case descriptor.FieldDescriptorProto_TYPE_GROUP: ++ g.P("msg := new(", fieldTypes[field][1:], ")") // drop star ++ lhs = "err" ++ dec = "b.DecodeGroup(msg)" ++ // handled specially below ++ case descriptor.FieldDescriptorProto_TYPE_MESSAGE: ++ g.P("msg := new(", fieldTypes[field][1:], ")") // drop star ++ lhs = "err" ++ dec = "b.DecodeMessage(msg)" ++ // handled specially below ++ case descriptor.FieldDescriptorProto_TYPE_BYTES: ++ dec = "b.DecodeRawBytes(true)" ++ case descriptor.FieldDescriptorProto_TYPE_UINT32: ++ dec, cast = "b.DecodeVarint()", "uint32" ++ case descriptor.FieldDescriptorProto_TYPE_ENUM: ++ dec, cast = "b.DecodeVarint()", fieldTypes[field] ++ case descriptor.FieldDescriptorProto_TYPE_SFIXED32: ++ dec, cast = "b.DecodeFixed32()", "int32" ++ case descriptor.FieldDescriptorProto_TYPE_SFIXED64: ++ dec, cast = "b.DecodeFixed64()", "int64" ++ case descriptor.FieldDescriptorProto_TYPE_SINT32: ++ dec, cast = "b.DecodeZigzag32()", "int32" ++ case descriptor.FieldDescriptorProto_TYPE_SINT64: ++ dec, cast = "b.DecodeZigzag64()", "int64" ++ default: ++ g.Fail("unhandled oneof field type ", field.Type.String()) ++ } ++ g.P(lhs, " := ", dec) ++ val := "x" ++ if cast != "" { ++ val = cast + "(" + val + ")" ++ } ++ if cast2 != "" { ++ val = cast2 + "(" + val + ")" ++ } ++ switch *field.Type { ++ case descriptor.FieldDescriptorProto_TYPE_BOOL: ++ val += " != 0" ++ case descriptor.FieldDescriptorProto_TYPE_GROUP, ++ descriptor.FieldDescriptorProto_TYPE_MESSAGE: ++ val = "msg" ++ } ++ g.P("m.", oneofFieldName[*field.OneofIndex], " = &", oneofTypeName[field], "{", val, "}") ++ g.P("return true, err") ++ } ++ g.P("default: return false, nil") ++ g.P("}") ++ g.P("}") ++ g.P() ++ ++ // sizer ++ g.P("func ", size, sizeSig, " {") ++ g.P("m := msg.(*", ccTypeName, ")") ++ for oi, odp := range message.OneofDecl { ++ g.P("// ", odp.GetName()) ++ fname := oneofFieldName[int32(oi)] ++ g.P("switch x := m.", fname, ".(type) {") ++ for _, field := range message.Field { ++ if field.OneofIndex == nil || int(*field.OneofIndex) != oi { ++ continue ++ } ++ g.P("case *", oneofTypeName[field], ":") ++ val := "x." + fieldNames[field] ++ var wire, varint, fixed string ++ switch *field.Type { ++ case descriptor.FieldDescriptorProto_TYPE_DOUBLE: ++ wire = "WireFixed64" ++ fixed = "8" ++ case descriptor.FieldDescriptorProto_TYPE_FLOAT: ++ wire = "WireFixed32" ++ fixed = "4" ++ case descriptor.FieldDescriptorProto_TYPE_INT64, ++ descriptor.FieldDescriptorProto_TYPE_UINT64, ++ descriptor.FieldDescriptorProto_TYPE_INT32, ++ descriptor.FieldDescriptorProto_TYPE_UINT32, ++ descriptor.FieldDescriptorProto_TYPE_ENUM: ++ wire = "WireVarint" ++ varint = val ++ case descriptor.FieldDescriptorProto_TYPE_FIXED64, ++ descriptor.FieldDescriptorProto_TYPE_SFIXED64: ++ wire = "WireFixed64" ++ fixed = "8" ++ case descriptor.FieldDescriptorProto_TYPE_FIXED32, ++ descriptor.FieldDescriptorProto_TYPE_SFIXED32: ++ wire = "WireFixed32" ++ fixed = "4" ++ case descriptor.FieldDescriptorProto_TYPE_BOOL: ++ wire = "WireVarint" ++ fixed = "1" ++ case descriptor.FieldDescriptorProto_TYPE_STRING: ++ wire = "WireBytes" ++ fixed = "len(" + val + ")" ++ varint = fixed ++ case descriptor.FieldDescriptorProto_TYPE_GROUP: ++ wire = "WireStartGroup" ++ fixed = g.Pkg["proto"] + ".Size(" + val + ")" ++ case descriptor.FieldDescriptorProto_TYPE_MESSAGE: ++ wire = "WireBytes" ++ g.P("s := ", g.Pkg["proto"], ".Size(", val, ")") ++ fixed = "s" ++ varint = fixed ++ case descriptor.FieldDescriptorProto_TYPE_BYTES: ++ wire = "WireBytes" ++ fixed = "len(" + val + ")" ++ varint = fixed ++ case descriptor.FieldDescriptorProto_TYPE_SINT32: ++ wire = "WireVarint" ++ varint = "(uint32(" + val + ") << 1) ^ uint32((int32(" + val + ") >> 31))" ++ case descriptor.FieldDescriptorProto_TYPE_SINT64: ++ wire = "WireVarint" ++ varint = "uint64(" + val + " << 1) ^ uint64((int64(" + val + ") >> 63))" ++ default: ++ g.Fail("unhandled oneof field type ", field.Type.String()) ++ } ++ g.P("n += ", g.Pkg["proto"], ".SizeVarint(", field.Number, "<<3|", g.Pkg["proto"], ".", wire, ")") ++ if varint != "" { ++ g.P("n += ", g.Pkg["proto"], ".SizeVarint(uint64(", varint, "))") ++ } ++ if fixed != "" { ++ g.P("n += ", fixed) ++ } ++ if *field.Type == descriptor.FieldDescriptorProto_TYPE_GROUP { ++ g.P("n += ", g.Pkg["proto"], ".SizeVarint(", field.Number, "<<3|", g.Pkg["proto"], ".WireEndGroup)") ++ } ++ } ++ g.P("case nil:") ++ g.P("default:") ++ g.P("panic(", g.Pkg["fmt"], ".Sprintf(\"proto: unexpected type %T in oneof\", x))") ++ g.P("}") ++ } ++ g.P("return n") ++ g.P("}") ++ g.P() ++ } ++ ++ for _, ext := range message.ext { ++ g.generateExtension(ext) ++ } ++ ++ fullName := strings.Join(message.TypeName(), ".") ++ if g.file.Package != nil { ++ fullName = *g.file.Package + "." + fullName ++ } ++ ++ g.addInitf("%s.RegisterType((*%s)(nil), %q)", g.Pkg["proto"], ccTypeName, fullName) ++} ++ ++func (g *Generator) generateExtension(ext *ExtensionDescriptor) { ++ ccTypeName := ext.DescName() ++ ++ extObj := g.ObjectNamed(*ext.Extendee) ++ var extDesc *Descriptor ++ if id, ok := extObj.(*ImportedDescriptor); ok { ++ // This is extending a publicly imported message. ++ // We need the underlying type for goTag. ++ extDesc = id.o.(*Descriptor) ++ } else { ++ extDesc = extObj.(*Descriptor) ++ } ++ extendedType := "*" + g.TypeName(extObj) // always use the original ++ field := ext.FieldDescriptorProto ++ fieldType, wireType := g.GoType(ext.parent, field) ++ tag := g.goTag(extDesc, field, wireType) ++ g.RecordTypeUse(*ext.Extendee) ++ if n := ext.FieldDescriptorProto.TypeName; n != nil { ++ // foreign extension type ++ g.RecordTypeUse(*n) ++ } ++ ++ typeName := ext.TypeName() ++ ++ // Special case for proto2 message sets: If this extension is extending ++ // proto2_bridge.MessageSet, and its final name component is "message_set_extension", ++ // then drop that last component. ++ mset := false ++ if extendedType == "*proto2_bridge.MessageSet" && typeName[len(typeName)-1] == "message_set_extension" { ++ typeName = typeName[:len(typeName)-1] ++ mset = true ++ } ++ ++ // For text formatting, the package must be exactly what the .proto file declares, ++ // ignoring overrides such as the go_package option, and with no dot/underscore mapping. ++ extName := strings.Join(typeName, ".") ++ if g.file.Package != nil { ++ extName = *g.file.Package + "." + extName ++ } ++ ++ g.P("var ", ccTypeName, " = &", g.Pkg["proto"], ".ExtensionDesc{") ++ g.In() ++ g.P("ExtendedType: (", extendedType, ")(nil),") ++ g.P("ExtensionType: (", fieldType, ")(nil),") ++ g.P("Field: ", field.Number, ",") ++ g.P(`Name: "`, extName, `",`) ++ g.P("Tag: ", tag, ",") ++ g.P(`Filename: "`, g.file.GetName(), `",`) ++ ++ g.Out() ++ g.P("}") ++ g.P() ++ ++ if mset { ++ // Generate a bit more code to register with message_set.go. ++ g.addInitf("%s.RegisterMessageSetType((%s)(nil), %d, %q)", g.Pkg["proto"], fieldType, *field.Number, extName) ++ } ++ ++ g.file.addExport(ext, constOrVarSymbol{ccTypeName, "var", ""}) ++} ++ ++func (g *Generator) generateInitFunction() { ++ for _, enum := range g.file.enum { ++ g.generateEnumRegistration(enum) ++ } ++ for _, d := range g.file.desc { ++ for _, ext := range d.ext { ++ g.generateExtensionRegistration(ext) ++ } ++ } ++ for _, ext := range g.file.ext { ++ g.generateExtensionRegistration(ext) ++ } ++ if len(g.init) == 0 { ++ return ++ } ++ g.P("func init() {") ++ g.In() ++ for _, l := range g.init { ++ g.P(l) ++ } ++ g.Out() ++ g.P("}") ++ g.init = nil ++} ++ ++func (g *Generator) generateFileDescriptor(file *FileDescriptor) { ++ // Make a copy and trim source_code_info data. ++ // TODO: Trim this more when we know exactly what we need. ++ pb := proto.Clone(file.FileDescriptorProto).(*descriptor.FileDescriptorProto) ++ pb.SourceCodeInfo = nil ++ ++ b, err := proto.Marshal(pb) ++ if err != nil { ++ g.Fail(err.Error()) ++ } ++ ++ var buf bytes.Buffer ++ w, _ := gzip.NewWriterLevel(&buf, gzip.BestCompression) ++ w.Write(b) ++ w.Close() ++ b = buf.Bytes() ++ ++ v := file.VarName() ++ g.P() ++ g.P("func init() { ", g.Pkg["proto"], ".RegisterFile(", strconv.Quote(*file.Name), ", ", v, ") }") ++ g.P("var ", v, " = []byte{") ++ g.In() ++ g.P("// ", len(b), " bytes of a gzipped FileDescriptorProto") ++ for len(b) > 0 { ++ n := 16 ++ if n > len(b) { ++ n = len(b) ++ } ++ ++ s := "" ++ for _, c := range b[:n] { ++ s += fmt.Sprintf("0x%02x,", c) ++ } ++ g.P(s) ++ ++ b = b[n:] ++ } ++ g.Out() ++ g.P("}") ++} ++ ++func (g *Generator) generateEnumRegistration(enum *EnumDescriptor) { ++ // // We always print the full (proto-world) package name here. ++ pkg := enum.File().GetPackage() ++ if pkg != "" { ++ pkg += "." ++ } ++ // The full type name ++ typeName := enum.TypeName() ++ // The full type name, CamelCased. ++ ccTypeName := CamelCaseSlice(typeName) ++ g.addInitf("%s.RegisterEnum(%q, %[3]s_name, %[3]s_value)", g.Pkg["proto"], pkg+ccTypeName, ccTypeName) ++} ++ ++func (g *Generator) generateExtensionRegistration(ext *ExtensionDescriptor) { ++ g.addInitf("%s.RegisterExtension(%s)", g.Pkg["proto"], ext.DescName()) ++} ++ ++// And now lots of helper functions. ++ ++// Is c an ASCII lower-case letter? ++func isASCIILower(c byte) bool { ++ return 'a' <= c && c <= 'z' ++} ++ ++// Is c an ASCII digit? ++func isASCIIDigit(c byte) bool { ++ return '0' <= c && c <= '9' ++} ++ ++// CamelCase returns the CamelCased name. ++// If there is an interior underscore followed by a lower case letter, ++// drop the underscore and convert the letter to upper case. ++// There is a remote possibility of this rewrite causing a name collision, ++// but it's so remote we're prepared to pretend it's nonexistent - since the ++// C++ generator lowercases names, it's extremely unlikely to have two fields ++// with different capitalizations. ++// In short, _my_field_name_2 becomes XMyFieldName_2. ++func CamelCase(s string) string { ++ if s == "" { ++ return "" ++ } ++ t := make([]byte, 0, 32) ++ i := 0 ++ if s[0] == '_' { ++ // Need a capital letter; drop the '_'. ++ t = append(t, 'X') ++ i++ ++ } ++ // Invariant: if the next letter is lower case, it must be converted ++ // to upper case. ++ // That is, we process a word at a time, where words are marked by _ or ++ // upper case letter. Digits are treated as words. ++ for ; i < len(s); i++ { ++ c := s[i] ++ if c == '_' && i+1 < len(s) && isASCIILower(s[i+1]) { ++ continue // Skip the underscore in s. ++ } ++ if isASCIIDigit(c) { ++ t = append(t, c) ++ continue ++ } ++ // Assume we have a letter now - if not, it's a bogus identifier. ++ // The next word is a sequence of characters that must start upper case. ++ if isASCIILower(c) { ++ c ^= ' ' // Make it a capital letter. ++ } ++ t = append(t, c) // Guaranteed not lower case. ++ // Accept lower case sequence that follows. ++ for i+1 < len(s) && isASCIILower(s[i+1]) { ++ i++ ++ t = append(t, s[i]) ++ } ++ } ++ return string(t) ++} ++ ++// CamelCaseSlice is like CamelCase, but the argument is a slice of strings to ++// be joined with "_". ++func CamelCaseSlice(elem []string) string { return CamelCase(strings.Join(elem, "_")) } ++ ++// dottedSlice turns a sliced name into a dotted name. ++func dottedSlice(elem []string) string { return strings.Join(elem, ".") } ++ ++// Is this field optional? ++func isOptional(field *descriptor.FieldDescriptorProto) bool { ++ return field.Label != nil && *field.Label == descriptor.FieldDescriptorProto_LABEL_OPTIONAL ++} ++ ++// Is this field required? ++func isRequired(field *descriptor.FieldDescriptorProto) bool { ++ return field.Label != nil && *field.Label == descriptor.FieldDescriptorProto_LABEL_REQUIRED ++} ++ ++// Is this field repeated? ++func isRepeated(field *descriptor.FieldDescriptorProto) bool { ++ return field.Label != nil && *field.Label == descriptor.FieldDescriptorProto_LABEL_REPEATED ++} ++ ++// Is this field a scalar numeric type? ++func isScalar(field *descriptor.FieldDescriptorProto) bool { ++ if field.Type == nil { ++ return false ++ } ++ switch *field.Type { ++ case descriptor.FieldDescriptorProto_TYPE_DOUBLE, ++ descriptor.FieldDescriptorProto_TYPE_FLOAT, ++ descriptor.FieldDescriptorProto_TYPE_INT64, ++ descriptor.FieldDescriptorProto_TYPE_UINT64, ++ descriptor.FieldDescriptorProto_TYPE_INT32, ++ descriptor.FieldDescriptorProto_TYPE_FIXED64, ++ descriptor.FieldDescriptorProto_TYPE_FIXED32, ++ descriptor.FieldDescriptorProto_TYPE_BOOL, ++ descriptor.FieldDescriptorProto_TYPE_UINT32, ++ descriptor.FieldDescriptorProto_TYPE_ENUM, ++ descriptor.FieldDescriptorProto_TYPE_SFIXED32, ++ descriptor.FieldDescriptorProto_TYPE_SFIXED64, ++ descriptor.FieldDescriptorProto_TYPE_SINT32, ++ descriptor.FieldDescriptorProto_TYPE_SINT64: ++ return true ++ default: ++ return false ++ } ++} ++ ++// badToUnderscore is the mapping function used to generate Go names from package names, ++// which can be dotted in the input .proto file. It replaces non-identifier characters such as ++// dot or dash with underscore. ++func badToUnderscore(r rune) rune { ++ if unicode.IsLetter(r) || unicode.IsDigit(r) || r == '_' { ++ return r ++ } ++ return '_' ++} ++ ++// baseName returns the last path element of the name, with the last dotted suffix removed. ++func baseName(name string) string { ++ // First, find the last element ++ if i := strings.LastIndex(name, "/"); i >= 0 { ++ name = name[i+1:] ++ } ++ // Now drop the suffix ++ if i := strings.LastIndex(name, "."); i >= 0 { ++ name = name[0:i] ++ } ++ return name ++} ++ ++// The SourceCodeInfo message describes the location of elements of a parsed ++// .proto file by way of a "path", which is a sequence of integers that ++// describe the route from a FileDescriptorProto to the relevant submessage. ++// The path alternates between a field number of a repeated field, and an index ++// into that repeated field. The constants below define the field numbers that ++// are used. ++// ++// See descriptor.proto for more information about this. ++const ( ++ // tag numbers in FileDescriptorProto ++ packagePath = 2 // package ++ messagePath = 4 // message_type ++ enumPath = 5 // enum_type ++ // tag numbers in DescriptorProto ++ messageFieldPath = 2 // field ++ messageMessagePath = 3 // nested_type ++ messageEnumPath = 4 // enum_type ++ messageOneofPath = 8 // oneof_decl ++ // tag numbers in EnumDescriptorProto ++ enumValuePath = 2 // value ++) +diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/grpc/grpc.go b/vendor/github.com/golang/protobuf/protoc-gen-go/grpc/grpc.go +new file mode 100644 +index 0000000..2660e47 +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/protoc-gen-go/grpc/grpc.go +@@ -0,0 +1,463 @@ ++// Go support for Protocol Buffers - Google's data interchange format ++// ++// Copyright 2015 The Go Authors. All rights reserved. ++// https://github.com/golang/protobuf ++// ++// Redistribution and use in source and binary forms, with or without ++// modification, are permitted provided that the following conditions are ++// met: ++// ++// * Redistributions of source code must retain the above copyright ++// notice, this list of conditions and the following disclaimer. ++// * Redistributions in binary form must reproduce the above ++// copyright notice, this list of conditions and the following disclaimer ++// in the documentation and/or other materials provided with the ++// distribution. ++// * Neither the name of Google Inc. nor the names of its ++// contributors may be used to endorse or promote products derived from ++// this software without specific prior written permission. ++// ++// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++// Package grpc outputs gRPC service descriptions in Go code. ++// It runs as a plugin for the Go protocol buffer compiler plugin. ++// It is linked in to protoc-gen-go. ++package grpc ++ ++import ( ++ "fmt" ++ "path" ++ "strconv" ++ "strings" ++ ++ pb "github.com/golang/protobuf/protoc-gen-go/descriptor" ++ "github.com/golang/protobuf/protoc-gen-go/generator" ++) ++ ++// generatedCodeVersion indicates a version of the generated code. ++// It is incremented whenever an incompatibility between the generated code and ++// the grpc package is introduced; the generated code references ++// a constant, grpc.SupportPackageIsVersionN (where N is generatedCodeVersion). ++const generatedCodeVersion = 4 ++ ++// Paths for packages used by code generated in this file, ++// relative to the import_prefix of the generator.Generator. ++const ( ++ contextPkgPath = "golang.org/x/net/context" ++ grpcPkgPath = "google.golang.org/grpc" ++) ++ ++func init() { ++ generator.RegisterPlugin(new(grpc)) ++} ++ ++// grpc is an implementation of the Go protocol buffer compiler's ++// plugin architecture. It generates bindings for gRPC support. ++type grpc struct { ++ gen *generator.Generator ++} ++ ++// Name returns the name of this plugin, "grpc". ++func (g *grpc) Name() string { ++ return "grpc" ++} ++ ++// The names for packages imported in the generated code. ++// They may vary from the final path component of the import path ++// if the name is used by other packages. ++var ( ++ contextPkg string ++ grpcPkg string ++) ++ ++// Init initializes the plugin. ++func (g *grpc) Init(gen *generator.Generator) { ++ g.gen = gen ++ contextPkg = generator.RegisterUniquePackageName("context", nil) ++ grpcPkg = generator.RegisterUniquePackageName("grpc", nil) ++} ++ ++// Given a type name defined in a .proto, return its object. ++// Also record that we're using it, to guarantee the associated import. ++func (g *grpc) objectNamed(name string) generator.Object { ++ g.gen.RecordTypeUse(name) ++ return g.gen.ObjectNamed(name) ++} ++ ++// Given a type name defined in a .proto, return its name as we will print it. ++func (g *grpc) typeName(str string) string { ++ return g.gen.TypeName(g.objectNamed(str)) ++} ++ ++// P forwards to g.gen.P. ++func (g *grpc) P(args ...interface{}) { g.gen.P(args...) } ++ ++// Generate generates code for the services in the given file. ++func (g *grpc) Generate(file *generator.FileDescriptor) { ++ if len(file.FileDescriptorProto.Service) == 0 { ++ return ++ } ++ ++ g.P("// Reference imports to suppress errors if they are not otherwise used.") ++ g.P("var _ ", contextPkg, ".Context") ++ g.P("var _ ", grpcPkg, ".ClientConn") ++ g.P() ++ ++ // Assert version compatibility. ++ g.P("// This is a compile-time assertion to ensure that this generated file") ++ g.P("// is compatible with the grpc package it is being compiled against.") ++ g.P("const _ = ", grpcPkg, ".SupportPackageIsVersion", generatedCodeVersion) ++ g.P() ++ ++ for i, service := range file.FileDescriptorProto.Service { ++ g.generateService(file, service, i) ++ } ++} ++ ++// GenerateImports generates the import declaration for this file. ++func (g *grpc) GenerateImports(file *generator.FileDescriptor) { ++ if len(file.FileDescriptorProto.Service) == 0 { ++ return ++ } ++ g.P("import (") ++ g.P(contextPkg, " ", strconv.Quote(path.Join(g.gen.ImportPrefix, contextPkgPath))) ++ g.P(grpcPkg, " ", strconv.Quote(path.Join(g.gen.ImportPrefix, grpcPkgPath))) ++ g.P(")") ++ g.P() ++} ++ ++// reservedClientName records whether a client name is reserved on the client side. ++var reservedClientName = map[string]bool{ ++// TODO: do we need any in gRPC? ++} ++ ++func unexport(s string) string { return strings.ToLower(s[:1]) + s[1:] } ++ ++// generateService generates all the code for the named service. ++func (g *grpc) generateService(file *generator.FileDescriptor, service *pb.ServiceDescriptorProto, index int) { ++ path := fmt.Sprintf("6,%d", index) // 6 means service. ++ ++ origServName := service.GetName() ++ fullServName := origServName ++ if pkg := file.GetPackage(); pkg != "" { ++ fullServName = pkg + "." + fullServName ++ } ++ servName := generator.CamelCase(origServName) ++ ++ g.P() ++ g.P("// Client API for ", servName, " service") ++ g.P() ++ ++ // Client interface. ++ g.P("type ", servName, "Client interface {") ++ for i, method := range service.Method { ++ g.gen.PrintComments(fmt.Sprintf("%s,2,%d", path, i)) // 2 means method in a service. ++ g.P(g.generateClientSignature(servName, method)) ++ } ++ g.P("}") ++ g.P() ++ ++ // Client structure. ++ g.P("type ", unexport(servName), "Client struct {") ++ g.P("cc *", grpcPkg, ".ClientConn") ++ g.P("}") ++ g.P() ++ ++ // NewClient factory. ++ g.P("func New", servName, "Client (cc *", grpcPkg, ".ClientConn) ", servName, "Client {") ++ g.P("return &", unexport(servName), "Client{cc}") ++ g.P("}") ++ g.P() ++ ++ var methodIndex, streamIndex int ++ serviceDescVar := "_" + servName + "_serviceDesc" ++ // Client method implementations. ++ for _, method := range service.Method { ++ var descExpr string ++ if !method.GetServerStreaming() && !method.GetClientStreaming() { ++ // Unary RPC method ++ descExpr = fmt.Sprintf("&%s.Methods[%d]", serviceDescVar, methodIndex) ++ methodIndex++ ++ } else { ++ // Streaming RPC method ++ descExpr = fmt.Sprintf("&%s.Streams[%d]", serviceDescVar, streamIndex) ++ streamIndex++ ++ } ++ g.generateClientMethod(servName, fullServName, serviceDescVar, method, descExpr) ++ } ++ ++ g.P("// Server API for ", servName, " service") ++ g.P() ++ ++ // Server interface. ++ serverType := servName + "Server" ++ g.P("type ", serverType, " interface {") ++ for i, method := range service.Method { ++ g.gen.PrintComments(fmt.Sprintf("%s,2,%d", path, i)) // 2 means method in a service. ++ g.P(g.generateServerSignature(servName, method)) ++ } ++ g.P("}") ++ g.P() ++ ++ // Server registration. ++ g.P("func Register", servName, "Server(s *", grpcPkg, ".Server, srv ", serverType, ") {") ++ g.P("s.RegisterService(&", serviceDescVar, `, srv)`) ++ g.P("}") ++ g.P() ++ ++ // Server handler implementations. ++ var handlerNames []string ++ for _, method := range service.Method { ++ hname := g.generateServerMethod(servName, fullServName, method) ++ handlerNames = append(handlerNames, hname) ++ } ++ ++ // Service descriptor. ++ g.P("var ", serviceDescVar, " = ", grpcPkg, ".ServiceDesc {") ++ g.P("ServiceName: ", strconv.Quote(fullServName), ",") ++ g.P("HandlerType: (*", serverType, ")(nil),") ++ g.P("Methods: []", grpcPkg, ".MethodDesc{") ++ for i, method := range service.Method { ++ if method.GetServerStreaming() || method.GetClientStreaming() { ++ continue ++ } ++ g.P("{") ++ g.P("MethodName: ", strconv.Quote(method.GetName()), ",") ++ g.P("Handler: ", handlerNames[i], ",") ++ g.P("},") ++ } ++ g.P("},") ++ g.P("Streams: []", grpcPkg, ".StreamDesc{") ++ for i, method := range service.Method { ++ if !method.GetServerStreaming() && !method.GetClientStreaming() { ++ continue ++ } ++ g.P("{") ++ g.P("StreamName: ", strconv.Quote(method.GetName()), ",") ++ g.P("Handler: ", handlerNames[i], ",") ++ if method.GetServerStreaming() { ++ g.P("ServerStreams: true,") ++ } ++ if method.GetClientStreaming() { ++ g.P("ClientStreams: true,") ++ } ++ g.P("},") ++ } ++ g.P("},") ++ g.P("Metadata: \"", file.GetName(), "\",") ++ g.P("}") ++ g.P() ++} ++ ++// generateClientSignature returns the client-side signature for a method. ++func (g *grpc) generateClientSignature(servName string, method *pb.MethodDescriptorProto) string { ++ origMethName := method.GetName() ++ methName := generator.CamelCase(origMethName) ++ if reservedClientName[methName] { ++ methName += "_" ++ } ++ reqArg := ", in *" + g.typeName(method.GetInputType()) ++ if method.GetClientStreaming() { ++ reqArg = "" ++ } ++ respName := "*" + g.typeName(method.GetOutputType()) ++ if method.GetServerStreaming() || method.GetClientStreaming() { ++ respName = servName + "_" + generator.CamelCase(origMethName) + "Client" ++ } ++ return fmt.Sprintf("%s(ctx %s.Context%s, opts ...%s.CallOption) (%s, error)", methName, contextPkg, reqArg, grpcPkg, respName) ++} ++ ++func (g *grpc) generateClientMethod(servName, fullServName, serviceDescVar string, method *pb.MethodDescriptorProto, descExpr string) { ++ sname := fmt.Sprintf("/%s/%s", fullServName, method.GetName()) ++ methName := generator.CamelCase(method.GetName()) ++ inType := g.typeName(method.GetInputType()) ++ outType := g.typeName(method.GetOutputType()) ++ ++ g.P("func (c *", unexport(servName), "Client) ", g.generateClientSignature(servName, method), "{") ++ if !method.GetServerStreaming() && !method.GetClientStreaming() { ++ g.P("out := new(", outType, ")") ++ // TODO: Pass descExpr to Invoke. ++ g.P("err := ", grpcPkg, `.Invoke(ctx, "`, sname, `", in, out, c.cc, opts...)`) ++ g.P("if err != nil { return nil, err }") ++ g.P("return out, nil") ++ g.P("}") ++ g.P() ++ return ++ } ++ streamType := unexport(servName) + methName + "Client" ++ g.P("stream, err := ", grpcPkg, ".NewClientStream(ctx, ", descExpr, `, c.cc, "`, sname, `", opts...)`) ++ g.P("if err != nil { return nil, err }") ++ g.P("x := &", streamType, "{stream}") ++ if !method.GetClientStreaming() { ++ g.P("if err := x.ClientStream.SendMsg(in); err != nil { return nil, err }") ++ g.P("if err := x.ClientStream.CloseSend(); err != nil { return nil, err }") ++ } ++ g.P("return x, nil") ++ g.P("}") ++ g.P() ++ ++ genSend := method.GetClientStreaming() ++ genRecv := method.GetServerStreaming() ++ genCloseAndRecv := !method.GetServerStreaming() ++ ++ // Stream auxiliary types and methods. ++ g.P("type ", servName, "_", methName, "Client interface {") ++ if genSend { ++ g.P("Send(*", inType, ") error") ++ } ++ if genRecv { ++ g.P("Recv() (*", outType, ", error)") ++ } ++ if genCloseAndRecv { ++ g.P("CloseAndRecv() (*", outType, ", error)") ++ } ++ g.P(grpcPkg, ".ClientStream") ++ g.P("}") ++ g.P() ++ ++ g.P("type ", streamType, " struct {") ++ g.P(grpcPkg, ".ClientStream") ++ g.P("}") ++ g.P() ++ ++ if genSend { ++ g.P("func (x *", streamType, ") Send(m *", inType, ") error {") ++ g.P("return x.ClientStream.SendMsg(m)") ++ g.P("}") ++ g.P() ++ } ++ if genRecv { ++ g.P("func (x *", streamType, ") Recv() (*", outType, ", error) {") ++ g.P("m := new(", outType, ")") ++ g.P("if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err }") ++ g.P("return m, nil") ++ g.P("}") ++ g.P() ++ } ++ if genCloseAndRecv { ++ g.P("func (x *", streamType, ") CloseAndRecv() (*", outType, ", error) {") ++ g.P("if err := x.ClientStream.CloseSend(); err != nil { return nil, err }") ++ g.P("m := new(", outType, ")") ++ g.P("if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err }") ++ g.P("return m, nil") ++ g.P("}") ++ g.P() ++ } ++} ++ ++// generateServerSignature returns the server-side signature for a method. ++func (g *grpc) generateServerSignature(servName string, method *pb.MethodDescriptorProto) string { ++ origMethName := method.GetName() ++ methName := generator.CamelCase(origMethName) ++ if reservedClientName[methName] { ++ methName += "_" ++ } ++ ++ var reqArgs []string ++ ret := "error" ++ if !method.GetServerStreaming() && !method.GetClientStreaming() { ++ reqArgs = append(reqArgs, contextPkg+".Context") ++ ret = "(*" + g.typeName(method.GetOutputType()) + ", error)" ++ } ++ if !method.GetClientStreaming() { ++ reqArgs = append(reqArgs, "*"+g.typeName(method.GetInputType())) ++ } ++ if method.GetServerStreaming() || method.GetClientStreaming() { ++ reqArgs = append(reqArgs, servName+"_"+generator.CamelCase(origMethName)+"Server") ++ } ++ ++ return methName + "(" + strings.Join(reqArgs, ", ") + ") " + ret ++} ++ ++func (g *grpc) generateServerMethod(servName, fullServName string, method *pb.MethodDescriptorProto) string { ++ methName := generator.CamelCase(method.GetName()) ++ hname := fmt.Sprintf("_%s_%s_Handler", servName, methName) ++ inType := g.typeName(method.GetInputType()) ++ outType := g.typeName(method.GetOutputType()) ++ ++ if !method.GetServerStreaming() && !method.GetClientStreaming() { ++ g.P("func ", hname, "(srv interface{}, ctx ", contextPkg, ".Context, dec func(interface{}) error, interceptor ", grpcPkg, ".UnaryServerInterceptor) (interface{}, error) {") ++ g.P("in := new(", inType, ")") ++ g.P("if err := dec(in); err != nil { return nil, err }") ++ g.P("if interceptor == nil { return srv.(", servName, "Server).", methName, "(ctx, in) }") ++ g.P("info := &", grpcPkg, ".UnaryServerInfo{") ++ g.P("Server: srv,") ++ g.P("FullMethod: ", strconv.Quote(fmt.Sprintf("/%s/%s", fullServName, methName)), ",") ++ g.P("}") ++ g.P("handler := func(ctx ", contextPkg, ".Context, req interface{}) (interface{}, error) {") ++ g.P("return srv.(", servName, "Server).", methName, "(ctx, req.(*", inType, "))") ++ g.P("}") ++ g.P("return interceptor(ctx, in, info, handler)") ++ g.P("}") ++ g.P() ++ return hname ++ } ++ streamType := unexport(servName) + methName + "Server" ++ g.P("func ", hname, "(srv interface{}, stream ", grpcPkg, ".ServerStream) error {") ++ if !method.GetClientStreaming() { ++ g.P("m := new(", inType, ")") ++ g.P("if err := stream.RecvMsg(m); err != nil { return err }") ++ g.P("return srv.(", servName, "Server).", methName, "(m, &", streamType, "{stream})") ++ } else { ++ g.P("return srv.(", servName, "Server).", methName, "(&", streamType, "{stream})") ++ } ++ g.P("}") ++ g.P() ++ ++ genSend := method.GetServerStreaming() ++ genSendAndClose := !method.GetServerStreaming() ++ genRecv := method.GetClientStreaming() ++ ++ // Stream auxiliary types and methods. ++ g.P("type ", servName, "_", methName, "Server interface {") ++ if genSend { ++ g.P("Send(*", outType, ") error") ++ } ++ if genSendAndClose { ++ g.P("SendAndClose(*", outType, ") error") ++ } ++ if genRecv { ++ g.P("Recv() (*", inType, ", error)") ++ } ++ g.P(grpcPkg, ".ServerStream") ++ g.P("}") ++ g.P() ++ ++ g.P("type ", streamType, " struct {") ++ g.P(grpcPkg, ".ServerStream") ++ g.P("}") ++ g.P() ++ ++ if genSend { ++ g.P("func (x *", streamType, ") Send(m *", outType, ") error {") ++ g.P("return x.ServerStream.SendMsg(m)") ++ g.P("}") ++ g.P() ++ } ++ if genSendAndClose { ++ g.P("func (x *", streamType, ") SendAndClose(m *", outType, ") error {") ++ g.P("return x.ServerStream.SendMsg(m)") ++ g.P("}") ++ g.P() ++ } ++ if genRecv { ++ g.P("func (x *", streamType, ") Recv() (*", inType, ", error) {") ++ g.P("m := new(", inType, ")") ++ g.P("if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err }") ++ g.P("return m, nil") ++ g.P("}") ++ g.P() ++ } ++ ++ return hname ++} +diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.go +new file mode 100644 +index 0000000..0ff4e13 +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.go +@@ -0,0 +1,229 @@ ++// Code generated by protoc-gen-go. ++// source: google/protobuf/compiler/plugin.proto ++// DO NOT EDIT! ++ ++/* ++Package plugin_go is a generated protocol buffer package. ++ ++It is generated from these files: ++ google/protobuf/compiler/plugin.proto ++ ++It has these top-level messages: ++ CodeGeneratorRequest ++ CodeGeneratorResponse ++*/ ++package plugin_go ++ ++import proto "github.com/golang/protobuf/proto" ++import fmt "fmt" ++import math "math" ++import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor" ++ ++// Reference imports to suppress errors if they are not otherwise used. ++var _ = proto.Marshal ++var _ = fmt.Errorf ++var _ = math.Inf ++ ++// This is a compile-time assertion to ensure that this generated file ++// is compatible with the proto package it is being compiled against. ++// A compilation error at this line likely means your copy of the ++// proto package needs to be updated. ++const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package ++ ++// An encoded CodeGeneratorRequest is written to the plugin's stdin. ++type CodeGeneratorRequest struct { ++ // The .proto files that were explicitly listed on the command-line. The ++ // code generator should generate code only for these files. Each file's ++ // descriptor will be included in proto_file, below. ++ FileToGenerate []string `protobuf:"bytes,1,rep,name=file_to_generate,json=fileToGenerate" json:"file_to_generate,omitempty"` ++ // The generator parameter passed on the command-line. ++ Parameter *string `protobuf:"bytes,2,opt,name=parameter" json:"parameter,omitempty"` ++ // FileDescriptorProtos for all files in files_to_generate and everything ++ // they import. The files will appear in topological order, so each file ++ // appears before any file that imports it. ++ // ++ // protoc guarantees that all proto_files will be written after ++ // the fields above, even though this is not technically guaranteed by the ++ // protobuf wire format. This theoretically could allow a plugin to stream ++ // in the FileDescriptorProtos and handle them one by one rather than read ++ // the entire set into memory at once. However, as of this writing, this ++ // is not similarly optimized on protoc's end -- it will store all fields in ++ // memory at once before sending them to the plugin. ++ ProtoFile []*google_protobuf.FileDescriptorProto `protobuf:"bytes,15,rep,name=proto_file,json=protoFile" json:"proto_file,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *CodeGeneratorRequest) Reset() { *m = CodeGeneratorRequest{} } ++func (m *CodeGeneratorRequest) String() string { return proto.CompactTextString(m) } ++func (*CodeGeneratorRequest) ProtoMessage() {} ++func (*CodeGeneratorRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } ++ ++func (m *CodeGeneratorRequest) GetFileToGenerate() []string { ++ if m != nil { ++ return m.FileToGenerate ++ } ++ return nil ++} ++ ++func (m *CodeGeneratorRequest) GetParameter() string { ++ if m != nil && m.Parameter != nil { ++ return *m.Parameter ++ } ++ return "" ++} ++ ++func (m *CodeGeneratorRequest) GetProtoFile() []*google_protobuf.FileDescriptorProto { ++ if m != nil { ++ return m.ProtoFile ++ } ++ return nil ++} ++ ++// The plugin writes an encoded CodeGeneratorResponse to stdout. ++type CodeGeneratorResponse struct { ++ // Error message. If non-empty, code generation failed. The plugin process ++ // should exit with status code zero even if it reports an error in this way. ++ // ++ // This should be used to indicate errors in .proto files which prevent the ++ // code generator from generating correct code. Errors which indicate a ++ // problem in protoc itself -- such as the input CodeGeneratorRequest being ++ // unparseable -- should be reported by writing a message to stderr and ++ // exiting with a non-zero status code. ++ Error *string `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"` ++ File []*CodeGeneratorResponse_File `protobuf:"bytes,15,rep,name=file" json:"file,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *CodeGeneratorResponse) Reset() { *m = CodeGeneratorResponse{} } ++func (m *CodeGeneratorResponse) String() string { return proto.CompactTextString(m) } ++func (*CodeGeneratorResponse) ProtoMessage() {} ++func (*CodeGeneratorResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } ++ ++func (m *CodeGeneratorResponse) GetError() string { ++ if m != nil && m.Error != nil { ++ return *m.Error ++ } ++ return "" ++} ++ ++func (m *CodeGeneratorResponse) GetFile() []*CodeGeneratorResponse_File { ++ if m != nil { ++ return m.File ++ } ++ return nil ++} ++ ++// Represents a single generated file. ++type CodeGeneratorResponse_File struct { ++ // The file name, relative to the output directory. The name must not ++ // contain "." or ".." components and must be relative, not be absolute (so, ++ // the file cannot lie outside the output directory). "/" must be used as ++ // the path separator, not "\". ++ // ++ // If the name is omitted, the content will be appended to the previous ++ // file. This allows the generator to break large files into small chunks, ++ // and allows the generated text to be streamed back to protoc so that large ++ // files need not reside completely in memory at one time. Note that as of ++ // this writing protoc does not optimize for this -- it will read the entire ++ // CodeGeneratorResponse before writing files to disk. ++ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` ++ // If non-empty, indicates that the named file should already exist, and the ++ // content here is to be inserted into that file at a defined insertion ++ // point. This feature allows a code generator to extend the output ++ // produced by another code generator. The original generator may provide ++ // insertion points by placing special annotations in the file that look ++ // like: ++ // @@protoc_insertion_point(NAME) ++ // The annotation can have arbitrary text before and after it on the line, ++ // which allows it to be placed in a comment. NAME should be replaced with ++ // an identifier naming the point -- this is what other generators will use ++ // as the insertion_point. Code inserted at this point will be placed ++ // immediately above the line containing the insertion point (thus multiple ++ // insertions to the same point will come out in the order they were added). ++ // The double-@ is intended to make it unlikely that the generated code ++ // could contain things that look like insertion points by accident. ++ // ++ // For example, the C++ code generator places the following line in the ++ // .pb.h files that it generates: ++ // // @@protoc_insertion_point(namespace_scope) ++ // This line appears within the scope of the file's package namespace, but ++ // outside of any particular class. Another plugin can then specify the ++ // insertion_point "namespace_scope" to generate additional classes or ++ // other declarations that should be placed in this scope. ++ // ++ // Note that if the line containing the insertion point begins with ++ // whitespace, the same whitespace will be added to every line of the ++ // inserted text. This is useful for languages like Python, where ++ // indentation matters. In these languages, the insertion point comment ++ // should be indented the same amount as any inserted code will need to be ++ // in order to work correctly in that context. ++ // ++ // The code generator that generates the initial file and the one which ++ // inserts into it must both run as part of a single invocation of protoc. ++ // Code generators are executed in the order in which they appear on the ++ // command line. ++ // ++ // If |insertion_point| is present, |name| must also be present. ++ InsertionPoint *string `protobuf:"bytes,2,opt,name=insertion_point,json=insertionPoint" json:"insertion_point,omitempty"` ++ // The file contents. ++ Content *string `protobuf:"bytes,15,opt,name=content" json:"content,omitempty"` ++ XXX_unrecognized []byte `json:"-"` ++} ++ ++func (m *CodeGeneratorResponse_File) Reset() { *m = CodeGeneratorResponse_File{} } ++func (m *CodeGeneratorResponse_File) String() string { return proto.CompactTextString(m) } ++func (*CodeGeneratorResponse_File) ProtoMessage() {} ++func (*CodeGeneratorResponse_File) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} } ++ ++func (m *CodeGeneratorResponse_File) GetName() string { ++ if m != nil && m.Name != nil { ++ return *m.Name ++ } ++ return "" ++} ++ ++func (m *CodeGeneratorResponse_File) GetInsertionPoint() string { ++ if m != nil && m.InsertionPoint != nil { ++ return *m.InsertionPoint ++ } ++ return "" ++} ++ ++func (m *CodeGeneratorResponse_File) GetContent() string { ++ if m != nil && m.Content != nil { ++ return *m.Content ++ } ++ return "" ++} ++ ++func init() { ++ proto.RegisterType((*CodeGeneratorRequest)(nil), "google.protobuf.compiler.CodeGeneratorRequest") ++ proto.RegisterType((*CodeGeneratorResponse)(nil), "google.protobuf.compiler.CodeGeneratorResponse") ++ proto.RegisterType((*CodeGeneratorResponse_File)(nil), "google.protobuf.compiler.CodeGeneratorResponse.File") ++} ++ ++func init() { proto.RegisterFile("google/protobuf/compiler/plugin.proto", fileDescriptor0) } ++ ++var fileDescriptor0 = []byte{ ++ // 310 bytes of a gzipped FileDescriptorProto ++ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x74, 0x51, 0xc1, 0x4a, 0xc3, 0x40, ++ 0x10, 0x25, 0xb6, 0x22, 0x19, 0xa5, 0x95, 0xa5, 0xc2, 0x52, 0x7a, 0x08, 0x45, 0x31, 0xa7, 0x14, ++ 0x44, 0xf0, 0xde, 0x8a, 0x7a, 0x2c, 0xc1, 0x93, 0x20, 0x21, 0xa6, 0xd3, 0xb0, 0x90, 0xec, 0xac, ++ 0xb3, 0xdb, 0x2f, 0xf2, 0x9f, 0xfc, 0x1e, 0xd9, 0x4d, 0x5b, 0xa5, 0xd8, 0xdb, 0xce, 0x7b, 0x6f, ++ 0xe6, 0xbd, 0x9d, 0x81, 0x9b, 0x9a, 0xa8, 0x6e, 0x70, 0x66, 0x98, 0x1c, 0x7d, 0x6c, 0xd6, 0xb3, ++ 0x8a, 0x5a, 0xa3, 0x1a, 0xe4, 0x99, 0x69, 0x36, 0xb5, 0xd2, 0x59, 0x20, 0x84, 0xec, 0x64, 0xd9, ++ 0x4e, 0x96, 0xed, 0x64, 0xe3, 0xe4, 0x70, 0xc0, 0x0a, 0x6d, 0xc5, 0xca, 0x38, 0xe2, 0x4e, 0x3d, ++ 0xfd, 0x8a, 0x60, 0xb4, 0xa0, 0x15, 0x3e, 0xa3, 0x46, 0x2e, 0x1d, 0x71, 0x8e, 0x9f, 0x1b, 0xb4, ++ 0x4e, 0xa4, 0x70, 0xb9, 0x56, 0x0d, 0x16, 0x8e, 0x8a, 0xba, 0xe3, 0x50, 0x46, 0x49, 0x2f, 0x8d, ++ 0xf3, 0x81, 0xc7, 0x5f, 0x69, 0xdb, 0x81, 0x62, 0x02, 0xb1, 0x29, 0xb9, 0x6c, 0xd1, 0x21, 0xcb, ++ 0x93, 0x24, 0x4a, 0xe3, 0xfc, 0x17, 0x10, 0x0b, 0x80, 0xe0, 0x54, 0xf8, 0x2e, 0x39, 0x4c, 0x7a, ++ 0xe9, 0xf9, 0xdd, 0x75, 0x76, 0x98, 0xf8, 0x49, 0x35, 0xf8, 0xb8, 0xcf, 0xb6, 0xf4, 0x70, 0x1e, ++ 0x07, 0xd6, 0x33, 0xd3, 0xef, 0x08, 0xae, 0x0e, 0x52, 0x5a, 0x43, 0xda, 0xa2, 0x18, 0xc1, 0x29, ++ 0x32, 0x13, 0xcb, 0x28, 0x18, 0x77, 0x85, 0x78, 0x81, 0xfe, 0x1f, 0xbb, 0xfb, 0xec, 0xd8, 0x82, ++ 0xb2, 0x7f, 0x87, 0x86, 0x34, 0x79, 0x98, 0x30, 0x7e, 0x87, 0xbe, 0xaf, 0x84, 0x80, 0xbe, 0x2e, ++ 0x5b, 0xdc, 0xda, 0x84, 0xb7, 0xb8, 0x85, 0xa1, 0xd2, 0x16, 0xd9, 0x29, 0xd2, 0x85, 0x21, 0xa5, ++ 0xdd, 0xf6, 0xfb, 0x83, 0x3d, 0xbc, 0xf4, 0xa8, 0x90, 0x70, 0x56, 0x91, 0x76, 0xa8, 0x9d, 0x1c, ++ 0x06, 0xc1, 0xae, 0x9c, 0x3f, 0xc0, 0xa4, 0xa2, 0xf6, 0x68, 0xbe, 0xf9, 0xc5, 0x32, 0x1c, 0x3a, ++ 0x2c, 0xc4, 0xbe, 0xc5, 0xdd, 0xd9, 0x8b, 0x9a, 0x7e, 0x02, 0x00, 0x00, 0xff, 0xff, 0x83, 0x7b, ++ 0x5c, 0x7c, 0x1b, 0x02, 0x00, 0x00, ++} +diff --git a/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go b/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go +new file mode 100644 +index 0000000..f2c6906 +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go +@@ -0,0 +1,155 @@ ++// Code generated by protoc-gen-go. ++// source: github.com/golang/protobuf/ptypes/any/any.proto ++// DO NOT EDIT! ++ ++/* ++Package any is a generated protocol buffer package. ++ ++It is generated from these files: ++ github.com/golang/protobuf/ptypes/any/any.proto ++ ++It has these top-level messages: ++ Any ++*/ ++package any ++ ++import proto "github.com/golang/protobuf/proto" ++import fmt "fmt" ++import math "math" ++ ++// Reference imports to suppress errors if they are not otherwise used. ++var _ = proto.Marshal ++var _ = fmt.Errorf ++var _ = math.Inf ++ ++// This is a compile-time assertion to ensure that this generated file ++// is compatible with the proto package it is being compiled against. ++// A compilation error at this line likely means your copy of the ++// proto package needs to be updated. ++const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package ++ ++// `Any` contains an arbitrary serialized protocol buffer message along with a ++// URL that describes the type of the serialized message. ++// ++// Protobuf library provides support to pack/unpack Any values in the form ++// of utility functions or additional generated methods of the Any type. ++// ++// Example 1: Pack and unpack a message in C++. ++// ++// Foo foo = ...; ++// Any any; ++// any.PackFrom(foo); ++// ... ++// if (any.UnpackTo(&foo)) { ++// ... ++// } ++// ++// Example 2: Pack and unpack a message in Java. ++// ++// Foo foo = ...; ++// Any any = Any.pack(foo); ++// ... ++// if (any.is(Foo.class)) { ++// foo = any.unpack(Foo.class); ++// } ++// ++// Example 3: Pack and unpack a message in Python. ++// ++// foo = Foo(...) ++// any = Any() ++// any.Pack(foo) ++// ... ++// if any.Is(Foo.DESCRIPTOR): ++// any.Unpack(foo) ++// ... ++// ++// The pack methods provided by protobuf library will by default use ++// 'type.googleapis.com/full.type.name' as the type URL and the unpack ++// methods only use the fully qualified type name after the last '/' ++// in the type URL, for example "foo.bar.com/x/y.z" will yield type ++// name "y.z". ++// ++// ++// JSON ++// ==== ++// The JSON representation of an `Any` value uses the regular ++// representation of the deserialized, embedded message, with an ++// additional field `@type` which contains the type URL. Example: ++// ++// package google.profile; ++// message Person { ++// string first_name = 1; ++// string last_name = 2; ++// } ++// ++// { ++// "@type": "type.googleapis.com/google.profile.Person", ++// "firstName": , ++// "lastName": ++// } ++// ++// If the embedded message type is well-known and has a custom JSON ++// representation, that representation will be embedded adding a field ++// `value` which holds the custom JSON in addition to the `@type` ++// field. Example (for message [google.protobuf.Duration][]): ++// ++// { ++// "@type": "type.googleapis.com/google.protobuf.Duration", ++// "value": "1.212s" ++// } ++// ++type Any struct { ++ // A URL/resource name whose content describes the type of the ++ // serialized protocol buffer message. ++ // ++ // For URLs which use the scheme `http`, `https`, or no scheme, the ++ // following restrictions and interpretations apply: ++ // ++ // * If no scheme is provided, `https` is assumed. ++ // * The last segment of the URL's path must represent the fully ++ // qualified name of the type (as in `path/google.protobuf.Duration`). ++ // The name should be in a canonical form (e.g., leading "." is ++ // not accepted). ++ // * An HTTP GET on the URL must yield a [google.protobuf.Type][] ++ // value in binary format, or produce an error. ++ // * Applications are allowed to cache lookup results based on the ++ // URL, or have them precompiled into a binary to avoid any ++ // lookup. Therefore, binary compatibility needs to be preserved ++ // on changes to types. (Use versioned type names to manage ++ // breaking changes.) ++ // ++ // Schemes other than `http`, `https` (or the empty scheme) might be ++ // used with implementation specific semantics. ++ // ++ TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl" json:"type_url,omitempty"` ++ // Must be a valid serialized protocol buffer of the above specified type. ++ Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` ++} ++ ++func (m *Any) Reset() { *m = Any{} } ++func (m *Any) String() string { return proto.CompactTextString(m) } ++func (*Any) ProtoMessage() {} ++func (*Any) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } ++func (*Any) XXX_WellKnownType() string { return "Any" } ++ ++func init() { ++ proto.RegisterType((*Any)(nil), "google.protobuf.Any") ++} ++ ++func init() { proto.RegisterFile("github.com/golang/protobuf/ptypes/any/any.proto", fileDescriptor0) } ++ ++var fileDescriptor0 = []byte{ ++ // 187 bytes of a gzipped FileDescriptorProto ++ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xd2, 0x4f, 0xcf, 0x2c, 0xc9, ++ 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0xd7, 0x2f, 0x28, ++ 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x28, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x4f, 0xcc, ++ 0xab, 0x04, 0x61, 0x3d, 0xb0, 0xb8, 0x10, 0x7f, 0x7a, 0x7e, 0x7e, 0x7a, 0x4e, 0xaa, 0x1e, 0x4c, ++ 0x95, 0x92, 0x19, 0x17, 0xb3, 0x63, 0x5e, 0xa5, 0x90, 0x24, 0x17, 0x07, 0x48, 0x79, 0x7c, 0x69, ++ 0x51, 0x8e, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x67, 0x10, 0x3b, 0x88, 0x1f, 0x5a, 0x94, 0x23, 0x24, ++ 0xc2, 0xc5, 0x5a, 0x96, 0x98, 0x53, 0x9a, 0x2a, 0xc1, 0xa4, 0xc0, 0xa8, 0xc1, 0x13, 0x04, 0xe1, ++ 0x38, 0x15, 0x71, 0x09, 0x27, 0xe7, 0xe7, 0xea, 0xa1, 0x19, 0xe7, 0xc4, 0xe1, 0x98, 0x57, 0x19, ++ 0x00, 0xe2, 0x04, 0x30, 0x46, 0xa9, 0x12, 0xe5, 0xb8, 0x05, 0x8c, 0x8c, 0x8b, 0x98, 0x98, 0xdd, ++ 0x03, 0x9c, 0x56, 0x31, 0xc9, 0xb9, 0x43, 0x4c, 0x0b, 0x80, 0xaa, 0xd2, 0x0b, 0x4f, 0xcd, 0xc9, ++ 0xf1, 0xce, 0xcb, 0x2f, 0xcf, 0x0b, 0x01, 0xa9, 0x4e, 0x62, 0x03, 0x6b, 0x37, 0x06, 0x04, 0x00, ++ 0x00, 0xff, 0xff, 0xc6, 0x4d, 0x03, 0x23, 0xf6, 0x00, 0x00, 0x00, ++} +diff --git a/vendor/github.com/golang/protobuf/ptypes/any/any.proto b/vendor/github.com/golang/protobuf/ptypes/any/any.proto +new file mode 100644 +index 0000000..81dcf46 +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/ptypes/any/any.proto +@@ -0,0 +1,140 @@ ++// Protocol Buffers - Google's data interchange format ++// Copyright 2008 Google Inc. All rights reserved. ++// https://developers.google.com/protocol-buffers/ ++// ++// Redistribution and use in source and binary forms, with or without ++// modification, are permitted provided that the following conditions are ++// met: ++// ++// * Redistributions of source code must retain the above copyright ++// notice, this list of conditions and the following disclaimer. ++// * Redistributions in binary form must reproduce the above ++// copyright notice, this list of conditions and the following disclaimer ++// in the documentation and/or other materials provided with the ++// distribution. ++// * Neither the name of Google Inc. nor the names of its ++// contributors may be used to endorse or promote products derived from ++// this software without specific prior written permission. ++// ++// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++syntax = "proto3"; ++ ++package google.protobuf; ++ ++option csharp_namespace = "Google.Protobuf.WellKnownTypes"; ++option go_package = "github.com/golang/protobuf/ptypes/any"; ++option java_package = "com.google.protobuf"; ++option java_outer_classname = "AnyProto"; ++option java_multiple_files = true; ++option java_generate_equals_and_hash = true; ++option objc_class_prefix = "GPB"; ++ ++// `Any` contains an arbitrary serialized protocol buffer message along with a ++// URL that describes the type of the serialized message. ++// ++// Protobuf library provides support to pack/unpack Any values in the form ++// of utility functions or additional generated methods of the Any type. ++// ++// Example 1: Pack and unpack a message in C++. ++// ++// Foo foo = ...; ++// Any any; ++// any.PackFrom(foo); ++// ... ++// if (any.UnpackTo(&foo)) { ++// ... ++// } ++// ++// Example 2: Pack and unpack a message in Java. ++// ++// Foo foo = ...; ++// Any any = Any.pack(foo); ++// ... ++// if (any.is(Foo.class)) { ++// foo = any.unpack(Foo.class); ++// } ++// ++// Example 3: Pack and unpack a message in Python. ++// ++// foo = Foo(...) ++// any = Any() ++// any.Pack(foo) ++// ... ++// if any.Is(Foo.DESCRIPTOR): ++// any.Unpack(foo) ++// ... ++// ++// The pack methods provided by protobuf library will by default use ++// 'type.googleapis.com/full.type.name' as the type URL and the unpack ++// methods only use the fully qualified type name after the last '/' ++// in the type URL, for example "foo.bar.com/x/y.z" will yield type ++// name "y.z". ++// ++// ++// JSON ++// ==== ++// The JSON representation of an `Any` value uses the regular ++// representation of the deserialized, embedded message, with an ++// additional field `@type` which contains the type URL. Example: ++// ++// package google.profile; ++// message Person { ++// string first_name = 1; ++// string last_name = 2; ++// } ++// ++// { ++// "@type": "type.googleapis.com/google.profile.Person", ++// "firstName": , ++// "lastName": ++// } ++// ++// If the embedded message type is well-known and has a custom JSON ++// representation, that representation will be embedded adding a field ++// `value` which holds the custom JSON in addition to the `@type` ++// field. Example (for message [google.protobuf.Duration][]): ++// ++// { ++// "@type": "type.googleapis.com/google.protobuf.Duration", ++// "value": "1.212s" ++// } ++// ++message Any { ++ // A URL/resource name whose content describes the type of the ++ // serialized protocol buffer message. ++ // ++ // For URLs which use the scheme `http`, `https`, or no scheme, the ++ // following restrictions and interpretations apply: ++ // ++ // * If no scheme is provided, `https` is assumed. ++ // * The last segment of the URL's path must represent the fully ++ // qualified name of the type (as in `path/google.protobuf.Duration`). ++ // The name should be in a canonical form (e.g., leading "." is ++ // not accepted). ++ // * An HTTP GET on the URL must yield a [google.protobuf.Type][] ++ // value in binary format, or produce an error. ++ // * Applications are allowed to cache lookup results based on the ++ // URL, or have them precompiled into a binary to avoid any ++ // lookup. Therefore, binary compatibility needs to be preserved ++ // on changes to types. (Use versioned type names to manage ++ // breaking changes.) ++ // ++ // Schemes other than `http`, `https` (or the empty scheme) might be ++ // used with implementation specific semantics. ++ // ++ string type_url = 1; ++ ++ // Must be a valid serialized protocol buffer of the above specified type. ++ bytes value = 2; ++} +diff --git a/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go b/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go +new file mode 100644 +index 0000000..5697483 +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go +@@ -0,0 +1,114 @@ ++// Code generated by protoc-gen-go. ++// source: github.com/golang/protobuf/ptypes/duration/duration.proto ++// DO NOT EDIT! ++ ++/* ++Package duration is a generated protocol buffer package. ++ ++It is generated from these files: ++ github.com/golang/protobuf/ptypes/duration/duration.proto ++ ++It has these top-level messages: ++ Duration ++*/ ++package duration ++ ++import proto "github.com/golang/protobuf/proto" ++import fmt "fmt" ++import math "math" ++ ++// Reference imports to suppress errors if they are not otherwise used. ++var _ = proto.Marshal ++var _ = fmt.Errorf ++var _ = math.Inf ++ ++// This is a compile-time assertion to ensure that this generated file ++// is compatible with the proto package it is being compiled against. ++// A compilation error at this line likely means your copy of the ++// proto package needs to be updated. ++const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package ++ ++// A Duration represents a signed, fixed-length span of time represented ++// as a count of seconds and fractions of seconds at nanosecond ++// resolution. It is independent of any calendar and concepts like "day" ++// or "month". It is related to Timestamp in that the difference between ++// two Timestamp values is a Duration and it can be added or subtracted ++// from a Timestamp. Range is approximately +-10,000 years. ++// ++// Example 1: Compute Duration from two Timestamps in pseudo code. ++// ++// Timestamp start = ...; ++// Timestamp end = ...; ++// Duration duration = ...; ++// ++// duration.seconds = end.seconds - start.seconds; ++// duration.nanos = end.nanos - start.nanos; ++// ++// if (duration.seconds < 0 && duration.nanos > 0) { ++// duration.seconds += 1; ++// duration.nanos -= 1000000000; ++// } else if (durations.seconds > 0 && duration.nanos < 0) { ++// duration.seconds -= 1; ++// duration.nanos += 1000000000; ++// } ++// ++// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. ++// ++// Timestamp start = ...; ++// Duration duration = ...; ++// Timestamp end = ...; ++// ++// end.seconds = start.seconds + duration.seconds; ++// end.nanos = start.nanos + duration.nanos; ++// ++// if (end.nanos < 0) { ++// end.seconds -= 1; ++// end.nanos += 1000000000; ++// } else if (end.nanos >= 1000000000) { ++// end.seconds += 1; ++// end.nanos -= 1000000000; ++// } ++// ++// ++type Duration struct { ++ // Signed seconds of the span of time. Must be from -315,576,000,000 ++ // to +315,576,000,000 inclusive. ++ Seconds int64 `protobuf:"varint,1,opt,name=seconds" json:"seconds,omitempty"` ++ // Signed fractions of a second at nanosecond resolution of the span ++ // of time. Durations less than one second are represented with a 0 ++ // `seconds` field and a positive or negative `nanos` field. For durations ++ // of one second or more, a non-zero value for the `nanos` field must be ++ // of the same sign as the `seconds` field. Must be from -999,999,999 ++ // to +999,999,999 inclusive. ++ Nanos int32 `protobuf:"varint,2,opt,name=nanos" json:"nanos,omitempty"` ++} ++ ++func (m *Duration) Reset() { *m = Duration{} } ++func (m *Duration) String() string { return proto.CompactTextString(m) } ++func (*Duration) ProtoMessage() {} ++func (*Duration) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } ++func (*Duration) XXX_WellKnownType() string { return "Duration" } ++ ++func init() { ++ proto.RegisterType((*Duration)(nil), "google.protobuf.Duration") ++} ++ ++func init() { ++ proto.RegisterFile("github.com/golang/protobuf/ptypes/duration/duration.proto", fileDescriptor0) ++} ++ ++var fileDescriptor0 = []byte{ ++ // 189 bytes of a gzipped FileDescriptorProto ++ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xb2, 0x4c, 0xcf, 0x2c, 0xc9, ++ 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0xd7, 0x2f, 0x28, ++ 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x28, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x4f, 0x29, ++ 0x2d, 0x4a, 0x2c, 0xc9, 0xcc, 0xcf, 0x83, 0x33, 0xf4, 0xc0, 0x2a, 0x84, 0xf8, 0xd3, 0xf3, 0xf3, ++ 0xd3, 0x73, 0x52, 0xf5, 0x60, 0xea, 0x95, 0xac, 0xb8, 0x38, 0x5c, 0xa0, 0x4a, 0x84, 0x24, 0xb8, ++ 0xd8, 0x8b, 0x53, 0x93, 0xf3, 0xf3, 0x52, 0x8a, 0x25, 0x18, 0x15, 0x18, 0x35, 0x98, 0x83, 0x60, ++ 0x5c, 0x21, 0x11, 0x2e, 0xd6, 0xbc, 0xc4, 0xbc, 0xfc, 0x62, 0x09, 0x26, 0x05, 0x46, 0x0d, 0xd6, ++ 0x20, 0x08, 0xc7, 0xa9, 0x86, 0x4b, 0x38, 0x39, 0x3f, 0x57, 0x0f, 0xcd, 0x48, 0x27, 0x5e, 0x98, ++ 0x81, 0x01, 0x20, 0x91, 0x00, 0xc6, 0x28, 0x2d, 0xe2, 0xdd, 0xbb, 0x80, 0x91, 0x71, 0x11, 0x13, ++ 0xb3, 0x7b, 0x80, 0xd3, 0x2a, 0x26, 0x39, 0x77, 0x88, 0xb9, 0x01, 0x50, 0xa5, 0x7a, 0xe1, 0xa9, ++ 0x39, 0x39, 0xde, 0x79, 0xf9, 0xe5, 0x79, 0x21, 0x20, 0x2d, 0x49, 0x6c, 0x60, 0x33, 0x8c, 0x01, ++ 0x01, 0x00, 0x00, 0xff, 0xff, 0x62, 0xfb, 0xb1, 0x51, 0x0e, 0x01, 0x00, 0x00, ++} +diff --git a/vendor/github.com/golang/protobuf/ptypes/duration/duration.proto b/vendor/github.com/golang/protobuf/ptypes/duration/duration.proto +new file mode 100644 +index 0000000..96c1796 +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/ptypes/duration/duration.proto +@@ -0,0 +1,98 @@ ++// Protocol Buffers - Google's data interchange format ++// Copyright 2008 Google Inc. All rights reserved. ++// https://developers.google.com/protocol-buffers/ ++// ++// Redistribution and use in source and binary forms, with or without ++// modification, are permitted provided that the following conditions are ++// met: ++// ++// * Redistributions of source code must retain the above copyright ++// notice, this list of conditions and the following disclaimer. ++// * Redistributions in binary form must reproduce the above ++// copyright notice, this list of conditions and the following disclaimer ++// in the documentation and/or other materials provided with the ++// distribution. ++// * Neither the name of Google Inc. nor the names of its ++// contributors may be used to endorse or promote products derived from ++// this software without specific prior written permission. ++// ++// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++syntax = "proto3"; ++ ++package google.protobuf; ++ ++option csharp_namespace = "Google.Protobuf.WellKnownTypes"; ++option go_package = "github.com/golang/protobuf/ptypes/duration"; ++option java_package = "com.google.protobuf"; ++option java_outer_classname = "DurationProto"; ++option java_multiple_files = true; ++option java_generate_equals_and_hash = true; ++option objc_class_prefix = "GPB"; ++ ++// A Duration represents a signed, fixed-length span of time represented ++// as a count of seconds and fractions of seconds at nanosecond ++// resolution. It is independent of any calendar and concepts like "day" ++// or "month". It is related to Timestamp in that the difference between ++// two Timestamp values is a Duration and it can be added or subtracted ++// from a Timestamp. Range is approximately +-10,000 years. ++// ++// Example 1: Compute Duration from two Timestamps in pseudo code. ++// ++// Timestamp start = ...; ++// Timestamp end = ...; ++// Duration duration = ...; ++// ++// duration.seconds = end.seconds - start.seconds; ++// duration.nanos = end.nanos - start.nanos; ++// ++// if (duration.seconds < 0 && duration.nanos > 0) { ++// duration.seconds += 1; ++// duration.nanos -= 1000000000; ++// } else if (durations.seconds > 0 && duration.nanos < 0) { ++// duration.seconds -= 1; ++// duration.nanos += 1000000000; ++// } ++// ++// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. ++// ++// Timestamp start = ...; ++// Duration duration = ...; ++// Timestamp end = ...; ++// ++// end.seconds = start.seconds + duration.seconds; ++// end.nanos = start.nanos + duration.nanos; ++// ++// if (end.nanos < 0) { ++// end.seconds -= 1; ++// end.nanos += 1000000000; ++// } else if (end.nanos >= 1000000000) { ++// end.seconds += 1; ++// end.nanos -= 1000000000; ++// } ++// ++// ++message Duration { ++ ++ // Signed seconds of the span of time. Must be from -315,576,000,000 ++ // to +315,576,000,000 inclusive. ++ int64 seconds = 1; ++ ++ // Signed fractions of a second at nanosecond resolution of the span ++ // of time. Durations less than one second are represented with a 0 ++ // `seconds` field and a positive or negative `nanos` field. For durations ++ // of one second or more, a non-zero value for the `nanos` field must be ++ // of the same sign as the `seconds` field. Must be from -999,999,999 ++ // to +999,999,999 inclusive. ++ int32 nanos = 2; ++} +diff --git a/vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go b/vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go +new file mode 100644 +index 0000000..197042e +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go +@@ -0,0 +1,382 @@ ++// Code generated by protoc-gen-go. ++// source: github.com/golang/protobuf/ptypes/struct/struct.proto ++// DO NOT EDIT! ++ ++/* ++Package structpb is a generated protocol buffer package. ++ ++It is generated from these files: ++ github.com/golang/protobuf/ptypes/struct/struct.proto ++ ++It has these top-level messages: ++ Struct ++ Value ++ ListValue ++*/ ++package structpb ++ ++import proto "github.com/golang/protobuf/proto" ++import fmt "fmt" ++import math "math" ++ ++// Reference imports to suppress errors if they are not otherwise used. ++var _ = proto.Marshal ++var _ = fmt.Errorf ++var _ = math.Inf ++ ++// This is a compile-time assertion to ensure that this generated file ++// is compatible with the proto package it is being compiled against. ++// A compilation error at this line likely means your copy of the ++// proto package needs to be updated. ++const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package ++ ++// `NullValue` is a singleton enumeration to represent the null value for the ++// `Value` type union. ++// ++// The JSON representation for `NullValue` is JSON `null`. ++type NullValue int32 ++ ++const ( ++ // Null value. ++ NullValue_NULL_VALUE NullValue = 0 ++) ++ ++var NullValue_name = map[int32]string{ ++ 0: "NULL_VALUE", ++} ++var NullValue_value = map[string]int32{ ++ "NULL_VALUE": 0, ++} ++ ++func (x NullValue) String() string { ++ return proto.EnumName(NullValue_name, int32(x)) ++} ++func (NullValue) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } ++func (NullValue) XXX_WellKnownType() string { return "NullValue" } ++ ++// `Struct` represents a structured data value, consisting of fields ++// which map to dynamically typed values. In some languages, `Struct` ++// might be supported by a native representation. For example, in ++// scripting languages like JS a struct is represented as an ++// object. The details of that representation are described together ++// with the proto support for the language. ++// ++// The JSON representation for `Struct` is JSON object. ++type Struct struct { ++ // Unordered map of dynamically typed values. ++ Fields map[string]*Value `protobuf:"bytes,1,rep,name=fields" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` ++} ++ ++func (m *Struct) Reset() { *m = Struct{} } ++func (m *Struct) String() string { return proto.CompactTextString(m) } ++func (*Struct) ProtoMessage() {} ++func (*Struct) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } ++func (*Struct) XXX_WellKnownType() string { return "Struct" } ++ ++func (m *Struct) GetFields() map[string]*Value { ++ if m != nil { ++ return m.Fields ++ } ++ return nil ++} ++ ++// `Value` represents a dynamically typed value which can be either ++// null, a number, a string, a boolean, a recursive struct value, or a ++// list of values. A producer of value is expected to set one of that ++// variants, absence of any variant indicates an error. ++// ++// The JSON representation for `Value` is JSON value. ++type Value struct { ++ // The kind of value. ++ // ++ // Types that are valid to be assigned to Kind: ++ // *Value_NullValue ++ // *Value_NumberValue ++ // *Value_StringValue ++ // *Value_BoolValue ++ // *Value_StructValue ++ // *Value_ListValue ++ Kind isValue_Kind `protobuf_oneof:"kind"` ++} ++ ++func (m *Value) Reset() { *m = Value{} } ++func (m *Value) String() string { return proto.CompactTextString(m) } ++func (*Value) ProtoMessage() {} ++func (*Value) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } ++func (*Value) XXX_WellKnownType() string { return "Value" } ++ ++type isValue_Kind interface { ++ isValue_Kind() ++} ++ ++type Value_NullValue struct { ++ NullValue NullValue `protobuf:"varint,1,opt,name=null_value,json=nullValue,enum=google.protobuf.NullValue,oneof"` ++} ++type Value_NumberValue struct { ++ NumberValue float64 `protobuf:"fixed64,2,opt,name=number_value,json=numberValue,oneof"` ++} ++type Value_StringValue struct { ++ StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,oneof"` ++} ++type Value_BoolValue struct { ++ BoolValue bool `protobuf:"varint,4,opt,name=bool_value,json=boolValue,oneof"` ++} ++type Value_StructValue struct { ++ StructValue *Struct `protobuf:"bytes,5,opt,name=struct_value,json=structValue,oneof"` ++} ++type Value_ListValue struct { ++ ListValue *ListValue `protobuf:"bytes,6,opt,name=list_value,json=listValue,oneof"` ++} ++ ++func (*Value_NullValue) isValue_Kind() {} ++func (*Value_NumberValue) isValue_Kind() {} ++func (*Value_StringValue) isValue_Kind() {} ++func (*Value_BoolValue) isValue_Kind() {} ++func (*Value_StructValue) isValue_Kind() {} ++func (*Value_ListValue) isValue_Kind() {} ++ ++func (m *Value) GetKind() isValue_Kind { ++ if m != nil { ++ return m.Kind ++ } ++ return nil ++} ++ ++func (m *Value) GetNullValue() NullValue { ++ if x, ok := m.GetKind().(*Value_NullValue); ok { ++ return x.NullValue ++ } ++ return NullValue_NULL_VALUE ++} ++ ++func (m *Value) GetNumberValue() float64 { ++ if x, ok := m.GetKind().(*Value_NumberValue); ok { ++ return x.NumberValue ++ } ++ return 0 ++} ++ ++func (m *Value) GetStringValue() string { ++ if x, ok := m.GetKind().(*Value_StringValue); ok { ++ return x.StringValue ++ } ++ return "" ++} ++ ++func (m *Value) GetBoolValue() bool { ++ if x, ok := m.GetKind().(*Value_BoolValue); ok { ++ return x.BoolValue ++ } ++ return false ++} ++ ++func (m *Value) GetStructValue() *Struct { ++ if x, ok := m.GetKind().(*Value_StructValue); ok { ++ return x.StructValue ++ } ++ return nil ++} ++ ++func (m *Value) GetListValue() *ListValue { ++ if x, ok := m.GetKind().(*Value_ListValue); ok { ++ return x.ListValue ++ } ++ return nil ++} ++ ++// XXX_OneofFuncs is for the internal use of the proto package. ++func (*Value) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { ++ return _Value_OneofMarshaler, _Value_OneofUnmarshaler, _Value_OneofSizer, []interface{}{ ++ (*Value_NullValue)(nil), ++ (*Value_NumberValue)(nil), ++ (*Value_StringValue)(nil), ++ (*Value_BoolValue)(nil), ++ (*Value_StructValue)(nil), ++ (*Value_ListValue)(nil), ++ } ++} ++ ++func _Value_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { ++ m := msg.(*Value) ++ // kind ++ switch x := m.Kind.(type) { ++ case *Value_NullValue: ++ b.EncodeVarint(1<<3 | proto.WireVarint) ++ b.EncodeVarint(uint64(x.NullValue)) ++ case *Value_NumberValue: ++ b.EncodeVarint(2<<3 | proto.WireFixed64) ++ b.EncodeFixed64(math.Float64bits(x.NumberValue)) ++ case *Value_StringValue: ++ b.EncodeVarint(3<<3 | proto.WireBytes) ++ b.EncodeStringBytes(x.StringValue) ++ case *Value_BoolValue: ++ t := uint64(0) ++ if x.BoolValue { ++ t = 1 ++ } ++ b.EncodeVarint(4<<3 | proto.WireVarint) ++ b.EncodeVarint(t) ++ case *Value_StructValue: ++ b.EncodeVarint(5<<3 | proto.WireBytes) ++ if err := b.EncodeMessage(x.StructValue); err != nil { ++ return err ++ } ++ case *Value_ListValue: ++ b.EncodeVarint(6<<3 | proto.WireBytes) ++ if err := b.EncodeMessage(x.ListValue); err != nil { ++ return err ++ } ++ case nil: ++ default: ++ return fmt.Errorf("Value.Kind has unexpected type %T", x) ++ } ++ return nil ++} ++ ++func _Value_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { ++ m := msg.(*Value) ++ switch tag { ++ case 1: // kind.null_value ++ if wire != proto.WireVarint { ++ return true, proto.ErrInternalBadWireType ++ } ++ x, err := b.DecodeVarint() ++ m.Kind = &Value_NullValue{NullValue(x)} ++ return true, err ++ case 2: // kind.number_value ++ if wire != proto.WireFixed64 { ++ return true, proto.ErrInternalBadWireType ++ } ++ x, err := b.DecodeFixed64() ++ m.Kind = &Value_NumberValue{math.Float64frombits(x)} ++ return true, err ++ case 3: // kind.string_value ++ if wire != proto.WireBytes { ++ return true, proto.ErrInternalBadWireType ++ } ++ x, err := b.DecodeStringBytes() ++ m.Kind = &Value_StringValue{x} ++ return true, err ++ case 4: // kind.bool_value ++ if wire != proto.WireVarint { ++ return true, proto.ErrInternalBadWireType ++ } ++ x, err := b.DecodeVarint() ++ m.Kind = &Value_BoolValue{x != 0} ++ return true, err ++ case 5: // kind.struct_value ++ if wire != proto.WireBytes { ++ return true, proto.ErrInternalBadWireType ++ } ++ msg := new(Struct) ++ err := b.DecodeMessage(msg) ++ m.Kind = &Value_StructValue{msg} ++ return true, err ++ case 6: // kind.list_value ++ if wire != proto.WireBytes { ++ return true, proto.ErrInternalBadWireType ++ } ++ msg := new(ListValue) ++ err := b.DecodeMessage(msg) ++ m.Kind = &Value_ListValue{msg} ++ return true, err ++ default: ++ return false, nil ++ } ++} ++ ++func _Value_OneofSizer(msg proto.Message) (n int) { ++ m := msg.(*Value) ++ // kind ++ switch x := m.Kind.(type) { ++ case *Value_NullValue: ++ n += proto.SizeVarint(1<<3 | proto.WireVarint) ++ n += proto.SizeVarint(uint64(x.NullValue)) ++ case *Value_NumberValue: ++ n += proto.SizeVarint(2<<3 | proto.WireFixed64) ++ n += 8 ++ case *Value_StringValue: ++ n += proto.SizeVarint(3<<3 | proto.WireBytes) ++ n += proto.SizeVarint(uint64(len(x.StringValue))) ++ n += len(x.StringValue) ++ case *Value_BoolValue: ++ n += proto.SizeVarint(4<<3 | proto.WireVarint) ++ n += 1 ++ case *Value_StructValue: ++ s := proto.Size(x.StructValue) ++ n += proto.SizeVarint(5<<3 | proto.WireBytes) ++ n += proto.SizeVarint(uint64(s)) ++ n += s ++ case *Value_ListValue: ++ s := proto.Size(x.ListValue) ++ n += proto.SizeVarint(6<<3 | proto.WireBytes) ++ n += proto.SizeVarint(uint64(s)) ++ n += s ++ case nil: ++ default: ++ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) ++ } ++ return n ++} ++ ++// `ListValue` is a wrapper around a repeated field of values. ++// ++// The JSON representation for `ListValue` is JSON array. ++type ListValue struct { ++ // Repeated field of dynamically typed values. ++ Values []*Value `protobuf:"bytes,1,rep,name=values" json:"values,omitempty"` ++} ++ ++func (m *ListValue) Reset() { *m = ListValue{} } ++func (m *ListValue) String() string { return proto.CompactTextString(m) } ++func (*ListValue) ProtoMessage() {} ++func (*ListValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } ++func (*ListValue) XXX_WellKnownType() string { return "ListValue" } ++ ++func (m *ListValue) GetValues() []*Value { ++ if m != nil { ++ return m.Values ++ } ++ return nil ++} ++ ++func init() { ++ proto.RegisterType((*Struct)(nil), "google.protobuf.Struct") ++ proto.RegisterType((*Value)(nil), "google.protobuf.Value") ++ proto.RegisterType((*ListValue)(nil), "google.protobuf.ListValue") ++ proto.RegisterEnum("google.protobuf.NullValue", NullValue_name, NullValue_value) ++} ++ ++func init() { ++ proto.RegisterFile("github.com/golang/protobuf/ptypes/struct/struct.proto", fileDescriptor0) ++} ++ ++var fileDescriptor0 = []byte{ ++ // 416 bytes of a gzipped FileDescriptorProto ++ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x92, 0x41, 0x8b, 0xd3, 0x40, ++ 0x14, 0x80, 0x3b, 0xc9, 0x36, 0x98, 0x17, 0x59, 0x97, 0x11, 0xb4, 0xac, 0xa0, 0xa1, 0x7b, 0x09, ++ 0x22, 0x09, 0x56, 0x04, 0x31, 0x5e, 0x0c, 0xac, 0xbb, 0x60, 0x58, 0x62, 0x74, 0x57, 0xf0, 0x52, ++ 0x9a, 0x34, 0x8d, 0xa1, 0xd3, 0x99, 0x90, 0xcc, 0x28, 0x3d, 0xfa, 0x2f, 0x3c, 0x8a, 0x47, 0x8f, ++ 0xfe, 0x42, 0x99, 0x99, 0x24, 0x4a, 0x4b, 0xc1, 0xd3, 0xf4, 0xbd, 0xf9, 0xde, 0x37, 0xef, 0xbd, ++ 0x06, 0x9e, 0x97, 0x15, 0xff, 0x2c, 0x32, 0x3f, 0x67, 0x9b, 0xa0, 0x64, 0x64, 0x41, 0xcb, 0xa0, ++ 0x6e, 0x18, 0x67, 0x99, 0x58, 0x05, 0x35, 0xdf, 0xd6, 0x45, 0x1b, 0xb4, 0xbc, 0x11, 0x39, 0xef, ++ 0x0e, 0x5f, 0xdd, 0xe2, 0x3b, 0x25, 0x63, 0x25, 0x29, 0xfc, 0x9e, 0x9d, 0x7e, 0x47, 0x60, 0xbd, ++ 0x57, 0x04, 0x0e, 0xc1, 0x5a, 0x55, 0x05, 0x59, 0xb6, 0x13, 0xe4, 0x9a, 0x9e, 0x33, 0x3b, 0xf3, ++ 0x77, 0x60, 0x5f, 0x83, 0xfe, 0x1b, 0x45, 0x9d, 0x53, 0xde, 0x6c, 0xd3, 0xae, 0xe4, 0xf4, 0x1d, ++ 0x38, 0xff, 0xa4, 0xf1, 0x09, 0x98, 0xeb, 0x62, 0x3b, 0x41, 0x2e, 0xf2, 0xec, 0x54, 0xfe, 0xc4, ++ 0x4f, 0x60, 0xfc, 0x65, 0x41, 0x44, 0x31, 0x31, 0x5c, 0xe4, 0x39, 0xb3, 0x7b, 0x7b, 0xf2, 0x1b, ++ 0x79, 0x9b, 0x6a, 0xe8, 0xa5, 0xf1, 0x02, 0x4d, 0x7f, 0x1b, 0x30, 0x56, 0x49, 0x1c, 0x02, 0x50, ++ 0x41, 0xc8, 0x5c, 0x0b, 0xa4, 0xf4, 0x78, 0x76, 0xba, 0x27, 0xb8, 0x12, 0x84, 0x28, 0xfe, 0x72, ++ 0x94, 0xda, 0xb4, 0x0f, 0xf0, 0x19, 0xdc, 0xa6, 0x62, 0x93, 0x15, 0xcd, 0xfc, 0xef, 0xfb, 0xe8, ++ 0x72, 0x94, 0x3a, 0x3a, 0x3b, 0x40, 0x2d, 0x6f, 0x2a, 0x5a, 0x76, 0x90, 0x29, 0x1b, 0x97, 0x90, ++ 0xce, 0x6a, 0xe8, 0x11, 0x40, 0xc6, 0x58, 0xdf, 0xc6, 0x91, 0x8b, 0xbc, 0x5b, 0xf2, 0x29, 0x99, ++ 0xd3, 0xc0, 0x2b, 0x65, 0x11, 0x39, 0xef, 0x90, 0xb1, 0x1a, 0xf5, 0xfe, 0x81, 0x3d, 0x76, 0x7a, ++ 0x91, 0xf3, 0x61, 0x4a, 0x52, 0xb5, 0x7d, 0xad, 0xa5, 0x6a, 0xf7, 0xa7, 0x8c, 0xab, 0x96, 0x0f, ++ 0x53, 0x92, 0x3e, 0x88, 0x2c, 0x38, 0x5a, 0x57, 0x74, 0x39, 0x0d, 0xc1, 0x1e, 0x08, 0xec, 0x83, ++ 0xa5, 0x64, 0xfd, 0x3f, 0x7a, 0x68, 0xe9, 0x1d, 0xf5, 0xf8, 0x01, 0xd8, 0xc3, 0x12, 0xf1, 0x31, ++ 0xc0, 0xd5, 0x75, 0x1c, 0xcf, 0x6f, 0x5e, 0xc7, 0xd7, 0xe7, 0x27, 0xa3, 0xe8, 0x1b, 0x82, 0xbb, ++ 0x39, 0xdb, 0xec, 0x2a, 0x22, 0x47, 0x4f, 0x93, 0xc8, 0x38, 0x41, 0x9f, 0x9e, 0xfe, 0xef, 0x87, ++ 0x19, 0xea, 0xa3, 0xce, 0x7e, 0x20, 0xf4, 0xd3, 0x30, 0x2f, 0x92, 0xe8, 0x97, 0xf1, 0xf0, 0x42, ++ 0xcb, 0x93, 0xbe, 0xbf, 0x8f, 0x05, 0x21, 0x6f, 0x29, 0xfb, 0x4a, 0x3f, 0xc8, 0xca, 0xcc, 0x52, ++ 0xaa, 0x67, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xbc, 0xcf, 0x6d, 0x50, 0xfe, 0x02, 0x00, 0x00, ++} +diff --git a/vendor/github.com/golang/protobuf/ptypes/struct/struct.proto b/vendor/github.com/golang/protobuf/ptypes/struct/struct.proto +new file mode 100644 +index 0000000..beeba81 +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/ptypes/struct/struct.proto +@@ -0,0 +1,96 @@ ++// Protocol Buffers - Google's data interchange format ++// Copyright 2008 Google Inc. All rights reserved. ++// https://developers.google.com/protocol-buffers/ ++// ++// Redistribution and use in source and binary forms, with or without ++// modification, are permitted provided that the following conditions are ++// met: ++// ++// * Redistributions of source code must retain the above copyright ++// notice, this list of conditions and the following disclaimer. ++// * Redistributions in binary form must reproduce the above ++// copyright notice, this list of conditions and the following disclaimer ++// in the documentation and/or other materials provided with the ++// distribution. ++// * Neither the name of Google Inc. nor the names of its ++// contributors may be used to endorse or promote products derived from ++// this software without specific prior written permission. ++// ++// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++syntax = "proto3"; ++ ++package google.protobuf; ++ ++option csharp_namespace = "Google.Protobuf.WellKnownTypes"; ++option go_package = "github.com/golang/protobuf/ptypes/struct;structpb"; ++option java_package = "com.google.protobuf"; ++option java_outer_classname = "StructProto"; ++option java_multiple_files = true; ++option java_generate_equals_and_hash = true; ++option objc_class_prefix = "GPB"; ++ ++ ++// `Struct` represents a structured data value, consisting of fields ++// which map to dynamically typed values. In some languages, `Struct` ++// might be supported by a native representation. For example, in ++// scripting languages like JS a struct is represented as an ++// object. The details of that representation are described together ++// with the proto support for the language. ++// ++// The JSON representation for `Struct` is JSON object. ++message Struct { ++ // Unordered map of dynamically typed values. ++ map fields = 1; ++} ++ ++// `Value` represents a dynamically typed value which can be either ++// null, a number, a string, a boolean, a recursive struct value, or a ++// list of values. A producer of value is expected to set one of that ++// variants, absence of any variant indicates an error. ++// ++// The JSON representation for `Value` is JSON value. ++message Value { ++ // The kind of value. ++ oneof kind { ++ // Represents a null value. ++ NullValue null_value = 1; ++ // Represents a double value. ++ double number_value = 2; ++ // Represents a string value. ++ string string_value = 3; ++ // Represents a boolean value. ++ bool bool_value = 4; ++ // Represents a structured value. ++ Struct struct_value = 5; ++ // Represents a repeated `Value`. ++ ListValue list_value = 6; ++ } ++} ++ ++// `NullValue` is a singleton enumeration to represent the null value for the ++// `Value` type union. ++// ++// The JSON representation for `NullValue` is JSON `null`. ++enum NullValue { ++ // Null value. ++ NULL_VALUE = 0; ++} ++ ++// `ListValue` is a wrapper around a repeated field of values. ++// ++// The JSON representation for `ListValue` is JSON array. ++message ListValue { ++ // Repeated field of dynamically typed values. ++ repeated Value values = 1; ++} +diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go +new file mode 100644 +index 0000000..ffcc515 +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go +@@ -0,0 +1,127 @@ ++// Code generated by protoc-gen-go. ++// source: github.com/golang/protobuf/ptypes/timestamp/timestamp.proto ++// DO NOT EDIT! ++ ++/* ++Package timestamp is a generated protocol buffer package. ++ ++It is generated from these files: ++ github.com/golang/protobuf/ptypes/timestamp/timestamp.proto ++ ++It has these top-level messages: ++ Timestamp ++*/ ++package timestamp ++ ++import proto "github.com/golang/protobuf/proto" ++import fmt "fmt" ++import math "math" ++ ++// Reference imports to suppress errors if they are not otherwise used. ++var _ = proto.Marshal ++var _ = fmt.Errorf ++var _ = math.Inf ++ ++// This is a compile-time assertion to ensure that this generated file ++// is compatible with the proto package it is being compiled against. ++// A compilation error at this line likely means your copy of the ++// proto package needs to be updated. ++const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package ++ ++// A Timestamp represents a point in time independent of any time zone ++// or calendar, represented as seconds and fractions of seconds at ++// nanosecond resolution in UTC Epoch time. It is encoded using the ++// Proleptic Gregorian Calendar which extends the Gregorian calendar ++// backwards to year one. It is encoded assuming all minutes are 60 ++// seconds long, i.e. leap seconds are "smeared" so that no leap second ++// table is needed for interpretation. Range is from ++// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. ++// By restricting to that range, we ensure that we can convert to ++// and from RFC 3339 date strings. ++// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). ++// ++// Example 1: Compute Timestamp from POSIX `time()`. ++// ++// Timestamp timestamp; ++// timestamp.set_seconds(time(NULL)); ++// timestamp.set_nanos(0); ++// ++// Example 2: Compute Timestamp from POSIX `gettimeofday()`. ++// ++// struct timeval tv; ++// gettimeofday(&tv, NULL); ++// ++// Timestamp timestamp; ++// timestamp.set_seconds(tv.tv_sec); ++// timestamp.set_nanos(tv.tv_usec * 1000); ++// ++// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. ++// ++// FILETIME ft; ++// GetSystemTimeAsFileTime(&ft); ++// UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; ++// ++// // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z ++// // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. ++// Timestamp timestamp; ++// timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); ++// timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); ++// ++// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. ++// ++// long millis = System.currentTimeMillis(); ++// ++// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) ++// .setNanos((int) ((millis % 1000) * 1000000)).build(); ++// ++// ++// Example 5: Compute Timestamp from current time in Python. ++// ++// now = time.time() ++// seconds = int(now) ++// nanos = int((now - seconds) * 10**9) ++// timestamp = Timestamp(seconds=seconds, nanos=nanos) ++// ++// ++type Timestamp struct { ++ // Represents seconds of UTC time since Unix epoch ++ // 1970-01-01T00:00:00Z. Must be from from 0001-01-01T00:00:00Z to ++ // 9999-12-31T23:59:59Z inclusive. ++ Seconds int64 `protobuf:"varint,1,opt,name=seconds" json:"seconds,omitempty"` ++ // Non-negative fractions of a second at nanosecond resolution. Negative ++ // second values with fractions must still have non-negative nanos values ++ // that count forward in time. Must be from 0 to 999,999,999 ++ // inclusive. ++ Nanos int32 `protobuf:"varint,2,opt,name=nanos" json:"nanos,omitempty"` ++} ++ ++func (m *Timestamp) Reset() { *m = Timestamp{} } ++func (m *Timestamp) String() string { return proto.CompactTextString(m) } ++func (*Timestamp) ProtoMessage() {} ++func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } ++func (*Timestamp) XXX_WellKnownType() string { return "Timestamp" } ++ ++func init() { ++ proto.RegisterType((*Timestamp)(nil), "google.protobuf.Timestamp") ++} ++ ++func init() { ++ proto.RegisterFile("github.com/golang/protobuf/ptypes/timestamp/timestamp.proto", fileDescriptor0) ++} ++ ++var fileDescriptor0 = []byte{ ++ // 194 bytes of a gzipped FileDescriptorProto ++ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xb2, 0x4e, 0xcf, 0x2c, 0xc9, ++ 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0xd7, 0x2f, 0x28, ++ 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x28, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x2f, 0xc9, ++ 0xcc, 0x4d, 0x2d, 0x2e, 0x49, 0xcc, 0x2d, 0x40, 0xb0, 0xf4, 0xc0, 0x6a, 0x84, 0xf8, 0xd3, 0xf3, ++ 0xf3, 0xd3, 0x73, 0x52, 0xf5, 0x60, 0x3a, 0x94, 0xac, 0xb9, 0x38, 0x43, 0x60, 0x6a, 0x84, 0x24, ++ 0xb8, 0xd8, 0x8b, 0x53, 0x93, 0xf3, 0xf3, 0x52, 0x8a, 0x25, 0x18, 0x15, 0x18, 0x35, 0x98, 0x83, ++ 0x60, 0x5c, 0x21, 0x11, 0x2e, 0xd6, 0xbc, 0xc4, 0xbc, 0xfc, 0x62, 0x09, 0x26, 0x05, 0x46, 0x0d, ++ 0xd6, 0x20, 0x08, 0xc7, 0xa9, 0x91, 0x91, 0x4b, 0x38, 0x39, 0x3f, 0x57, 0x0f, 0xcd, 0x50, 0x27, ++ 0x3e, 0xb8, 0x91, 0x01, 0x20, 0xa1, 0x00, 0xc6, 0x28, 0x6d, 0x12, 0x1c, 0xbd, 0x80, 0x91, 0xf1, ++ 0x07, 0x23, 0xe3, 0x22, 0x26, 0x66, 0xf7, 0x00, 0xa7, 0x55, 0x4c, 0x72, 0xee, 0x10, 0xc3, 0x03, ++ 0xa0, 0xca, 0xf5, 0xc2, 0x53, 0x73, 0x72, 0xbc, 0xf3, 0xf2, 0xcb, 0xf3, 0x42, 0x40, 0xda, 0x92, ++ 0xd8, 0xc0, 0xe6, 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x17, 0x5f, 0xb7, 0xdc, 0x17, 0x01, ++ 0x00, 0x00, ++} +diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto +new file mode 100644 +index 0000000..7992a85 +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto +@@ -0,0 +1,111 @@ ++// Protocol Buffers - Google's data interchange format ++// Copyright 2008 Google Inc. All rights reserved. ++// https://developers.google.com/protocol-buffers/ ++// ++// Redistribution and use in source and binary forms, with or without ++// modification, are permitted provided that the following conditions are ++// met: ++// ++// * Redistributions of source code must retain the above copyright ++// notice, this list of conditions and the following disclaimer. ++// * Redistributions in binary form must reproduce the above ++// copyright notice, this list of conditions and the following disclaimer ++// in the documentation and/or other materials provided with the ++// distribution. ++// * Neither the name of Google Inc. nor the names of its ++// contributors may be used to endorse or promote products derived from ++// this software without specific prior written permission. ++// ++// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++syntax = "proto3"; ++ ++package google.protobuf; ++ ++option csharp_namespace = "Google.Protobuf.WellKnownTypes"; ++option cc_enable_arenas = true; ++option go_package = "github.com/golang/protobuf/ptypes/timestamp"; ++option java_package = "com.google.protobuf"; ++option java_outer_classname = "TimestampProto"; ++option java_multiple_files = true; ++option java_generate_equals_and_hash = true; ++option objc_class_prefix = "GPB"; ++ ++// A Timestamp represents a point in time independent of any time zone ++// or calendar, represented as seconds and fractions of seconds at ++// nanosecond resolution in UTC Epoch time. It is encoded using the ++// Proleptic Gregorian Calendar which extends the Gregorian calendar ++// backwards to year one. It is encoded assuming all minutes are 60 ++// seconds long, i.e. leap seconds are "smeared" so that no leap second ++// table is needed for interpretation. Range is from ++// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. ++// By restricting to that range, we ensure that we can convert to ++// and from RFC 3339 date strings. ++// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). ++// ++// Example 1: Compute Timestamp from POSIX `time()`. ++// ++// Timestamp timestamp; ++// timestamp.set_seconds(time(NULL)); ++// timestamp.set_nanos(0); ++// ++// Example 2: Compute Timestamp from POSIX `gettimeofday()`. ++// ++// struct timeval tv; ++// gettimeofday(&tv, NULL); ++// ++// Timestamp timestamp; ++// timestamp.set_seconds(tv.tv_sec); ++// timestamp.set_nanos(tv.tv_usec * 1000); ++// ++// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. ++// ++// FILETIME ft; ++// GetSystemTimeAsFileTime(&ft); ++// UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; ++// ++// // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z ++// // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. ++// Timestamp timestamp; ++// timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); ++// timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); ++// ++// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. ++// ++// long millis = System.currentTimeMillis(); ++// ++// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) ++// .setNanos((int) ((millis % 1000) * 1000000)).build(); ++// ++// ++// Example 5: Compute Timestamp from current time in Python. ++// ++// now = time.time() ++// seconds = int(now) ++// nanos = int((now - seconds) * 10**9) ++// timestamp = Timestamp(seconds=seconds, nanos=nanos) ++// ++// ++message Timestamp { ++ ++ // Represents seconds of UTC time since Unix epoch ++ // 1970-01-01T00:00:00Z. Must be from from 0001-01-01T00:00:00Z to ++ // 9999-12-31T23:59:59Z inclusive. ++ int64 seconds = 1; ++ ++ // Non-negative fractions of a second at nanosecond resolution. Negative ++ // second values with fractions must still have non-negative nanos values ++ // that count forward in time. Must be from 0 to 999,999,999 ++ // inclusive. ++ int32 nanos = 2; ++} +diff --git a/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go b/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go +new file mode 100644 +index 0000000..5e52a81 +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go +@@ -0,0 +1,200 @@ ++// Code generated by protoc-gen-go. ++// source: github.com/golang/protobuf/ptypes/wrappers/wrappers.proto ++// DO NOT EDIT! ++ ++/* ++Package wrappers is a generated protocol buffer package. ++ ++It is generated from these files: ++ github.com/golang/protobuf/ptypes/wrappers/wrappers.proto ++ ++It has these top-level messages: ++ DoubleValue ++ FloatValue ++ Int64Value ++ UInt64Value ++ Int32Value ++ UInt32Value ++ BoolValue ++ StringValue ++ BytesValue ++*/ ++package wrappers ++ ++import proto "github.com/golang/protobuf/proto" ++import fmt "fmt" ++import math "math" ++ ++// Reference imports to suppress errors if they are not otherwise used. ++var _ = proto.Marshal ++var _ = fmt.Errorf ++var _ = math.Inf ++ ++// This is a compile-time assertion to ensure that this generated file ++// is compatible with the proto package it is being compiled against. ++// A compilation error at this line likely means your copy of the ++// proto package needs to be updated. ++const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package ++ ++// Wrapper message for `double`. ++// ++// The JSON representation for `DoubleValue` is JSON number. ++type DoubleValue struct { ++ // The double value. ++ Value float64 `protobuf:"fixed64,1,opt,name=value" json:"value,omitempty"` ++} ++ ++func (m *DoubleValue) Reset() { *m = DoubleValue{} } ++func (m *DoubleValue) String() string { return proto.CompactTextString(m) } ++func (*DoubleValue) ProtoMessage() {} ++func (*DoubleValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } ++func (*DoubleValue) XXX_WellKnownType() string { return "DoubleValue" } ++ ++// Wrapper message for `float`. ++// ++// The JSON representation for `FloatValue` is JSON number. ++type FloatValue struct { ++ // The float value. ++ Value float32 `protobuf:"fixed32,1,opt,name=value" json:"value,omitempty"` ++} ++ ++func (m *FloatValue) Reset() { *m = FloatValue{} } ++func (m *FloatValue) String() string { return proto.CompactTextString(m) } ++func (*FloatValue) ProtoMessage() {} ++func (*FloatValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } ++func (*FloatValue) XXX_WellKnownType() string { return "FloatValue" } ++ ++// Wrapper message for `int64`. ++// ++// The JSON representation for `Int64Value` is JSON string. ++type Int64Value struct { ++ // The int64 value. ++ Value int64 `protobuf:"varint,1,opt,name=value" json:"value,omitempty"` ++} ++ ++func (m *Int64Value) Reset() { *m = Int64Value{} } ++func (m *Int64Value) String() string { return proto.CompactTextString(m) } ++func (*Int64Value) ProtoMessage() {} ++func (*Int64Value) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } ++func (*Int64Value) XXX_WellKnownType() string { return "Int64Value" } ++ ++// Wrapper message for `uint64`. ++// ++// The JSON representation for `UInt64Value` is JSON string. ++type UInt64Value struct { ++ // The uint64 value. ++ Value uint64 `protobuf:"varint,1,opt,name=value" json:"value,omitempty"` ++} ++ ++func (m *UInt64Value) Reset() { *m = UInt64Value{} } ++func (m *UInt64Value) String() string { return proto.CompactTextString(m) } ++func (*UInt64Value) ProtoMessage() {} ++func (*UInt64Value) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } ++func (*UInt64Value) XXX_WellKnownType() string { return "UInt64Value" } ++ ++// Wrapper message for `int32`. ++// ++// The JSON representation for `Int32Value` is JSON number. ++type Int32Value struct { ++ // The int32 value. ++ Value int32 `protobuf:"varint,1,opt,name=value" json:"value,omitempty"` ++} ++ ++func (m *Int32Value) Reset() { *m = Int32Value{} } ++func (m *Int32Value) String() string { return proto.CompactTextString(m) } ++func (*Int32Value) ProtoMessage() {} ++func (*Int32Value) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } ++func (*Int32Value) XXX_WellKnownType() string { return "Int32Value" } ++ ++// Wrapper message for `uint32`. ++// ++// The JSON representation for `UInt32Value` is JSON number. ++type UInt32Value struct { ++ // The uint32 value. ++ Value uint32 `protobuf:"varint,1,opt,name=value" json:"value,omitempty"` ++} ++ ++func (m *UInt32Value) Reset() { *m = UInt32Value{} } ++func (m *UInt32Value) String() string { return proto.CompactTextString(m) } ++func (*UInt32Value) ProtoMessage() {} ++func (*UInt32Value) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } ++func (*UInt32Value) XXX_WellKnownType() string { return "UInt32Value" } ++ ++// Wrapper message for `bool`. ++// ++// The JSON representation for `BoolValue` is JSON `true` and `false`. ++type BoolValue struct { ++ // The bool value. ++ Value bool `protobuf:"varint,1,opt,name=value" json:"value,omitempty"` ++} ++ ++func (m *BoolValue) Reset() { *m = BoolValue{} } ++func (m *BoolValue) String() string { return proto.CompactTextString(m) } ++func (*BoolValue) ProtoMessage() {} ++func (*BoolValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } ++func (*BoolValue) XXX_WellKnownType() string { return "BoolValue" } ++ ++// Wrapper message for `string`. ++// ++// The JSON representation for `StringValue` is JSON string. ++type StringValue struct { ++ // The string value. ++ Value string `protobuf:"bytes,1,opt,name=value" json:"value,omitempty"` ++} ++ ++func (m *StringValue) Reset() { *m = StringValue{} } ++func (m *StringValue) String() string { return proto.CompactTextString(m) } ++func (*StringValue) ProtoMessage() {} ++func (*StringValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } ++func (*StringValue) XXX_WellKnownType() string { return "StringValue" } ++ ++// Wrapper message for `bytes`. ++// ++// The JSON representation for `BytesValue` is JSON string. ++type BytesValue struct { ++ // The bytes value. ++ Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` ++} ++ ++func (m *BytesValue) Reset() { *m = BytesValue{} } ++func (m *BytesValue) String() string { return proto.CompactTextString(m) } ++func (*BytesValue) ProtoMessage() {} ++func (*BytesValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } ++func (*BytesValue) XXX_WellKnownType() string { return "BytesValue" } ++ ++func init() { ++ proto.RegisterType((*DoubleValue)(nil), "google.protobuf.DoubleValue") ++ proto.RegisterType((*FloatValue)(nil), "google.protobuf.FloatValue") ++ proto.RegisterType((*Int64Value)(nil), "google.protobuf.Int64Value") ++ proto.RegisterType((*UInt64Value)(nil), "google.protobuf.UInt64Value") ++ proto.RegisterType((*Int32Value)(nil), "google.protobuf.Int32Value") ++ proto.RegisterType((*UInt32Value)(nil), "google.protobuf.UInt32Value") ++ proto.RegisterType((*BoolValue)(nil), "google.protobuf.BoolValue") ++ proto.RegisterType((*StringValue)(nil), "google.protobuf.StringValue") ++ proto.RegisterType((*BytesValue)(nil), "google.protobuf.BytesValue") ++} ++ ++func init() { ++ proto.RegisterFile("github.com/golang/protobuf/ptypes/wrappers/wrappers.proto", fileDescriptor0) ++} ++ ++var fileDescriptor0 = []byte{ ++ // 260 bytes of a gzipped FileDescriptorProto ++ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xb2, 0x4c, 0xcf, 0x2c, 0xc9, ++ 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0xd7, 0x2f, 0x28, ++ 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x28, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x2f, 0x2f, ++ 0x4a, 0x2c, 0x28, 0x48, 0x2d, 0x42, 0x30, 0xf4, 0xc0, 0x2a, 0x84, 0xf8, 0xd3, 0xf3, 0xf3, 0xd3, ++ 0x73, 0x52, 0xf5, 0x60, 0xea, 0x95, 0x94, 0xb9, 0xb8, 0x5d, 0xf2, 0x4b, 0x93, 0x72, 0x52, 0xc3, ++ 0x12, 0x73, 0x4a, 0x53, 0x85, 0x44, 0xb8, 0x58, 0xcb, 0x40, 0x0c, 0x09, 0x46, 0x05, 0x46, 0x0d, ++ 0xc6, 0x20, 0x08, 0x47, 0x49, 0x89, 0x8b, 0xcb, 0x2d, 0x27, 0x3f, 0xb1, 0x04, 0x8b, 0x1a, 0x26, ++ 0x24, 0x35, 0x9e, 0x79, 0x25, 0x66, 0x26, 0x58, 0xd4, 0x30, 0xc3, 0xd4, 0x28, 0x73, 0x71, 0x87, ++ 0xe2, 0x52, 0xc4, 0x82, 0x6a, 0x90, 0xb1, 0x11, 0x16, 0x35, 0xac, 0x68, 0x06, 0x61, 0x55, 0xc4, ++ 0x0b, 0x53, 0xa4, 0xc8, 0xc5, 0xe9, 0x94, 0x9f, 0x9f, 0x83, 0x45, 0x09, 0x07, 0x92, 0x39, 0xc1, ++ 0x25, 0x45, 0x99, 0x79, 0xe9, 0x58, 0x14, 0x71, 0x22, 0x39, 0xc8, 0xa9, 0xb2, 0x24, 0xb5, 0x18, ++ 0x8b, 0x1a, 0x1e, 0xa8, 0x1a, 0xa7, 0x7a, 0x2e, 0xe1, 0xe4, 0xfc, 0x5c, 0x3d, 0xb4, 0xd0, 0x75, ++ 0xe2, 0x0d, 0x87, 0x06, 0x7f, 0x00, 0x48, 0x24, 0x80, 0x31, 0x4a, 0x8b, 0xf8, 0xa8, 0x5b, 0xc0, ++ 0xc8, 0xf8, 0x83, 0x91, 0x71, 0x11, 0x13, 0xb3, 0x7b, 0x80, 0xd3, 0x2a, 0x26, 0x39, 0x77, 0x88, ++ 0xd1, 0x01, 0x50, 0xd5, 0x7a, 0xe1, 0xa9, 0x39, 0x39, 0xde, 0x79, 0xf9, 0xe5, 0x79, 0x21, 0x20, ++ 0x5d, 0x49, 0x6c, 0x60, 0x63, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa9, 0xdf, 0x64, 0x4b, ++ 0x1c, 0x02, 0x00, 0x00, ++} +diff --git a/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.proto b/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.proto +new file mode 100644 +index 0000000..4828ad9 +--- /dev/null ++++ b/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.proto +@@ -0,0 +1,119 @@ ++// Protocol Buffers - Google's data interchange format ++// Copyright 2008 Google Inc. All rights reserved. ++// https://developers.google.com/protocol-buffers/ ++// ++// Redistribution and use in source and binary forms, with or without ++// modification, are permitted provided that the following conditions are ++// met: ++// ++// * Redistributions of source code must retain the above copyright ++// notice, this list of conditions and the following disclaimer. ++// * Redistributions in binary form must reproduce the above ++// copyright notice, this list of conditions and the following disclaimer ++// in the documentation and/or other materials provided with the ++// distribution. ++// * Neither the name of Google Inc. nor the names of its ++// contributors may be used to endorse or promote products derived from ++// this software without specific prior written permission. ++// ++// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++// Wrappers for primitive (non-message) types. These types are useful ++// for embedding primitives in the `google.protobuf.Any` type and for places ++// where we need to distinguish between the absence of a primitive ++// typed field and its default value. ++ ++syntax = "proto3"; ++ ++package google.protobuf; ++ ++option csharp_namespace = "Google.Protobuf.WellKnownTypes"; ++option cc_enable_arenas = true; ++option go_package = "github.com/golang/protobuf/ptypes/wrappers"; ++option java_package = "com.google.protobuf"; ++option java_outer_classname = "WrappersProto"; ++option java_multiple_files = true; ++option java_generate_equals_and_hash = true; ++option objc_class_prefix = "GPB"; ++ ++// Wrapper message for `double`. ++// ++// The JSON representation for `DoubleValue` is JSON number. ++message DoubleValue { ++ // The double value. ++ double value = 1; ++} ++ ++// Wrapper message for `float`. ++// ++// The JSON representation for `FloatValue` is JSON number. ++message FloatValue { ++ // The float value. ++ float value = 1; ++} ++ ++// Wrapper message for `int64`. ++// ++// The JSON representation for `Int64Value` is JSON string. ++message Int64Value { ++ // The int64 value. ++ int64 value = 1; ++} ++ ++// Wrapper message for `uint64`. ++// ++// The JSON representation for `UInt64Value` is JSON string. ++message UInt64Value { ++ // The uint64 value. ++ uint64 value = 1; ++} ++ ++// Wrapper message for `int32`. ++// ++// The JSON representation for `Int32Value` is JSON number. ++message Int32Value { ++ // The int32 value. ++ int32 value = 1; ++} ++ ++// Wrapper message for `uint32`. ++// ++// The JSON representation for `UInt32Value` is JSON number. ++message UInt32Value { ++ // The uint32 value. ++ uint32 value = 1; ++} ++ ++// Wrapper message for `bool`. ++// ++// The JSON representation for `BoolValue` is JSON `true` and `false`. ++message BoolValue { ++ // The bool value. ++ bool value = 1; ++} ++ ++// Wrapper message for `string`. ++// ++// The JSON representation for `StringValue` is JSON string. ++message StringValue { ++ // The string value. ++ string value = 1; ++} ++ ++// Wrapper message for `bytes`. ++// ++// The JSON representation for `BytesValue` is JSON string. ++message BytesValue { ++ // The bytes value. ++ bytes value = 1; ++} +-- +2.32.0 + diff --git a/series.conf b/series.conf index 42771a46ce8a9a81c624743ac0c7e50ac5bf39ae..cd40983a090feff3b54f6737fdf22b0bdaef3311 100644 --- a/series.conf +++ b/series.conf @@ -128,4 +128,8 @@ patch/0127-runc-add-mount-destination-validation-fix-CVE-2021.patch patch/0128-runc-optimize-nsexec-logging.patch patch/0129-runc-improve-log-for-debugging.patch patch/0130-runc-fix-cgroup-info-print-error.patch +patch/0131-Update-criurpc.patch +patch/0132-cr-set-a-freezer-cgroup-for-criu.patch +patch/0133-cr-don-t-dump-network-devices-and-their-configuratio.patch +patch/0134-PATCH-Update-github.com-golang-protobuf.patch #end