Generic method to take line cells of a tbody, thead or tfoot structure and returns as a List<List<Cell>>.
@param type
@return List<List<Cell>>
555202
private List<List<Cell>> getAllCellsByLine(CellType type) {
	
		String locatorLines="", locatorColumn="";
		
		switch(type){
			case HEAD: 	locatorLines = ".//thead/tr";
						locatorColumn = ".//th";
						break;
			case BODY: 	locatorLines = ".//tbody/tr";
						locatorColumn = ".//td";
						break;
			case FOOT: 	locatorLines = ".//tfoot/tr";
						locatorColumn = ".//td";
						break;
		}
		
		List<WebElement> lines = this.getElement().findElements(By.xpath(locatorLines)); // Recover all lines from the table
		
		List<List<Cell>> cellLines = new ArrayList<List<Cell>>(); // List of lines of the table
		
		Integer lineIndex = 1;
		
		for (WebElement line : lines) { // iterate the lines taken from table
			
			List<Cell> cellColumns = new ArrayList<Cell>();
			List<WebElement> columns = line.findElements(By.xpath(locatorColumn)); // Recover all columns from the lines
			Integer columnIndex = 1;
			
			for (WebElement column : columns) { // iterate the columns taken from the line
				Cell cell = new SeleniumCell(column);
				cell.setCoordinates(lineIndex, columnIndex);
				cellColumns.add(cell);
				columnIndex++;
			} // end of columns iteration
			
			cellLines.add(cellColumns);
			lineIndex++;
		}// end of lines iteration
		
		return cellLines;
	}
200659
@SuppressWarnings("unchecked")
    public static <T> RuntimeFieldFactory<T> getInline(Class<T> typeClass)
    {
        return (RuntimeFieldFactory<T>) __inlineValues.get(typeClass.getName());
    }
95199
public static List<String> getTables(DataSource ds, TableType... types) {
		return getTables(ds, null, null, types);
	}
201782
public static <T> CsvWriterDSL<T> from(Type type) {

        ClassMeta<T> classMeta = ReflectionService.newInstance().getClassMeta(type);

        CellWriter cellWriter = CsvCellWriter.DEFAULT_WRITER;

        CsvWriterBuilder<T> builder = CsvWriterBuilder
                .newBuilder(classMeta, cellWriter);

        MapperConfig<CsvColumnKey, ?> mapperConfig = MapperConfig.<CsvColumnKey, CsvRow>fieldMapperConfig();
        try {
            String[] headers = defaultHeaders(classMeta);
            for(String header : headers) {
                builder.addColumn(header);
            }
            ContextualSourceFieldMapperImpl<T, Appendable> mapper = builder.mapper();

            return new DefaultCsvWriterDSL<T>(
                    CsvWriter.<T>toColumnDefinitions(headers),
                    cellWriter,
                    mapper,
                    classMeta,
                    mapperConfig, false);
        } catch (UnsupportedOperationException e) {
            return new NoColumnCsvWriterDSL<T>(
                    cellWriter,
                    classMeta,
                    mapperConfig, false);
        }
    }
617333
public <E extends Enum<E>> List<E> getTypeList(Class<E> clz, E[] typeList) {
        if (typeList.length > 0) {
            return new ArrayList<>(Arrays.asList(typeList));
        } else {
            return new ArrayList<>(EnumSet.allOf(clz));
        }
    }
55942
public static List<OpenCLDevice> listDevices(TYPE type) {
      final OpenCLPlatform platform = new OpenCLPlatform(0, null, null, null);
      final ArrayList<OpenCLDevice> results = new ArrayList<>();

      for (final OpenCLPlatform p : platform.getOpenCLPlatforms()) {
         for (final OpenCLDevice device : p.getOpenCLDevices()) {
            if (type == null || device.getType() == type) {
               results.add(device);
            }
         }
      }

      return results;
   }
177154
def _line_by_type(self, line, header, hgroups, htypes, out, want_type,
                      collapse_quals_fn = None):
        
        for index, htype in ((i, t) for i, t in enumerate(htypes) if t == want_type):
            col = hgroups[index][0]
            key = header[col]#self._clean_header(header[col])
            if collapse_quals_fn:
                val = collapse_quals_fn(line, header, hgroups[index])
            else:
                val = line[col]
            out[key].add(val)
        return out
548784
public <U extends T> List<U> getAll(Class<U> type) {
        List<U> r = new ArrayList<>();
        for (T t : data)
            if(type.isInstance(t))
                r.add(type.cast(t));
        return r;
    }
211430
public static List<AbstractType<?>> split(AbstractType<?> type) {
        if (type instanceof CompositeType) {
            return type.getComponents();
        } else {
            List<AbstractType<?>> result = new ArrayList<>(1);
            result.add(type);
            return result;
        }
    }
115187
@SuppressWarnings("static-method")
	protected List<JvmTypeParameter> getTypeParametersFor(XtendTypeDeclaration type) {
		if (type instanceof XtendClass) {
			return ((XtendClass) type).getTypeParameters();
		}
		if (type instanceof XtendInterface) {
			return ((XtendInterface) type).getTypeParameters();
		}
		return Collections.emptyList();
	}
1227166
public static <T extends GraphQLType> List<T> sortGraphQLTypes(Collection<T> types) {
        List<T> sorted = new ArrayList<>(types);
        sorted.sort(graphQLTypeComparator());
        return sorted;
    }
578753
public List<Type> insert(List<Type> cl, Type t) {
        if (cl.isEmpty()) {
            return cl.prepend(t);
        } else if (t.tsym == cl.head.tsym) {
            return cl;
        } else if (t.tsym.precedes(cl.head.tsym, this)) {
            return cl.prepend(t);
        } else {
            // t comes after head, or the two are unrelated
            return insert(cl.tail, t).prepend(cl.head);
        }
    }
1237467
public DataPoint type(Type type) {
        if (this.type != type) {
            this.type = type;
            switch (type) {
            case AVERAGE:
            case SUM:
                this.value = 0;
                break;
            case MAXIMUM:
                this.value = Long.MIN_VALUE;
                break;
            case MINIMUM:
                this.value = Long.MAX_VALUE;
                break;
            default:
                this.value = 0;
                break;
            }
            this.numPoints = 0;
        }
        return this;
    }
368083
public static List<Field> getAllFields(Class<?> type) {
        List<Field> fields = new ArrayList<>();

        for (Class<?> currentType = type; currentType != null; currentType = currentType.getSuperclass()) {
            fields.addAll(Arrays.asList(currentType.getDeclaredFields()));
        }

        return fields;
    }
473678
public void getRowHeadingBasedOnCells(TableCandidate tc) {
	String rowHeadingThisTable = "";
	int footnoteLineIndex = tc.getFootnoteBeginRow();
	String[][] cells = tc.getCells();
	// if (cells[0][0].length()==0 ) {
	for (int j = 0; j < footnoteLineIndex; j++) {
	    if (cells[j][0].length() > 0)
		rowHeadingThisTable = rowHeadingThisTable + cells[j][0] + "; ";
	}
	// }
	rowHeadingThisTable = tc
		.replaceAllSpecialChracters(rowHeadingThisTable);
	tc.setHeadingRows(rowHeadingThisTable);
    }
410310
@SuppressWarnings("unchecked")
    public static List<Class<?>> getSupertypes(Class<?> type) {
        List<Class<?>> supertypes = new LinkedList<>();
        supertypes.add(type.getSuperclass());
        Collections.addAll(supertypes, type.getInterfaces());
        return supertypes;
    }
40155
public FastTrackTable getTable(FastTrackTableType type)
   {
      FastTrackTable result = m_tables.get(type);
      if (result == null)
      {
         result = EMPTY_TABLE;
      }
      return result;
   }