code: protected void lookupSetters(final Map<String, Property> properties,
              final MethodHolder<?> clazz)
     {
        for (Method<?, ?> method : clazz.getMethods())
        {
           // Exclude static methods
  
           if (method.isStatic())
           {
              continue;
           }
  
           // Exclude non-public methods. Section 8.3.1 of the JavaBean specification requires that setters be public.
           if (!method.isPublic())
           {
              continue;
           }
  
           // Get type
  
           List<? extends Parameter<?>> parameters = method.getParameters();
  
           if (parameters.size() != 1)
           {
              continue;
           }
  
           // Get name
  
           String propertyName = isSetter(method);
  
           if (propertyName == null)
           {
              continue;
           }
  
           // Exclude based on other criteria
           //
           // (explicitly set to null in case we encountered an imbalanced field/getter)
  
           String type = parameters.get(0).getType().getQualifiedName();
  
           Field<?> privateField = getPrivateField((FieldHolder<?>) clazz, propertyName);
  
           if (privateField != null && this.privateFieldConvention == null)
           {
              propertyName = privateField.getName();
           }
  
           // Already found via its getter?
  
           Property existingProperty = properties.get(propertyName);
  
           if (existingProperty instanceof ForgeProperty)
           {
              ForgeProperty existingForgeProperty = (ForgeProperty) existingProperty;
  
              // Beware covariant return types: always prefer the getter's type
  
              properties.put(
                       propertyName,
                       new ForgeProperty(propertyName, existingForgeProperty.getType(),
                                existingForgeProperty.getReadMethod(), method, getPrivateField((FieldHolder<?>) clazz,
                                         propertyName), this.project));
              continue;
           }
  
           // Explicitly excluded based on getter already?
  
           if ((existingProperty == null) && properties.containsKey(propertyName))
           {
              continue;
           }
  
           properties
                    .put(propertyName,
                             new ForgeProperty(propertyName, type, null, method, privateField, this.project));
        }
     }
docs: Lookup setter-based properties.
  <p>
  This method will be called after <code>lookupFields</code> and <code>lookupGetters</code>.