org.hibernate.cfg.annotations.reflection.XMLContext$Default 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 Tabnine
}

public Default getDefault(String className) {
  Default xmlDefault = new Default();
  xmlDefault.override( globalDefaults );
  if ( className != null ) {
    Default entityMappingOverriding = defaultsOverriding.get( className );
    xmlDefault.override( entityMappingOverriding );
  }
  return xmlDefault;
}

  copyStringAttribute( annotation, element, "name", false );
  copyStringAttribute( annotation, element, "catalog", false );
  if ( StringHelper.isNotEmpty( defaults.getCatalog() )
      && StringHelper.isEmpty( (String) annotation.valueOf( "catalog" ) ) ) {
    annotation.setValue( "catalog", defaults.getCatalog() );
  if ( StringHelper.isNotEmpty( defaults.getSchema() )
      && StringHelper.isEmpty( (String) annotation.valueOf( "schema" ) ) ) {
    annotation.setValue( "schema", defaults.getSchema() );
if ( secondaryTables.size() == 0 && defaults.canUseJavaAnnotations() ) {
  SecondaryTable secTableAnn = getPhysicalAnnotation( SecondaryTable.class );
  overridesDefaultInSecondaryTable( secTableAnn, defaults, secondaryTables );

XMLContext.Default xmlDefaults = xmlContext.getDefault( null );
defaults.put( "schema", xmlDefaults.getSchema() );
defaults.put( "catalog", xmlDefaults.getCatalog() );
defaults.put( "delimited-identifier", xmlDefaults.getDelimitedIdentifier() );
defaults.put( "cascade-persist", xmlDefaults.getCascadePersist() );
List<Class> entityListeners = new ArrayList<Class>();
for ( String className : xmlContext.getDefaultEntityListeners() ) {

public Default getDefault(String className) {
  Default xmlDefault = new Default();
  xmlDefault.override( globalDefaults );
  if ( className != null ) {
    Default entityMappingOverriding = defaultsOverriding.get( className );
    xmlDefault.override( entityMappingOverriding );
  }
  return xmlDefault;
}

public void override(Default globalDefault) {
  if ( globalDefault != null ) {
    if ( globalDefault.getAccess() != null ) access = globalDefault.getAccess();
    if ( globalDefault.getPackageName() != null ) packageName = globalDefault.getPackageName();
    if ( globalDefault.getSchema() != null ) schema = globalDefault.getSchema();
    if ( globalDefault.getCatalog() != null ) catalog = globalDefault.getCatalog();
    if ( globalDefault.getDelimitedIdentifier() != null ) delimitedIdentifier = globalDefault.getDelimitedIdentifier();
    if ( globalDefault.getMetadataComplete() != null ) {
      metadataComplete = globalDefault.getMetadataComplete();
    }
    //TODO fix that in stone if cascade-persist is set already?
    if ( globalDefault.getCascadePersist() != null ) cascadePersist = globalDefault.getCascadePersist();
  }
}

public static String buildSafeClassName(String className, XMLContext.Default defaults) {
  return buildSafeClassName( className, defaults.getPackageName() );
}

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()
      && ( isJavaAnnotationPresent( Id.class ) || isJavaAnnotationPresent( 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 void getJoinTable(List<Annotation> annotationList, Element tree, XMLContext.Default defaults) {
  Element subelement = tree == null ? null : tree.element( "join-table" );
  final Class<JoinTable> annotationType = JoinTable.class;
  if ( subelement != null ) {
    //ignore java annotation, an element is defined
    AnnotationDescriptor annotation = new AnnotationDescriptor( annotationType );
    copyStringAttribute( annotation, subelement, "name", false );
    copyStringAttribute( annotation, subelement, "catalog", false );
    if ( StringHelper.isNotEmpty( defaults.getCatalog() )
        && StringHelper.isEmpty( (String) annotation.valueOf( "catalog" ) ) ) {
      annotation.setValue( "catalog", defaults.getCatalog() );
    }
    copyStringAttribute( annotation, subelement, "schema", false );
    if ( StringHelper.isNotEmpty( defaults.getSchema() )
        && StringHelper.isEmpty( (String) annotation.valueOf( "schema" ) ) ) {
      annotation.setValue( "schema", defaults.getSchema() );
    }
    buildUniqueConstraints( annotation, subelement );
    annotation.setValue( "joinColumns", getJoinColumns( subelement, false ) );
    annotation.setValue( "inverseJoinColumns", getJoinColumns( subelement, true ) );
    annotationList.add( AnnotationFactory.create( annotation ) );
  }
}

private void addClass(List<Element> entities, String packageName, Default defaults, List<String> addedClasses) {
  for (Element element : entities) {
    String className = buildSafeClassName( element.attributeValue( "class" ), packageName );
    if ( classOverriding.containsKey( className ) ) {
      //maybe switch it to warn?
      throw new IllegalStateException( "Duplicate XML entry for " + className );
    }
    addedClasses.add( className );
    classOverriding.put( className, element );
    Default localDefault = new Default();
    localDefault.override( defaults );
    String metadataCompleteString = element.attributeValue( "metadata-complete" );
    if ( metadataCompleteString != null ) {
      localDefault.setMetadataComplete( Boolean.parseBoolean( metadataCompleteString ) );
    }
    String access = element.attributeValue( "access" );
    setAccess( access, localDefault );
    defaultsOverriding.put( className, localDefault );
    log.debug( "Adding XML overriding information for {}", className );
    addEntityListenerClasses( element, packageName, addedClasses );
  }
}

public static TableGenerator buildTableGeneratorAnnotation(Element element, XMLContext.Default defaults) {
  AnnotationDescriptor ad = new AnnotationDescriptor( TableGenerator.class );
  copyStringAttribute( ad, element, "name", false );
  copyStringAttribute( ad, element, "table", false );
  copyStringAttribute( ad, element, "catalog", false );
  copyStringAttribute( ad, element, "schema", false );
  copyStringAttribute( ad, element, "pk-column-name", false );
  copyStringAttribute( ad, element, "value-column-name", false );
  copyStringAttribute( ad, element, "pk-column-value", false );
  copyIntegerAttribute( ad, element, "initial-value" );
  copyIntegerAttribute( ad, element, "allocation-size" );
  buildUniqueConstraints( ad, element );
  if ( StringHelper.isEmpty( (String) ad.valueOf( "schema" ) )
      && StringHelper.isNotEmpty( defaults.getSchema() ) ) {
    ad.setValue( "schema", defaults.getSchema() );
  }
  if ( StringHelper.isEmpty( (String) ad.valueOf( "catalog" ) )
      && StringHelper.isNotEmpty( defaults.getCatalog() ) ) {
    ad.setValue( "catalog", defaults.getCatalog() );
  }
  return AnnotationFactory.create( ad );
}

private Access getAccessType(Element tree, XMLContext.Default defaults) {
  String access = tree == null ? null : tree.attributeValue( "access" );
  if ( access != null ) {
    AnnotationDescriptor ad = new AnnotationDescriptor( Access.class );
    AccessType type;
    try {
      type = AccessType.valueOf( access );
    }
    catch ( IllegalArgumentException e ) {
      throw new AnnotationException( access + " is not a valid access type. Check you xml confguration." );
    }
    ad.setValue( "value", type );
    return AnnotationFactory.create( ad );
  }
  else if ( defaults.canUseJavaAnnotations() && isJavaAnnotationPresent( Access.class ) ) {
    return getJavaAnnotation( Access.class );
  }
  else if ( defaults.getAccess() != null ) {
    AnnotationDescriptor ad = new AnnotationDescriptor( Access.class );
    ad.setValue( "value", defaults.getAccess() );
    return AnnotationFactory.create( ad );
  }
  else {
    return null;
  }
}

private void overridesDefaultInSecondaryTable(
    SecondaryTable secTableAnn, XMLContext.Default defaults, List<SecondaryTable> secondaryTables
) {
  if ( secTableAnn != null ) {
    //handle default values
    if ( StringHelper.isNotEmpty( defaults.getCatalog() )
        || StringHelper.isNotEmpty( defaults.getSchema() ) ) {
      AnnotationDescriptor annotation = new AnnotationDescriptor( SecondaryTable.class );
      annotation.setValue( "name", secTableAnn.name() );
      annotation.setValue( "schema", secTableAnn.schema() );
      annotation.setValue( "catalog", secTableAnn.catalog() );
      annotation.setValue( "uniqueConstraints", secTableAnn.uniqueConstraints() );
      annotation.setValue( "pkJoinColumns", secTableAnn.pkJoinColumns() );
      if ( StringHelper.isEmpty( (String) annotation.valueOf( "schema" ) )
          && StringHelper.isNotEmpty( defaults.getSchema() ) ) {
        annotation.setValue( "schema", defaults.getSchema() );
      }
      if ( StringHelper.isEmpty( (String) annotation.valueOf( "catalog" ) )
          && StringHelper.isNotEmpty( defaults.getCatalog() ) ) {
        annotation.setValue( "catalog", defaults.getCatalog() );
      }
      secondaryTables.add( (SecondaryTable) AnnotationFactory.create( annotation ) );
    }
    else {
      secondaryTables.add( secTableAnn );
    }
  }
}

if ( subelement == null ) {
  if ( StringHelper.isNotEmpty( defaults.getCatalog() )
      || StringHelper.isNotEmpty( defaults.getSchema() ) ) {
    AnnotationDescriptor annotation = new AnnotationDescriptor( Table.class );
    if ( defaults.canUseJavaAnnotations() ) {
      Table table = getPhysicalAnnotation( Table.class );
      if ( table != null ) {
        && StringHelper.isNotEmpty( defaults.getSchema() ) ) {
      annotation.setValue( "schema", defaults.getSchema() );
        && StringHelper.isNotEmpty( defaults.getCatalog() ) ) {
      annotation.setValue( "catalog", defaults.getCatalog() );
  else if ( defaults.canUseJavaAnnotations() ) {
    return getPhysicalAnnotation( Table.class );
  copyStringAttribute( annotation, subelement, "name", false );
  copyStringAttribute( annotation, subelement, "catalog", false );
  if ( StringHelper.isNotEmpty( defaults.getCatalog() )
      && StringHelper.isEmpty( (String) annotation.valueOf( "catalog" ) ) ) {
    annotation.setValue( "catalog", defaults.getCatalog() );
  if ( StringHelper.isNotEmpty( defaults.getSchema() )
      && StringHelper.isEmpty( (String) annotation.valueOf( "schema" ) ) ) {
    annotation.setValue( "schema", defaults.getSchema() );

  return buildTableGeneratorAnnotation( element, defaults );
else if ( defaults.canUseJavaAnnotations() && isJavaAnnotationPresent( TableGenerator.class ) ) {
  TableGenerator tableAnn = getJavaAnnotation( TableGenerator.class );
  if ( StringHelper.isNotEmpty( defaults.getSchema() )
      || StringHelper.isNotEmpty( defaults.getCatalog() ) ) {
    AnnotationDescriptor annotation = new AnnotationDescriptor( TableGenerator.class );
    annotation.setValue( "name", tableAnn.name() );
    annotation.setValue( "catalog", tableAnn.table() );
    if ( StringHelper.isEmpty( (String) annotation.valueOf( "catalog" ) )
        && StringHelper.isNotEmpty( defaults.getCatalog() ) ) {
      annotation.setValue( "catalog", defaults.getCatalog() );
        && StringHelper.isNotEmpty( defaults.getSchema() ) ) {
      annotation.setValue( "catalog", defaults.getSchema() );

if ( metadata != null ) {
  if ( globalDefaults == null ) {
    globalDefaults = new Default();
    globalDefaults.setMetadataComplete(
        metadata.element( "xml-mapping-metadata-complete" ) != null ?
            Boolean.TRUE :
    if ( defaultElement != null ) {
      Element unitElement = defaultElement.element( "schema" );
      globalDefaults.setSchema( unitElement != null ? unitElement.getTextTrim() : null );
      unitElement = defaultElement.element( "catalog" );
      globalDefaults.setCatalog( unitElement != null ? unitElement.getTextTrim() : null );
      unitElement = defaultElement.element( "access" );
      setAccess( unitElement, globalDefaults );
      unitElement = defaultElement.element( "cascade-persist" );
      globalDefaults.setCascadePersist( unitElement != null ? Boolean.TRUE : null );
      unitElement = defaultElement.element( "delimited-identifiers" );
      globalDefaults.setDelimitedIdentifiers( unitElement != null ? Boolean.TRUE : null );
      defaultEntityListeners.addAll( addEntityListenerClasses( defaultElement, null, addedClasses ) );
Default entityMappingDefault = new Default();
Element unitElement = root.element( "package" );
String packageName = unitElement != null ? unitElement.getTextTrim() : null;
entityMappingDefault.setPackageName( packageName );
unitElement = root.element( "schema" );
entityMappingDefault.setSchema( unitElement != null ? unitElement.getTextTrim() : null );
unitElement = root.element( "catalog" );
entityMappingDefault.setCatalog( unitElement != null ? unitElement.getTextTrim() : null );
unitElement = root.element( "access" );

  copyStringAttribute( annotation, element, "name", false );
  copyStringAttribute( annotation, element, "catalog", false );
  if ( StringHelper.isNotEmpty( defaults.getCatalog() )
      && StringHelper.isEmpty( (String) annotation.valueOf( "catalog" ) ) ) {
    annotation.setValue( "catalog", defaults.getCatalog() );
  if ( StringHelper.isNotEmpty( defaults.getSchema() )
      && StringHelper.isEmpty( (String) annotation.valueOf( "schema" ) ) ) {
    annotation.setValue( "schema", defaults.getSchema() );
if ( secondaryTables.size() == 0 && defaults.canUseJavaAnnotations() ) {
  SecondaryTable secTableAnn = getJavaAnnotation( SecondaryTable.class );
  overridesDefaultInSecondaryTable( secTableAnn, defaults, secondaryTables );

final Class<JoinTable> annotationType = JoinTable.class;
if ( defaultToJoinTable
    && ( StringHelper.isNotEmpty( defaults.getCatalog() )
    || StringHelper.isNotEmpty( defaults.getSchema() ) ) ) {
  AnnotationDescriptor ad = new AnnotationDescriptor( annotationType );
  if ( defaults.canUseJavaAnnotations() ) {
    JoinTable table = getJavaAnnotation( annotationType );
    if ( table != null ) {
      && StringHelper.isNotEmpty( defaults.getSchema() ) ) {
    ad.setValue( "schema", defaults.getSchema() );
      && StringHelper.isNotEmpty( defaults.getCatalog() ) ) {
    ad.setValue( "catalog", defaults.getCatalog() );
else if ( defaults.canUseJavaAnnotations() ) {
  return getJavaAnnotation( annotationType );

final Class<JoinTable> annotationType = JoinTable.class;
if ( defaultToJoinTable
    && ( StringHelper.isNotEmpty( defaults.getCatalog() )
    || StringHelper.isNotEmpty( defaults.getSchema() ) ) ) {
  AnnotationDescriptor ad = new AnnotationDescriptor( annotationType );
  if ( defaults.canUseJavaAnnotations() ) {
    JoinTable table = getPhysicalAnnotation( annotationType );
    if ( table != null ) {
      && StringHelper.isNotEmpty( defaults.getSchema() ) ) {
    ad.setValue( "schema", defaults.getSchema() );
      && StringHelper.isNotEmpty( defaults.getCatalog() ) ) {
    ad.setValue( "catalog", defaults.getCatalog() );
else if ( defaults.canUseJavaAnnotations() ) {
  return getPhysicalAnnotation( annotationType );

if ( subelement == null ) {
  if ( StringHelper.isNotEmpty( defaults.getCatalog() )
      || StringHelper.isNotEmpty( defaults.getSchema() ) ) {
    AnnotationDescriptor annotation = new AnnotationDescriptor( Table.class );
    if ( defaults.canUseJavaAnnotations() ) {
      Table table = getJavaAnnotation( Table.class );
      if ( table != null ) {
        && StringHelper.isNotEmpty( defaults.getSchema() ) ) {
      annotation.setValue( "schema", defaults.getSchema() );
        && StringHelper.isNotEmpty( defaults.getCatalog() ) ) {
      annotation.setValue( "catalog", defaults.getCatalog() );
  else if ( defaults.canUseJavaAnnotations() ) {
    return getJavaAnnotation( Table.class );
  copyStringAttribute( annotation, subelement, "name", false );
  copyStringAttribute( annotation, subelement, "catalog", false );
  if ( StringHelper.isNotEmpty( defaults.getCatalog() )
      && StringHelper.isEmpty( (String) annotation.valueOf( "catalog" ) ) ) {
    annotation.setValue( "catalog", defaults.getCatalog() );
  if ( StringHelper.isNotEmpty( defaults.getSchema() )
      && StringHelper.isEmpty( (String) annotation.valueOf( "schema" ) ) ) {
    annotation.setValue( "schema", defaults.getSchema() );

if ( elementsForProperty.size() == 0 && defaults.canUseJavaAnnotations() ) {
  Annotation annotation = getPhysicalAnnotation( EmbeddedId.class );
  if ( annotation != null ) {

How to useXMLContext$Default in org.hibernate.cfg.annotations.reflection

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

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