report.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: desmos/posts/v1beta1/report.proto

package types

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// Report is the struct of a post's reports
type Report struct {
	// ID of the post for which the report has been created
	PostID string `protobuf:"bytes,1,opt,name=post_id,json=postId,proto3" json:"post_id,omitempty" yaml:"post_id"`
	// Identifies the type of the reports
	Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty" yaml:"type"`
	// User message
	Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty" yaml:"message"`
	// Identifies the reporting user
	User string `protobuf:"bytes,4,opt,name=user,proto3" json:"user,omitempty" yaml:"user"`
}

func (m *Report) Reset()         { *m = Report{} }
func (m *Report) String() string { return proto.CompactTextString(m) }
func (*Report) ProtoMessage()    {}
func (*Report) Descriptor() ([]byte, []int) {
	return fileDescriptor_49358fa634b11ca9, []int{0}
}
func (m *Report) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Report) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Report.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Report) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Report.Merge(m, src)
}
func (m *Report) XXX_Size() int {
	return m.Size()
}
func (m *Report) XXX_DiscardUnknown() {
	xxx_messageInfo_Report.DiscardUnknown(m)
}

var xxx_messageInfo_Report proto.InternalMessageInfo

func (m *Report) GetPostID() string {
	if m != nil {
		return m.PostID
	}
	return ""
}

func (m *Report) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *Report) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *Report) GetUser() string {
	if m != nil {
		return m.User
	}
	return ""
}

// Reports wraps a list of Report objects
type Reports struct {
	Reports []Report `protobuf:"bytes,1,rep,name=reports,proto3" json:"reports"`
}

func (m *Reports) Reset()         { *m = Reports{} }
func (m *Reports) String() string { return proto.CompactTextString(m) }
func (*Reports) ProtoMessage()    {}
func (*Reports) Descriptor() ([]byte, []int) {
	return fileDescriptor_49358fa634b11ca9, []int{1}
}
func (m *Reports) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Reports) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Reports.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Reports) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Reports.Merge(m, src)
}
func (m *Reports) XXX_Size() int {
	return m.Size()
}
func (m *Reports) XXX_DiscardUnknown() {
	xxx_messageInfo_Reports.DiscardUnknown(m)
}

var xxx_messageInfo_Reports proto.InternalMessageInfo

func (m *Reports) GetReports() []Report {
	if m != nil {
		return m.Reports
	}
	return nil
}

func init() {
	proto.RegisterType((*Report)(nil), "desmos.posts.v1beta1.Report")
	proto.RegisterType((*Reports)(nil), "desmos.posts.v1beta1.Reports")
}

func init() { proto.RegisterFile("desmos/posts/v1beta1/report.proto", fileDescriptor_49358fa634b11ca9) }

var fileDescriptor_49358fa634b11ca9 = []byte{
	// 321 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x91, 0x31, 0x4b, 0xc3, 0x40,
	0x1c, 0xc5, 0x73, 0xb6, 0x24, 0x7a, 0x05, 0x85, 0xd0, 0x21, 0x48, 0x49, 0xea, 0xb9, 0x74, 0xd0,
	0x1c, 0xad, 0xe8, 0x50, 0x9c, 0x8a, 0x20, 0xdd, 0x4a, 0x46, 0x17, 0x49, 0xec, 0x71, 0x16, 0x1a,
	0x2f, 0xe4, 0x7f, 0x2d, 0xf6, 0x5b, 0x38, 0x3a, 0xf6, 0xab, 0xb8, 0x75, 0xec, 0xe8, 0x14, 0x24,
	0x59, 0x9c, 0xfb, 0x09, 0xe4, 0xee, 0x52, 0x04, 0x71, 0x7b, 0xdc, 0xfb, 0xbd, 0x07, 0xff, 0x77,
	0xf8, 0x6c, 0xca, 0x20, 0x15, 0x40, 0x33, 0x01, 0x12, 0xe8, 0xb2, 0x9f, 0x30, 0x19, 0xf7, 0x69,
	0xce, 0x32, 0x91, 0xcb, 0x30, 0xcb, 0x85, 0x14, 0x6e, 0xdb, 0x20, 0xa1, 0x46, 0xc2, 0x1a, 0x39,
	0x6d, 0x73, 0xc1, 0x85, 0x06, 0xa8, 0x52, 0x86, 0x25, 0x1f, 0x08, 0xdb, 0x91, 0x0e, 0xbb, 0xd7,
	0xd8, 0x51, 0x89, 0xc7, 0xd9, 0xd4, 0x43, 0x5d, 0xd4, 0x3b, 0x1a, 0x75, 0xca, 0x22, 0xb0, 0x27,
	0x02, 0xe4, 0xf8, 0x6e, 0x57, 0x04, 0xc7, 0xab, 0x38, 0x9d, 0x0f, 0x49, 0x8d, 0x90, 0xc8, 0x56,
	0x6a, 0x3c, 0x75, 0xcf, 0x71, 0x53, 0xae, 0x32, 0xe6, 0x1d, 0xe8, 0xcc, 0xc9, 0xae, 0x08, 0x5a,
	0x86, 0x54, 0xaf, 0x24, 0xd2, 0xa6, 0x7b, 0x81, 0x9d, 0x94, 0x01, 0xc4, 0x9c, 0x79, 0x0d, 0xcd,
	0xb9, 0xbf, 0x8d, 0xb5, 0x41, 0xa2, 0x3d, 0xa2, 0x2a, 0x17, 0xc0, 0x72, 0xaf, 0xf9, 0xb7, 0x52,
	0xbd, 0x92, 0x48, 0x9b, 0xc3, 0xc3, 0xf7, 0x75, 0x80, 0xbe, 0xd7, 0x01, 0x22, 0xf7, 0xd8, 0x31,
	0x27, 0x80, 0x7b, 0x8b, 0x1d, 0x33, 0x05, 0x78, 0xa8, 0xdb, 0xe8, 0xb5, 0x06, 0x9d, 0xf0, 0xbf,
	0x31, 0x42, 0xc3, 0x8f, 0x9a, 0x9b, 0x22, 0xb0, 0xa2, 0x7d, 0x64, 0x34, 0xd9, 0x94, 0x3e, 0xda,
	0x96, 0x3e, 0xfa, 0x2a, 0x7d, 0xf4, 0x56, 0xf9, 0xd6, 0xb6, 0xf2, 0xad, 0xcf, 0xca, 0xb7, 0x1e,
	0x6e, 0xf8, 0x4c, 0x3e, 0x2f, 0x92, 0xf0, 0x49, 0xa4, 0xd4, 0x14, 0x5e, 0xce, 0xe3, 0x04, 0x6a,
	0x4d, 0x97, 0x03, 0xfa, 0x4a, 0x41, 0xc6, 0x7c, 0xf6, 0xc2, 0xeb, 0x9f, 0x51, 0x67, 0x43, 0x62,
	0xeb, 0x95, 0xaf, 0x7e, 0x02, 0x00, 0x00, 0xff, 0xff, 0xcd, 0x0b, 0xbe, 0x50, 0xb6, 0x01, 0x00,
	0x00,
}

func (this *Report) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Report)
	if !ok {
		that2, ok := that.(Report)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.PostID != that1.PostID {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	if this.User != that1.User {
		return false
	}
	return true
}
func (m *Report) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Report) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Report) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.User) > 0 {
		i -= len(m.User)
		copy(dAtA[i:], m.User)
		i = encodeVarintReport(dAtA, i, uint64(len(m.User)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintReport(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintReport(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.PostID) > 0 {
		i -= len(m.PostID)
		copy(dAtA[i:], m.PostID)
		i = encodeVarintReport(dAtA, i, uint64(len(m.PostID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Reports) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Reports) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Reports) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Reports) > 0 {
		for iNdEx := len(m.Reports) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Reports[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintReport(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintReport(dAtA []byte, offset int, v uint64) int {
	offset -= sovReport(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Report) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PostID)
	if l > 0 {
		n += 1 + l + sovReport(uint64(l))
	}
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovReport(uint64(l))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovReport(uint64(l))
	}
	l = len(m.User)
	if l > 0 {
		n += 1 + l + sovReport(uint64(l))
	}
	return n
}

func (m *Reports) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Reports) > 0 {
		for _, e := range m.Reports {
			l = e.Size()
			n += 1 + l + sovReport(uint64(l))
		}
	}
	return n
}

func sovReport(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozReport(x uint64) (n int) {
	return sovReport(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Report) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowReport
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Report: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Report: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PostID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReport
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthReport
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthReport
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PostID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReport
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthReport
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthReport
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReport
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthReport
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthReport
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReport
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthReport
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthReport
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.User = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipReport(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthReport
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Reports) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowReport
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Reports: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Reports: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reports", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReport
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReport
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReport
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reports = append(m.Reports, Report{})
			if err := m.Reports[len(m.Reports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipReport(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthReport
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipReport(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowReport
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowReport
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowReport
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthReport
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupReport
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthReport
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthReport        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowReport          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupReport = fmt.Errorf("proto: unexpected end of group")
)