def xget(self, key, column_start="", column_finish="", column_reversed=False,
             column_count=None, include_timestamp=False, read_consistency_level=None,
             buffer_size=None, include_ttl=False):

        packed_key = self._pack_key(key)
        cp = self._column_parent(None)
        rcl = read_consistency_level or self.read_consistency_level

        if buffer_size is None:
            buffer_size = self.column_buffer_size

        count = i = 0
        last_name = finish = ""
        if column_start != "":
            last_name = self._pack_name(column_start,
                    is_supercol_name=self.super,
                    slice_start=(not column_reversed))
        if column_finish != "":
            finish = self._pack_name(column_finish,
                    is_supercol_name=self.super,
                    slice_start=column_reversed)

        while True:
            if column_count is not None:
                if i == 0 and column_count <= buffer_size:
                    buffer_size = column_count
                else:
                    buffer_size = min(column_count - count + 1, buffer_size)

            sp = self._slice_predicate(None, last_name, finish,
                                       column_reversed, buffer_size, None, pack=False)
            list_cosc = self.pool.execute('get_slice', packed_key, cp, sp, rcl)

            if not list_cosc:
                return

            for j, cosc in enumerate(list_cosc):
                if j == 0 and i != 0:
                    continue

                if self.super:
                    if self._have_counters:
                        scol = cosc.counter_super_column
                    else:
                        scol = cosc.super_column
                    yield (self._unpack_name(scol.name, True), self._scol_to_dict(scol, include_timestamp, include_ttl))
                else:
                    if self._have_counters:
                        col = cosc.counter_column
                    else:
                        col = cosc.column
                    yield (self._unpack_name(col.name, False), self._col_to_dict(col, include_timestamp, include_ttl))

                count += 1
                if column_count is not None and count >= column_count:
                    return

            if len(list_cosc) != buffer_size:
                return

            if self.super:
                if self._have_counters:
                    last_name = list_cosc[-1].counter_super_column.name
                else:
                    last_name = list_cosc[-1].super_column.name
            else:
                if self._have_counters:
                    last_name = list_cosc[-1].counter_column.name
                else:
                    last_name = list_cosc[-1].column.name
            i += 1
Perfrom scroll action.
dataset/ETHPy150Open pycassa/pycassa/pycassa/columnfamily.py/ColumnFamily.xget--crossover with--dataset/ETHPy150Open xiaocong/uiautomator/uiautomator/__init__.py/AutomatorDeviceObject.scroll