/*
(non-Javadoc)

@see javax.persistence.metamodel.Metamodel#getEmbeddables()
170902
@Override
    public Set<EmbeddableType<?>> getEmbeddables()
    {
        Set embeddableEntities = null;
        if (embeddables != null)
        {
            embeddableEntities = new HashSet(embeddables.values());
        }
        return embeddableEntities;
    }
123696
@Override
  public Iterable<ObjectType> getCtorImplementedInterfaces() {
    LinkedHashSet<ObjectType> resolvedImplementedInterfaces = new LinkedHashSet<>();
    for (ObjectType obj : getReferencedObjTypeInternal().getCtorImplementedInterfaces()) {
      resolvedImplementedInterfaces.add(obj.visit(replacer).toObjectType());
    }
    return resolvedImplementedInterfaces;
  }
610540
public List<Option> getOptions(boolean includeDisabled) {
        List<Option> result = new ArrayList<>(); //Keep order

        if (!includeDisabled && !enabled) {
            return result;//This group is disabled entirely
        }

        for (Option option : options.values()) {
            if (includeDisabled || option.isEnabled()) {
                result.add(option);
            }
        }

        return result;
    }
38724
public List<MappedSuperclass<EntityMappings<T>>> getAllMappedSuperclass()
   {
      List<MappedSuperclass<EntityMappings<T>>> list = new ArrayList<MappedSuperclass<EntityMappings<T>>>();
      List<Node> nodeList = childNode.get("mapped-superclass");
      for(Node node: nodeList)
      {
         MappedSuperclass<EntityMappings<T>>  type = new MappedSuperclassImpl<EntityMappings<T>>(this, "mapped-superclass", childNode, node);
         list.add(type);
      }
      return list;
   }
932401
private static void onEmbeddable(EntityType entityType, Attribute column, Object entity,
            EmbeddableType embeddableType, JsonObject jsonObject)
    {
        Object embeddedObject = PropertyAccessorHelper.getObject(entity, (Field) column.getJavaMember());
        String embeddedColumnName = ((AbstractAttribute) column).getJPAColumnName();
        Set<Attribute> embeddableAttributes = embeddableType.getAttributes();
        jsonObject.add(embeddedColumnName, getJsonObject(embeddableAttributes, embeddedObject));
    }
369992
@Override
    public Set<String> getAvailableQueryAttributes() {
        if (this.queryAttributeMapping == null) {
            return Collections.emptySet();
        }

        return Collections.unmodifiableSet(this.queryAttributeMapping.keySet());
    }
681702
public java.util.List<String> getEnableLogTypes() {
        if (enableLogTypes == null) {
            enableLogTypes = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return enableLogTypes;
    }
1052797
public java.util.List<String> getSupportedAddonList() {
        if (supportedAddonList == null) {
            supportedAddonList = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return supportedAddonList;
    }
107100
public boolean isEmbeddable(Class embeddableClazz)
    {
        return embeddables != null ? embeddables.containsKey(embeddableClazz)
                && embeddables.get(embeddableClazz).getPersistenceType().equals(PersistenceType.EMBEDDABLE) : false;
    }
137678
public final ImmutableList<ObjectType> getImplementedInterfaces() {
    FunctionType superCtor = isConstructor() ? getSuperClassConstructor() : null;
    if (superCtor == null) {
      return implementedInterfaces;
    }
    ImmutableList.Builder<ObjectType> builder = ImmutableList.builder();
    builder.addAll(implementedInterfaces);
    while (superCtor != null) {
      builder.addAll(superCtor.implementedInterfaces);
      superCtor = superCtor.getSuperClassConstructor();
    }
    return builder.build();
  }
494039
@Override
  public final ImmutableSet<String> getSupportedAnnotationTypes() {
    ImmutableSet.Builder<String> builder = ImmutableSet.builder();
    for (Class<? extends Annotation> annotationClass : getSupportedAnnotationClasses()) {
      builder.add(annotationClass.getCanonicalName());
    }
    return builder.build();
  }
182664
private EmbeddedColumnInfo getEmbeddedColumn(TableInfo tableInfo, EmbeddableType embeddableType,
            String embeddableColName, Class embeddedEntityClass, Field field)
    {

        String[] orderByColumns = null;
        if (field.isAnnotationPresent(OrderBy.class))
        {
            OrderBy order = (OrderBy) field.getAnnotation(OrderBy.class);
            orderByColumns = order.value().split("\\s*,\\s*");
        }
        EmbeddedColumnInfo embeddedColumnInfo = new EmbeddedColumnInfo(embeddableType);
        embeddedColumnInfo.setEmbeddedColumnName(embeddableColName);
        Map<String, PropertyIndex> indexedColumns = IndexProcessor.getIndexesOnEmbeddable(embeddedEntityClass);
        List<ColumnInfo> columns = new ArrayList<ColumnInfo>();

        Set attributes = embeddableType.getAttributes();
        Iterator<Attribute> iter = attributes.iterator();

        while (iter.hasNext())
        {
            Attribute attr = iter.next();
            columns.add(getColumn(tableInfo, attr, indexedColumns.get(attr.getName()), orderByColumns));
        }
        embeddedColumnInfo.setColumns(columns);
        return embeddedColumnInfo;
    }
269603
protected function getEmbeddedObjectAttributes() : array
    {
        $entityMap = $this->getRelatedMapper()->getEntityMap();

        $attributes = $entityMap->getAttributes();
        $properties = $entityMap->getProperties();

        return array_merge($attributes, $properties);
    }
377846
public List<IfClassAvailable<Exclude<T>>> getAllIfClassAvailable()
   {
      List<IfClassAvailable<Exclude<T>>> list = new ArrayList<IfClassAvailable<Exclude<T>>>();
      List<Node> nodeList = childNode.get("if-class-available");
      for(Node node: nodeList)
      {
         IfClassAvailable<Exclude<T>>  type = new IfClassAvailableImpl<Exclude<T>>(this, "if-class-available", childNode, node);
         list.add(type);
      }
      return list;
   }
917081
public static Collection getEmbeddedCollectionInstance(Field embeddedCollectionField)
    {
        Collection embeddedCollection = null;
        Class embeddedCollectionFieldClass = embeddedCollectionField.getType();

        if (embeddedCollection == null || embeddedCollection.isEmpty())
        {
            if (embeddedCollectionFieldClass.equals(List.class))
            {
                embeddedCollection = new ArrayList<Object>();
            }
            else if (embeddedCollectionFieldClass.equals(Set.class))
            {
                embeddedCollection = new HashSet<Object>();
            }
            else
            {
                throw new InvalidEntityDefinitionException("Field " + embeddedCollectionField.getName()
                        + " must be either instance of List or Set");
            }
        }
        return embeddedCollection;
    }
624403
public List<ManyToOne<EmbeddableAttributes<T>>> getAllManyToOne()
   {
      List<ManyToOne<EmbeddableAttributes<T>>> list = new ArrayList<ManyToOne<EmbeddableAttributes<T>>>();
      List<Node> nodeList = childNode.get("many-to-one");
      for(Node node: nodeList)
      {
         ManyToOne<EmbeddableAttributes<T>>  type = new ManyToOneImpl<EmbeddableAttributes<T>>(this, "many-to-one", childNode, node);
         list.add(type);
      }
      return list;
   }
1206686
public Collection<XAttributeNameMap> getAvailableMappings() {
		HashSet<XAttributeNameMap> result = new HashSet<XAttributeNameMap>();
		result.addAll(mappings.values());
		return Collections.unmodifiableCollection(result);
	}