Projects >> hibernate-orm >>a00f23c6f66d87c51a1a2a58a0e7b1c51b505dec

Chunk
Conflicting content 
					entityName, xmlMappingData, false);
			return;// mod flag field has been already generated in first pass
		} else if (type instanceof ManyToOneType) {
<<<<<<< HEAD
			toOneRelationMetadataGenerator.addToOne(parent, propertyAuditingData, value, currentMapper,
					entityName, insertable);
		} else if (type instanceof OneToOneType) {
			toOneRelationMetadataGenerator.addOneToOneNotOwning(propertyAuditingData, value,
					currentMapper, entityName);
		} else if (type instanceof CollectionType) {
			CollectionMetadataGenerator collectionMetadataGenerator = new CollectionMetadataGenerator(this,
					(Collection) value, currentMapper, entityName, xmlMappingData,
					propertyAuditingData);
			collectionMetadataGenerator.addCollection();
		} else {
			return;
		}
		addModifiedFlagIfNeeded(parent, propertyAuditingData, processModifiedFlag);
	}

	private void addModifiedFlagIfNeeded(Element parent, PropertyAuditingData propertyAuditingData, boolean processModifiedFlag) {
		if (processModifiedFlag && propertyAuditingData.isUsingModifiedFlag()) {
			MetadataTools.addModifiedFlagProperty(parent,
					propertyAuditingData.getName(),
					globalCfg.getModifiedFlagSuffix());
		}
	}

	void addValue(Element parent, Value value, CompositeMapperBuilder currentMapper, String entityName,
				  EntityXmlMappingData xmlMappingData, PropertyAuditingData propertyAuditingData,
				  boolean insertable, boolean firstPass, boolean processModifiedFlag) {
		if (firstPass) {
			addValueInFirstPass(parent, value, currentMapper, entityName,
					xmlMappingData, propertyAuditingData, insertable, processModifiedFlag);
		} else {
			addValueInSecondPass(parent, value, currentMapper, entityName,
					xmlMappingData, propertyAuditingData, insertable, processModifiedFlag);
		}
	}
=======
            // only second pass
            if (!firstPass) {
                toOneRelationMetadataGenerator.addToOne(parent, propertyAuditingData, value, currentMapper,
                        entityName, insertable);
            }
        } else if (type instanceof OneToOneType) {
            // only second pass
            if (!firstPass) {
                OneToOne oneToOne = (OneToOne) value;
                if (oneToOne.getReferencedPropertyName() != null) {
                    toOneRelationMetadataGenerator.addOneToOneNotOwning(propertyAuditingData, value,
                            currentMapper, entityName);
                } else {
                    // @OneToOne relation marked with @PrimaryKeyJoinColumn
                    toOneRelationMetadataGenerator.addOneToOnePrimaryKeyJoinColumn(propertyAuditingData, value,
                            currentMapper, entityName, insertable);
                }
            }
        } else if (type instanceof CollectionType) {
            // only second pass
            if (!firstPass) {
                CollectionMetadataGenerator collectionMetadataGenerator = new CollectionMetadataGenerator(this,
                        (Collection) value, currentMapper, entityName, xmlMappingData,
						propertyAuditingData);
                collectionMetadataGenerator.addCollection();
            }
        } else {
            if (firstPass) {
                // If we got here in the first pass, it means the basic mapper didn't map it, and none of the
                // above branches either.
                throwUnsupportedTypeException(type, entityName, propertyAuditingData.getName());
            }
        }
    }
>>>>>>> e0a09dbd793f247af85f276a92a07c17e635cdf3

	private void addProperties(Element parent, Iterator properties, CompositeMapperBuilder currentMapper,
                               ClassAuditingData auditingData, String entityName, EntityXmlMappingData xmlMappingData,
Solution content 
					entityName, xmlMappingData, false);
			return;// mod flag field has been already generated in first pass
		} else if (type instanceof ManyToOneType) {
			toOneRelationMetadataGenerator.addToOne(parent, propertyAuditingData, value, currentMapper,
					entityName, insertable);
		} else if (type instanceof OneToOneType) {
            OneToOne oneToOne = (OneToOne) value;
            if (oneToOne.getReferencedPropertyName() != null) {
                toOneRelationMetadataGenerator.addOneToOneNotOwning(propertyAuditingData, value,
                        currentMapper, entityName);
            } else {
                // @OneToOne relation marked with @PrimaryKeyJoinColumn
                toOneRelationMetadataGenerator.addOneToOnePrimaryKeyJoinColumn(propertyAuditingData, value,
                        currentMapper, entityName, insertable);
            }
		} else if (type instanceof CollectionType) {
			CollectionMetadataGenerator collectionMetadataGenerator = new CollectionMetadataGenerator(this,
					(Collection) value, currentMapper, entityName, xmlMappingData,
					propertyAuditingData);
			collectionMetadataGenerator.addCollection();
		} else {
			return;
		}
		addModifiedFlagIfNeeded(parent, propertyAuditingData, processModifiedFlag);
	}

	private void addModifiedFlagIfNeeded(Element parent, PropertyAuditingData propertyAuditingData, boolean processModifiedFlag) {
		if (processModifiedFlag && propertyAuditingData.isUsingModifiedFlag()) {
			MetadataTools.addModifiedFlagProperty(parent,
					propertyAuditingData.getName(),
					globalCfg.getModifiedFlagSuffix());
		}
	}

	void addValue(Element parent, Value value, CompositeMapperBuilder currentMapper, String entityName,
				  EntityXmlMappingData xmlMappingData, PropertyAuditingData propertyAuditingData,
				  boolean insertable, boolean firstPass, boolean processModifiedFlag) {
		if (firstPass) {
			addValueInFirstPass(parent, value, currentMapper, entityName,
					xmlMappingData, propertyAuditingData, insertable, processModifiedFlag);
		} else {
			addValueInSecondPass(parent, value, currentMapper, entityName,
					xmlMappingData, propertyAuditingData, insertable, processModifiedFlag);
		}
	}

	private void addProperties(Element parent, Iterator properties, CompositeMapperBuilder currentMapper,
                               ClassAuditingData auditingData, String entityName, EntityXmlMappingData xmlMappingData,
File
AuditMetadataGenerator.java
Developer's decision
Combination
Kind of conflict
Comment
If statement
Method declaration
Method invocation
Chunk
Conflicting content 
 * Property mapper for not owning side of {@link OneToOne} relation.
 * @author Adam Warski (adam at warski dot org)
 * @author Hern�n Chanfreau
<<<<<<< HEAD
 * @author Michal Skowronek (mskowr at o2 dot pl)
=======
 * @author Lukasz Antoniak (lukasz dot antoniak at gmail dot com)
>>>>>>> e0a09dbd793f247af85f276a92a07c17e635cdf3
 */
public class OneToOneNotOwningMapper extends AbstractOneToOneMapper {
    private final String owningReferencePropertyName;
Solution content 
 * Property mapper for not owning side of {@link OneToOne} relation.
 * @author Adam Warski (adam at warski dot org)
 * @author Hern�n Chanfreau
 * @author Michal Skowronek (mskowr at o2 dot pl)  
 * @author Lukasz Antoniak (lukasz dot antoniak at gmail dot com)
 */
public class OneToOneNotOwningMapper extends AbstractOneToOneMapper {
    private final String owningReferencePropertyName;
File
OneToOneNotOwningMapper.java
Developer's decision
Concatenation
Kind of conflict
Comment
Chunk
Conflicting content 
            return;
        }
                                   PropertyData propertyData) {
        super(notOwningEntityName, owningEntityName, propertyData);
        this.owningReferencePropertyName = owningReferencePropertyName;
<<<<<<< HEAD
        this.owningEntityName = owningEntityName;
        this.propertyData = propertyData;
    }

    public boolean mapToMapFromEntity(SessionImplementor session, Map data, Object newObj, Object oldObj) {
        return false;
    }

	@Override
	public void mapModifiedFlagsToMapFromEntity(SessionImplementor session, Map data, Object newObj, Object oldObj) {
	}

	@Override
	public void mapModifiedFlagsToMapForCollectionChange(String collectionPropertyName, Map data) {
		if (propertyData.isUsingModifiedFlag()) {
			data.put(propertyData.getModifiedFlagPropertyName(), collectionPropertyName.equals(propertyData.getName()));
		}
	}

	public void mapToEntityFromMap(AuditConfiguration verCfg, Object obj, Map data, Object primaryKey, AuditReaderImplementor versionsReader, Number revision) {
        if (obj == null) {

    	EntityConfiguration entCfg = verCfg.getEntCfg().get(owningEntityName);
    	if(entCfg == null) {
    		// a relation marked as RelationTargetAuditMode.NOT_AUDITED 
    		entCfg = verCfg.getEntCfg().getNotVersionEntityConfiguration(owningEntityName);
    	}

        Class entityClass = ReflectionTools.loadClass(entCfg.getEntityClassName());

        Object value;

        try {
            value = versionsReader.createQuery().forEntitiesAtRevision(entityClass, owningEntityName, revision)
                    .add(AuditEntity.relatedId(owningReferencePropertyName).eq(primaryKey)).getSingleResult();
        } catch (NoResultException e) {
            value = null;
        } catch (NonUniqueResultException e) {
            throw new AuditException("Many versions results for one-to-one relationship: (" + owningEntityName +
                    ", " + owningReferencePropertyName + ")");
        }

        Setter setter = ReflectionTools.getSetter(obj.getClass(), propertyData);
        setter.set(obj, value, null);
=======
>>>>>>> e0a09dbd793f247af85f276a92a07c17e635cdf3
    }

    @Override
Solution content 
                                   PropertyData propertyData) {
        super(notOwningEntityName, owningEntityName, propertyData);
        this.owningReferencePropertyName = owningReferencePropertyName;
    }

    @Override
File
OneToOneNotOwningMapper.java
Developer's decision
Version 2
Kind of conflict
Annotation
Attribute
If statement
Method declaration
Method invocation
Method signature
Try statement
Variable
Chunk
Conflicting content 
        return checkModified(session, newObj, oldObj);
    }

<<<<<<< HEAD
	@Override
	public void mapModifiedFlagsToMapFromEntity(SessionImplementor session, Map data, Object newObj, Object oldObj) {
		if (propertyData.isUsingModifiedFlag()) {
			data.put(propertyData.getModifiedFlagPropertyName(), checkModified(session, newObj, oldObj));
		}
	}

	@Override
	public void mapModifiedFlagsToMapForCollectionChange(String collectionPropertyName, Map data) {
		if (propertyData.isUsingModifiedFlag()) {
			data.put(propertyData.getModifiedFlagPropertyName(), collectionPropertyName.equals(propertyData.getName()));
		}
	}

	private boolean checkModified(SessionImplementor session, Object newObj, Object oldObj) {
		//noinspection SimplifiableConditionalExpression
		return nonInsertableFake ? false : !Tools.entitiesEqual(session, referencedEntityName, newObj, oldObj);
	}

	public void mapToEntityFromMap(AuditConfiguration verCfg, Object obj, Map data, Object primaryKey,
                                   AuditReaderImplementor versionsReader, Number revision) {
        if (obj == null) {
            return;
        }

		Object entityId;
		entityId = delegate.mapToIdFromMap(data);
        Object value;
        if (entityId == null) {
            value = null;
        } else {
=======
    public void nullSafeMapToEntityFromMap(AuditConfiguration verCfg, Object obj, Map data, Object primaryKey,
                                           AuditReaderImplementor versionsReader, Number revision) {
        Object entityId = delegate.mapToIdFromMap(data);
        Object value = null;
        if (entityId != null) {
>>>>>>> e0a09dbd793f247af85f276a92a07c17e635cdf3
            if (versionsReader.getFirstLevelCache().contains(referencedEntityName, revision, entityId)) {
                value = versionsReader.getFirstLevelCache().get(referencedEntityName, revision, entityId);
            } else {
Solution content 
        return checkModified(session, newObj, oldObj);
    }

    @Override
    public void mapModifiedFlagsToMapFromEntity(SessionImplementor session, Map data, Object newObj, Object oldObj) {
        if (propertyData.isUsingModifiedFlag()) {
            data.put(propertyData.getModifiedFlagPropertyName(), checkModified(session, newObj, oldObj));
        }
    }

    @Override
    public void mapModifiedFlagsToMapForCollectionChange(String collectionPropertyName, Map data) {
        if (propertyData.isUsingModifiedFlag()) {
            data.put(propertyData.getModifiedFlagPropertyName(), collectionPropertyName.equals(propertyData.getName()));
        }
    }

    private boolean checkModified(SessionImplementor session, Object newObj, Object oldObj) {
        //noinspection SimplifiableConditionalExpression
        return nonInsertableFake ? false : !Tools.entitiesEqual(session, referencedEntityName, newObj, oldObj);
    }

    public void nullSafeMapToEntityFromMap(AuditConfiguration verCfg, Object obj, Map data, Object primaryKey,
                                           AuditReaderImplementor versionsReader, Number revision) {
        Object entityId = delegate.mapToIdFromMap(data);
        Object value = null;
        if (entityId != null) {
            if (versionsReader.getFirstLevelCache().contains(referencedEntityName, revision, entityId)) {
                value = versionsReader.getFirstLevelCache().get(referencedEntityName, revision, entityId);
            } else {
File
ToOneIdMapper.java
Developer's decision
Combination
Kind of conflict
Annotation
If statement
Method declaration
Method invocation
Method signature
Variable