Java wrapper for {@link FeatureSpec#extractWithSettings(Object, Object, CollectionType)}.
186599
public JFeatureExtractor<T> extractWithSettings(List<T> input, String settings) {
    return new JFeatureExtractor<>(JavaOps.extractWithSettings(self, input, settings));
  }
1298016
@SuppressWarnings("unchecked")
    protected Map<String, Object> handleGetSettingsData(Set<String> settingSet) {

        if(settingSet == null || settingSet.size() == 0){
            throw new NotEnoughFieldsSpecifiedException("At least one settings field needs to passed in as an argument.");
        }

        Map<String, String> uriVariables = restUriVariablesFactory.getUriVariablesForSettings(settingSet);
        String url = restUrlFactory.assembleUrlForSettings();

        Map<String, Object> response = this.performGetRequest(url, Map.class, uriVariables);

        return response;

    }
285438
public static List<Object> extract(Iterable<?> collection, Editor<Object> editor) {
		return extract(collection, editor, false);
	}
668693
private Set<TypeMirror> getExcludedAnnotationTypes(Element element) {
    Optional<AnnotationMirror> maybeAnnotation =
        getAnnotationMirror(element, COPY_ANNOTATIONS_NAME);
    if (!maybeAnnotation.isPresent()) {
      return ImmutableSet.of();
    }

    @SuppressWarnings("unchecked")
    List<AnnotationValue> excludedClasses =
        (List<AnnotationValue>) getAnnotationValue(maybeAnnotation.get(), "exclude").getValue();
    return excludedClasses
        .stream()
        .map(annotationValue -> (DeclaredType) annotationValue.getValue())
        .collect(toCollection(TypeMirrorSet::new));
  }
351892
private List<List<IType>> extractContextTypes( List<? extends IInvocableType>  funcTypes )
  {
    if( funcTypes != null )
    {
      ArrayList<List<IType>> returnList = new ArrayList<>();
      for( IInvocableType funcType : funcTypes )
      {
        for( int i = 0; i < funcType.getParameterTypes().length; i++ )
        {
          IType paramType = funcType.getParameterTypes()[i];
          if( i >= returnList.size() )
          {
            returnList.add( new ArrayList<>() );
          }
          List<IType> paramTypeList = returnList.get( i );
          if( !paramTypeList.contains( paramType ) )
          {
            paramTypeList.add( paramType );
          }
        }
      }
      return returnList;
    }
    else
    {
      return Collections.emptyList();
    }
  }
1134058
public JRecordExtractor<T, DoubleSparseArray>
  extractWithSettingsDoubleSparseArray(String settings) {
    return new JRecordExtractor<>(JavaOps.extractWithSettingsDoubleSparseArray(self, settings));
  }
823582
@Override
    public FeatureResponseResult extractFeature(UploadSearchParams uploadSearchParams) {
        FeatureResponseResult result = searchOperations.extractFeature(uploadSearchParams);
        return result;
    }
411520
@SuppressWarnings({ "rawtypes", "unchecked" })
    protected Object parseCollection(GetterMethodCover method, 
            Collection collection) {
        if(method.isArrayObjectCollection()) {
            return parseArrayObjectCollection(method, collection);
        }
        else if(method.isObjectCollection()) {
            return parseObjectCollection(method, collection);
        }
        else if(method.isByteCollection()) {
            return collectionToPrimitiveByteArray(collection);
        }
        else if(method.isCharCollection()) {
            return charCollectionToPrimitiveByteArray(collection);
        }
        else if(method.isArrayCollection()) {
            return parseArrayCollection(method, collection);
        }
        return collection;
    }
404525
private void fromCollect(PatternDescrBuilder<?> pattern) throws RecognitionException {
        CollectDescrBuilder<?> collect = helper.start(pattern,
                CollectDescrBuilder.class,
                null);
        try {
            match(input,
                    DRL6Lexer.ID,
                    DroolsSoftKeywords.COLLECT,
                    null,
                    DroolsEditorType.KEYWORD);
            if (state.failed)
                return;
            if (state.backtracking == 0 && input.LA(1) != DRL6Lexer.EOF) {
                helper.emit(Location.LOCATION_LHS_FROM_COLLECT);
            }

            match(input,
                    DRL6Lexer.LEFT_PAREN,
                    null,
                    null,
                    DroolsEditorType.SYMBOL);
            if (state.failed)
                return;

            lhsPatternBind(collect,
                    false);
            if (state.failed)
                return;

            match(input,
                    DRL6Lexer.RIGHT_PAREN,
                    null,
                    null,
                    DroolsEditorType.SYMBOL);
            if (state.failed)
                return;
        } finally {
            helper.end(CollectDescrBuilder.class,
                    collect);
            if (state.backtracking == 0 && input.LA(1) != DRL6Lexer.EOF) {
                helper.emit(Location.LOCATION_LHS_BEGIN_OF_CONDITION);
            }
        }
    }
250467
public static List<String> extractAsStringArray(ModelMethod method, ModelAnnotation annotationClass, AnnotationAttributeType attribute) {
		final Elements elementUtils=BaseProcessor.elementUtils;
		final One<List<String>> result = new One<List<String>>();
		extractAttributeValue(elementUtils, method.getElement(), annotationClass.getName(), attribute, new OnAttributeFoundListener() {

			@Override
			public void onFound(String value) {
				result.value0 = AnnotationUtility.extractAsArrayOfString(value);
			}
		});

		return result.value0;
	}
25281
private <T> T injectSetters(T r, JSONObject j, Collection<String> exclusions) {
        // try to assign rest of the properties
        OUTER:
        for (String key : (Set<String>)j.keySet()) {
            if (!exclusions.contains(key)) {
                try {
                    // try field injection first
                    for (Class c=r.getClass(); c!=null; c=c.getSuperclass()) {
                        try {
                            Field f = c.getDeclaredField(key);
                            if (f.getAnnotation(DataBoundSetter.class)!=null) {
                                f.setAccessible(true);
                                f.set(r, bindJSON(f.getGenericType(), f.getType(), j.get(key)));
                                continue OUTER;
                            }
                        } catch (NoSuchFieldException e) {
                            // recurse into parents
                        }
                    }

                    Method wm = findDataBoundSetter(r.getClass(), key);
                    if (wm==null)   continue;

                    Class<?>[] pt = wm.getParameterTypes();
                    assert pt.length==1;

                    // only invoking public methods for security reasons
                    wm.invoke(r, bindJSON(wm.getGenericParameterTypes()[0], pt[0], j.get(key)));
                } catch (IllegalAccessException e) {
                    LOGGER.log(WARNING, "Cannot access property " + key + " of " + r.getClass(), e);
                } catch (InvocationTargetException e) {
                    LOGGER.log(WARNING, "Cannot access property " + key + " of " + r.getClass(), e);
                }
            }
        }

        invokePostConstruct(getWebApp().getMetaClass(r).getPostConstructMethods(), r);

        return r;
    }
620619
private void extractMithraInterfaces(Map<String, MithraInterfaceType> mithraInterfaces, List<String> errors)
    {
        for (String mithraInterfaceType : this.getWrapped().getMithraInterfaces())
        {
            MithraInterfaceType mithraInterfaceObject = mithraInterfaces.get(mithraInterfaceType);

            if (mithraInterfaceObject != null)
            {
                //boolean hasNoSuperClass  = validateObjectHasNoSuperClass(errors);
                boolean hasAllInterfaceAttributes = validateObjectHasAllMithraInterfaceAttributes(mithraInterfaceObject, errors);

                boolean hasAllInterfaceRelationships = validateObjectHasAllMithraInterfaceRelationships(mithraInterfaceObject, mithraInterfaces, errors);

                if (hasAllInterfaceAttributes && hasAllInterfaceRelationships)
                {
                    this.mithraInterfaces.add(mithraInterfaceObject);
                    this.addToRequiredClasses(mithraInterfaceObject.getPackageName(), mithraInterfaceObject.getClassName());
                    this.addToRequiredClasses(mithraInterfaceObject.getPackageName(), mithraInterfaceObject.getClassName() + "Finder");
                }
            }
        }
    }
189121
private Set<String> collectFields(Class clazz, String fieldPrefix, Set<String> fields) {
        Map<String, Class> fieldsAndClasses = getFieldsAndClasses(clazz, fieldPrefix);

        for (Map.Entry<String, Class> entry : fieldsAndClasses.entrySet()) {
            String field = entry.getKey();
            Class fieldClass = entry.getValue();

            if (DIRECTLY_PROJECTED_TYPES.contains(fieldClass) || Collection.class.isAssignableFrom(fieldClass)) {
                fields.add(field);
            } else {
                collectFields(fieldClass, field + ".", fields);
            }
        }

        return fields;
    }
392068
public Map<List<String>, String> extractNestedTypes(XTrace trace) {
		return XCostType.instance().extractNestedValues(trace);
	}
497968
public static Class[] getCollectionType( PropertyDescriptor pd, boolean useGetter )
         throws JSONException {

      Type type;
      if( useGetter ){
         Method m = pd.getReadMethod();
         type = m.getGenericReturnType();
      }else{
         Method m = pd.getWriteMethod();
         Type[] gpts = m.getGenericParameterTypes();

         if( 1 != gpts.length ){
            throw new JSONException( "method " + m + " is not a standard setter" );
         }
         type = gpts[0];
      }

      if( !(type instanceof ParameterizedType) ){
         return null;
         // throw new JSONException("type not instanceof ParameterizedType:
         // "+type.getClass());
      }

      ParameterizedType pType = (ParameterizedType) type;
      Type[] actualTypes = pType.getActualTypeArguments();

      Class[] ret = new Class[actualTypes.length];
      for( int i = 0; i < ret.length; i++ ){
         ret[i] = (Class) actualTypes[i];
      }

      return ret;
   }
1112965
public static Map<Object, Object> getAllNotEqualsGetterAndSetterAndRemoveThisProperties(Map<Object, Object> pvGetterMap, Map<Object, Object> pvSetterMap) {
		Map<Object, Object> lvMap = new TreeMap<Object, Object>();
		Iterator<Object> it = new ArrayList<Object>(pvGetterMap.keySet()).iterator();
		lvMap.put(Util.getKeyWordClass(), pvGetterMap.get(Util.getKeyWordClass()));
		while (it.hasNext()) {
			Object lvGetterProp = it.next();
			if (pvSetterMap.containsKey(lvGetterProp)) {
				lvMap.put(lvGetterProp, pvGetterMap.get(lvGetterProp));
			}
		}
		return Collections.unmodifiableMap(lvMap);
	}
142300
public JSONReader withFeatures(int features)
    {
        if (_features == features) {
            return this;
        }
        return _with(features, _readerLocator, _treeCodec, _collectionBuilder, _mapBuilder);
    }