Get the next controller while iterating.

        :return: a dict with the keys: id, type, name, available.
6607
def tdController(self):
        
        cid = c_int()
        ctype = c_int()
        name = create_string_buffer(255)
        available = c_int()

        self._lib.tdController(byref(cid), byref(ctype), name, sizeof(name),
                               byref(available))
        return {'id': cid.value, 'type': ctype.value,
                'name': self._to_str(name), 'available': available.value}
190410
def _get_controller_type(self):
        """"""

        if self.node_type == self.NODE_CONTROLLER_ROOT and self.name in self.CONTROLLERS:
            return self.name
        elif self.parent:
            return self.parent.controller_type
        else:
            return None
158209
def next(self):
        
        next = request.args.get('next')
        if next is None:
            params = self.default_redirect_params
            next = url_for(self.default_redirect_endpoint, **params)
        return next
818616
def get_next_item(iterable):
    """"""
    try: x = iterable.next()
    except StopIteration: x = None
    except AttributeError: x = None
    return x
437555
def get(self, targetId):
        
        result = self._targetController.analyse(targetId)
        if result:
            if len(result) == 2:
                if result[1] == 404:
                    return result
                else:
                    return {'name': targetId, 'data': self._jsonify(result)}, 200
            else:
                return None, 404
        else:
            return None, 500
159966
def next_style(self):
        
        next = self.next
        if next is None:
            return None
        styles = self.getparent()
        return styles.get_by_id(next.val)
1328934
def get_controller(self, state):
        '''
        
        '''
        path = state.request.pecan['routing_path'].split('/')[1:]
        return state.controller.__str__().split()[2]
1293149
def get_controller_state(self):
        """"""
        dpos = self.pos - self.last_pos
        self.last_pos = np.array(self.pos)
        return dict(
            dpos=dpos,
            rotation=self.rotation,
            grasp=int(self.grasp),
            reset=self._reset_state,
        )
680859
def get_next(self, query, **options):
        """"""
        iterator = EventsPageIterator(self.client, '/events', query, options)
        result = iterator.next()
        return (result, iterator.sync)
465714
def next(self) -> mx.io.DataBatch:
        
        if self.iter_next():
            return self.next_batch
        raise StopIteration
199886
def fetch_next_page(self):
        """"""
        result = self.request_handler.get(url=self.next_page_url).json()
        self.__init__(self.request_handler, result,
                      self.data_type, self.automatic_pagination)
613745
def next(self):
        
        try:
            return self.dict_to_xn(self.csvreader.next())
        except MetadataException:
            # row was metadata; proceed to next row
            return next(self)
369186
def _get_array_controller_resource(self):
        
        headers, storage_uri, storage_settings = self._get_storage_resource()
        if ('links' in storage_settings and
                'ArrayControllers' in storage_settings['links']):
            # Get the ArrayCOntrollers URI and Settings
            array_uri = storage_settings['links']['ArrayControllers']['href']
            status, headers, array_settings = self._rest_get(array_uri)

            if status >= 300:
                msg = self._get_extended_error(array_settings)
                raise exception.IloError(msg)

            return headers, array_uri, array_settings
        else:
            msg = ('"links/ArrayControllers" section in SmartStorage'
                   ' does not exist')
            raise exception.IloCommandNotSupportedError(msg)
216696
def get_next_step(self, step=None):
        
        if step is None:
            step = self.steps.current
        form_list = self.get_form_list()
        key = form_list.keyOrder.index(step) + 1
        if len(form_list.keyOrder) > key:
            return form_list.keyOrder[key]
        return None
882258
def next(self):
        
        smallest = None
        for key in self.queue.keys():
            if self.queue[key]['status'] == 'queued':
                if smallest is None or key < smallest:
                    smallest = key
        return smallest
156125
def grab_next(self, timeout: float=None) -> typing.List[DataAndMetadata.DataAndMetadata]:
        """"""
        with self.__buffer_lock:
            self.__buffer = list()
        return self.grab_latest(timeout)
1218895
def get_next_step(self, step=None):
        
        if step is None:
            step = self.steps.current
        form_list = self.get_form_list()
        keys = list(form_list.keys())
        key = keys.index(step) + 1
        for next_step in keys[key:]:
            if self.is_step_visible(next_step):
                return next_step
        return None