Creates the list of Array Controller URIs.

        :raises: IloCommandNotSupportedError if the ArrayControllers
            doesnt have member "Member".
        :returns list of ArrayControllers.
165855
def _create_list_of_array_controllers(self):
        
        headers, array_uri, array_settings = (
            self._get_array_controller_resource())
        array_uri_links = []
        if ('links' in array_settings and
                'Member' in array_settings['links']):
            array_uri_links = array_settings['links']['Member']
        else:
            msg = ('"links/Member" section in ArrayControllers'
                   ' does not exist')
            raise exception.IloCommandNotSupportedError(msg)
        return array_uri_links
197631
def get_build_controllers(self, name=None):
        
        query_parameters = {}
        if name is not None:
            query_parameters['name'] = self._serialize.query('name', name, 'str')
        response = self._send(http_method='GET',
                              location_id='fcac1932-2ee1-437f-9b6f-7f696be858f6',
                              version='5.0',
                              query_parameters=query_parameters)
        return self._deserialize('[BuildController]', self._unwrap_collection(response))
988507
public function controllers(array $controllers)
    {
        $group = new Group;
        foreach ($controllers as $controller)
            $group->set($this->controller($controller));
        return $group;
    }
136299
def build
      controller_name = @klass.name.gsub(/Controller$/, '').underscore
      Rails.application.routes.routes.each_with_object({}) do |route, comments|
        if route.defaults[:controller] == controller_name
          verb_match = route.verb.to_s.match(/\^(.*)\$/)
          verbs = verb_match.nil? ? '*' : verb_match[1]
          (comments[route.defaults[:action]] ||= []) << "#{verbs} #{route.ast}"
        end
      end
    end
1244272
def index
      @lists = {}
      unless @dt_request.provided?
        Incline::ActionSecurity.valid_items   # ensure only valid items are in the database.

        # build lists for the dropdown filters.
        @lists[:controller_name] = Incline::ActionSecurity.visible.pluck(:controller_name).uniq.sort
        @lists[:action_name] = Incline::ActionSecurity.visible.pluck(:action_name).uniq.sort
        @lists[:short_permitted] = Incline::ActionSecurity::SHORT_PERMITTED_FILTERS
      end
    end
1336618
def get_all(cls):
        '''  '''
        redis = cls.get_redis()

        return list(map(
            lambda id: cls.get(id),
            map(
                debyte_string,
                redis.smembers(cls.members_key())
            )
        ))
224566
def create_controller_handler(full_path, controller_path)
      # If arguments is nil, then an blank SubContext will be created
      args = [SubContext.new(@arguments, nil, true)]

      # get the controller class and action
      controller_class, action = ControllerHandler.get_controller_and_action(controller_path)

      generated_new = false
      new_controller = proc do
        # Mark that we needed to generate a new controller instance (not reused
        # from the group)
        generated_new = true
        # Setup the controller
        controller_class.new(@volt_app, *args)
      end

      # Fetch grouped controllers if we're grouping
      if @grouped_controller
        # Find the controller in the group, or create it
        controller = @grouped_controller.lookup_or_create(controller_class, &new_controller)
      else
        # Just create the controller
        controller = new_controller.call
      end

      handler = ControllerHandler.fetch(controller, action)

      if generated_new
        # Call the action
        stopped = handler.call_action

        controller.instance_variable_set('@chain_stopped', true) if stopped
      else
        stopped = controller.instance_variable_get('@chain_stopped')
      end

      [handler, generated_new, stopped]
    end
968899
def [](*args)
      a = @images[*args]
      if a.respond_to?(:each)
        ilist = self.class.new
        a.each { |image| ilist << image }
        a = ilist
      end
      a
    end
39165
async def SetExternalControllerInfo(self, controllers):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='ExternalControllerUpdater',
                   request='SetExternalControllerInfo',
                   version=1,
                   params=_params)
        _params['controllers'] = controllers
        reply = await self.rpc(msg)
        return reply
344869
def members
            unless @members
                @members = []
                [Adauth::AdObjects::Computer, Adauth::AdObjects::OU, Adauth::AdObjects::User, Adauth::AdObjects::Group].each do |object|
                    object.all.each do |entity|
                        @members.push entity if entity.is_a_member?(self)
                    end
                end
            end
            @members
        end
614323
def []=(*args)  # :nodoc:
      raise ArgumentError => 'wrong number of arguments' unless args.size > 1
      unless args[-1].is_a?(Sycl::Hash) || args[-1].is_a?(Sycl::Array)
        args[-1] = Sycl::from_object(args[-1])
      end
      super
    end
280948
def [](val)
      links = []
      @set.each do |item|
        if item.is_a?(ActiveScaffold::DataStructures::ActionLinks)
          collected = item[val]
          links << collected unless collected.nil?
        elsif item.action.to_s == val.to_s
          links << item
        end
      end
      links.first
    end
108473
def get_build_controller(self, controller_id):
        
        route_values = {}
        if controller_id is not None:
            route_values['controllerId'] = self._serialize.url('controller_id', controller_id, 'int')
        response = self._send(http_method='GET',
                              location_id='fcac1932-2ee1-437f-9b6f-7f696be858f6',
                              version='5.0',
                              route_values=route_values)
        return self._deserialize('BuildController', response)
1327194
private static ControllerRegistry build(ControllerLookup lookup) {
        List<BaseController> controllers = new LinkedList<>();
        controllers.addAll(lookup.getControllers());
        return new ControllerRegistry(controllers);
    }
489183
def alias_list
      lines = normalize_array(rvm(:alias, :list).stdout)
      lines.inject({}) do |acc, current|
        alias_name, ruby_string = current.to_s.split(" => ")
        unless alias_name.empty? || ruby_string.empty?
          acc[alias_name] = ruby_string
        end
        acc
      end
    end
621992
protected function _getControllers()
	{
		if( $this->_controllers === array() )
		{
			$subFolder = str_replace( '_', DIRECTORY_SEPARATOR, $this->_getClassPrefix() );

			foreach( $this->_cntlPaths as $path => $list )
			{
				foreach( $list as $relpath )
				{
					$path .= DIRECTORY_SEPARATOR . $relpath . DIRECTORY_SEPARATOR . $subFolder;

					if( is_dir( $path ) ) {
						$this->_addControllers( new DirectoryIterator( $path ) );
					}
				}
			}
		}

		return $this->_controllers;
	}
753814
def saml_providers(options = {})
      batches = Enumerator.new do |y|
        batch = []
        resp = @client.list_saml_providers(options)
        resp.data.saml_provider_list.each do |s|
          batch << SamlProvider.new(
            arn: s.arn,
            client: @client
          )
        end
        y.yield(batch)
      end
      SamlProvider::Collection.new(batches)
    end