Request the names for all active, configured inputs on the device.

        Once we learn how many inputs are configured, this function is called
        which will ask for the name of each active input.
179246
def _populate_inputs(self, total):
        
        total = total + 1
        for input_number in range(1, total):
            self.query('ISN'+str(input_number).zfill(2))
1013526
def get_inputs(node, kwargs):
    """"""
    name = node["name"]
    proc_nodes = kwargs["proc_nodes"]
    index_lookup = kwargs["index_lookup"]
    inputs = node["inputs"]
    attrs = node.get("attrs", {})

    input_nodes = []
    for ip in inputs:
        input_node_id = index_lookup[ip[0]]
        input_nodes.append(proc_nodes[input_node_id].name)

    return name, input_nodes, attrs
637088
def current_kv_names(self):
        """"""
        return current_kv_names(self.sci, self.username, self.appname, request=self._request)
282617
def list_registered_stateful_ops_without_inputs():
  
  return set([
      name
      for name, op in op_def_registry.get_registered_ops().items()
      if op.is_stateful and not op.input_arg
  ])
568160
def rpc_get_all_names( self, offset, count, **con_info ):
        
        if not check_offset(offset):
            return {'error': 'invalid offset', 'http_status': 400}

        if not check_count(count, 100):
            return {'error': 'invalid count', 'http_status': 400}

        db = get_db_state(self.working_dir)
        num_domains = db.get_num_names()
        if num_domains > offset:
           all_domains = db.get_all_names( offset=offset, count=count )
        else:
           all_domains = []
        db.close()

        return self.success_response( {'names': all_domains} )
696550
@Override
    public int getNumberOfDevices() {
        if (numberOfDevices.get() < 0) {
            synchronized (this) {
                if (numberOfDevices.get() < 1) {
                    numberOfDevices.set(NativeOpsHolder.getInstance().getDeviceNativeOps().getAvailableDevices());
                }
            }
        }

        return numberOfDevices.get();
    }
81691
def refresh_devices(self):
        ''''''
        try:
            response = self.api.get("/api/v2/devices", {'properties':'all'})
            for device_data in response['DeviceList']:
                self.devices.append(Device(device_data, self))
        except APIError as e:
            print("API error: ")
            for key,value in e.data.iteritems:
                print(str(key) + ": " + str(value))
1146345
def get_names(self):
        '''  '''
        # Overridden to support autocompletion for the ROBOFORTH commands.
        return (['do_' + x for x in self.commands['shell']]
              + ['do_' + x for x in self.commands['forth']])
380471
def get_app_names(self):
        
        app_names = set()
        for name in self.apps:
            app_names.add(name)

        return app_names
541163
public static String[] getAvailableStatusNames() {
    List<String> nameList = new ArrayList<>();
    for (Status status : INSTANCES.values()) {
      nameList.add(status.getName());
    }
    return nameList.toArray(new String[nameList.size()]);
  }
387805
def get_devices(self):
        """"""
        utils.pending_message('Fetching device list...')

        get_devices_task = self.client.devices(
            account=self.account
        )

        # We wait for device list info as this sample relies on it next.
        get_devices_task.wait_for_result(timeout=self.timeout)

        get_devices_result = json.loads(get_devices_task.result)
        self.devices = get_devices_result['devices']

        utils.info_message('Get devices successful')
40401
public void setActiveNames(java.util.Collection<String> activeNames) {
        if (activeNames == null) {
            this.activeNames = null;
            return;
        }

        this.activeNames = new java.util.ArrayList<String>(activeNames);
    }
286527
@GET
    @Produces({MediaType.TEXT_HTML, MediaType.APPLICATION_JSON})
    @Path(ServerAPI.GET_NAMES)
    public Response getNames(){
        LOG.info("Got a get organization names request.");

        final ListView view = new ListView("Organization Ids list", "Organizations");
        final List<String> names = getOrganizationHandler().getOrganizationNames();
        view.addAll(names);

        return Response.ok(view).build();
    }
29120
function getActiveTouches(mouseEv, eventName) {
        // empty list
        if (mouseEv.type == 'mouseup') {
            return new TouchList();
        }

        var touchList = createTouchList(mouseEv);
        if(isMultiTouch && mouseEv.type != 'mouseup' && eventName == 'touchend') {
            touchList.splice(1, 1);
        }
        return touchList;
    }
1149788
private function checkInput()
    {
        $actions = $this->getAllowedActions();
        $pendingActionName = 'check' . $actions[$this->options['action']].'Input';
        if (method_exists($this, $pendingActionName)) {
            return $this->$pendingActionName();
        }
    }
232020
public function getAllInput()
    {
        return array_merge(
            $this->input[self::INPUT_METHOD_QUERY],
            $this->input[self::INPUT_METHOD_POST]
        );
    }
1199715
private function collectOptionsFromUserInputClass()
    {
        foreach (RequestBroker::targetMethodsOf($this->userInput) as $targetMethod) {
            $name = $targetMethod->paramName();
            if (substr($name, 0, 5) === 'argv.') {
                continue;
            }

            if (strlen($name) === 1) {
                $this->options .= $name . ($targetMethod->requiresParameter() ? ':' : '');
            } else {
                $this->longopts[] = $name . ($targetMethod->requiresParameter() ? ':' : '');
            }
        }

        if (null === $this->options || !strpos($this->options, 'h')) {
            $this->options .= 'h';
        }

        if (!in_array('help', $this->longopts)) {
            $this->longopts[] = 'help';
        }
    }