Clears the list to be returned from {@link
org.inferred.freebuilder.processor.property.Property#getAccessorAnnotations()}.

@return this {@code Builder} object
351601
public org.inferred.freebuilder.processor.property.Property.Builder clearAccessorAnnotations() {
    if (accessorAnnotations instanceof ImmutableList) {
      accessorAnnotations = ImmutableList.of();
    } else {
      accessorAnnotations.clear();
    }
    return (org.inferred.freebuilder.processor.property.Property.Builder) this;
  }
873829
protected void clearCaches() {
        DescriptorFactory.clearInstance();
        ObjectTypeFactory.clearInstance();
        TypeQualifierApplications.clearInstance();
        TypeQualifierAnnotation.clearInstance();
        TypeQualifierValue.clearInstance();
        // Make sure the codebases on the classpath are closed
        AnalysisContext.removeCurrentAnalysisContext();
        Global.removeAnalysisCacheForCurrentThread();
        IO.close(classPath);
    }
480819
public org.inferred.freebuilder.processor.property.Property.Builder mergeFrom(
      org.inferred.freebuilder.processor.property.Property.Builder template) {
    // Upcast to access private fields; otherwise, oddly, we get an access violation.
    Property_Builder base = template;
    Property_Builder defaults = new org.inferred.freebuilder.processor.property.Property.Builder();
    if (!base._unsetProperties.contains(Property.TYPE)
        && (defaults._unsetProperties.contains(Property.TYPE)
            || !Objects.equals(template.getType(), defaults.getType()))) {
      setType(template.getType());
    }
    template.getBoxedType().ifPresent(this::setBoxedType);
    if (!base._unsetProperties.contains(Property.NAME)
        && (defaults._unsetProperties.contains(Property.NAME)
            || !Objects.equals(template.getName(), defaults.getName()))) {
      setName(template.getName());
    }
    if (!base._unsetProperties.contains(Property.CAPITALIZED_NAME)
        && (defaults._unsetProperties.contains(Property.CAPITALIZED_NAME)
            || !Objects.equals(template.getCapitalizedName(), defaults.getCapitalizedName()))) {
      setCapitalizedName(template.getCapitalizedName());
    }
    if (!base._unsetProperties.contains(Property.ALL_CAPS_NAME)
        && (defaults._unsetProperties.contains(Property.ALL_CAPS_NAME)
            || !Objects.equals(template.getAllCapsName(), defaults.getAllCapsName()))) {
      setAllCapsName(template.getAllCapsName());
    }
    if (!base._unsetProperties.contains(Property.USING_BEAN_CONVENTION)
        && (defaults._unsetProperties.contains(Property.USING_BEAN_CONVENTION)
            || template.isUsingBeanConvention() != defaults.isUsingBeanConvention())) {
      setUsingBeanConvention(template.isUsingBeanConvention());
    }
    if (!base._unsetProperties.contains(Property.GETTER_NAME)
        && (defaults._unsetProperties.contains(Property.GETTER_NAME)
            || !Objects.equals(template.getGetterName(), defaults.getGetterName()))) {
      setGetterName(template.getGetterName());
    }
    if (!base._unsetProperties.contains(Property.FULLY_CHECKED_CAST)
        && (defaults._unsetProperties.contains(Property.FULLY_CHECKED_CAST)
            || template.isFullyCheckedCast() != defaults.isFullyCheckedCast())) {
      setFullyCheckedCast(template.isFullyCheckedCast());
    }
    addAllAccessorAnnotations(base.accessorAnnotations);
    return (org.inferred.freebuilder.processor.property.Property.Builder) this;
  }
1112202
public List<FacesConfigFlowDefinitionFlowReturnType<FacesConfigFlowDefinitionType<T>>> getAllFlowReturn()
   {
      List<FacesConfigFlowDefinitionFlowReturnType<FacesConfigFlowDefinitionType<T>>> list = new ArrayList<FacesConfigFlowDefinitionFlowReturnType<FacesConfigFlowDefinitionType<T>>>();
      List<Node> nodeList = childNode.get("flow-return");
      for(Node node: nodeList)
      {
         FacesConfigFlowDefinitionFlowReturnType<FacesConfigFlowDefinitionType<T>>  type = new FacesConfigFlowDefinitionFlowReturnTypeImpl<FacesConfigFlowDefinitionType<T>>(this, "flow-return", childNode, node);
         list.add(type);
      }
      return list;
   }
256498
public java.util.List<
          ? extends com.google.privacy.dlp.v2.TransformationSummary.SummaryResultOrBuilder>
      getResultsOrBuilderList() {
    return results_;
  }
883209
public BType getBuilder() {
    if (builder == null) {
      // builder.mergeFrom() on a fresh builder
      // does not create any sub-objects with independent clean/dirty states,
      // therefore setting the builder itself to clean without actually calling
      // build() cannot break any invariants.
      builder = newBuilderForType(message.getDescriptorForType(), this);
      builder.mergeFrom(message); // no-op if message is the default message
      markClean(builder);
    }
    return builder;
  }
1009202
public static Collection<String> getPropertyNames(
                    final Class<?> clazz
                    )
    {
        if (clazz == null) {
            throw new IllegalArgumentException( "no class specified" );
        }

        Map<String, PropertyAccessor>  accessors = _getAccessors( clazz );

        return accessors.keySet();
    }
1358756
@Override
	protected Set<Class<? extends Annotation>> getSupportedAnnotationClasses() {
		Set<Class<? extends Annotation>> annotations = new LinkedHashSet<Class<? extends Annotation>>();

		annotations.add(BindType.class);
		annotations.add(BindDataSource.class);
		annotations.add(BindDataSourceOptions.class);
		annotations.add(BindSqlType.class);
		annotations.add(BindDao.class);
		annotations.add(BindDaoMany2Many.class);
		annotations.add(BindGeneratedDao.class);

		return annotations;
	}
154972
public List /*<Property>*/ getPropertyList()
    {
        Field [] fields = getClass().getFields();
        List /*<Property>*/ list = new ArrayList /*<Property>*/();
        for (int i = 0; i < fields.length; i++) {
            Field field = fields[i];
            if (!Modifier.isStatic(field.getModifiers())
                && Property.class.isAssignableFrom(
                    field.getType()))
            {
                try {
                    list.add((Property) field.get(this));
                } catch (IllegalAccessException e) {
                    throw new RuntimeException(
                        "Error while accessing property '" + field.getName()
                        + "'",
                        e);
                }
            }
        }
        return list;
    }
262993
public RedwoodConfiguration clear(){
    tasks = new LinkedList<Runnable>();
    tasks.add(new Runnable(){ public void run(){
      Redwood.clearHandlers();
      Redwood.restoreSystemStreams();
      Redwood.clearLoggingClasses();
    } });
    return this;
  }
83333
private static Map<String, PropertyAccessor> _getAccessors(
                    final Class<?> clazz
                    )
    {
        Map<String, PropertyAccessor>  accessors = null;

        synchronized (_ACCESSORS_REG_) {
            accessors = _ACCESSORS_REG_.get( clazz );
            if (accessors == null) {
                accessors = PropertyAccessor.findAll( clazz );
                _ACCESSORS_REG_.put( clazz, accessors );
            }
        }

        return accessors;
    }
236249
public List<ElementType<AnnotationType<T>>> getAllElement()
   {
      List<ElementType<AnnotationType<T>>> list = new ArrayList<ElementType<AnnotationType<T>>>();
      List<Node> nodeList = childNode.get("element");
      for(Node node: nodeList)
      {
         ElementType<AnnotationType<T>>  type = new ElementTypeImpl<AnnotationType<T>>(this, "element", childNode, node);
         list.add(type);
      }
      return list;
   }
412618
public List<FacesConfigManagedPropertyType<FacesConfigManagedBeanType<T>>> getAllManagedProperty()
   {
      List<FacesConfigManagedPropertyType<FacesConfigManagedBeanType<T>>> list = new ArrayList<FacesConfigManagedPropertyType<FacesConfigManagedBeanType<T>>>();
      List<Node> nodeList = childNode.get("managed-property");
      for(Node node: nodeList)
      {
         FacesConfigManagedPropertyType<FacesConfigManagedBeanType<T>>  type = new FacesConfigManagedPropertyTypeImpl<FacesConfigManagedBeanType<T>>(this, "managed-property", childNode, node);
         list.add(type);
      }
      return list;
   }
143318
@Override
    public Map<K, V> clearAll() {
        Map<K, V> result = new LinkedHashMap<K, V>(map.size());

        for (Map.Entry<K, V> entry : map.entrySet()) {
            K key = entry.getKey();
            V value = entry.getValue();

            boolean removed = map.remove(key, value);

            if (removed) {
                result.put(key, value);
            }
        }

        return result;
    }
1186601
public org.inferred.freebuilder.processor.property.Property.Builder setGetterName(
      String getterName) {
    this.getterName = Objects.requireNonNull(getterName);
    _unsetProperties.remove(Property.GETTER_NAME);
    return (org.inferred.freebuilder.processor.property.Property.Builder) this;
  }
922521
public Datatype.Builder clear() {
    Datatype_Builder defaults = new Datatype.Builder();
    type = defaults.type;
    interfaceType = defaults.interfaceType;
    builder = defaults.builder;
    extensible = defaults.extensible;
    builderFactory = defaults.builderFactory;
    generatedBuilder = defaults.generatedBuilder;
    valueType = defaults.valueType;
    partialType = defaults.partialType;
    rebuildableType = defaults.rebuildableType;
    propertyEnum = defaults.propertyEnum;
    standardMethodUnderrides.clear();
    builderSerializable = defaults.builderSerializable;
    hasToBuilderMethod = defaults.hasToBuilderMethod;
    clearGeneratedBuilderAnnotations();
    clearValueTypeAnnotations();
    valueTypeVisibility = defaults.valueTypeVisibility;
    clearNestedClasses();
    _unsetProperties.clear();
    _unsetProperties.addAll(defaults._unsetProperties);
    return (Datatype.Builder) this;
  }
889198
public Collection<AnnotatedMethod> getMethods() {
        for (Method method : type.getDeclaredMethods()) {
            // only consider methods which have been explicitly declared in the
            // interface
            if (!method.isSynthetic()) {
                Class<?> returnType = method.getReturnType();
                Type genericReturnType = method.getGenericReturnType();
                Class<?>[] parameterTypes = method.getParameterTypes();
                Type[] genericParameterTypes = method.getGenericParameterTypes();
                if (PropertyMethod.GET.matches(method)) {
                    String name = PropertyMethod.GET.getName(method);
                    getters.put(name, method);
                    addType(type, name, returnType, genericReturnType);
                } else if (PropertyMethod.IS.matches(method)) {
                    String name = PropertyMethod.IS.getName(method);
                    getters.put(name, method);
                    addType(type, name, returnType, genericReturnType);
                } else if (PropertyMethod.SET.matches(method)) {
                    String name = PropertyMethod.SET.getName(method);
                    setters.put(name, method);
                    addType(type, name, parameterTypes[0], genericParameterTypes[0]);
                } else {
                    methods.add(method);
                }
            }
        }
        List<AnnotatedMethod> typeMethods = new ArrayList<>();
        Map<String, GetPropertyMethod> getPropertyMethods = new HashMap<>();
        for (Map.Entry<String, Method> methodEntry : getters.entrySet()) {
            String name = methodEntry.getKey();
            Method getter = methodEntry.getValue();
            Class<?> propertyType = types.get(name);
            Type genericType = genericTypes.get(name);
            GetPropertyMethod getPropertyMethod = new GetPropertyMethod(getter, name, propertyType, genericType);
            typeMethods.add(getPropertyMethod);
            getPropertyMethods.put(name, getPropertyMethod);
        }
        for (Map.Entry<String, Method> methodEntry : setters.entrySet()) {
            String name = methodEntry.getKey();
            Method setter = methodEntry.getValue();
            GetPropertyMethod getPropertyMethod = getPropertyMethods.get(name);
            Class<?> propertyType = types.get(name);
            Type genericType = genericTypes.get(name);
            SetPropertyMethod setPropertyMethod = new SetPropertyMethod(setter, getPropertyMethod, name, propertyType, genericType);
            typeMethods.add(setPropertyMethod);
        }
        for (Method method : methods) {
            typeMethods.add(new UserMethod(method));
        }
        return typeMethods;
    }