Return a list of table column informations for the given class.

@param clasz
Class to check for <code>@TableColumn</code> and <code>@Label</code> annotations.
@param locale
Locale to use.

@return List of table columns sorted by the position.
168717
public static List<TableColumnInfo> create(@NotNull final Class<?> clasz, @NotNull final Locale locale) {

        Contract.requireArgNotNull("clasz", clasz);
        Contract.requireArgNotNull("locale", locale);

        final List<TableColumnInfo> list = new ArrayList<TableColumnInfo>();
        final Field[] fields = clasz.getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            final TableColumnInfo tableColumnInfo = create(fields[i], locale);
            if (tableColumnInfo != null) {
                list.add(tableColumnInfo);
            }
        }
        Collections.sort(list);
        return list;
    }
399154
public Properties getLables(JKLocale locale) {
		Properties properties = lables.get(locale);
		if (properties == null) {
			properties = new Properties();
			lables.put(locale, properties);
		}
		return properties;
	}
895706
public static Field[] getFields (Class<?> clazz)
    {
        ArrayList<Field> list = new ArrayList<Field>();
        getFields(clazz, list);
        return list.toArray(new Field[list.size()]);
    }
1250403
public static Resources getClassResources( Class clazz, Locale locale )
    {
        return getBaseResources( getClassResourcesBaseName( clazz ), locale, clazz.getClassLoader() );
    }
137226
public static List<Locale> getLocalesFromHeader(final String acceptLanguage) {
        if(acceptLanguage == null) {
            return Collections.emptyList();
        }
        return getLocalesFromHeader(Collections.singletonList(acceptLanguage));
    }
156223
public static Field[] jlClassGetFields(Class<?> clazz) {
		ReloadableType rtype = getRType(clazz);
		if (rtype == null) {
			return clazz.getFields();
		}
		else {
			List<Field> allFields = new ArrayList<Field>();
			gatherFields(clazz, allFields, new HashSet<Class<?>>());
			return allFields.toArray(new Field[allFields.size()]);
		}
	}
955942
public function listColumns()
    {
        if (!is_null($this->listColumns)) {
            return $this->listColumns;
        }

        // We use this method to load the annotation classes, because the annotation Library Doctrine does not
        AnnotationManager::autoLoadAnnotation();

        // Set the list of properties, an array to contain the list of columns and a boolean to check if the class has several indexes
        $properties = $this->reflection->getProperties();
        $haveIndex = false;
        $columns = array();

        foreach ($properties as $property) {
            // For each properties, get the list of annotations
            $propertyAnnotation = $this->annotationReader->getPropertyAnnotations($property);
            // Check the property has a Column Annotation
            if (($columnAnnotation = self::haveAnnotation(self::$ColumnAnnotation, $propertyAnnotation)) !== false) {
                $columnAnnotation->check();
                $column = array(
                    'type' => $columnAnnotation->type,
                    'strict' => $columnAnnotation->strict
                );
                // Check the property has an Index Annotation
                if (($indexAnnotation = self::haveAnnotation(self::$IndexAnnotation, $propertyAnnotation)) !== false) {
                    $indexAnnotation->check();
                    // Verify that the class have a unique index annotation
                    if ($haveIndex == true) {
                        throw new InvalidAnnotationException($indexAnnotation, $property->getName(), 'Class ' . $this->className . ' have already an index when he read the annotation of ' . $property->getName());
                    }
                    $column['index'] = true;
                    $haveIndex = true;
                } else {
                    $column['index'] = false;
                }

                // If is an entity Column, check entityRelationAnnotation
                if ($column['type'] == 'entity') {
                    if (($relationAnnotation = self::haveAnnotation(self::$entityRelationAnnotation, $propertyAnnotation)) !== false) {
                        $relationAnnotation->check();
                        try {
                            $annotationClassOfRelation = EntityAnalyzer::get($relationAnnotation->classname)->getClassAnnotation();
                        } catch (InvalidEntityException $e) {
                            throw new InvalidAnnotationException($relationAnnotation, 'classname', 'The class ' . $relationAnnotation->classname . ' is not an Entity');
                        }

                        $column['relation'] = array(
                            'classname' => $relationAnnotation->classname,
                            'multi' => $relationAnnotation->multi,
                            'ignore_errors' => $relationAnnotation->ignore_errors
                        );
                    } else {
                        throw new InvalidAnnotationException(null, null, 'A Entity Column must have a EntityRelation annotations');
                    }
                }

                $columns[$property->getName()] = $column;
            }
        }

        $this->listColumns = $columns;
        return $columns;
    }
24626
public static List<Field> getKeyColumns(Class<?> clazz) 
	    throws NoKeyColumnAnnotationException {
		List<Field> fields = getColumns(clazz);
		List<Field> keyFields = new ArrayList<Field>();
		for(Field field : fields) {
			Column column = field.getAnnotation(Column.class);
			if(column.isKey()) {
				keyFields.add(field);
			}
		}
		if(keyFields.isEmpty()) {
			throw new NoKeyColumnAnnotationException();
		}
		return keyFields;
	}
932162
<T> DynamoDBTable getTable(Class<T> clazz) {
        DynamoDBTable table = clazz.getAnnotation(DynamoDBTable.class);
        if ( table == null )
            throw new DynamoDBMappingException("Class " + clazz + " must be annotated with " + DynamoDBTable.class);
        return table;
    }
592560
public static List<Locale> getCandidateLocales(Locale locale) {

        String language = LanguageMatch.getAlias(locale);
        String country = FormatUtils.getRegion(locale);
        String variant = locale.getVariant();

        if (language.equals("zh") && locale.getScript().equals("Hant")) {
            country = "TW";
        }

        List<Locale> list = new LinkedList<>();

        if (!variant.isEmpty()) {
            list.add(new Locale(language, country, variant));
        }

        if (!country.isEmpty()) {
            list.add(new Locale(language, country, ""));
        }

        if (!language.isEmpty()) {
            list.add(new Locale(language, "", ""));
            if (language.equals("nn")) {
                list.add(new Locale("nb", "", ""));
            }
        }

        list.add(Locale.ROOT);
        return list;

    }
703376
@Override
    public List<Column> getColumns(List<String> columnNames) {
        if (columnsByName.isEmpty()) {
            Map<String, Column> columnsMap = new HashMap<String, Column>();
            List<Column> allColumns = sasFileParser.getColumns();
            for (Column column : allColumns) {
                columnsMap.put(column.getName(), column);
            }
            for (String name : columnNames) {
                if (columnsMap.containsKey(name)) {
                    columnsByName.add(columnsMap.get(name));
                } else {
                    throw new NoSuchElementException(UNKNOWN_COLUMN_NAME);
                }
            }
        }
        return columnsByName;
    }
948243
@Override
  public OperationHandle getColumns(SessionHandle sessionHandle, String catalogName,
      String schemaName, String tableName, String columnName) throws HiveSQLException {
    return cliService.getColumns(sessionHandle, catalogName, schemaName, tableName, columnName);
  }
771254
final List<DBColumn> getPrimaryKeyColumnList() {

		final List<DBColumn> primaryKeyColumnList = new ArrayList<DBColumn>();

		final Set<String> columnNameSet = getAllColumnNames();

		for (String columnName : columnNameSet) {

			final D6ModelClassFieldInfo fieldInfo = getFieldInfo(columnName);

			final Field field = fieldInfo.field;

			final DBColumn dbColumn = field.getAnnotation(DBColumn.class);

			if (dbColumn.isPrimaryKey()) {

				primaryKeyColumnList.add(dbColumn);
			}
		}

		return primaryKeyColumnList;
	}
317475
public static Field[] getAnnotationFields(Class<?> clazz, Class<? extends Annotation> annotationClass) {
        if (clazz == null || annotationClass == null) {
            return null;
        }

        List<Field> fields = getAllFieldsOfClass0(clazz);
        if (CollectionUtil.isEmpty(fields)) {
            return null;
        }

        List<Field> list = CollectionUtil.createArrayList();
        for (Field field : fields) {
            if (null != field.getAnnotation(annotationClass)) {
                list.add(field);
                field.setAccessible(true);
            }
        }

        return list.toArray(new Field[0]);
    }
679369
public List<ConversionMethod> getConversionMethods (Class<?> clazz){
		List<ConversionMethod> conversions = new ArrayList<ConversionMethod>();
		Map<String, List<ConversionMethod>> conversionsMap = this.conversionsLoad();
		for (Class<?> classToCheck : getAllsuperClasses(clazz)){
			List<ConversionMethod> methods = conversionsMap.get(classToCheck.getName());
			if(methods != null)conversions.addAll(methods);
		}
		return conversions;
	}
37132
public static String getAllColumns(Class<?> entityClass) {
        Set<EntityColumn> columnSet = EntityHelper.getColumns(entityClass);
        StringBuilder sql = new StringBuilder();
        for (EntityColumn entityColumn : columnSet) {
            sql.append(entityColumn.getColumn()).append(",");
        }
        return sql.substring(0, sql.length() - 1);
    }
1237985
@Override
    public String[] getColumns() {
        if (metaData != null && columns == null) {
            final List<ColumnMetaData> cmds = metaData.getColumnsNames();

            columns = new String[cmds.size()];
            for (int i = 0; i < cmds.size(); i++) {
                columns[i] = cmds.get(i).getColName();
            }
        }

        return columns;
    }