Gives all fields of underlying inputs in order of those inputs and order of fields within input.

@return concatenated list of fields of all inputs.
161673
public List<FieldReferenceExpression> getAllInputFields() {
		return fieldReferences.stream().flatMap(input -> input.values().stream()).collect(toList());
	}
646963
public Iterator<Map.Entry<String, JrsValue>> fields() {
        if (_values.isEmpty()) {
            return _values.entrySet().iterator();
        }
        return _values.entrySet().iterator();
    }
990600
public List<CmpFieldType<EntityBeanType<T>>> getAllCmpField()
   {
      List<CmpFieldType<EntityBeanType<T>>> list = new ArrayList<CmpFieldType<EntityBeanType<T>>>();
      List<Node> nodeList = childNode.get("cmp-field");
      for(Node node: nodeList)
      {
         CmpFieldType<EntityBeanType<T>>  type = new CmpFieldTypeImpl<EntityBeanType<T>>(this, "cmp-field", childNode, node);
         list.add(type);
      }
      return list;
   }
1083199
private Set<Field> getItemFields() {
		Class next = Item.class;
		Set<Field> fields = new HashSet<>(getFields(next));
		while (next.getSuperclass() != Object.class) {
			next = next.getSuperclass();
			fields.addAll(getFields(next));
		}
		return fields;
	}
431553
public List<String> calculateRollupBaseFields() {
		if(rollupFrom == null) {
			return getGroupByFields();
		}

		List<String> result = new ArrayList<String>();
		for(SortElement element : commonCriteria.getElements()) {
			result.add(element.getName());
			if(element.getName().equals(rollupFrom)) {
				break;
			}
		}
		return result;
	}
1340052
public java.util.List<ExtensionField> getExtensionFields() {
        if (extensionFields == null) {
            extensionFields = new com.amazonaws.internal.SdkInternalList<ExtensionField>();
        }
        return extensionFields;
    }
360441
public Map<String, String> getSortedMap()
    {
        ImmutableSortedMap.Builder<String, String> builder = ImmutableSortedMap.naturalOrder();
        for ( FieldValue fv : fieldValues )
        {
            builder.put(fv.getField(), fv.getValue());
        }

        return builder.build();
    }
959096
public List<E> order() {
		int index = 0;
		for (E item : input) {
			index = output.indexOf(item);
			if (index == -1) {
				insert(item, item);
			}
		}

		return output;
	}
919533
public List<Permutation> all() {
        final List<Permutation> permutations = new ArrayList<Permutation>();
        Backtracker counter = new Backtracker() {

            @Override
            public void applyTo(Permutation p) {
                permutations.add(p);
            }

            @Override
            public boolean isFinished() {
                return false;
            }
        };
        this.apply(counter);
        return permutations;
    }
1004589
public JField []getFields()
  {
    ArrayList<JField> fieldList = new ArrayList<JField>();

    getFields(fieldList);

    JField []fields = new JField[fieldList.size()];
    fieldList.toArray(fields);

    return fields;
  }
555605
public Map<String, String> getCustomFields() {
        Map<String, String> fields = new HashMap<String, String>();
        for (CustomField f : customFields) {
            fields.put(f.getName(), f.getValue());
        }
        return fields;
    }
757778
public List getFormBeansAsList()
    {
        ArrayList retList = new ArrayList();
        
        for ( Iterator i = _formBeans.values().iterator(); i.hasNext(); )
        {
            FormBeanModel fb = ( FormBeanModel ) i.next();
            if ( fb != null ) retList.add( fb );
        }
        
        return retList;
    }
125412
public List<FacesConfigOrderingType<WebFacesConfigDescriptor>> getAllOrdering()
   {
      List<FacesConfigOrderingType<WebFacesConfigDescriptor>> list = new ArrayList<FacesConfigOrderingType<WebFacesConfigDescriptor>>();
      List<Node> nodeList = model.get("ordering");
      for(Node node: nodeList)
      {
         FacesConfigOrderingType<WebFacesConfigDescriptor>  type = new FacesConfigOrderingTypeImpl<WebFacesConfigDescriptor>(this, "ordering", model, node);
         list.add(type);
      }
      return list;
   }
900890
public List<ExpressionMapping> getInputOnlyExpressionMappings() {
        List<ExpressionMapping> list = new LinkedList<ExpressionMapping>();
        for (ExpressionMapping em : _inputExpressionMappings) {
            if (em.getOutput() == null) {
                list.add(em);
            }
        }
        return list;
    }
1002777
public List<T> getSortedKeys() {
    List<T> l = Lists.newArrayList(counts.keySet());
    Collections.sort(l, Ordering.natural().reverse().onResultOf(Functions.forMap(counts.getBaseMap())));
    return l;
  }
300452
protected B fields(List<F> fields) {
        if (instance.def.fields == null) {
            instance.def.fields = new ArrayList<F>(fields.size());
        }
        instance.def.fields.addAll(fields);
        return returnThis();
    }
445462
public FieldInfo[] getFields() {
        FieldInfo[] fields = new FieldInfo[mFields.size()];
        return mFields.toArray(fields);
    }