// VCenterHypervisors retrieves the list of child VCenterHypervisors of the VCenterCluster
769805
func (o *VCenterCluster) VCenterHypervisors(info *bambou.FetchingInfo) (VCenterHypervisorsList, *bambou.Error) {

	var list VCenterHypervisorsList
	err := bambou.CurrentSession().FetchChildren(o, VCenterHypervisorIdentity, &list, info)
	return list, err
}
537675
func NewVCenter() *VCenter {

	return &VCenter{
		ManageVRSAvailability:             false,
		SecondaryDataUplinkDHCPEnabled:    false,
		SecondaryDataUplinkEnabled:        false,
		SecondaryDataUplinkMTU:            1500,
		SecondaryDataUplinkUnderlayID:     1,
		SecondaryDataUplinkVDFControlVLAN: 0,
		MemorySizeInGB:                    "DEFAULT_4",
		RemoteSyslogServerPort:            514,
		RemoteSyslogServerType:            "NONE",
		Personality:                       "VRS",
		DestinationMirrorPort:             "no_mirror",
		RevertiveControllerEnabled:        false,
		RevertiveTimer:                    300,
		DisableGROOnDatapath:              false,
		DisableLROOnDatapath:              false,
		EnableVRSResourceReservation:      false,
		ConfiguredMetricsPushInterval:     60,
		CpuCount:                          "DEFAULT_2",
		PrimaryDataUplinkUnderlayID:       0,
		PrimaryDataUplinkVDFControlVLAN:   0,
		AvrsEnabled:                       false,
		AvrsProfile:                       "AVRS_25G",
	}
}
74829
func (o *VCenter) CreateVCenterDataCenter(child *VCenterDataCenter) *bambou.Error {

	return bambou.CurrentSession().CreateChild(o, child)
}
74693
func (mc MongoClient) GetAllProvisionWatchers() (pw []contract.ProvisionWatcher, err error) {
	return mc.getProvisionWatchers(bson.M{})
}
464871
func NewCadvisorStatsProvider(
	cadvisor cadvisor.Interface,
	resourceAnalyzer stats.ResourceAnalyzer,
	podManager kubepod.Manager,
	runtimeCache kubecontainer.RuntimeCache,
	imageService kubecontainer.ImageService,
	statusProvider status.PodStatusProvider,
) *StatsProvider {
	return newStatsProvider(cadvisor, podManager, runtimeCache, newCadvisorStatsProvider(cadvisor, resourceAnalyzer, imageService, statusProvider))
}
72476
func (s *HypervisorService) NewListHypervisorsParams() *ListHypervisorsParams {
	p := &ListHypervisorsParams{}
	p.p = make(map[string]interface{})
	return p
}
130187
func (m *containerManager) ListContainers() ([]instances.Instance, error) {
	containers, err := m.server.FilterContainers(m.namespace.Prefix())
	if err != nil {
		return nil, errors.Trace(err)
	}

	var result []instances.Instance
	for _, i := range containers {
		result = append(result, &lxdInstance{i.Name, m.server.ContainerServer})
	}
	return result, nil
}
1273270
func (o *VSP) NetconfManagers(info *bambou.FetchingInfo) (NetconfManagersList, *bambou.Error) {

	var list NetconfManagersList
	err := bambou.CurrentSession().FetchChildren(o, NetconfManagerIdentity, &list, info)
	return list, err
}
830574
func (c *Calcium) ListContainers(ctx context.Context, opts *types.ListContainersOptions) ([]*types.Container, error) {
	return c.store.ListContainers(ctx, opts.Appname, opts.Entrypoint, opts.Nodename)
}
1313409
func (o *PolicyStatement) PolicyEntries(info *bambou.FetchingInfo) (PolicyEntriesList, *bambou.Error) {

	var list PolicyEntriesList
	err := bambou.CurrentSession().FetchChildren(o, PolicyEntryIdentity, &list, info)
	return list, err
}
232387
func (u *User) GetCollaborators() int {
	if u == nil || u.Collaborators == nil {
		return 0
	}
	return *u.Collaborators
}
452614
func (_m *DBClient) GetProvisionWatchersByIdentifier(k string, v string) ([]models.ProvisionWatcher, error) {
	ret := _m.Called(k, v)

	var r0 []models.ProvisionWatcher
	if rf, ok := ret.Get(0).(func(string, string) []models.ProvisionWatcher); ok {
		r0 = rf(k, v)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]models.ProvisionWatcher)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string) error); ok {
		r1 = rf(k, v)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}
263478
func (s *roleManagementServiceImpl) ListAvailableRolesByResourceType(ctx context.Context, resourceType string) ([]role.RoleDescriptor, error) {
	return s.Repositories().RoleRepository().FindRolesByResourceType(ctx, resourceType)
}
986267
func (o *VCenterCluster) CreateVCenterHypervisor(child *VCenterHypervisor) *bambou.Error {

	return bambou.CurrentSession().CreateChild(o, child)
}
1197102
func (c *Client) OrganizationAppCollaboratorList(appIdentity string, lr *ListRange) ([]OrganizationAppCollaborator, error) {
	req, err := c.NewRequest("GET", "/organizations/apps/"+appIdentity+"/collaborators", nil, nil)
	if err != nil {
		return nil, err
	}

	if lr != nil {
		lr.SetHeader(req)
	}

	var organizationAppCollaboratorsRes []OrganizationAppCollaborator
	return organizationAppCollaboratorsRes, c.DoReq(req, &organizationAppCollaboratorsRes)
}
391007
func (d *DomainSnapshot) ListAllChildren(flags DomainSnapshotListFlags) ([]DomainSnapshot, error) {
	var cList *C.virDomainSnapshotPtr
	var err C.virError
	numVols := C.virDomainSnapshotListAllChildrenWrapper(d.ptr, (**C.virDomainSnapshotPtr)(&cList), C.uint(flags), &err)
	if numVols == -1 {
		return nil, makeError(&err)
	}
	hdr := reflect.SliceHeader{
		Data: uintptr(unsafe.Pointer(cList)),
		Len:  int(numVols),
		Cap:  int(numVols),
	}
	var pools []DomainSnapshot
	slice := *(*[]C.virDomainSnapshotPtr)(unsafe.Pointer(&hdr))
	for _, ptr := range slice {
		pools = append(pools, DomainSnapshot{ptr})
	}
	C.free(unsafe.Pointer(cList))
	return pools, nil
}
1051197
func (o *Organization) GetCollaborators() int {
	if o == nil || o.Collaborators == nil {
		return 0
	}
	return *o.Collaborators
}