{@inheritDoc}

@throws SuperCsvCellProcessorException
if value is null
8970
public Object execute(final Object value, final CsvContext context) {
		if (value == null){
			throw new SuperCsvConstraintViolationException("null value encountered", context, this);
		}
		return next.execute(value, context);
	}
27745
@Override
	protected String initValuesImpl(final FieldCase ca) {
		if (ca == FieldCase.NULL || ca == FieldCase.BLANK) {
			return null;
		}
		return field.getString(control.getNext(ca));
	}
143600
public Object execute(final Object value, final CsvContext context) {
		validateInputNotNull(value, context);
		if (!(value instanceof Duration)) {
			throw new SuperCsvCellProcessorException(Duration.class, value,
					context, this);
		}
		final Duration duration = (Duration) value;
		final String result = duration.toString();
		return next.execute(result, context);
	}
1105397
@Override
    public String convertTo(final Object value) {
        if (value == null) return "null";
        return convertTo(value.getClass(), value);
    }
398966
public static <T> T checkNotNull(T value) throws NullPointerException {
    if (value == null) {
      throw new NullPointerException();
    }
    return value;
  }
746340
public static void checkNotNull(Object value, String message, Object... args) {
    if (value == null) {
      throw new NullPointerException(String.format(message, args));
    }
  }
230646
@SuppressWarnings("unchecked")
	public <T extends RepresentationModel<T>> T invokeProcessorsFor(T value, ResolvableType referenceType) {

		Assert.notNull(value, "Value must not be null!");
		Assert.notNull(referenceType, "Reference type must not be null!");

		// For Resources implementations, process elements first
		if (RepresentationModelProcessorHandlerMethodReturnValueHandler.COLLECTION_MODEL_TYPE
				.isAssignableFrom(referenceType)) {

			CollectionModel<?> collectionModel = (CollectionModel<?>) value;
			Class<?> rawClass = referenceType.getRawClass();

			if (rawClass == null) {
				throw new IllegalArgumentException(String.format("%s does not expose a raw type!", referenceType));
			}

			ResolvableType elementTargetType = ResolvableType.forClass(CollectionModel.class, rawClass).getGeneric(0);
			List<Object> result = new ArrayList<>(collectionModel.getContent().size());

			for (Object element : collectionModel) {

				ResolvableType elementType = ResolvableType.forClass(element.getClass());

				if (!getRawType(elementTargetType).equals(elementType.getRawClass())) {
					elementTargetType = elementType;
				}

				result.add(invokeProcessorsFor(element, elementTargetType));
			}

			if (RepresentationModelProcessorHandlerMethodReturnValueHandler.CONTENT_FIELD != null) {

				ReflectionUtils.setField( //
						RepresentationModelProcessorHandlerMethodReturnValueHandler.CONTENT_FIELD, //
						collectionModel, //
						result //
				);
			}
		}

		return (T) invokeProcessorsFor((Object) value, referenceType);
	}
1081345
@Override
    public byte[] convertTo(final Object value) {
        if (value == null) {
            final BsonWriter out = writerPool.get().tiny(tiny);
            out.writeNull();
            byte[] result = out.toArray();
            writerPool.accept(out);
            return result;
        }
        return convertTo(value.getClass(), value);
    }
575677
public Object execute(final Object value, final CsvContext context) {
		validateInputNotNull(value, context);
		
		int hash = value.hashCode();
		if( !uniqueSet.add(hash) ) {
			throw new SuperCsvConstraintViolationException(
				String.format("duplicate value '%s' encountered with hashcode %d", value, hash), context, this);
		}
		
		return next.execute(value, context);
	}
454210
public Object execute(final Object value, final CsvContext context) {
		validateInputNotNull(value, context);
		
		if( !possibleValues.contains(value) ) {
			throw new SuperCsvConstraintViolationException(String.format(
				"'%s' is not included in the allowed set of values", value), context, this);
		}
		
		return next.execute(value, context);
	}
231799
@Override
    public void setValue(Object value) {
        super.setValue(value);
        if (parent != null) {
            Object parentValue = parent.getValue();
            if (parentValue != null) {
                writeToObject(parentValue);
                parent.setValue(parentValue);
            }
        }
        if (value != null) {
            for (Property subProperty : subProperties) {
                subProperty.readFromObject(value);
            }
        }
    }
1114136
public Object execute(final Object value, final CsvContext context) {
		validateInputNotNull(value, context);
		
		int hash = value.hashCode();
		if( !requiredHashCodes.contains(hash) ) {
			throw new SuperCsvConstraintViolationException(String.format(
				"the hashcode of %d for value '%s' does not match any of the required hashcodes", hash, value),
				context, this);
		}
		
		return next.execute(value, context);
	}
947160
static void validateHeaderValue(CharSequence value) {
        if (value == null) {
            throw new NullPointerException("value");
        }
        for (int i = 0; i < value.length(); i ++) {
            char c = value.charAt(i);
            if (c == 0) {
                throw new IllegalArgumentException(
                        "value contains null character: " + value);
            }
        }
    }
617515
public static void checkNotEmpty(@Nullable String value, @NonNull String message) {
        if (value == null) {
            throw new NullPointerException(message);
        } else if (value.length() == 0) {
            throw new IllegalStateException(message);
        }
    }
1270140
public Object execute(final Object value, final CsvContext context) {
		validateInputNotNull(value, context);
		
		final String result = value.toString().trim();
		return next.execute(result, context);
	}
743732
protected final @Nullable V copyValue(@Nullable Expirable<V> expirable) {
    if (expirable == null) {
      return null;
    }
    V copy = copier.copy(expirable.get(), cacheManager.getClassLoader());
    return requireNonNull(copy);
  }
883978
@Override public Object transform(Object value) {
        if (value == null) {
            return value;
        } else if (value instanceof Boolean) {
            return value;
        } else if (value instanceof String) {
            return value;
        } else if (value instanceof Number) {
            return InternalUtils.toBigDecimal((Number)value);
        } else if (value instanceof byte[]) {
            return value;
        } else if (value instanceof ByteBuffer) {
            return copyBytesFrom((ByteBuffer)value);
        } else if (value instanceof Set) {
            @SuppressWarnings("unchecked")
            Set<Object> set = (Set<Object>) value;
            if (set.size() == 0)
                return value;
            Object element = set.iterator().next();
            if (element instanceof String) {
                return value;
            } else if (element instanceof BigDecimal) {
                return value;
            } else if (element instanceof Number) {
                @SuppressWarnings("unchecked")
                Set<Number> in = (Set<Number>) value;
                Set<BigDecimal> out = new LinkedHashSet<BigDecimal>(set.size());
                for (Number n : in)
                    out.add(InternalUtils.toBigDecimal(n));
                return out;
            } else if (element instanceof byte[]) {
                return value;
            } else if (element instanceof ByteBuffer) {
                @SuppressWarnings("unchecked")
                Set<ByteBuffer> bs = (Set<ByteBuffer>) value;
                Set<byte[]> out = new LinkedHashSet<byte[]>(bs.size());
                for (ByteBuffer bb: bs)
                    out.add(copyBytesFrom(bb));
                return out;
            } else {
                throw new UnsupportedOperationException("element type: "
                        + element.getClass());
            }
        } else if (value instanceof List) {
            @SuppressWarnings("unchecked")
            List<Object> in = (List<Object>) value;
            if (in.size() == 0)
                return in;
            List<Object> out = new ArrayList<Object>();
            for (Object v : in)
                out.add(transform(v));
            return out;
        } else if (value instanceof Map) {
            @SuppressWarnings("unchecked")
            Map<String, Object> in = (Map<String, Object>) value;
            if (in.size() == 0)
                return in;
            Map<String, Object> out = new LinkedHashMap<String, Object>(in.size());
            for (Map.Entry<String, Object> e : in.entrySet())
                out.put(e.getKey(), transform(e.getValue()));
            return out;
        } else {
            throw new UnsupportedOperationException("value type: "
                    + value.getClass());
        }
    }