Returns the fields that are a subset from the groupBy fields and will be
used when rollup is needed.

@see RollupReducer
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;
	}
849302
@SuppressWarnings("unchecked")
	@Override
	public Collection<String> getCopyFields() {

		Indexed indexedAnnotation = getIndexAnnotation();
		if (indexedAnnotation != null && indexedAnnotation.copyTo().length > 0) {
			return CollectionUtils.arrayToList(indexedAnnotation.copyTo());
		}
		return Collections.emptyList();
	}
550126
public Set<String> getUpdatedFieldNames() {
        Set<String> fieldNames = new HashSet<String>(m_valueMap.keySet());
        fieldNames.addAll(m_valueRemoveMap.keySet());
        return fieldNames;
    }
1122670
def get_fields(self):
        
        fields = super(BaseHookSerializer, self).get_fields()
        fields['event_types'] = serializers.MultipleChoiceField(
            choices=loggers.get_valid_events(), required=False)
        fields['event_groups'] = serializers.MultipleChoiceField(
            choices=loggers.get_event_groups_keys(), required=False)
        return fields
465194
private AggregatedGroupMapping[] extractGroupsArray(Set<D> columnGroups) {
        Set<AggregatedGroupMapping> groupMappings = new HashSet<AggregatedGroupMapping>();
        for (D discriminator : columnGroups) {
            groupMappings.add(discriminator.getAggregatedGroup());
        }
        return groupMappings.toArray(new AggregatedGroupMapping[0]);
    }
824505
protected Field getField()
    {
        // make sure class was initialized
        if (!isInitialized)
        {
            /*
            first we build a graph of fields for nested fields support,
            but for best performance on non-nested fields we also keep
            the latest field separate and set a 'is nested' flag.
            */
            fieldsList = getFieldGraph(makeAccessible());
            field = (Field) fieldsList.get(fieldsList.size() - 1);
            nonNested = fieldsList.size() == 1;
            isInitialized = true;
        }
        return field;
    }
1234389
private Set<String> collidingFieldNames(ImmutableList<Field> fields) {
    Set<String> fieldNames = new LinkedHashSet<>();
    Set<String> collidingNames = new LinkedHashSet<>();
    for (Field field : fields) {
      if (!fieldNames.add(field.name())) {
        collidingNames.add(field.name());
      }
    }
    return collidingNames;
  }
723564
public Collection<String> getFieldNames()
    {
        Set<String> fieldNames = new LinkedHashSet<String> ();
        
        fieldNames.addAll( keys );
        
        return fieldNames;
        
    }
299670
public Stream partitionBy(Fields fields) {
        projectionValidation(fields);
        return partition(Grouping.fields(fields.toList()));
    }
852768
public SortField[] sortFields() {
        return new SortField[]{new SortField(FIELD_NAME, new FieldComparatorSource() {
            @Override
            public FieldComparator<?> newComparator(String field,
                                                    int hits,
                                                    int sort,
                                                    boolean reversed) throws IOException {
                return new ClusteringKeySorter(ClusteringKeyMapper.this, hits, field);
            }
        })};
    }
469787
public FieldDescriptor[] getNonPkRwFields()
    {
        if (m_RwNonPkFieldDescriptors == null)
        {
            FieldDescriptor[] fields = getNonPkFields();
            Collection rwFields = new ArrayList();

            for (int i = 0; i < fields.length; i++)
            {
                FieldDescriptor fd = fields[i];
                if (!fd.isAccessReadOnly())
                {
                    rwFields.add(fd);
                }
            }
            m_RwNonPkFieldDescriptors =
                (FieldDescriptor[]) rwFields.toArray(new FieldDescriptor[rwFields.size()]);
        }
        return m_RwNonPkFieldDescriptors;
    }
323396
private AbstractAggregationBuilder makeTopHitsAgg(MethodField field) {
        String alias = gettAggNameFromParamsOrAlias(field);
        TopHitsAggregationBuilder topHits = AggregationBuilders.topHits(alias);
        List<KVValue> params = field.getParams();
        String[] include = null;
        String[] exclude = null;
        for (KVValue kv : params) {
            switch (kv.key) {
                case "from":
                    topHits.from((int) kv.value);
                    break;
                case "size":
                    topHits.size((int) kv.value);
                    break;
                case "include":
                    include = kv.value.toString().split(",");
                    break;
                case "exclude":
                    exclude = kv.value.toString().split(",");
                    break;
                case "alias":
                case "nested":
                case "reverse_nested":
                case "children":
                    break;
                default:
                    topHits.sort(kv.key, SortOrder.valueOf(kv.value.toString().toUpperCase()));
                    break;
            }
        }
        if (include != null || exclude != null) {
            topHits.fetchSource(include, exclude);
        }
        return topHits;
    }
695984
public JField []getDeclaredFields()
  {
    Field []fields = _class.getDeclaredFields();
    
    JField []jFields = new JField[fields.length];

    for (int i = 0; i < fields.length; i++) {
      jFields[i] = new JFieldWrapper(fields[i], getClassLoader());
    }

    return jFields;
  }
223224
public Iterable<BoxMetadataCascadePolicy.Info> getMetadataCascadePolicies(String... fields) {
        Iterable<BoxMetadataCascadePolicy.Info> cascadePoliciesInfo =
                BoxMetadataCascadePolicy.getAll(this.getAPI(), this.getID(), fields);

        return cascadePoliciesInfo;
    }
1229585
public java.util.List<ReplicationGroup> getReplicationGroups() {
        if (replicationGroups == null) {
            replicationGroups = new com.amazonaws.internal.SdkInternalList<ReplicationGroup>();
        }
        return replicationGroups;
    }
1274568
@Override
  public List<AggregatorFactory> getRequiredColumns()
  {
    return Collections.singletonList(new HllSketchBuildAggregatorFactory(fieldName, fieldName, lgK, tgtHllType.toString()));
  }
1368388
private static Set<Field> findAllFieldsUsingStrategy(FieldMatcherStrategy strategy, Object object,
                                                         boolean checkHierarchy, Class<?> startClass) {
        assertObjectInGetInternalStateIsNotNull(object);
        final Set<Field> foundFields = new LinkedHashSet<Field>();
        while (startClass != null) {
            final Field[] declaredFields = startClass.getDeclaredFields();
            for (Field field : declaredFields) {
                if (strategy.matches(field) && hasFieldProperModifier(object, field)) {
                    // TODO replace by the class 
                    try {
                        field.setAccessible(true);
                        foundFields.add(field);
                    } catch (Exception ignored) {
                        // the InaccessibleObjectException is thrown in Java 9 in case
                        // if a field is private and a module is not open
                    }
                }
            }
            if (!checkHierarchy) {
                break;
            }
            startClass = startClass.getSuperclass();
        }

        return Collections.unmodifiableSet(foundFields);
    }