Java Fields类代码示例

import com.redhat.lightblue.metadata.Fields; //导入依赖的package包/类
@Test
public void shouldGenerateArrayFieldTypesForSimpleArrayElements() {
  class HasArray {
    public List<String> getFoobars() {
      return Arrays.asList("foo", "bars");
    }

    public void setFoobars(List<String> foobars) {

    }
  }

  EntitySchema expectedSchema = new EntitySchema("hasArray");
  ArrayField expectedArrayField = new ArrayField("foobars", new SimpleArrayElement(StringType.TYPE));
  Fields expectedFields = expectedSchema.getFields();
  expectedFields.addNew(expectedArrayField);

  EntitySchema schema = generator.generateSchema(HasArray.class);

  assertThat(schema.getFields(), equalToFields(expectedFields));
}
 

import com.redhat.lightblue.metadata.Fields; //导入依赖的package包/类
@Override
protected boolean matchesSafely(Fields item, Description mismatchDescription) {
  boolean matches = true;

  List<Matcher<? super Field>> matchingAllFields = Arrays
      .stream(Iterables.toArray(fields::getFields, Field.class))
      .map(EqualToField::new)
      .collect(Collectors.toList());

  Matcher matcher = Matchers.containsInAnyOrder(matchingAllFields);
  if (!matcher.matches((Iterable) item::getFields)) {
    matches = false;
    matcher.describeMismatch(item, mismatchDescription);
  }

  return matches;
}
 

import com.redhat.lightblue.metadata.Fields; //导入依赖的package包/类
/**
 * Adds the <code>newField</cod> to the <code>newFieldPath</code>.
 * @param md - {@link EntityMetadata}
 * @param newFieldPath - {@link Path} to add
 * @param newField - {@link Field} to add at the <code>newFieldPath</code>
 */
private void addFieldToParent(EntityMetadata md, Path newFieldPath, Field newField){
    Fields fields;

    if(newFieldPath.numSegments() == 1){
        fields = md.getFields();
    }
    else{
        Path parentPath = newFieldPath.prefix(-1);
        FieldTreeNode parent = md.resolve(parentPath);

        if(parent instanceof ObjectField){
            fields = ((ObjectField) parent).getFields();
        }
        else if (parent instanceof ObjectArrayElement){
            fields = ((ObjectArrayElement) parent).getFields();
        }
        else {
            throw Error.get(MetadataConstants.ERR_FIELD_WRONG_TYPE, parentPath.toString());
        }
    }
    fields.addNew(newField);
}
 

import com.redhat.lightblue.metadata.Fields; //导入依赖的package包/类
/**
 * The fields that were defined should remain.
 */
@Test
public void testBeforeCreateNewSchema_alreadyHasDefinedDnAndObjectClass(){
    EntityMetadata md = new EntityMetadata("fake");
    setupEntityMetadata(md);
    Fields fields = md.getEntitySchema().getFields();

    SimpleField dnField = new SimpleField(LdapConstant.ATTRIBUTE_DN, StringType.TYPE);
    fields.addNew(dnField);
    ArrayField objectClassField = new ArrayField(LdapConstant.ATTRIBUTE_OBJECT_CLASS, new SimpleArrayElement(StringType.TYPE));
    fields.addNew(objectClassField);
    SimpleField objectClassCountField = new SimpleField(LdapConstant.ATTRIBUTE_OBJECT_CLASS + "#", IntegerType.TYPE);
    fields.addNew(objectClassCountField);

    LdapMetadataListener listener = new LdapMetadataListener();
    listener.beforeCreateNewSchema(null, md);

    assertTrue(md.getFields().has(LdapConstant.ATTRIBUTE_DN));
    assertTrue(md.getFields().has(LdapConstant.ATTRIBUTE_OBJECT_CLASS));
    assertTrue(md.getFields().has(LdapConstant.ATTRIBUTE_OBJECT_CLASS + "#"));

    assertEquals(dnField, md.getFields().getField(LdapConstant.ATTRIBUTE_DN));
    assertEquals(objectClassField, md.getFields().getField(LdapConstant.ATTRIBUTE_OBJECT_CLASS));
    assertEquals(objectClassCountField, md.getFields().getField(LdapConstant.ATTRIBUTE_OBJECT_CLASS + "#"));
}
 

import com.redhat.lightblue.metadata.Fields; //导入依赖的package包/类
@Override
ObjectNode translateToObjectNode(Object value, FieldCursor cursor) {
    FieldTreeNode field = cursor.getCurrentNode();

    //Store the current fields so that they can be put back after this operation is complete.
    Fields storeFieldsUntilLater = currentFields;
    if (field instanceof ObjectField) {
        currentFields = ((ObjectField) field).getFields();
    }
    else if (field instanceof ObjectArrayElement) {
        currentFields = ((ObjectArrayElement) field).getFields();
    }
    else {
        throw new IllegalArgumentException("Only Object Field/Element types are supported: " + field.getClass());
    }

    ObjectNode node = super.translateToObjectNode(value, cursor);

    currentFields = storeFieldsUntilLater;

    return node;
}
 

import com.redhat.lightblue.metadata.Fields; //导入依赖的package包/类
@Override
protected void translate(JsonNodeCursor cursor, Object target) {
    Path path = cursor.getCurrentPath();
    FieldTreeNode fieldNode = entityMetadata.resolve(path);
    if(fieldNode instanceof Field){
        String fieldName = ((Field) fieldNode).getName();

        Fields fields = entityMetadata.getFields();
        if(fieldNode instanceof ObjectField){
            fields = ((ObjectField) fieldNode).getFields();
        }

        if(PredefinedFields.isPredefinedField(fieldName, fields)){
            /*
             * Indicates the field is auto-generated for lightblue purposes. These fields
             * should not be inserted into the data store.
             */
            return;
        }
    }

    super.translate(cursor, target);
}
 

import com.redhat.lightblue.metadata.Fields; //导入依赖的package包/类
private void addFieldsFromBeanMirror(BeanMirror beanMirror, Fields fields,
    Optional<Fields> maybeOriginal) {
  for (FieldMirror fieldMirror : beanMirror.getFields()) {
    String name = fieldMirror.name();
    Optional<Field> maybeOriginalField = maybeOriginal.map(o -> o.getField(name));

    Field field = getFieldFromFieldMirror(fieldMirror, maybeOriginalField);
    field.setConstraints(getConstraintsForBeanField(fieldMirror));
    fieldMirror.description().ifPresent(field::setDescription);

    if (field instanceof SimpleField) {
      SimpleField simpleField = (SimpleField) field;
      getValueGeneratorForBeanField(fieldMirror).ifPresent(simpleField::setValueGenerator);
    }

    maybeOriginalField.ifPresent(original -> {
      FieldAccess access = field.getAccess();
      FieldAccess originalAccess = original.getAccess();

      access.getFind().setRoles(originalAccess.getFind());
      access.getInsert().setRoles(originalAccess.getInsert());
      access.getUpdate().setRoles(originalAccess.getUpdate());
    });

    fields.addNew(field);
  }
}
 

import com.redhat.lightblue.metadata.Fields; //导入依赖的package包/类
@Test
public void shouldGenerateObjectFieldTypes() {
  class HasInnerObject {
    public InnerObject getInnerObject() {
      return new InnerObject();
    }

    public void setInnerObject(InnerObject innerObject) {

    }

    class InnerObject {
      public String getFoo() {
        return "foo";
      }

      public void setFoo(String foo) {
      }
    }
  }

  EntitySchema expectedSchema = new EntitySchema("hasInnerObject");
  Fields expectedFields = expectedSchema.getFields();
  ObjectField expectedObjectField = new ObjectField("innerObject");
  expectedObjectField.getFields().addNew(new SimpleField("foo", StringType.TYPE));
  expectedFields.addNew(expectedObjectField);

  EntitySchema schema = generator.generateSchema(HasInnerObject.class);

  assertThat(schema.getFields(), equalToFields(expectedFields));
}
 

import com.redhat.lightblue.metadata.Fields; //导入依赖的package包/类
@Test
public void shouldGenerateArrayFieldTypesForObjectArrayElements() {
  class HasObjectArray {
    public List<SomeObject> getSomeObjects() {
      return Arrays.asList(new SomeObject(), new SomeObject());
    }

    public void setSomeObjects(List<SomeObject> someObjects) {

    }

    class SomeObject {
      public Integer getSomeNumber() {
        return 42;
      }

      public void setSomeNumber(Integer someNumber) {

      }
    }
  }

  EntitySchema expectedSchema = new EntitySchema("hasObjectArray");
  ObjectArrayElement expectedArrayElement = new ObjectArrayElement();
  expectedArrayElement.getFields().addNew(new SimpleField("someNumber", IntegerType.TYPE));
  ArrayField expectedArrayField = new ArrayField("someObjects", expectedArrayElement);
  Fields expectedFields = expectedSchema.getFields();
  expectedFields.addNew(expectedArrayField);

  EntitySchema schema = generator.generateSchema(HasObjectArray.class);

  assertThat(schema.getFields(), equalToFields(expectedFields));
}
 

import com.redhat.lightblue.metadata.Fields; //导入依赖的package包/类
@Test(expected = Error.class)
public void testBeforeCreateNewSchema_alreadyHasDefinedDn_butAsWrongType(){
    EntityMetadata md = new EntityMetadata("fake");
    setupEntityMetadata(md);
    Fields fields = md.getEntitySchema().getFields();

    fields.addNew(new SimpleField(LdapConstant.ATTRIBUTE_DN, IntegerType.TYPE));

    new LdapMetadataListener().beforeCreateNewSchema(null, md);
}
 

import com.redhat.lightblue.metadata.Fields; //导入依赖的package包/类
@Test(expected = Error.class)
public void testBeforeCreateNewSchema_alreadyHasDefinedDn_butAsWrongField(){
    EntityMetadata md = new EntityMetadata("fake");
    setupEntityMetadata(md);
    Fields fields = md.getEntitySchema().getFields();

    fields.addNew(new ArrayField(LdapConstant.ATTRIBUTE_DN));

    new LdapMetadataListener().beforeCreateNewSchema(null, md);
}
 

import com.redhat.lightblue.metadata.Fields; //导入依赖的package包/类
@Test(expected = Error.class)
public void testBeforeCreateNewSchema_alreadyHasDefinedObjectClass_butAsWrongType(){
    EntityMetadata md = new EntityMetadata("fake");
    setupEntityMetadata(md);
    Fields fields = md.getEntitySchema().getFields();

    fields.addNew(new SimpleField(LdapConstant.ATTRIBUTE_OBJECT_CLASS, StringType.TYPE));

    new LdapMetadataListener().beforeCreateNewSchema(null, md);
}
 

import com.redhat.lightblue.metadata.Fields; //导入依赖的package包/类
@Test(expected = Error.class)
public void testBeforeCreateNewSchema_alreadyHasDefinedObjectClass_butAsWrongField(){
    EntityMetadata md = new EntityMetadata("fake");
    setupEntityMetadata(md);
    Fields fields = md.getEntitySchema().getFields();

    fields.addNew(new SimpleField(LdapConstant.ATTRIBUTE_OBJECT_CLASS));

    new LdapMetadataListener().beforeCreateNewSchema(null, md);
}
 

import com.redhat.lightblue.metadata.Fields; //导入依赖的package包/类
@Test(expected = Error.class)
public void testBeforeCreateNewSchema_alreadyHasDefinedObjectClass_butWithWrongElementType(){
    EntityMetadata md = new EntityMetadata("fake");
    setupEntityMetadata(md);
    Fields fields = md.getEntitySchema().getFields();

    fields.addNew(new ArrayField(LdapConstant.ATTRIBUTE_OBJECT_CLASS, new SimpleArrayElement(IntegerType.TYPE)));

    new LdapMetadataListener().beforeCreateNewSchema(null, md);
}
 

import com.redhat.lightblue.metadata.Fields; //导入依赖的package包/类
@Test(expected = Error.class)
public void testBeforeCreateNewSchema_alreadyHasDefinedObjectClass_butWithWrongElementField(){
    EntityMetadata md = new EntityMetadata("fake");
    setupEntityMetadata(md);
    Fields fields = md.getEntitySchema().getFields();

    ArrayField field = new ArrayField(LdapConstant.ATTRIBUTE_OBJECT_CLASS, new ObjectArrayElement());
    fields.addNew(field);

    new LdapMetadataListener().beforeCreateNewSchema(null, md);
}