common.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: greenfield/permission/common.proto

package types

import (
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	_ "github.com/cosmos/gogoproto/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

// ActionType defines the operations you can execute in greenfield storage network
type ActionType int32

const (
	ACTION_UPDATE_BUCKET_INFO  ActionType = 0
	ACTION_DELETE_BUCKET       ActionType = 1
	ACTION_CREATE_OBJECT       ActionType = 2
	ACTION_DELETE_OBJECT       ActionType = 3
	ACTION_COPY_OBJECT         ActionType = 4
	ACTION_GET_OBJECT          ActionType = 5
	ACTION_EXECUTE_OBJECT      ActionType = 6
	ACTION_LIST_OBJECT         ActionType = 7
	ACTION_UPDATE_GROUP_MEMBER ActionType = 8
	ACTION_DELETE_GROUP        ActionType = 9
	ACTION_GROUP_MEMBER        ActionType = 10
	ACTION_TYPE_ALL            ActionType = 99
)

var ActionType_name = map[int32]string{
	0:  "ACTION_UPDATE_BUCKET_INFO",
	1:  "ACTION_DELETE_BUCKET",
	2:  "ACTION_CREATE_OBJECT",
	3:  "ACTION_DELETE_OBJECT",
	4:  "ACTION_COPY_OBJECT",
	5:  "ACTION_GET_OBJECT",
	6:  "ACTION_EXECUTE_OBJECT",
	7:  "ACTION_LIST_OBJECT",
	8:  "ACTION_UPDATE_GROUP_MEMBER",
	9:  "ACTION_DELETE_GROUP",
	10: "ACTION_GROUP_MEMBER",
	99: "ACTION_TYPE_ALL",
}

var ActionType_value = map[string]int32{
	"ACTION_UPDATE_BUCKET_INFO":  0,
	"ACTION_DELETE_BUCKET":       1,
	"ACTION_CREATE_OBJECT":       2,
	"ACTION_DELETE_OBJECT":       3,
	"ACTION_COPY_OBJECT":         4,
	"ACTION_GET_OBJECT":          5,
	"ACTION_EXECUTE_OBJECT":      6,
	"ACTION_LIST_OBJECT":         7,
	"ACTION_UPDATE_GROUP_MEMBER": 8,
	"ACTION_DELETE_GROUP":        9,
	"ACTION_GROUP_MEMBER":        10,
	"ACTION_TYPE_ALL":            99,
}

func (x ActionType) String() string {
	return proto.EnumName(ActionType_name, int32(x))
}

func (ActionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_33a4d646aee30990, []int{0}
}

// Effect define the effect of the operation permission, include Allow or deny
type Effect int32

const (
	EFFECT_ALLOW Effect = 0
	EFFECT_DENY  Effect = 1
	// Use internally, means skipped. there is no explicit ALLOW or DENY, and further permission checks are required.
	EFFECT_PASS Effect = 2
)

var Effect_name = map[int32]string{
	0: "EFFECT_ALLOW",
	1: "EFFECT_DENY",
	2: "EFFECT_PASS",
}

var Effect_value = map[string]int32{
	"EFFECT_ALLOW": 0,
	"EFFECT_DENY":  1,
	"EFFECT_PASS":  2,
}

func (x Effect) String() string {
	return proto.EnumName(Effect_name, int32(x))
}

func (Effect) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_33a4d646aee30990, []int{1}
}

type PrincipalType int32

const (
	// Reserved for extended use
	TYPE_GNFD_ACCOUNT PrincipalType = 0
	TYPE_GNFD_GROUP   PrincipalType = 1
)

var PrincipalType_name = map[int32]string{
	0: "TYPE_GNFD_ACCOUNT",
	1: "TYPE_GNFD_GROUP",
}

var PrincipalType_value = map[string]int32{
	"TYPE_GNFD_ACCOUNT": 0,
	"TYPE_GNFD_GROUP":   1,
}

func (x PrincipalType) String() string {
	return proto.EnumName(PrincipalType_name, int32(x))
}

func (PrincipalType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_33a4d646aee30990, []int{2}
}

// TODO: add expiration time.
type Statement struct {
	// effect define the impact of permissions, which can be Allow/Deny
	Effect Effect `protobuf:"varint,1,opt,name=effect,proto3,enum=bnbchain.greenfield.permission.Effect" json:"effect,omitempty"`
	// action_type define the operation type you can act. greenfield defines a set of permission
	// that you can specify in a permissionInfo. see ActionType enum for detail.
	Actions []ActionType `protobuf:"varint,2,rep,packed,name=actions,proto3,enum=bnbchain.greenfield.permission.ActionType" json:"actions,omitempty"`
	// resources define the resource list you can operate.
	// CAN ONLY USED IN bucket level. Support fuzzy match and limit to 5
	Resources []string `protobuf:"bytes,3,rep,name=resources,proto3" json:"resources,omitempty"`
}

func (m *Statement) Reset()         { *m = Statement{} }
func (m *Statement) String() string { return proto.CompactTextString(m) }
func (*Statement) ProtoMessage()    {}
func (*Statement) Descriptor() ([]byte, []int) {
	return fileDescriptor_33a4d646aee30990, []int{0}
}
func (m *Statement) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Statement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Statement.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 *Statement) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Statement.Merge(m, src)
}
func (m *Statement) XXX_Size() int {
	return m.Size()
}
func (m *Statement) XXX_DiscardUnknown() {
	xxx_messageInfo_Statement.DiscardUnknown(m)
}

var xxx_messageInfo_Statement proto.InternalMessageInfo

func (m *Statement) GetEffect() Effect {
	if m != nil {
		return m.Effect
	}
	return EFFECT_ALLOW
}

func (m *Statement) GetActions() []ActionType {
	if m != nil {
		return m.Actions
	}
	return nil
}

func (m *Statement) GetResources() []string {
	if m != nil {
		return m.Resources
	}
	return nil
}

// Principal define the roles that can grant permissions. Currently, it can be account or group.
type Principal struct {
	Type  PrincipalType `protobuf:"varint,1,opt,name=type,proto3,enum=bnbchain.greenfield.permission.PrincipalType" json:"type,omitempty"`
	Value string        `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *Principal) Reset()         { *m = Principal{} }
func (m *Principal) String() string { return proto.CompactTextString(m) }
func (*Principal) ProtoMessage()    {}
func (*Principal) Descriptor() ([]byte, []int) {
	return fileDescriptor_33a4d646aee30990, []int{1}
}
func (m *Principal) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Principal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Principal.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 *Principal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Principal.Merge(m, src)
}
func (m *Principal) XXX_Size() int {
	return m.Size()
}
func (m *Principal) XXX_DiscardUnknown() {
	xxx_messageInfo_Principal.DiscardUnknown(m)
}

var xxx_messageInfo_Principal proto.InternalMessageInfo

func (m *Principal) GetType() PrincipalType {
	if m != nil {
		return m.Type
	}
	return TYPE_GNFD_ACCOUNT
}

func (m *Principal) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

func init() {
	proto.RegisterEnum("bnbchain.greenfield.permission.ActionType", ActionType_name, ActionType_value)
	proto.RegisterEnum("bnbchain.greenfield.permission.Effect", Effect_name, Effect_value)
	proto.RegisterEnum("bnbchain.greenfield.permission.PrincipalType", PrincipalType_name, PrincipalType_value)
	proto.RegisterType((*Statement)(nil), "bnbchain.greenfield.permission.Statement")
	proto.RegisterType((*Principal)(nil), "bnbchain.greenfield.permission.Principal")
}

func init() {
	proto.RegisterFile("greenfield/permission/common.proto", fileDescriptor_33a4d646aee30990)
}

var fileDescriptor_33a4d646aee30990 = []byte{
	// 539 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x93, 0xcf, 0x8e, 0xd2, 0x50,
	0x14, 0xc6, 0x5b, 0x98, 0x61, 0xec, 0x51, 0x67, 0xae, 0x77, 0x66, 0x14, 0x88, 0x36, 0x84, 0x85,
	0x21, 0x24, 0x53, 0x12, 0xdc, 0x9b, 0x94, 0x72, 0x21, 0x28, 0x43, 0x9b, 0x52, 0xa2, 0xb8, 0x69,
	0x68, 0xe7, 0xc2, 0x34, 0xa1, 0xbd, 0xa4, 0x2d, 0xc6, 0x79, 0x03, 0x97, 0xbe, 0x83, 0x0f, 0xe0,
	0x6b, 0xcc, 0x72, 0x96, 0x2e, 0x0d, 0xbc, 0x88, 0xe9, 0x1f, 0x68, 0x89, 0x89, 0xb3, 0xeb, 0xfd,
	0xbe, 0xf3, 0x3b, 0xe7, 0x6b, 0x7b, 0x0f, 0xd4, 0x17, 0x3e, 0xa5, 0xde, 0xdc, 0xa1, 0xcb, 0x9b,
	0xd6, 0x8a, 0xfa, 0xae, 0x13, 0x04, 0x0e, 0xf3, 0x5a, 0x36, 0x73, 0x5d, 0xe6, 0x49, 0x2b, 0x9f,
	0x85, 0x0c, 0x8b, 0x96, 0x67, 0xd9, 0xb7, 0x33, 0xc7, 0x93, 0xb2, 0x62, 0x29, 0x2b, 0xae, 0x56,
	0x6c, 0x16, 0xb8, 0x2c, 0x30, 0xe3, 0xea, 0x56, 0x72, 0x48, 0xd0, 0xea, 0xc5, 0x82, 0x2d, 0x58,
	0xa2, 0x47, 0x4f, 0x89, 0x5a, 0xff, 0xc5, 0x83, 0x30, 0x0e, 0x67, 0x21, 0x75, 0xa9, 0x17, 0xe2,
	0xf7, 0x50, 0xa2, 0xf3, 0x39, 0xb5, 0xc3, 0x32, 0x5f, 0xe3, 0x1b, 0xa7, 0xed, 0xb7, 0xd2, 0xff,
	0xe7, 0x49, 0x24, 0xae, 0xd6, 0x53, 0x0a, 0x77, 0xe1, 0x64, 0x66, 0x87, 0x0e, 0xf3, 0x82, 0x72,
	0xa1, 0x56, 0x6c, 0x9c, 0xb6, 0x9b, 0x8f, 0x35, 0x90, 0xe3, 0x72, 0xe3, 0x6e, 0x45, 0xf5, 0x1d,
	0x8a, 0x5f, 0x83, 0xe0, 0xd3, 0x80, 0xad, 0x7d, 0x9b, 0x06, 0xe5, 0x62, 0xad, 0xd8, 0x10, 0xf4,
	0x4c, 0xa8, 0xdf, 0x80, 0xa0, 0xf9, 0x8e, 0x67, 0x3b, 0xab, 0xd9, 0x12, 0xcb, 0x70, 0x14, 0xde,
	0xad, 0x68, 0x1a, 0xf7, 0xea, 0xb1, 0x69, 0x7b, 0x30, 0x1e, 0x18, 0xa3, 0xf8, 0x02, 0x8e, 0xbf,
	0xce, 0x96, 0x6b, 0x5a, 0x2e, 0xd4, 0xf8, 0x86, 0xa0, 0x27, 0x87, 0xe6, 0x7d, 0x01, 0x20, 0xcb,
	0x86, 0xdf, 0x40, 0x45, 0x56, 0x8c, 0x81, 0x3a, 0x32, 0x27, 0x5a, 0x57, 0x36, 0x88, 0xd9, 0x99,
	0x28, 0x1f, 0x89, 0x61, 0x0e, 0x46, 0x3d, 0x15, 0x71, 0xb8, 0x0c, 0x17, 0xa9, 0xdd, 0x25, 0x43,
	0xb2, 0xb7, 0x11, 0x9f, 0x73, 0x14, 0x9d, 0x44, 0xa0, 0xda, 0xf9, 0x40, 0x14, 0x03, 0x15, 0xfe,
	0x65, 0x52, 0xa7, 0x88, 0x5f, 0x02, 0xde, 0x31, 0xaa, 0x36, 0xdd, 0xe9, 0x47, 0xf8, 0x12, 0x5e,
	0xa4, 0x7a, 0x9f, 0x18, 0x3b, 0xf9, 0x18, 0x57, 0xe0, 0x32, 0x95, 0xc9, 0x67, 0xa2, 0x4c, 0xb2,
	0x4e, 0xa5, 0x5c, 0xa7, 0xe1, 0x60, 0xbc, 0x47, 0x4e, 0xb0, 0x08, 0xd5, 0xc3, 0xd7, 0xe9, 0xeb,
	0xea, 0x44, 0x33, 0xaf, 0xc9, 0x75, 0x87, 0xe8, 0xe8, 0x09, 0x7e, 0x05, 0xe7, 0x87, 0xd9, 0x62,
	0x1f, 0x09, 0x39, 0xe3, 0x80, 0x00, 0x7c, 0x0e, 0x67, 0xa9, 0x61, 0x4c, 0x35, 0x62, 0xca, 0xc3,
	0x21, 0xb2, 0xab, 0x47, 0xdf, 0x7f, 0x8a, 0x5c, 0xb3, 0x03, 0xa5, 0xe4, 0x9a, 0x60, 0x04, 0xcf,
	0x48, 0xaf, 0x47, 0x14, 0x23, 0xf2, 0xd5, 0x4f, 0x88, 0xc3, 0x67, 0xf0, 0x34, 0x55, 0xba, 0x64,
	0x34, 0x45, 0x7c, 0x4e, 0xd0, 0xe4, 0xf1, 0x18, 0x15, 0xd2, 0x1e, 0x32, 0x3c, 0x3f, 0xf8, 0x77,
	0xd1, 0xb7, 0x88, 0x07, 0xf5, 0x47, 0xbd, 0xae, 0x29, 0x2b, 0x8a, 0x3a, 0x19, 0x19, 0x88, 0x8b,
	0x62, 0x64, 0x72, 0x12, 0x9a, 0x4f, 0x5a, 0x74, 0x86, 0xf7, 0x1b, 0x91, 0x7f, 0xd8, 0x88, 0xfc,
	0x9f, 0x8d, 0xc8, 0xff, 0xd8, 0x8a, 0xdc, 0xc3, 0x56, 0xe4, 0x7e, 0x6f, 0x45, 0xee, 0x4b, 0x7b,
	0xe1, 0x84, 0xb7, 0x6b, 0x4b, 0xb2, 0x99, 0xdb, 0xb2, 0x3c, 0xeb, 0x2a, 0xbe, 0x41, 0xad, 0xdc,
	0x36, 0x7e, 0xcb, 0xef, 0x63, 0x74, 0x69, 0x02, 0xab, 0x14, 0xaf, 0xcf, 0xbb, 0xbf, 0x01, 0x00,
	0x00, 0xff, 0xff, 0xa0, 0xdf, 0xa1, 0xbf, 0xb5, 0x03, 0x00, 0x00,
}

func (m *Statement) 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 *Statement) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Statement) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Resources) > 0 {
		for iNdEx := len(m.Resources) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Resources[iNdEx])
			copy(dAtA[i:], m.Resources[iNdEx])
			i = encodeVarintCommon(dAtA, i, uint64(len(m.Resources[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Actions) > 0 {
		dAtA2 := make([]byte, len(m.Actions)*10)
		var j1 int
		for _, num := range m.Actions {
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		i -= j1
		copy(dAtA[i:], dAtA2[:j1])
		i = encodeVarintCommon(dAtA, i, uint64(j1))
		i--
		dAtA[i] = 0x12
	}
	if m.Effect != 0 {
		i = encodeVarintCommon(dAtA, i, uint64(m.Effect))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Principal) 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 *Principal) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Principal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintCommon(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if m.Type != 0 {
		i = encodeVarintCommon(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintCommon(dAtA []byte, offset int, v uint64) int {
	offset -= sovCommon(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Statement) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Effect != 0 {
		n += 1 + sovCommon(uint64(m.Effect))
	}
	if len(m.Actions) > 0 {
		l = 0
		for _, e := range m.Actions {
			l += sovCommon(uint64(e))
		}
		n += 1 + sovCommon(uint64(l)) + l
	}
	if len(m.Resources) > 0 {
		for _, s := range m.Resources {
			l = len(s)
			n += 1 + l + sovCommon(uint64(l))
		}
	}
	return n
}

func (m *Principal) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovCommon(uint64(m.Type))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovCommon(uint64(l))
	}
	return n
}

func sovCommon(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozCommon(x uint64) (n int) {
	return sovCommon(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Statement) 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 ErrIntOverflowCommon
			}
			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: Statement: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Statement: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Effect", wireType)
			}
			m.Effect = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Effect |= Effect(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType == 0 {
				var v ActionType
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowCommon
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= ActionType(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Actions = append(m.Actions, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowCommon
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthCommon
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthCommon
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.Actions) == 0 {
					m.Actions = make([]ActionType, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v ActionType
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowCommon
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= ActionType(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Actions = append(m.Actions, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Actions", wireType)
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommon
				}
				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 ErrInvalidLengthCommon
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Resources = append(m.Resources, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Principal) 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 ErrIntOverflowCommon
			}
			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: Principal: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Principal: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommon
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= PrincipalType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommon
				}
				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 ErrInvalidLengthCommon
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommon
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommon(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommon
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipCommon(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, ErrIntOverflowCommon
			}
			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, ErrIntOverflowCommon
				}
				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, ErrIntOverflowCommon
				}
				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, ErrInvalidLengthCommon
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupCommon
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthCommon
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthCommon        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowCommon          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupCommon = fmt.Errorf("proto: unexpected end of group")
)