javax.persistence.metamodel.EmbeddableType Java Examples

@SuppressWarnings("rawtypes")
@Override
public EmbeddableType<?> getJPAEmbeddableType() {
  @SuppressWarnings("hiding")
  class JPAComplexAttribute<Long> extends JPAEmbeddableMock<Long> {

    @SuppressWarnings("unchecked")
    @Override
    public Class<Long> getJavaType() {

      return (Class<Long>) java.lang.Long.class;
    }

  }
  return new JPAComplexAttribute();
}
 

@SuppressWarnings("rawtypes")
@Override
public EmbeddableType<?> getJPAEmbeddableType() {
  @SuppressWarnings("hiding")
  class JPAComplexAttribute<Long> extends JPAEmbeddableMock<Long>
  {

    @SuppressWarnings("unchecked")
    @Override
    public Class<Long> getJavaType() {

      return (Class<Long>) java.lang.Long.class;
    }

  }
  return new JPAComplexAttribute();
}
 

GraphQLObjectType getObjectType(EmbeddableType<?> embeddableType) {
	
    if (embeddableCache.containsKey(embeddableType))
        return embeddableCache.get(embeddableType);

    String embeddableName= embeddableType.getJavaType().getSimpleName();
    GraphQLObjectType answer = GraphQLObjectType.newObject()
            .name(embeddableName)
            .description(getSchemaDocumentation(embeddableType.getJavaType()))
            .fields(embeddableType.getAttributes().stream().filter(this::isNotIgnored).flatMap(this::getObjectField).collect(Collectors.toList()))
            .build();

    embeddableCache.put(embeddableType, answer);

    return answer;
}
 

@Override
@SuppressWarnings({"unchecked"})
public <X> EmbeddableType<X> embeddable(Class<X> cls) {
	final EmbeddableType<?> embeddableType = jpaEmbeddableTypeMap.get( cls );
	if ( embeddableType == null ) {
		throw new IllegalArgumentException( "Not an embeddable: " + cls );
	}
	return (EmbeddableType<X>) embeddableType;
}
 

/**
    * Gets the attribute names for the primary keys from the given entity type.
    *
    * @param entityType The entity type of the data object.
    * @return A list of primary key attribute names.
    */
protected List<String> getPrimaryKeyAttributeNames(EntityType<?> entityType) {
	List<String> primaryKeyAttributeNames = new ArrayList<String>();
	// JHK: After examining of the metadata structures of EclipseLink, I determined that there
	// was nothing in those which preserved the order of the original annotations.
	// We *need* to know the order of PK fields for KNS/KRAD functionality.
	// So, I'm falling back to checking the annotations and fields on the referenced objects.
	// Yes, the Javadoc states that the getDeclaredFields() method does not guarantee order,
	// But, it's the best we have. And, as of Java 6, it is returning them in declaration order.

	if (entityType.getIdType() instanceof EmbeddableType) {
		for (Field pkField : entityType.getIdType().getJavaType().getDeclaredFields()) {
			primaryKeyAttributeNames.add(pkField.getName());
		}
	} else {
		// First, get the ID attributes from the metadata
		List<String> unsortedPkFields = new ArrayList<String>();
		for (SingularAttribute attr : entityType.getSingularAttributes()) {
			if (attr.isId()) {
				unsortedPkFields.add(attr.getName());
			}
		}

           getPrimaryKeyNamesInOrder(primaryKeyAttributeNames, unsortedPkFields, entityType.getJavaType().getDeclaredFields(), entityType.getJavaType());
	}
	return primaryKeyAttributeNames;
}
 

public JPAEdmComplexType(final JPAEdmSchemaView view, final Attribute<?, ?> complexAttribute) {
  super(view);
  schemaView = view;
  for (EmbeddableType<?> jpaEmbeddable : schemaView.getJPAMetaModel().getEmbeddables())
  {
    if (jpaEmbeddable.getJavaType().getName().equals(complexAttribute.getJavaType().getName()))
    {
      nestedComplexType = jpaEmbeddable;
      break;
    }
  }
  directBuild = false;
}
 

public JPAEdmComplexType(final JPAEdmSchemaView view, final Attribute<?, ?> complexAttribute) {
  super(view);
  schemaView = view;
  for (EmbeddableType<?> jpaEmbeddable : schemaView.getJPAMetaModel().getEmbeddables()) {
    if (jpaEmbeddable.getJavaType().getName().equals(complexAttribute.getJavaType().getName())) {
      nestedComplexType = jpaEmbeddable;
      break;
    }
  }
  directBuild = false;
  if (nonKeyComplexList == null) {
    nonKeyComplexList = new ArrayList<String>();
  }
}
 

GraphQLFieldDefinition getQueryEmbeddedFieldDefinition(EmbeddableType<?> embeddableType) {
	String embeddedName = embeddableType.getJavaType().getSimpleName();
    return GraphQLFieldDefinition.newFieldDefinition()
            .name(embeddedName)
            .description(getSchemaDocumentation(embeddableType.getJavaType()))
            .type(new GraphQLList(getObjectType(embeddableType)))
            .argument(embeddableType.getAttributes().stream().filter(this::isValidInput).filter(this::isNotIgnored).flatMap(this::getArgument).collect(Collectors.toList()))
            .build();
}
 

@Override
public void discoverElements(MetaProviderContext context) {
	if (entityManagerFactory != null) {
		Set<EmbeddableType<?>> embeddables = entityManagerFactory.getMetamodel().getEmbeddables();
		for (EmbeddableType<?> embeddable : embeddables) {
			context.getLookup().getMeta(embeddable.getJavaType(), MetaJpaDataObject.class);
		}

		Set<EntityType<?>> entities = entityManagerFactory.getMetamodel().getEntities();
		for (EntityType<?> entity : entities) {
			context.getLookup().getMeta(entity.getJavaType(), MetaJpaDataObject.class);
		}
	}
}
 

private ManagedType<X> resolveManagedType(SingularAttribute<?, X> attribute) {
	if ( Attribute.PersistentAttributeType.BASIC == attribute.getPersistentAttributeType() ) {
		return null;
	}
	else if ( Attribute.PersistentAttributeType.EMBEDDED == attribute.getPersistentAttributeType() ) {
		return (EmbeddableType<X>) attribute.getType();
	}
	else {
		return (IdentifiableType<X>) attribute.getType();
	}
}
 

private static Set<Class> toTypes(EntityManagerFactory entityManagerFactory) {
	Set<Class> set = new HashSet<>();

	Set<EmbeddableType<?>> embeddables = entityManagerFactory.getMetamodel().getEmbeddables();
	for (EmbeddableType<?> embeddable : embeddables) {
		set.add(embeddable.getJavaType());
	}

	Set<EntityType<?>> entities = entityManagerFactory.getMetamodel().getEntities();
	for (EntityType<?> entity : entities) {
		set.add(entity.getJavaType());
	}
	return set;
}
 

public JPAEdmMetaModel() {
  embeddableSet = new HashSet<EmbeddableType<?>>();
}
 

@Override
public Set<EmbeddableType<?>> getEmbeddables() {
  embeddableSet.add(new JPAEdmEmbeddable<String>());
  return embeddableSet;
}
 

public JPAEdmMetaModel() {
  entities = new HashSet<EntityType<?>>();
  embeddableSet = new HashSet<EmbeddableType<?>>();
}
 

@Override
public EmbeddableType<?> getJPAEmbeddableType() {
  return new JPAEdmEmbeddable<java.lang.String>();
}
 

@Override
public Set<EmbeddableType<?>> getEmbeddables() {
  embeddableSet.add(new JPAEdmEmbeddable<String>());
  return embeddableSet;
}
 

public JPAEdmMetaModel() {
  embeddableSet = new HashSet<EmbeddableType<?>>();
}
 

@Override
public EmbeddableType<?> getJPAEmbeddableType() {
  return null;
}
 

@Override
public Set<EmbeddableType<?>> getEmbeddables() {
  return null;
}
 

@Override
public <X> EmbeddableType<X> embeddable(final Class<X> arg0) {
  return null;
}
 

@Override
public void build() throws ODataJPAModelException, ODataJPARuntimeException {
  Set<EmbeddableType<?>> embeddables = new HashSet<EmbeddableType<?>>();

  if (consistentComplextTypes == null) {
    consistentComplextTypes = new ArrayList<ComplexType>();
  }

  if (searchMap == null) {
    searchMap = new HashMap<String, ComplexType>();
  }

  if (directBuild) {
    embeddables = schemaView.getJPAMetaModel().getEmbeddables();
  } else {
    embeddables.add(nestedComplexType);
  }

  for (EmbeddableType<?> embeddableType : embeddables) {

    currentEmbeddableType = embeddableType;
    String searchKey = embeddableType.getJavaType().getName();

    if (searchMap.containsKey(searchKey)) {
      continue;
    }

    // Check for need to Exclude
    if (isExcluded(JPAEdmComplexType.this)) {
      continue;
    }

    JPAEdmPropertyView propertyView = new JPAEdmProperty(
        schemaView, JPAEdmComplexType.this);
    propertyView.getBuilder().build();

    currentComplexType = new ComplexType();
    currentComplexType
        .setProperties(propertyView.getEdmPropertyList());
    JPAEdmNameBuilder.build(JPAEdmComplexType.this);

    searchMap.put(searchKey, currentComplexType);
    consistentComplextTypes.add(currentComplexType);

  }

}
 

@Override
public EmbeddableType<?> getJPAEmbeddableType() {
  return currentEmbeddableType;
}
 

@Override
public Set<EmbeddableType<?>> getEmbeddables() {
  embeddableSet.add(new JPAEdmEmbeddable<String>());
  return embeddableSet;
}
 

@Override
public Set<EmbeddableType<?>> getEmbeddables() {
  embeddableSet.add(new JPAEdmEmbeddable<String>());
  return embeddableSet;
}
 

public JPAEdmMetaModel() {
  embeddableSet = new HashSet<EmbeddableType<?>>();
}
 

@Override
public Set<EmbeddableType<?>> getEmbeddables() {
  embeddableSet.add(new JPAEdmEmbeddable<String>());
  return embeddableSet;
}
 

public JPAEdmMetaModel() {
  entities = new HashSet<EntityType<?>>();
  embeddableSet = new HashSet<EmbeddableType<?>>();
}
 

@Override
public EmbeddableType<?> getJPAEmbeddableType() {
  return new JPAEdmEmbeddable<java.lang.String>();
}
 

@Override
public Set<EmbeddableType<?>> getEmbeddables() {
  embeddableSet.add(new JPAEdmEmbeddable<String>());
  return embeddableSet;
}
 

public JPAEdmMetaModel() {
  embeddableSet = new HashSet<EmbeddableType<?>>();
}