Ejemplo n.º 1
0
  /** Computes the byte offset to store this field at, when serializing it to a Slice */
  private static int offsetOfField(StateField targetField, List<StateField> fields) {
    int offset = 0;
    for (StateField field : fields) {
      if (targetField.getName().equals(field.getName())) {
        break;
      }
      offset += field.sizeOfType();
    }

    return offset;
  }
Ejemplo n.º 2
0
  private static void generateField(
      ClassDefinition definition, Block constructor, StateField stateField) {
    FieldDefinition field =
        definition.declareField(
            a(PRIVATE),
            UPPER_CAMEL.to(LOWER_CAMEL, stateField.getName()) + "Value",
            stateField.getType());

    // Generate getter
    definition
        .declareMethod(a(PUBLIC), stateField.getGetterName(), type(stateField.getType()))
        .getBody()
        .pushThis()
        .getField(field)
        .ret(stateField.getType());

    // Generate setter
    definition
        .declareMethod(
            a(PUBLIC),
            stateField.getSetterName(),
            type(void.class),
            arg("value", stateField.getType()))
        .getBody()
        .pushThis()
        .getVariable("value")
        .putField(field)
        .ret();

    constructor.pushThis();
    pushInitialValue(constructor, stateField);
    constructor.putField(field);
  }
Ejemplo n.º 3
0
  private static FieldDefinition generateGroupedField(
      ClassDefinition definition, Block constructor, Block ensureCapacity, StateField stateField) {
    Class<?> bigArrayType = getBigArrayType(stateField.getType());
    FieldDefinition field =
        definition.declareField(
            a(PRIVATE), UPPER_CAMEL.to(LOWER_CAMEL, stateField.getName()) + "Values", bigArrayType);

    // Generate getter
    definition
        .declareMethod(a(PUBLIC), stateField.getGetterName(), type(stateField.getType()))
        .getBody()
        .comment("return field.get(getGroupId());")
        .pushThis()
        .getField(field)
        .pushThis()
        .invokeVirtual(AbstractGroupedAccumulatorState.class, "getGroupId", long.class)
        .invokeVirtual(bigArrayType, "get", stateField.getType(), long.class)
        .ret(stateField.getType());

    // Generate setter
    definition
        .declareMethod(
            a(PUBLIC),
            stateField.getSetterName(),
            type(void.class),
            arg("value", stateField.getType()))
        .getBody()
        .comment("return field.set(getGroupId(), value);")
        .pushThis()
        .getField(field)
        .pushThis()
        .invokeVirtual(AbstractGroupedAccumulatorState.class, "getGroupId", long.class)
        .getVariable("value")
        .invokeVirtual(bigArrayType, "set", void.class, long.class, stateField.getType())
        .ret();

    ensureCapacity
        .pushThis()
        .getField(field)
        .getVariable("size")
        .invokeVirtual(field.getType(), "ensureCapacity", type(void.class), type(long.class));

    // Initialize field in constructor
    constructor.pushThis().newObject(field.getType()).dup();
    pushInitialValue(constructor, stateField);
    constructor.invokeConstructor(field.getType(), type(stateField.getType()));
    constructor.putField(field);

    return field;
  }
Ejemplo n.º 4
0
  private static void checkInterface(Class<?> clazz, List<StateField> fields) {
    checkArgument(clazz.isInterface(), clazz.getName() + " is not an interface");
    Set<String> setters = new HashSet<>();
    Set<String> getters = new HashSet<>();
    Set<String> isGetters = new HashSet<>();

    Map<String, Class<?>> fieldTypes = new HashMap<>();
    for (StateField field : fields) {
      fieldTypes.put(field.getName(), field.getType());
    }

    for (Method method : clazz.getMethods()) {
      if (method.getName().equals("getEstimatedSize")) {
        checkArgument(
            method.getReturnType().equals(long.class), "getEstimatedSize must return long");
        checkArgument(
            method.getParameterTypes().length == 0, "getEstimatedSize may not have parameters");
        continue;
      }

      if (method.getName().startsWith("get")) {
        String name = method.getName().substring(3);
        checkArgument(
            fieldTypes.get(name).equals(method.getReturnType()),
            "Expected %s to return type %s, but found %s",
            method.getName(),
            fieldTypes.get(name),
            method.getReturnType());
        checkArgument(
            method.getParameterTypes().length == 0,
            "Expected %s to have zero parameters",
            method.getName());
        getters.add(name);
      } else if (method.getName().startsWith("is")) {
        String name = method.getName().substring(2);
        checkArgument(
            fieldTypes.get(name) == boolean.class,
            "Expected %s to have type boolean, but found %s",
            name,
            fieldTypes.get(name));
        checkArgument(
            method.getParameterTypes().length == 0,
            "Expected %s to have zero parameters",
            method.getName());
        checkArgument(
            method.getReturnType() == boolean.class,
            "Expected %s to return boolean",
            method.getName());
        isGetters.add(name);
      } else if (method.getName().startsWith("set")) {
        String name = method.getName().substring(3);
        checkArgument(
            method.getParameterTypes().length == 1, "Expected setter to have one parameter");
        checkArgument(
            fieldTypes.get(name).equals(method.getParameterTypes()[0]),
            "Expected %s to accept type %s, but found %s",
            method.getName(),
            fieldTypes.get(name),
            method.getParameterTypes()[0]);
        checkArgument(
            getInitialValue(method) == null, "initial value annotation not allowed on setter");
        checkArgument(
            method.getReturnType().equals(void.class),
            "%s may not return a value",
            method.getName());
        setters.add(name);
      } else {
        throw new IllegalArgumentException(
            "Cannot generate implementation for method: " + method.getName());
      }
    }
    checkArgument(
        getters.size() + isGetters.size() == setters.size() && setters.size() == fields.size(),
        "Wrong number of getters/setters");
  }