docs: private static boolean setValueForProperty(final Property property, final Object value, final Object object) {
          final Field field = fieldForPropertyName(property.getName(), object);
          if (null == field) {
              return false;
          }
          final Property.Type type = property.getType();
          final Property.Type ftype = propertyTypeFromFieldType(field.getType());
          if (ftype != property.getType()
                  && !(ftype == Property.Type.String
                       && (property.getType() == Property.Type.Select ||
                           property.getType() == Property.Type.FreeSelect ||
                           property.getType() == Property.Type.Options))) {
  
              throw new IllegalStateException(
                      String.format(
                              "cannot map property {%s type: %s} to field {%s type: %s}",
                              property.getName(),
                              property.getType(),
                              field.getName(),
                              ftype
                      ));
          }
          final Object resolvedValue;
          if (type == Property.Type.Integer) {
              final Integer intvalue;
              if (value instanceof String) {
                  intvalue = Integer.parseInt((String) value);
              } else if (value instanceof Integer) {
                  intvalue = (Integer) value;
              } else {
                  //XXX
                  return false;
              }
              resolvedValue = intvalue;
          } else if (type == Property.Type.Long) {
              final Long longvalue;
              if (value instanceof String) {
                  longvalue = Long.parseLong((String) value);
              } else if (value instanceof Long) {
                  longvalue = (Long) value;
              } else if (value instanceof Integer) {
                  final int val = (Integer) value;
                  longvalue = (long) val;
              } else {
                  //XXX
                  return false;
              }
              resolvedValue = longvalue;
          } else if (type == Property.Type.Boolean) {
              final Boolean boolvalue;
              if (value instanceof String) {
                  boolvalue = Boolean.parseBoolean((String) value);
              } else if (value instanceof Boolean) {
                  boolvalue = (Boolean) value;
              } else {
                  //XXX
                  return false;
              }
              resolvedValue = boolvalue;
          } else if (type == Property.Type.Options) {
              final List<String> splitList;
              if (value instanceof String) {
                  String valstring = (String) value;
                  splitList = Arrays.asList(valstring.split(", *"));
              } else if (value instanceof List) {
                  splitList = (List<String>) value;
              } else if (value instanceof Set) {
                  splitList = new ArrayList<>((Set) value);
              } else if (value.getClass() == String[].class) {
                  splitList = Arrays.asList((String[]) value);
              } else {
                  return false;
              }
              Set<String> resolvedValueSet = null;
              //not a String field
              if (field.getType().isAssignableFrom(Set.class)) {
                  HashSet<String> strings = new HashSet<>();
                  strings.addAll(splitList);
                  resolvedValueSet = strings;
                  resolvedValue = strings;
              } else if (field.getType().isAssignableFrom(List.class)) {
                  ArrayList<String> strings = new ArrayList<>();
                  strings.addAll(splitList);
                  resolvedValueSet = new HashSet<>(strings);
                  resolvedValue = strings;
              } else if (field.getType() == String[].class) {
                  ArrayList<String> strings = new ArrayList<>();
                  strings.addAll(splitList);
                  resolvedValueSet = new HashSet<>(strings);
                  resolvedValue = strings.toArray(new String[strings.size()]);
              } else if (field.getType() == String.class) {
                  resolvedValueSet = new HashSet<>();
                  resolvedValueSet.addAll(splitList);
                  resolvedValue = value;
              } else {
                  return false;
              }
              if (property.getSelectValues() != null && !property.getSelectValues().containsAll(resolvedValueSet)) {
                  throw new RuntimeException(String.format(
                          "Some options values were not allowed for property %s: %s",
                          property.getName(),
                          resolvedValue
                  ));
              }
  
          } else if (type == Property.Type.String || type == Property.Type.FreeSelect) {
              if (value instanceof String) {
                  resolvedValue = value;
              } else {
                  //XXX
                  return false;
              }
          } else if (type == Property.Type.Select) {
              if (value instanceof String) {
                  resolvedValue = value;
                  if (!field.getAnnotation(SelectValues.class).dynamicValues() && !property.getSelectValues().contains((String) resolvedValue)) {
                      throw new RuntimeException(
                              "value not allowed for property " + property.getName() + ": " + resolvedValue);
                  }
              } else {
                  //XXX
                  return false;
              }
          } else {
              //XXX
              return false;
          }
          try {
              setFieldValue(field, resolvedValue, object);
          } catch (IllegalAccessException e) {
              throw new RuntimeException("Unable to configure plugin: " + e.getMessage(), e);
          }
          return true;
      }