Read a list of fixed sized blocks from the input stream.

@return List of MapRow instances representing the fixed size blocks
352966
public List<MapRow> read() throws IOException
   {
      List<MapRow> result = new ArrayList<MapRow>();
      int fileCount = m_stream.readInt();
      if (fileCount != 0)
      {
         for (int index = 0; index < fileCount; index++)
         {
            // We use a LinkedHashMap to preserve insertion order in iteration
            // Useful when debugging the file format.
            Map<String, Object> map = new LinkedHashMap<String, Object>();
            readBlock(map);
            result.add(new MapRow(map));
         }
      }
      return result;
   }
1093164
public java.util.List<alluxio.grpc.BlockMasterInfoField> getFiltersList() {
    return new com.google.protobuf.Internal.ListAdapter<
        java.lang.Integer, alluxio.grpc.BlockMasterInfoField>(filters_, filters_converter_);
  }
235999
public ArrayList getChunks() {
        ArrayList tmp = new ArrayList();
        Chunk chunk;
        Iterator i = iterator();
        boolean localDestination = (reference != null && reference.startsWith("#"));
        boolean notGotoOK = true;
        while (i.hasNext()) {
            chunk = (Chunk) i.next();
            if (name != null && notGotoOK && !chunk.isEmpty()) {
                chunk.setLocalDestination(name);
                notGotoOK = false;
            }
            if (localDestination) {
                chunk.setLocalGoto(reference.substring(1));
            }
            else if (reference != null)
                chunk.setAnchor(reference);
            tmp.add(chunk);
        }
        return tmp;
    }
610840
private String getRowFormat(List<Integer> widths) {
    StringBuilder rowFormat = new StringBuilder(spaces(this.indentation));
    for (int i=0; i< widths.size(); i++) {
      rowFormat.append("%");
      rowFormat.append(this.flags != null ? this.flags.get(i) : "");
      rowFormat.append(widths.get(i).toString());
      rowFormat.append("s");
      rowFormat.append(spaces(this.delimiterWidth));
    }
    rowFormat.append("\n");

    return rowFormat.toString();
  }
1155767
public List<UIContext> getRowContexts() {
		List<?> beanList = this.getBeanList();
		List<UIContext> contexts = new ArrayList<>(beanList.size());

		for (int i = 0; i < beanList.size(); i++) {
			Object rowData = beanList.get(i);
			contexts.add(this.getRowContext(rowData, i));
		}

		return Collections.unmodifiableList(contexts);
	}
802471
public MatrixSize readCoordinateSize() throws IOException {
        int numRows = getInt(), numColumns = getInt(), numEntries = getInt();

        return new MatrixSize(numRows, numColumns, numEntries);
    }
1181111
private List<Object> readList() {
    if (readChar() != '[') throw new AssertionError();
    List<Object> result = new ArrayList<>();
    while (true) {
      if (peekChar() == ']') {
        // If we see the close brace, finish immediately. This handles [] and ,] cases.
        pos++;
        return result;
      }

      result.add(readKindAndValue().value());

      char c = peekChar();
      if (c == ',') {
        pos++;
      } else if (c != ']') {
        throw unexpected("expected ',' or ']'");
      }
    }
  }
1259179
public java.util.List<? extends com.google.bigtable.v2.ReadRowsResponse.CellChunkOrBuilder>
      getChunksOrBuilderList() {
    return chunks_;
  }
211918
public List<Polygon> polygons() {
        return positions().children().stream()
                .map(Polygon::new)
                .collect(Collectors.toList());

    }
1062792
def _readall(self, size):
        
        data = b""
        while len(data) < size:
            d = self._read(size - len(data))
            if self._broken:
                raise StopIteration
            if not d:
                # NOTE (Buro/jgross): Force a yield here to another thread. In
                # case the stream fails midstream, the spinning here causes
                # the UI thread to lock up without yielding.
                time.sleep(0)
                continue
            data += d
        return data
800541
public void readSingleRow() {
    // [START bigtable_hw_get_by_key_veneer]
    try {
      System.out.println("\nReading a single row by row key");
      Row row = dataClient.readRow(tableId, ROW_KEY_PREFIX + 0);
      System.out.println("Row: " + row.getKey().toStringUtf8());
      for (RowCell cell : row.getCells()) {
        System.out.printf(
            "Family: %s    Qualifier: %s    Value: %s%n",
            cell.getFamily(), cell.getQualifier().toStringUtf8(), cell.getValue().toStringUtf8());
      }
    } catch (NotFoundException e) {
      System.err.println("Failed to read from a non-existent table: " + e.getMessage());
    }
    // [END bigtable_hw_get_by_key_veneer]
  }
1197014
private List<TableRow> getTableRows(Context context, Cursor cursor) {

        List<TableRow> rows = new ArrayList<>();
        TableRow header = new TableRow(context);
        cursor.moveToFirst();

        int paddingPx = context.getResources().getDimensionPixelSize(R.dimen.hsql_column_padding);

        for (int col = 0; col < cursor.getColumnCount(); col++) {
            TextView textView = new TextView(context);
            textView.setText(cursor.getColumnName(col));
            textView.setPadding(paddingPx, paddingPx / 2, paddingPx, paddingPx / 2);
            textView.setTypeface(Typeface.DEFAULT_BOLD);
            header.addView(textView);
        }

        rows.add(header);

        boolean alternate = true;

        if (cursor.getCount() == 0) {
            return rows;
        }

        do {
            TableRow row = new TableRow(context);
            for (int col = 0; col < cursor.getColumnCount(); col++) {
                TextView textView = new TextView(context);
                if (cursor.getType(col) == FIELD_TYPE_BLOB) {
                    //We don't need to display the contents of the blob
                    textView.setText(R.string.hsql_data_type_blob);
                } else {
                    textView.setText(cursor.getString(col));
                }
                textView.setPadding(paddingPx, paddingPx / 2, paddingPx, paddingPx / 2);
                int rowBgRes;
                if (alternate) {
                    rowBgRes = R.color.hsql_table_row_colour_alt;
                } else {
                    rowBgRes = R.color.hsql_table_row_colour_standard;
                }
                textView.setBackgroundColor(context.getResources().getColor(rowBgRes));
                row.addView(textView);
            }

            alternate = !alternate;
            rows.add(row);

        } while (cursor.moveToNext());

        cursor.close();
        return rows;
    }
545051
protected Set<String> getPrevExpandedRows() {
		Set<String> prev = getComponentModel().prevExpandedRows;
		if (prev == null) {
			return Collections.emptySet();
		} else {
			return Collections.unmodifiableSet(prev);
		}
	}
299458
public <T> List<T> read(int headerRowIndex, int startRowIndex, Class<T> beanType) {
		return read(headerRowIndex, startRowIndex, Integer.MAX_VALUE, beanType);
	}
1193110
public ArrayList<String> getThrowsList()
    {
        ArrayList<String> throwsList = new ArrayList<String>();

        if ( _methodDecl == null ||
             _methodDecl.getThrownTypes() == null ||
             _methodDecl.getThrownTypes().size() == 0 )
            return throwsList;
        
        Collection<ReferenceType> thrownTypes = _methodDecl.getThrownTypes();
        for (ReferenceType exceptType : thrownTypes)
            throwsList.add(exceptType.toString());

        return throwsList;
    }
590904
public List<String> readBulk(final List<String> keys) throws Exception {
        List<String> responses = new ArrayList<>(keys.size());
        JanusGraphTransaction transaction = useJanusgraphTransaction ? graph.newTransaction() : null;

        try {
            for (String key : keys) {
                String response = readSingleInternal(key, transaction);
                responses.add(response);
            }
        } finally {
            if (transaction != null)
                transaction.close();
        }
        return responses;
    }
1027646
public List<MapRow> readTableConditional(Class<? extends TableReader> readerClass) throws IOException
   {
      List<MapRow> result;
      if (DatatypeConverter.getBoolean(m_stream))
      {
         result = readTable(readerClass);
      }
      else
      {
         result = Collections.emptyList();
      }
      return result;
   }