limit.pb.collections.go

// Code generated by protoc-gen-goten-resource
// Resource: Limit
// DO NOT EDIT!!!

package limit

import (
	gotenresource "github.com/cloudwan/goten-sdk/runtime/resource"
)

// proto imports
import (
	ntt_meta "github.com/cloudwan/edgelq-sdk/common/types/meta"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/project"
	limit_pool "github.com/cloudwan/edgelq-sdk/limits/resources/v1alpha2/limit_pool"
	meta_resource "github.com/cloudwan/edgelq-sdk/meta/resources/v1alpha2/resource"
	meta_service "github.com/cloudwan/edgelq-sdk/meta/resources/v1alpha2/service"
)

// ensure the imports are used
var (
	_ = gotenresource.ListQuery(nil)
)

// make sure we're using proto imports
var (
	_ = &ntt_meta.Meta{}
	_ = &iam_project.Project{}
	_ = &limit_pool.LimitPool{}
	_ = &meta_resource.Resource{}
	_ = &meta_service.Service{}
)

type LimitList []*Limit

func (l LimitList) Append(item gotenresource.Resource) gotenresource.ResourceList {
	return append(l, item.(*Limit))
}

func (l LimitList) AppendList(list gotenresource.ResourceList) gotenresource.ResourceList {
	return append(l, list.(LimitList)...)
}

func (l LimitList) Slice(first, second int) gotenresource.ResourceList {
	if first > 0 && second > 0 {
		return l[first:second]
	} else if first > 0 {
		return l[first:]
	} else if second > 0 {
		return l[:second]
	}
	return l[:]
}

func (l LimitList) At(idx int) gotenresource.Resource {
	return l[idx]
}

func (l LimitList) Set(idx int, res gotenresource.Resource) {
	l[idx] = res.(*Limit)
}

func (l LimitList) Length() int {
	return len(l)
}

type LimitChangeList []*LimitChange

func (l LimitChangeList) Append(item gotenresource.ResourceChange) gotenresource.ResourceChangeList {
	return append(l, item.(*LimitChange))
}

func (l LimitChangeList) AppendList(list gotenresource.ResourceChangeList) gotenresource.ResourceChangeList {
	return append(l, list.(LimitChangeList)...)
}

func (l LimitChangeList) Slice(first, second int) gotenresource.ResourceChangeList {
	if first > 0 && second > 0 {
		return l[first:second]
	} else if first > 0 {
		return l[first:]
	} else if second > 0 {
		return l[:second]
	}
	return l[:]
}

func (l LimitChangeList) At(idx int) gotenresource.ResourceChange {
	return l[idx]
}

func (l LimitChangeList) Set(idx int, change gotenresource.ResourceChange) {
	l[idx] = change.(*LimitChange)
}

func (l LimitChangeList) Length() int {
	return len(l)
}

type LimitNameList []*Name

func (l LimitNameList) Append(name gotenresource.Name) gotenresource.NameList {
	return append(l, name.(*Name))
}

func (l LimitNameList) AppendList(list gotenresource.NameList) gotenresource.NameList {
	return append(l, list.(LimitNameList)...)
}

func (l LimitNameList) Slice(first, second int) gotenresource.NameList {
	if first > 0 && second > 0 {
		return l[first:second]
	} else if first > 0 {
		return l[first:]
	} else if second > 0 {
		return l[:second]
	}
	return l[:]
}

func (l LimitNameList) At(idx int) gotenresource.Name {
	return l[idx]
}

func (l LimitNameList) Set(idx int, name gotenresource.Name) {
	l[idx] = name.(*Name)
}

func (l LimitNameList) Length() int {
	return len(l)
}

type LimitReferenceList []*Reference

func (l LimitReferenceList) Append(ref gotenresource.Reference) gotenresource.ReferenceList {
	return append(l, ref.(*Reference))
}

func (l LimitReferenceList) AppendList(list gotenresource.ReferenceList) gotenresource.ReferenceList {
	return append(l, list.(LimitReferenceList)...)
}

func (l LimitReferenceList) Slice(first, second int) gotenresource.ReferenceList {
	if first > 0 && second > 0 {
		return l[first:second]
	} else if first > 0 {
		return l[first:]
	} else if second > 0 {
		return l[:second]
	}
	return l[:]
}

func (l LimitReferenceList) At(idx int) gotenresource.Reference {
	return l[idx]
}

func (l LimitReferenceList) Set(idx int, ref gotenresource.Reference) {
	l[idx] = ref.(*Reference)
}

func (l LimitReferenceList) Length() int {
	return len(l)
}

type LimitParentNameList []*ParentName

func (l LimitParentNameList) Append(name gotenresource.Name) gotenresource.ParentNameList {
	return append(l, name.(*ParentName))
}

func (l LimitParentNameList) AppendList(list gotenresource.ParentNameList) gotenresource.ParentNameList {
	return append(l, list.(LimitParentNameList)...)
}

func (l LimitParentNameList) Slice(first, second int) gotenresource.ParentNameList {
	if first > 0 && second > 0 {
		return l[first:second]
	} else if first > 0 {
		return l[first:]
	} else if second > 0 {
		return l[:second]
	}
	return l[:]
}

func (l LimitParentNameList) At(idx int) gotenresource.Name {
	return l[idx]
}

func (l LimitParentNameList) Set(idx int, name gotenresource.Name) {
	l[idx] = name.(*ParentName)
}

func (l LimitParentNameList) Length() int {
	return len(l)
}

type LimitParentReferenceList []*ParentReference

func (l LimitParentReferenceList) Append(ref gotenresource.Reference) gotenresource.ParentReferenceList {
	return append(l, ref.(*ParentReference))
}

func (l LimitParentReferenceList) AppendList(list gotenresource.ParentReferenceList) gotenresource.ParentReferenceList {
	return append(l, list.(LimitParentReferenceList)...)
}

func (l LimitParentReferenceList) Slice(first, second int) gotenresource.ParentReferenceList {
	if first > 0 && second > 0 {
		return l[first:second]
	} else if first > 0 {
		return l[first:]
	} else if second > 0 {
		return l[:second]
	}
	return l[:]
}

func (l LimitParentReferenceList) At(idx int) gotenresource.Reference {
	return l[idx]
}

func (l LimitParentReferenceList) Set(idx int, ref gotenresource.Reference) {
	l[idx] = ref.(*ParentReference)
}

func (l LimitParentReferenceList) Length() int {
	return len(l)
}

type LimitMap map[Name]*Limit

func (m LimitMap) Get(name gotenresource.Name) gotenresource.Resource {
	return m[*name.(*Name)]
}

func (m LimitMap) Set(res gotenresource.Resource) {
	tRes := res.(*Limit)
	m[*tRes.Name] = tRes
}

func (m LimitMap) Delete(name gotenresource.Name) {
	delete(m, *name.(*Name))
}

func (m LimitMap) Length() int {
	return len(m)
}

func (m LimitMap) ForEach(cb func(gotenresource.Name, gotenresource.Resource) bool) {
	for name, res := range m {
		if !cb(&name, res) {
			break
		}
	}
}

type LimitChangeMap map[Name]*LimitChange

func (m LimitChangeMap) Get(name gotenresource.Name) gotenresource.ResourceChange {
	return m[*name.(*Name)]
}

func (m LimitChangeMap) Set(change gotenresource.ResourceChange) {
	tChange := change.(*LimitChange)
	m[*tChange.GetLimitName()] = tChange
}

func (m LimitChangeMap) Delete(name gotenresource.Name) {
	delete(m, *name.(*Name))
}

func (m LimitChangeMap) Length() int {
	return len(m)
}

func (m LimitChangeMap) ForEach(cb func(gotenresource.Name, gotenresource.ResourceChange) bool) {
	for name, res := range m {
		if !cb(&name, res) {
			break
		}
	}
}