// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: app/service/openplatform/ticket-item/api/grpc/v1/time.proto

package v1

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"

import io "io"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// The response message containing the Item related time
type ItemTime struct {
	Stime int32 `protobuf:"varint,1,opt,name=stime,proto3" json:"stime"`
	Etime int32 `protobuf:"varint,2,opt,name=etime,proto3" json:"etime"`
}

func (m *ItemTime) Reset()                    { *m = ItemTime{} }
func (m *ItemTime) String() string            { return proto.CompactTextString(m) }
func (*ItemTime) ProtoMessage()               {}
func (*ItemTime) Descriptor() ([]byte, []int) { return fileDescriptorTime, []int{0} }

func (m *ItemTime) GetStime() int32 {
	if m != nil {
		return m.Stime
	}
	return 0
}

func (m *ItemTime) GetEtime() int32 {
	if m != nil {
		return m.Etime
	}
	return 0
}

// The response message containing the Screen related time
type ScreenTime struct {
	Stime     int32 `protobuf:"varint,1,opt,name=stime,proto3" json:"stime" validate:"min=0"`
	Etime     int32 `protobuf:"varint,2,opt,name=etime,proto3" json:"etime" validate:"min=0"`
	SaleStime int32 `protobuf:"varint,3,opt,name=sale_stime,json=saleStime,proto3" json:"sales" validate:"min=0"`
	SaleEtime int32 `protobuf:"varint,4,opt,name=sale_etime,json=saleEtime,proto3" json:"salee" validate:"min=0"`
}

func (m *ScreenTime) Reset()                    { *m = ScreenTime{} }
func (m *ScreenTime) String() string            { return proto.CompactTextString(m) }
func (*ScreenTime) ProtoMessage()               {}
func (*ScreenTime) Descriptor() ([]byte, []int) { return fileDescriptorTime, []int{1} }

func (m *ScreenTime) GetStime() int32 {
	if m != nil {
		return m.Stime
	}
	return 0
}

func (m *ScreenTime) GetEtime() int32 {
	if m != nil {
		return m.Etime
	}
	return 0
}

func (m *ScreenTime) GetSaleStime() int32 {
	if m != nil {
		return m.SaleStime
	}
	return 0
}

func (m *ScreenTime) GetSaleEtime() int32 {
	if m != nil {
		return m.SaleEtime
	}
	return 0
}

// The response message containing the Ticket related time
type TicketTime struct {
	SaleStime int64 `protobuf:"varint,1,opt,name=sale_stime,json=saleStime,proto3" json:"sales" validate:"min=0"`
	SaleEtime int64 `protobuf:"varint,2,opt,name=sale_etime,json=saleEtime,proto3" json:"salee" validate:"min=0"`
}

func (m *TicketTime) Reset()                    { *m = TicketTime{} }
func (m *TicketTime) String() string            { return proto.CompactTextString(m) }
func (*TicketTime) ProtoMessage()               {}
func (*TicketTime) Descriptor() ([]byte, []int) { return fileDescriptorTime, []int{2} }

func (m *TicketTime) GetSaleStime() int64 {
	if m != nil {
		return m.SaleStime
	}
	return 0
}

func (m *TicketTime) GetSaleEtime() int64 {
	if m != nil {
		return m.SaleEtime
	}
	return 0
}

func init() {
	proto.RegisterType((*ItemTime)(nil), "ticket.service.item.v1.ItemTime")
	proto.RegisterType((*ScreenTime)(nil), "ticket.service.item.v1.ScreenTime")
	proto.RegisterType((*TicketTime)(nil), "ticket.service.item.v1.TicketTime")
}
func (m *ItemTime) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ItemTime) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Stime != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintTime(dAtA, i, uint64(m.Stime))
	}
	if m.Etime != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintTime(dAtA, i, uint64(m.Etime))
	}
	return i, nil
}

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

func (m *ScreenTime) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Stime != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintTime(dAtA, i, uint64(m.Stime))
	}
	if m.Etime != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintTime(dAtA, i, uint64(m.Etime))
	}
	if m.SaleStime != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintTime(dAtA, i, uint64(m.SaleStime))
	}
	if m.SaleEtime != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintTime(dAtA, i, uint64(m.SaleEtime))
	}
	return i, nil
}

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

func (m *TicketTime) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.SaleStime != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintTime(dAtA, i, uint64(m.SaleStime))
	}
	if m.SaleEtime != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintTime(dAtA, i, uint64(m.SaleEtime))
	}
	return i, nil
}

func encodeVarintTime(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *ItemTime) Size() (n int) {
	var l int
	_ = l
	if m.Stime != 0 {
		n += 1 + sovTime(uint64(m.Stime))
	}
	if m.Etime != 0 {
		n += 1 + sovTime(uint64(m.Etime))
	}
	return n
}

func (m *ScreenTime) Size() (n int) {
	var l int
	_ = l
	if m.Stime != 0 {
		n += 1 + sovTime(uint64(m.Stime))
	}
	if m.Etime != 0 {
		n += 1 + sovTime(uint64(m.Etime))
	}
	if m.SaleStime != 0 {
		n += 1 + sovTime(uint64(m.SaleStime))
	}
	if m.SaleEtime != 0 {
		n += 1 + sovTime(uint64(m.SaleEtime))
	}
	return n
}

func (m *TicketTime) Size() (n int) {
	var l int
	_ = l
	if m.SaleStime != 0 {
		n += 1 + sovTime(uint64(m.SaleStime))
	}
	if m.SaleEtime != 0 {
		n += 1 + sovTime(uint64(m.SaleEtime))
	}
	return n
}

func sovTime(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozTime(x uint64) (n int) {
	return sovTime(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ItemTime) 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 ErrIntOverflowTime
			}
			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: ItemTime: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ItemTime: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stime", wireType)
			}
			m.Stime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTime
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Stime |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Etime", wireType)
			}
			m.Etime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTime
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Etime |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTime(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTime
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ScreenTime) 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 ErrIntOverflowTime
			}
			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: ScreenTime: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ScreenTime: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stime", wireType)
			}
			m.Stime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTime
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Stime |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Etime", wireType)
			}
			m.Etime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTime
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Etime |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SaleStime", wireType)
			}
			m.SaleStime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTime
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SaleStime |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SaleEtime", wireType)
			}
			m.SaleEtime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTime
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SaleEtime |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTime(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTime
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TicketTime) 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 ErrIntOverflowTime
			}
			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: TicketTime: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TicketTime: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SaleStime", wireType)
			}
			m.SaleStime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTime
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SaleStime |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SaleEtime", wireType)
			}
			m.SaleEtime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTime
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SaleEtime |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTime(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTime
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTime(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowTime
			}
			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, ErrIntOverflowTime
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTime
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthTime
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowTime
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipTime(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthTime = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTime   = fmt.Errorf("proto: integer overflow")
)

func init() {
	proto.RegisterFile("app/service/openplatform/ticket-item/api/grpc/v1/time.proto", fileDescriptorTime)
}

var fileDescriptorTime = []byte{
	// 310 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x91, 0xbf, 0x4e, 0xc3, 0x30,
	0x10, 0xc6, 0xe5, 0x94, 0x22, 0xea, 0xa9, 0xca, 0x80, 0x10, 0x52, 0x13, 0x94, 0x89, 0xa5, 0x31,
	0x51, 0x36, 0xfe, 0x2c, 0x95, 0x18, 0x90, 0x98, 0x68, 0x26, 0x16, 0xe4, 0x84, 0x6b, 0xb0, 0x88,
	0x63, 0x2b, 0x71, 0xf3, 0x0c, 0x3c, 0x1a, 0x23, 0x4f, 0x50, 0xa1, 0x8c, 0x8c, 0x7d, 0x02, 0x94,
	0x33, 0x14, 0x22, 0x8a, 0x90, 0x98, 0x9c, 0xcb, 0x7d, 0xdf, 0xf7, 0xbb, 0xd3, 0xd1, 0x33, 0xae,
	0x35, 0xab, 0xa1, 0x6a, 0x44, 0x06, 0x4c, 0x69, 0x28, 0x75, 0xc1, 0xcd, 0x42, 0x55, 0x92, 0x19,
	0x91, 0x3d, 0x82, 0x99, 0x0a, 0x03, 0x92, 0x71, 0x2d, 0x58, 0x5e, 0xe9, 0x8c, 0x35, 0x11, 0x33,
	0x42, 0x42, 0xa8, 0x2b, 0x65, 0x94, 0xbb, 0x6f, 0x35, 0xe1, 0x87, 0x3f, 0xec, 0xb4, 0x61, 0x13,
	0x1d, 0x4e, 0x73, 0x61, 0x1e, 0x96, 0x69, 0x98, 0x29, 0xc9, 0x72, 0x95, 0x2b, 0x86, 0xf2, 0x74,
	0xb9, 0xc0, 0x0a, 0x0b, 0xfc, 0xb2, 0x31, 0xc1, 0x35, 0xdd, 0xbb, 0x32, 0x20, 0x13, 0x21, 0xc1,
	0xf5, 0xe9, 0xb0, 0xee, 0x08, 0x07, 0xe4, 0x88, 0x1c, 0x0f, 0x67, 0xa3, 0xb7, 0x95, 0x6f, 0x7f,
	0xdc, 0xd8, 0xa7, 0x13, 0x00, 0x0a, 0x9c, 0x2f, 0x01, 0x58, 0x01, 0x3e, 0xc1, 0x9a, 0x50, 0x3a,
	0xcf, 0x2a, 0x80, 0x12, 0x03, 0xe3, 0x7e, 0xe0, 0x64, 0x13, 0xb8, 0x5e, 0xf9, 0xe3, 0x86, 0x17,
	0xe2, 0x9e, 0x1b, 0x38, 0x0d, 0xa4, 0x28, 0x2f, 0x4e, 0x82, 0x4f, 0x48, 0xdc, 0x87, 0x4c, 0x36,
	0x90, 0xed, 0x26, 0x6c, 0xb9, 0xe7, 0x94, 0xd6, 0xbc, 0x80, 0x3b, 0x8b, 0x1b, 0x7c, 0xc3, 0xf1,
	0x02, 0xea, 0xad, 0xce, 0x51, 0xd7, 0x9a, 0xf7, 0xdc, 0x96, 0xbb, 0xd3, 0x77, 0xc3, 0xef, 0xee,
	0x4b, 0x5c, 0xfa, 0x89, 0x50, 0x9a, 0xe0, 0x31, 0x92, 0x9f, 0xa3, 0x74, 0x9b, 0x0f, 0xfe, 0x3d,
	0x8a, 0xd3, 0x77, 0xff, 0x35, 0xca, 0x6c, 0xfc, 0xdc, 0x7a, 0xe4, 0xa5, 0xf5, 0xc8, 0x6b, 0xeb,
	0x91, 0x5b, 0xa7, 0x89, 0xd2, 0x5d, 0x3c, 0x73, 0xfc, 0x1e, 0x00, 0x00, 0xff, 0xff, 0x47, 0x84,
	0xeb, 0xce, 0x6c, 0x02, 0x00, 0x00,
}