org.hibernate.cfg.annotations.reflection.XMLContext$Default.canUseJavaAnnotations java code examples

Common ways to obtain XMLContext$Default

private void myMethod () {
 XMLContext$Default x =new Default()
XMLContext xMLContext;String className;xMLContext.getDefault(className)
XMLContext xMLContext;xMLContext.getDefault(null)
Smart code suggestions by Codota
}

private Annotation getTableGenerator(List<Element> elementsForProperty, XMLContext.Default defaults) {
  for ( Element element : elementsForProperty ) {
    Element subelement = element != null ? element.element( annotationToXml.get( TableGenerator.class ) ) : null;
    if ( subelement != null ) {
      return buildTableGeneratorAnnotation( subelement, defaults );
    }
  }
  if ( elementsForProperty.size() == 0 && defaults.canUseJavaAnnotations() ) {
    return getPhysicalAnnotation( TableGenerator.class );
  }
  else {
    return null;
  }
}

private Annotation getSequenceGenerator(List<Element> elementsForProperty, XMLContext.Default defaults) {
  for ( Element element : elementsForProperty ) {
    Element subelement = element != null ? element.element( annotationToXml.get( SequenceGenerator.class ) ) : null;
    if ( subelement != null ) {
      return buildSequenceGeneratorAnnotation( subelement );
    }
  }
  if ( elementsForProperty.size() == 0 && defaults.canUseJavaAnnotations() ) {
    return getPhysicalAnnotation( SequenceGenerator.class );
  }
  else {
    return null;
  }
}

private SequenceGenerator getSequenceGenerator(Element tree, XMLContext.Default defaults) {
  Element element = tree != null ? tree.element( annotationToXml.get( SequenceGenerator.class ) ) : null;
  if ( element != null ) {
    return buildSequenceGeneratorAnnotation( element );
  }
  else if ( defaults.canUseJavaAnnotations() ) {
    return getPhysicalAnnotation( SequenceGenerator.class );
  }
  else {
    return null;
  }
}

private Embeddable getEmbeddable(Element tree, XMLContext.Default defaults) {
  if ( tree == null ) {
    return defaults.canUseJavaAnnotations() ? getPhysicalAnnotation( Embeddable.class ) : null;
  }
  else {
    if ( "embeddable".equals( tree.getName() ) ) {
      AnnotationDescriptor entity = new AnnotationDescriptor( Embeddable.class );
      return AnnotationFactory.create( entity );
    }
    else {
      return null; //this is not an entity
    }
  }
}

private Annotation getMarkerAnnotation(
    Class<? extends Annotation> clazz, Element element, XMLContext.Default defaults
) {
  Element subelement = element == null ? null : element.element( annotationToXml.get( clazz ) );
  if ( subelement != null ) {
    return AnnotationFactory.create( new AnnotationDescriptor( clazz ) );
  }
  else if ( defaults.canUseJavaAnnotations() ) {
    //TODO wonder whether it should be excluded so that user can undone it
    return getPhysicalAnnotation( clazz );
  }
  else {
    return null;
  }
}

private Converts getConverts(Element tree, XMLContext.Default defaults) {
  // NOTE : we use a map here to make sure that an xml and annotation referring to the same attribute
  // properly overrides.  Bit sparse, but easy...
  final Map<String,Convert> convertAnnotationsMap = new HashMap<>();
  if ( tree != null ) {
    applyXmlDefinedConverts( tree, defaults, null, convertAnnotationsMap );
  }
  // NOTE : per section 12.2.3.16 of the spec <convert/> is additive, although only if "metadata-complete" is not
  // specified in the XML
  if ( defaults.canUseJavaAnnotations() ) {
    applyPhysicalConvertAnnotations( null, convertAnnotationsMap );
  }
  if ( !convertAnnotationsMap.isEmpty() ) {
    final AnnotationDescriptor groupingDescriptor = new AnnotationDescriptor( Converts.class );
    groupingDescriptor.setValue( "value", convertAnnotationsMap.values().toArray( new Convert[convertAnnotationsMap.size()]) );
    return AnnotationFactory.create( groupingDescriptor );
  }
  return null;
}

private boolean isProcessingId(XMLContext.Default defaults) {
  boolean isExplicit = defaults.getAccess() != null;
  boolean correctAccess =
      ( PropertyType.PROPERTY.equals( propertyType ) && AccessType.PROPERTY.equals( defaults.getAccess() ) )
          || ( PropertyType.FIELD.equals( propertyType ) && AccessType.FIELD
          .equals( defaults.getAccess() ) );
  boolean hasId = defaults.canUseJavaAnnotations()
      && ( isPhysicalAnnotationPresent( Id.class ) || isPhysicalAnnotationPresent( EmbeddedId.class ) );
  //if ( properAccessOnMetadataComplete || properOverridingOnMetadataNonComplete ) {
  boolean mirrorAttributeIsId = defaults.canUseJavaAnnotations() &&
      ( mirroredAttribute != null &&
          ( mirroredAttribute.isAnnotationPresent( Id.class )
              || mirroredAttribute.isAnnotationPresent( EmbeddedId.class ) ) );
  boolean propertyIsDefault = PropertyType.PROPERTY.equals( propertyType )
      && !mirrorAttributeIsId;
  return correctAccess || ( !isExplicit && hasId ) || ( !isExplicit && propertyIsDefault );
}

private Transient getTransient(XMLContext.Default defaults) {
  for ( Element element : elementsForProperty ) {
    if ( "transient".equals( element.getName() ) ) {
      AnnotationDescriptor ad = new AnnotationDescriptor( Transient.class );
      return AnnotationFactory.create( ad );
    }
  }
  if ( elementsForProperty.size() == 0 && defaults.canUseJavaAnnotations() ) {
    return getPhysicalAnnotation( Transient.class );
  }
  else {
    return null;
  }
}

private SqlResultSetMappings getSqlResultSetMappings(Element tree, XMLContext.Default defaults) {
  List<SqlResultSetMapping> results = buildSqlResultsetMappings( tree, defaults, classLoaderAccess );
  if ( defaults.canUseJavaAnnotations() ) {
    SqlResultSetMapping annotation = getPhysicalAnnotation( SqlResultSetMapping.class );
    addSqlResultsetMappingIfNeeded( annotation, results );
    SqlResultSetMappings annotations = getPhysicalAnnotation( SqlResultSetMappings.class );
    if ( annotations != null ) {
      for ( SqlResultSetMapping current : annotations.value() ) {
        addSqlResultsetMappingIfNeeded( current, results );
      }
    }
  }
  if ( results.size() > 0 ) {
    AnnotationDescriptor ad = new AnnotationDescriptor( SqlResultSetMappings.class );
    ad.setValue( "value", results.toArray( new SqlResultSetMapping[results.size()] ) );
    return AnnotationFactory.create( ad );
  }
  else {
    return null;
  }
}

private NamedStoredProcedureQueries getNamedStoredProcedureQueries(Element tree, XMLContext.Default defaults) {
  List<NamedStoredProcedureQuery> queries = buildNamedStoreProcedureQueries( tree, defaults, classLoaderAccess );
  if ( defaults.canUseJavaAnnotations() ) {
    NamedStoredProcedureQuery annotation = getPhysicalAnnotation( NamedStoredProcedureQuery.class );
    addNamedStoredProcedureQueryIfNeeded( annotation, queries );
    NamedStoredProcedureQueries annotations = getPhysicalAnnotation( NamedStoredProcedureQueries.class );
    if ( annotations != null ) {
      for ( NamedStoredProcedureQuery current : annotations.value() ) {
        addNamedStoredProcedureQueryIfNeeded( current, queries );
      }
    }
  }
  if ( queries.size() > 0 ) {
    AnnotationDescriptor ad = new AnnotationDescriptor( NamedStoredProcedureQueries.class );
    ad.setValue( "value", queries.toArray( new NamedStoredProcedureQuery[queries.size()] ) );
    return AnnotationFactory.create( ad );
  }
  else {
    return null;
  }
}

private NamedEntityGraphs getNamedEntityGraphs(Element tree, XMLContext.Default defaults) {
  List<NamedEntityGraph> queries = buildNamedEntityGraph( tree, defaults, classLoaderAccess );
  if ( defaults.canUseJavaAnnotations() ) {
    NamedEntityGraph annotation = getPhysicalAnnotation( NamedEntityGraph.class );
    addNamedEntityGraphIfNeeded( annotation, queries );
    NamedEntityGraphs annotations = getPhysicalAnnotation( NamedEntityGraphs.class );
    if ( annotations != null ) {
      for ( NamedEntityGraph current : annotations.value() ) {
        addNamedEntityGraphIfNeeded( current, queries );
      }
    }
  }
  if ( queries.size() > 0 ) {
    AnnotationDescriptor ad = new AnnotationDescriptor( NamedEntityGraphs.class );
    ad.setValue( "value", queries.toArray( new NamedEntityGraph[queries.size()] ) );
    return AnnotationFactory.create( ad );
  }
  else {
    return null;
  }
}

private NamedQueries getNamedQueries(Element tree, XMLContext.Default defaults) {
  //TODO avoid the Proxy Creation (@NamedQueries) when possible
  List<NamedQuery> queries = (List<NamedQuery>) buildNamedQueries( tree, false, defaults, classLoaderAccess );
  if ( defaults.canUseJavaAnnotations() ) {
    NamedQuery annotation = getPhysicalAnnotation( NamedQuery.class );
    addNamedQueryIfNeeded( annotation, queries );
    NamedQueries annotations = getPhysicalAnnotation( NamedQueries.class );
    if ( annotations != null ) {
      for ( NamedQuery current : annotations.value() ) {
        addNamedQueryIfNeeded( current, queries );
      }
    }
  }
  if ( queries.size() > 0 ) {
    AnnotationDescriptor ad = new AnnotationDescriptor( NamedQueries.class );
    ad.setValue( "value", queries.toArray( new NamedQuery[queries.size()] ) );
    return AnnotationFactory.create( ad );
  }
  else {
    return null;
  }
}

/**
 * @param mergeWithAnnotations Whether to use Java annotations for this
 * element, if present and not disabled by the XMLContext defaults.
 * In some contexts (such as an element-collection mapping) merging
 * with annotations is never allowed.
 */
private AssociationOverrides getAssociationOverrides(Element tree, XMLContext.Default defaults, boolean mergeWithAnnotations) {
  List<AssociationOverride> attributes = buildAssociationOverrides( tree, defaults );
  if ( mergeWithAnnotations && defaults.canUseJavaAnnotations() ) {
    AssociationOverride annotation = getPhysicalAnnotation( AssociationOverride.class );
    addAssociationOverrideIfNeeded( annotation, attributes );
    AssociationOverrides annotations = getPhysicalAnnotation( AssociationOverrides.class );
    if ( annotations != null ) {
      for ( AssociationOverride current : annotations.value() ) {
        addAssociationOverrideIfNeeded( current, attributes );
      }
    }
  }
  if ( attributes.size() > 0 ) {
    AnnotationDescriptor ad = new AnnotationDescriptor( AssociationOverrides.class );
    ad.setValue( "value", attributes.toArray( new AssociationOverride[attributes.size()] ) );
    return AnnotationFactory.create( ad );
  }
  else {
    return null;
  }
}

private Entity getEntity(Element tree, XMLContext.Default defaults) {
  if ( tree == null ) {
    return defaults.canUseJavaAnnotations() ? getPhysicalAnnotation( Entity.class ) : null;
  }
  else {
    if ( "entity".equals( tree.getName() ) ) {
      AnnotationDescriptor entity = new AnnotationDescriptor( Entity.class );
      copyStringAttribute( entity, tree, "name", false );
      if ( defaults.canUseJavaAnnotations()
          && StringHelper.isEmpty( (String) entity.valueOf( "name" ) ) ) {
        Entity javaAnn = getPhysicalAnnotation( Entity.class );
        if ( javaAnn != null ) {
          entity.setValue( "name", javaAnn.name() );
        }
      }
      return AnnotationFactory.create( entity );
    }
    else {
      return null; //this is not an entity
    }
  }
}

private DiscriminatorValue getDiscriminatorValue(Element tree, XMLContext.Default defaults) {
  Element element = tree != null ? tree.element( "discriminator-value" ) : null;
  if ( element != null ) {
    AnnotationDescriptor ad = new AnnotationDescriptor( DiscriminatorValue.class );
    copyStringElement( element, ad, "value" );
    return AnnotationFactory.create( ad );
  }
  else if ( defaults.canUseJavaAnnotations() ) {
    return getPhysicalAnnotation( DiscriminatorValue.class );
  }
  else {
    return null;
  }
}

private NamedNativeQueries getNamedNativeQueries(
    Element tree,
    XMLContext.Default defaults) {
  List<NamedNativeQuery> queries = (List<NamedNativeQuery>) buildNamedQueries( tree, true, defaults, classLoaderAccess );
  if ( defaults.canUseJavaAnnotations() ) {
    NamedNativeQuery annotation = getPhysicalAnnotation( NamedNativeQuery.class );
    addNamedNativeQueryIfNeeded( annotation, queries );
    NamedNativeQueries annotations = getPhysicalAnnotation( NamedNativeQueries.class );
    if ( annotations != null ) {
      for ( NamedNativeQuery current : annotations.value() ) {
        addNamedNativeQueryIfNeeded( current, queries );
      }
    }
  }
  if ( queries.size() > 0 ) {
    AnnotationDescriptor ad = new AnnotationDescriptor( NamedNativeQueries.class );
    ad.setValue( "value", queries.toArray( new NamedNativeQuery[queries.size()] ) );
    return AnnotationFactory.create( ad );
  }
  else {
    return null;
  }
}

private IdClass getIdClass(Element tree, XMLContext.Default defaults) {
  Element element = tree == null ? null : tree.element( "id-class" );
  if ( element != null ) {
    Attribute attr = element.attribute( "class" );
    if ( attr != null ) {
      AnnotationDescriptor ad = new AnnotationDescriptor( IdClass.class );
      Class clazz;
      try {
        clazz = classLoaderAccess.classForName( XMLContext.buildSafeClassName( attr.getValue(), defaults )
        );
      }
      catch ( ClassLoadingException e ) {
        throw new AnnotationException( "Unable to find id-class: " + attr.getValue(), e );
      }
      ad.setValue( "value", clazz );
      return AnnotationFactory.create( ad );
    }
    else {
      throw new AnnotationException( "id-class without class. " + SCHEMA_VALIDATION );
    }
  }
  else if ( defaults.canUseJavaAnnotations() ) {
    return getPhysicalAnnotation( IdClass.class );
  }
  else {
    return null;
  }
}

private MappedSuperclass getMappedSuperclass(Element tree, XMLContext.Default defaults) {
  if ( tree == null ) {
    return defaults.canUseJavaAnnotations() ? getPhysicalAnnotation( MappedSuperclass.class ) : null;
  }
  else {
    if ( "mapped-superclass".equals( tree.getName() ) ) {
      AnnotationDescriptor entity = new AnnotationDescriptor( MappedSuperclass.class );
      return AnnotationFactory.create( entity );
    }
    else {
      return null; //this is not an entity
    }
  }
}

private void getVersion(List<Annotation> annotationList, XMLContext.Default defaults) {
  for ( Element element : elementsForProperty ) {
    if ( "version".equals( element.getName() ) ) {
      Annotation annotation = buildColumns( element );
      addIfNotNull( annotationList, annotation );
      getTemporal( annotationList, element );
      AnnotationDescriptor basic = new AnnotationDescriptor( Version.class );
      annotationList.add( AnnotationFactory.create( basic ) );
      getAccessType( annotationList, element );
    }
  }
  if ( elementsForProperty.size() == 0 && defaults.canUseJavaAnnotations() ) {
    //we have nothing, so Java annotations might occurs
    Annotation annotation = getPhysicalAnnotation( Version.class );
    if ( annotation != null ) {
      annotationList.add( annotation );
      annotation = getPhysicalAnnotation( Column.class );
      addIfNotNull( annotationList, annotation );
      annotation = getPhysicalAnnotation( Columns.class );
      addIfNotNull( annotationList, annotation );
      annotation = getPhysicalAnnotation( Temporal.class );
      addIfNotNull( annotationList, annotation );
    }
  }
}

private Cacheable getCacheable(Element element, XMLContext.Default defaults){
  if ( element != null ) {
    String attValue = element.attributeValue( "cacheable" );
    if ( attValue != null ) {
      AnnotationDescriptor ad = new AnnotationDescriptor( Cacheable.class );
      ad.setValue( "value", Boolean.valueOf( attValue ) );
      return AnnotationFactory.create( ad );
    }
  }
  if ( defaults.canUseJavaAnnotations() ) {
    return getPhysicalAnnotation( Cacheable.class );
  }
  else {
    return null;
  }
}
/**

Popular methods of XMLContext$Default

Popular in Java

Start an intent from android
addToBackStack (FragmentTransaction)
getResourceAsStream (ClassLoader)
getSupportFragmentManager (FragmentActivity)
Return the FragmentManager for interacting with fragments associated with this activity.
Socket (java.net)
Provides a client-side TCP socket.
DecimalFormat (java.text)
DecimalFormat is a concrete subclass ofNumberFormat that formats decimal numbers. It has a variety o
GregorianCalendar (java.util)
GregorianCalendar is a concrete subclass of Calendarand provides the standard calendar used by most
Iterator (java.util)
An iterator over a collection. Iterator takes the place of Enumeration in the Java Collections Frame
ConcurrentHashMap (java.util.concurrent)
A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updat
Filter (javax.servlet)
A filter is an object that performs filtering tasks on either the request to a resource (a servlet o

How to use canUseJavaAnnotationsmethodin org.hibernate.cfg.annotations.reflection.XMLContext$Default

Best Java code snippets using org.hibernate.cfg.annotations.reflection.XMLContext$Default.canUseJavaAnnotations (Showing top 20 results out of 315)

How to use
canUseJavaAnnotations
method
in
org.hibernate.cfg.annotations.reflection.XMLContext$Default