import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
private Value(@AutoMatter.Field("field1") T1 field1, @AutoMatter.Field("field2") T2 field2, @AutoMatter.Field("field3") T3 field3, @AutoMatter.Field("field4") T4 field4, @AutoMatter.Field("plain") String plain) {
  if (field1 == null) {
    throw new NullPointerException("field1");
  }
  if (field2 == null) {
    throw new NullPointerException("field2");
  }
  if (field3 == null) {
    throw new NullPointerException("field3");
  }
  if (field4 == null) {
    throw new NullPointerException("field4");
  }
  if (plain == null) {
    throw new NullPointerException("plain");
  }
  this.field1 = field1;
  this.field2 = field2;
  this.field3 = field3;
  this.field4 = field4;
  this.plain = plain;
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
private MethodSpec valueGetter(final Descriptor d, final ExecutableElement field) throws AutoMatterProcessorException {
  String fieldName = fieldName(field);

  return MethodSpec.methodBuilder(fieldName)
      .addAnnotation(AutoMatter.Field.class)
      .addAnnotation(Override.class)
      .addModifiers(PUBLIC)
      .returns(fieldType(d, field))
      .addStatement("return $N", fieldName)
      .build();
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
private Value(@AutoMatter.Field("foo") Optional<String> foo,
              @AutoMatter.Field("bar") Optional<String> bar) {
  if (foo == null) {
    throw new NullPointerException("foo");
  }
  this.foo = foo;
  this.bar = bar;
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
private Value(@AutoMatter.Field("foo") Optional<T> foo, @AutoMatter.Field("bar") Optional<T> bar) {
  if (foo == null) {
    throw new NullPointerException("foo");
  }
  this.foo = foo;
  this.bar = bar;
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
private Value(@AutoMatter.Field("foo") String foo, @AutoMatter.Field("bar") Integer bar, @AutoMatter.Field("baz") int baz) {
  if (foo == null) {
    throw new NullPointerException("foo");
  }
  if (bar == null) {
    throw new NullPointerException("bar");
  }
  this.foo = foo;
  this.bar = bar;
  this.baz = baz;
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
private Value(@AutoMatter.Field("foo") String foo, @AutoMatter.Field("bar") T bar, @AutoMatter.Field("baz") int baz) {
  if (foo == null) {
    throw new NullPointerException("foo");
  }
  if (bar == null) {
    throw new NullPointerException("bar");
  }
  this.foo = foo;
  this.bar = bar;
  this.baz = baz;
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
private Value(
    @AutoMatter.Field("aBoolean") boolean aBoolean,
    @AutoMatter.Field("aByte") byte aByte,
    @AutoMatter.Field("aShort") short aShort,
    @AutoMatter.Field("aInt") int aInt,
    @AutoMatter.Field("aLong") long aLong,
    @AutoMatter.Field("aChar") char aChar,
    @AutoMatter.Field("aFloat") float aFloat,
    @AutoMatter.Field("aDouble") double aDouble,
    @AutoMatter.Field("object") Object object,
    @AutoMatter.Field("array") Object[] array
) {
  if (object == null) {
    throw new NullPointerException("object");
  }
  if (array == null) {
    throw new NullPointerException("array");
  }
  this.aBoolean = aBoolean;
  this.aByte = aByte;
  this.aShort = aShort;
  this.aInt = aInt;
  this.aLong = aLong;
  this.aChar = aChar;
  this.aFloat = aFloat;
  this.aDouble = aDouble;
  this.object = object;
  this.array = array;
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
private Value(@AutoMatter.Field("strings") List<String> strings,
              @AutoMatter.Field("integers") Map<String,Integer> integers,
              @AutoMatter.Field("numbers") Set<Long> numbers) {
  this.strings = strings;
  this.integers = integers;
  this.numbers = numbers;
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
private Value(@AutoMatter.Field("strings") List<String> strings,
              @AutoMatter.Field("integers") Map<String,Integer> integers,
              @AutoMatter.Field("numbers") Set<Long> numbers) {
  this.strings = (strings != null) ? strings : Collections.<String>emptyList();
  this.integers = (integers != null) ? integers : Collections.<String,Integer>emptyMap();
  this.numbers = (numbers != null) ? numbers : Collections.<Long>emptySet();
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
private Value(
    @AutoMatter.Field("nullableFoo") String nullableFoo,
    @AutoMatter.Field("customNullableBar") String customNullableBar,
    @AutoMatter.Field("nonNullQuux") String nonNullQuux,
    @AutoMatter.Field("nonNullPrimitive") int nonNullPrimitive
) {
  if (nonNullQuux == null) {
    throw new NullPointerException("nonNullQuux");
  }
  this.nullableFoo = nullableFoo;
  this.customNullableBar = customNullableBar;
  this.nonNullQuux = nonNullQuux;
  this.nonNullPrimitive = nonNullPrimitive;
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
@Override
public String findImplicitPropertyName(final AnnotatedMember member) {
  final AutoMatter.Field field = member.getAnnotation(AutoMatter.Field.class);
  if (field == null) {
    return null;
  }
  if (member instanceof AnnotatedParameter) {
    return field.value();
  }
  if (member instanceof AnnotatedMethod) {
    return member.getName();
  }
  return null;
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
@Override
public boolean hasCreatorAnnotation(final Annotated a) {
  if (!(a instanceof AnnotatedConstructor)) {
    return false;
  }
  final AnnotatedConstructor ctor = (AnnotatedConstructor) a;
  if (ctor.getParameterCount() == 0) {
    return true;
  }
  final AutoMatter.Field field = ctor.getParameter(0).getAnnotation(AutoMatter.Field.class);
  return field != null;
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
private JavaType resolveAbstractType0(final DeserializationConfig config, final Class<?> rawClass) {
  final AutoMatter annotation = rawClass.getAnnotation(AutoMatter.class);
  if (annotation == null) {
    // This was not an @AutoMatter type.
    return null;
  }

  // Return the cached type, if present.
  final JavaType cached = types.get(rawClass);
  if (cached != null) {
    return cached;
  }

  // Look up and instantiate the value class
  final String packageName = rawClass.getPackage().getName();
  final String name = rawClass.getSimpleName();
  final String valueName = packageName + '.' + name + VALUE_SUFFIX;
  final Class<?> cls;
  try {
    cls = Class.forName(valueName);
  } catch (ClassNotFoundException e) {
    throw new IllegalArgumentException("No builder found for @AutoMatter type: " + name, e);
  }
  final JavaType materialized = config.getTypeFactory().constructType(cls);

  // Cache the materialized type before returning
  final JavaType existing = types.putIfAbsent(rawClass, materialized);
  return (existing != null) ? existing : materialized;
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
@Override
public Set<String> getSupportedAnnotationTypes() {
  return ImmutableSet.of(AutoMatter.class.getName());
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
@AutoMatter.Field
@Override
public Optional<String> foo() {
  return foo;
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
@AutoMatter.Field
@Override
public Optional<String> bar() {
  return bar;
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
@AutoMatter.Field
@Override
public Optional<T> foo() {
  return foo;
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
@AutoMatter.Field
@Override
public Optional<T> bar() {
  return bar;
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
@AutoMatter.Field
@Override
public String foo() {
  return foo;
}
 

import io.norberg.automatter.AutoMatter; //导入依赖的package包/类
@AutoMatter.Field
@Override
public Integer bar() {
  return bar;
}