/*******************************************************************************
 * Copyright (c) 2013, 2018 CEA LIST and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v20.html
 *
 * Contributors:
 *   E.D.Willink(CEA LIST) - Initial API and implementation
 *******************************************************************************/
package org.eclipse.ocl.examples.codegen.utilities;

import java.util.List;

import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.ocl.examples.codegen.cgmodel.CGCallExp;
import org.eclipse.ocl.examples.codegen.cgmodel.CGCollectionExp;
import org.eclipse.ocl.examples.codegen.cgmodel.CGCollectionPart;
import org.eclipse.ocl.examples.codegen.cgmodel.CGIfExp;
import org.eclipse.ocl.examples.codegen.cgmodel.CGIterationCallExp;
import org.eclipse.ocl.examples.codegen.cgmodel.CGIterator;
import org.eclipse.ocl.examples.codegen.cgmodel.CGLetExp;
import org.eclipse.ocl.examples.codegen.cgmodel.CGMapExp;
import org.eclipse.ocl.examples.codegen.cgmodel.CGMapPart;
import org.eclipse.ocl.examples.codegen.cgmodel.CGNavigationCallExp;
import org.eclipse.ocl.examples.codegen.cgmodel.CGNumber;
import org.eclipse.ocl.examples.codegen.cgmodel.CGOperationCallExp;
import org.eclipse.ocl.examples.codegen.cgmodel.CGShadowExp;
import org.eclipse.ocl.examples.codegen.cgmodel.CGShadowPart;
import org.eclipse.ocl.examples.codegen.cgmodel.CGTupleExp;
import org.eclipse.ocl.examples.codegen.cgmodel.CGTuplePart;
import org.eclipse.ocl.examples.codegen.cgmodel.CGValuedElement;
import org.eclipse.ocl.pivot.CollectionLiteralExp;
import org.eclipse.ocl.pivot.Element;
import org.eclipse.ocl.pivot.LoopExp;
import org.eclipse.ocl.pivot.MapLiteralExp;
import org.eclipse.ocl.pivot.NavigationCallExp;
import org.eclipse.ocl.pivot.OperationCallExp;
import org.eclipse.ocl.pivot.OppositePropertyCallExp;
import org.eclipse.ocl.pivot.Property;
import org.eclipse.ocl.pivot.PropertyCallExp;
import org.eclipse.ocl.pivot.ShadowExp;
import org.eclipse.ocl.pivot.ShadowPart;
import org.eclipse.ocl.pivot.TupleLiteralExp;
import org.eclipse.ocl.pivot.TupleLiteralPart;
import org.eclipse.ocl.pivot.utilities.ValueUtil;
import org.eclipse.ocl.pivot.values.IntegerValue;
import org.eclipse.ocl.pivot.values.RealValue;

/**
 * EquivalenceUtil provides the bodies for many of the isEquivalentToInternal operations.
 *
 * These return:
 * <br>
 * true if two values are definitely the same.
 * <br>
 * false if two values are definitely different.
 * <br>
 * null if the values could be the same or different.
 */
public class EquivalenceUtil
{
	public static @Nullable Boolean isEquivalent(@NonNull CGCallExp thisValue, @NonNull CGCallExp thatValue) {
		if (thisValue == thatValue) {
			return Boolean.TRUE;
		}
		CGValuedElement thisSource = thisValue.getSource();
		CGValuedElement thatSource = thatValue.getSource();
		if ((thisSource != null) || (thatSource != null)) {
			if ((thisSource == null) || (thatSource == null)) {
				return null;			// Inconsistent sources should never happen
			}
			Boolean equivalence = thisSource.isEquivalentTo(thatSource);
			if (equivalence != Boolean.TRUE) {
				return null;			// Different sources do not guarantee different results
			}
		}
		return Boolean.TRUE;
	}

	public static @Nullable Boolean isEquivalent(@NonNull CGCollectionExp thisValue, @NonNull CGCollectionExp thatValue) {
		if (thisValue == thatValue) {
			return Boolean.TRUE;
		}
		Element thisAST = thisValue.getAst();
		Element thatAST = thatValue.getAst();
		if (!(thisAST instanceof CollectionLiteralExp) || !(thatAST instanceof CollectionLiteralExp)) {
			return null;					// Null ASTs should never happen
		}
		if (((CollectionLiteralExp)thisAST).getKind() != ((CollectionLiteralExp)thatAST).getKind()) {
			return Boolean.FALSE;			// Distinct kinds are not necessarily not equal
		}
		List<CGCollectionPart> theseParts = thisValue.getParts();
		List<CGCollectionPart> thoseParts = thatValue.getParts();
		int iSize = theseParts.size();
		if (iSize != thoseParts.size()) {
			return null; //Boolean.FALSE;				-- FIXME support range/items comparison
		}
		for (int i = 0; i < iSize; i++) {
			CGCollectionPart thisPart = theseParts.get(i);
			CGCollectionPart thatPart = thoseParts.get(i);
			if ((thisPart == null) || (thatPart == null)) {
				return null;				// Null parts should never happen
			}
			Boolean equivalence = thisPart.isEquivalentTo(thatPart);
			if (equivalence != Boolean.TRUE) {
				return null; // equivalence;			-- FIXME support differently ordered comparison
			}
		}
		return Boolean.TRUE;
	}

	public static @Nullable Boolean isEquivalent(@NonNull CGCollectionPart thisValue, @NonNull CGCollectionPart thatValue) {
		if (thisValue == thatValue) {
			return Boolean.TRUE;
		}
		CGValuedElement thisLast = thisValue.getLast();
		CGValuedElement thatLast = thatValue.getLast();
		if ((thisLast != null) || (thatLast != null)) {
			if ((thisLast == null) || (thatLast == null)) {
				return null; 				// FIXME could support range/items comparison
			}
			Boolean equivalence = thisLast.isEquivalentTo(thatLast);
			if (equivalence != Boolean.TRUE) {
				return equivalence;
			}
		}
		CGValuedElement thisFirst = thisValue.getFirst();
		CGValuedElement thatFirst = thatValue.getFirst();
		if ((thisFirst == null) || (thatFirst == null)) {
			return null; 					// FIXME could support range/items comparison
		}
		return thisFirst.isEquivalentTo(thatFirst);
	}

	public static @Nullable Boolean isEquivalent(@NonNull CGIfExp thisValue, @NonNull CGIfExp thatValue) {
		if (thisValue == thatValue) {
			return Boolean.TRUE;
		}
		if (thisValue.isConstant() && thatValue.isConstant()) {				// FIXME Move to caller
			CGValuedElement thisConstant = thisValue.getNamedValue();
			CGValuedElement thatConstant = thatValue.getNamedValue();
			return thisConstant.isEquivalentTo(thatConstant);
		}
		CGValuedElement thisCondition = thisValue.getCondition();
		CGValuedElement thatCondition = thatValue.getCondition();
		if ((thisCondition != null) || (thatCondition != null)) {
			if ((thisCondition == null) || (thatCondition == null)) {
				return null;			// Inconsistent conditions should never happen
			}
			Boolean equivalence = thisCondition.isEquivalentTo(thatCondition);
			if (equivalence != Boolean.TRUE) {
				return null;			// Different conditions do not guarantee different results
			}
		}
		CGValuedElement thisThen = thisValue.getThenExpression();
		CGValuedElement thatThen = thatValue.getThenExpression();
		if ((thisThen != null) || (thatThen != null)) {
			if ((thisThen == null) || (thatThen == null)) {
				return null;			// Inconsistent expressions should never happen
			}
			Boolean equivalence = thisThen.isEquivalentTo(thatThen);
			if (equivalence != Boolean.TRUE) {
				return null;			// Different expressions do not guarantee different results
			}
		}
		CGValuedElement thisElse = thisValue.getElseExpression();
		CGValuedElement thatElse = thatValue.getElseExpression();
		if ((thisElse != null) || (thatElse != null)) {
			if ((thisElse == null) || (thatElse == null)) {
				return null;			// Inconsistent expressions should never happen
			}
			Boolean equivalence = thisElse.isEquivalentTo(thatElse);
			if (equivalence != Boolean.TRUE) {
				return null;			// Different expressions do not guarantee different results
			}
		}
		return Boolean.TRUE;
	}

	public static @Nullable Boolean isEquivalent(@NonNull CGIterationCallExp thisValue, @NonNull CGIterationCallExp thatValue) {
		if (thisValue == thatValue) {
			return Boolean.TRUE;
		}
		Element thisAST = thisValue.getAst();
		Element thatAST = thatValue.getAst();
		if (!(thisAST instanceof LoopExp) || !(thatAST instanceof LoopExp)) {
			return null;			// Null ASTs should never happen
		}
		if (((LoopExp)thisAST).getReferredIteration() != ((LoopExp)thatAST).getReferredIteration()) {
			return null;			// Different iterators do not guarantee different results
		}
		CGValuedElement thisSource = thisValue.getSource();
		CGValuedElement thatSource = thatValue.getSource();
		if ((thisSource != null) || (thatSource != null)) {
			if ((thisSource == null) || (thatSource == null)) {
				return null;			// Inconsistent sources should never happen
			}
			Boolean equivalence = thisSource.isEquivalentTo(thatSource);
			if (equivalence != Boolean.TRUE) {
				return null;			// Different sources do not guarantee different results
			}
		}
		CGValuedElement thisBody = thisValue.getBody();
		CGValuedElement thatBody = thatValue.getBody();
		if ((thisBody != null) || (thatBody != null)) {
			if ((thisBody == null) || (thatBody == null)) {
				return null;			// Null bodies should never happen
			}
			Boolean equivalence = thisBody.isEquivalentTo(thatBody);
			if (equivalence != Boolean.TRUE) {
				return null;			// Different bodies do not guarantee different results
			}
		}
		List<CGIterator> theseIterators = thisValue.getIterators();
		List<CGIterator> thoseIterators = thatValue.getIterators();
		int iSize = theseIterators.size();
		if (iSize != thoseIterators.size()) {
			return null;			// Different iterator lists do not guarantee different results
		}
		for (int i = 0; i < iSize; i++) {
			CGIterator thisIterator = theseIterators.get(i);
			CGIterator thatIterator = thoseIterators.get(i);
			if ((thisIterator != null) || (thatIterator != null)) {
				if ((thisIterator == null) || (thatIterator == null)) {
					return null;			// Null iterators should never happen
				}
				Boolean equivalence = thisIterator.isEquivalentTo(thatIterator);
				if (equivalence != Boolean.TRUE) {
					return null;			// Different iterators do not guarantee different results
				}
			}
		}
		List<CGIterator> theseCoIterators = thisValue.getCoIterators();
		List<CGIterator> thoseCoIterators = thatValue.getCoIterators();
		int iCoSize = theseCoIterators.size();
		if (iCoSize != thoseCoIterators.size()) {
			return null;			// Different iterator lists do not guarantee different results
		}
		for (int i = 0; i < iCoSize; i++) {
			CGIterator thisCoIterator = theseCoIterators.get(i);
			CGIterator thatCoIterator = thoseCoIterators.get(i);
			if ((thisCoIterator != null) || (thatCoIterator != null)) {
				if ((thisCoIterator == null) || (thatCoIterator == null)) {
					return null;			// Null co-iterators should never happen
				}
				Boolean equivalence = thisCoIterator.isEquivalentTo(thatCoIterator);
				if (equivalence != Boolean.TRUE) {
					return null;			// Different iterators do not guarantee different results
				}
			}
		}
		return Boolean.TRUE;
	}

	public static @Nullable Boolean isEquivalent(@NonNull CGLetExp thisValue, @NonNull CGLetExp thatValue) {
		if (thisValue == thatValue) {
			return Boolean.TRUE;
		}
		if (thisValue.isConstant() && thatValue.isConstant()) {				// FIXME Move to caller
			CGValuedElement thisConstant = thisValue.getNamedValue();
			CGValuedElement thatConstant = thatValue.getNamedValue();
			return thisConstant.isEquivalentTo(thatConstant);
		}
		CGValuedElement thisInit = thisValue.getInit();
		CGValuedElement thatInit = thatValue.getInit();
		if ((thisInit != null) || (thatInit != null)) {
			if ((thisInit == null) || (thatInit == null)) {
				return null;			// Inconsistent inits should never happen
			}
			Boolean equivalence = thisInit.isEquivalentTo(thatInit);
			if (equivalence != Boolean.TRUE) {
				return null;			// Different inits do not guarantee different results
			}
		}
		CGValuedElement thisIn = thisValue.getIn();
		CGValuedElement thatIn = thatValue.getIn();
		if ((thisIn != null) || (thatIn != null)) {
			if ((thisIn == null) || (thatIn == null)) {
				return null;			// Inconsistent expressions should never happen
			}
			Boolean equivalence = thisIn.isEquivalentTo(thatIn);
			if (equivalence != Boolean.TRUE) {
				return null;			// Different expressions do not guarantee different results
			}
		}
		return Boolean.TRUE;
	}

	public static @Nullable Boolean isEquivalent(@NonNull CGMapExp thisValue, @NonNull CGMapExp thatValue) {
		if (thisValue == thatValue) {
			return Boolean.TRUE;
		}
		Element thisAST = thisValue.getAst();
		Element thatAST = thatValue.getAst();
		if (!(thisAST instanceof MapLiteralExp) || !(thatAST instanceof MapLiteralExp)) {
			return null;					// Null ASTs should never happen
		}
		List<CGMapPart> theseParts = thisValue.getParts();
		List<CGMapPart> thoseParts = thatValue.getParts();
		int iSize = theseParts.size();
		if (iSize != thoseParts.size()) {
			return null; //Boolean.FALSE;				-- FIXME support range/items comparison
		}
		for (int i = 0; i < iSize; i++) {
			CGMapPart thisPart = theseParts.get(i);
			CGMapPart thatPart = thoseParts.get(i);
			if ((thisPart == null) || (thatPart == null)) {
				return null;				// Null parts should never happen
			}
			Boolean equivalence = thisPart.isEquivalentTo(thatPart);
			if (equivalence != Boolean.TRUE) {
				return null; // equivalence;			-- FIXME support differently ordered comparison
			}
		}
		return Boolean.TRUE;
	}

	public static @Nullable Boolean isEquivalent(@NonNull CGMapPart thisPart, @NonNull CGMapPart thatPart) {
		if (thisPart == thatPart) {
			return Boolean.TRUE;
		}
		CGValuedElement thisKey = thisPart.getKey();
		CGValuedElement thatKey = thatPart.getKey();
		if ((thisKey != null) || (thatKey != null)) {
			if ((thisKey == null) || (thatKey == null)) {
				return null;
			}
			Boolean equivalence = thisKey.isEquivalentTo(thatKey);
			if (equivalence != Boolean.TRUE) {
				return equivalence;
			}
		}
		CGValuedElement thisValue = thisPart.getValue();
		CGValuedElement thatValue = thatPart.getValue();
		if ((thisValue == null) || (thatValue == null)) {
			return null; 					// FIXME could support range/items comparison
		}
		return thisValue.isEquivalentTo(thatValue);
	}

	public static @Nullable Boolean isEquivalent(@NonNull CGNumber thisValue, @NonNull CGNumber thatValue) {
		if (thisValue == thatValue) {
			return Boolean.TRUE;
		}
		Number thisNumber = thisValue.getNumericValue();
		Number thatNumber = thatValue.getNumericValue();
		if ((thisNumber == null) || (thatNumber == null)) {
			return null;			// Null numbers should never happen
		}
		else if (thisNumber.getClass() == thatNumber.getClass()) {
			return thisNumber.equals(thatNumber);
		}
		else if ((thisNumber instanceof RealValue) && (thatNumber instanceof RealValue)) {
			return thisNumber.equals(thatNumber);
		}
		else if (ValueUtil.isRealNumber(thisNumber) || ValueUtil.isRealNumber(thatNumber)) {
			RealValue thisReal = ValueUtil.realValueOf(thisNumber);
			RealValue thatReal = ValueUtil.realValueOf(thatNumber);
			return thisReal.equals(thatReal);
		}
		else if (ValueUtil.isIntegerNumber(thisNumber) && ValueUtil.isIntegerNumber(thatNumber)) {
			IntegerValue thisInteger = ValueUtil.integerValueOf(thisNumber);
			IntegerValue thatInterger = ValueUtil.integerValueOf(thatNumber);
			return thisInteger.equals(thatInterger);
		}
		else {					// This should never happen
			double thisDouble = thisNumber.doubleValue();
			double thatDouble = thatNumber.doubleValue();
			return thisDouble == thatDouble;
		}
	}

	public static @Nullable Boolean isEquivalent(@NonNull CGOperationCallExp thisValue, @NonNull CGOperationCallExp thatValue) {
		if (thisValue == thatValue) {
			return Boolean.TRUE;
		}
		Element thisAST = thisValue.getAst();
		Element thatAST = thatValue.getAst();
		if (!(thisAST instanceof OperationCallExp) || !(thatAST instanceof OperationCallExp)) {
			return null;			// Null ASTs should never happen
		}
		if (((OperationCallExp)thisAST).getReferredOperation() != ((OperationCallExp)thatAST).getReferredOperation()) {
			return null;			// Different operations do not guarantee different results
		}
		// FIXME non-conformant return types can be guaranteed to be different
		CGValuedElement thisSource = thisValue.getSource();
		CGValuedElement thatSource = thatValue.getSource();
		if ((thisSource != null) || (thatSource != null)) {
			if ((thisSource == null) || (thatSource == null)) {
				return null;			// Inconsistently null sources should never happen
			}
			Boolean equivalence = thisSource.isEquivalentTo(thatSource);
			if (equivalence != Boolean.TRUE) {
				return null;			// Different sources do not guarantee different results
			}
		}
		List<CGValuedElement> theseArguments = thisValue.getArguments();
		List<CGValuedElement> thoseArguments = thatValue.getArguments();
		int iSize = theseArguments.size();
		if (iSize != thoseArguments.size()) {
			return null;				// Different argument lists do not guarantee different results
		}
		for (int i = 0; i < iSize; i++) {
			CGValuedElement thisArgument = theseArguments.get(i);
			CGValuedElement thatArgument = thoseArguments.get(i);
			if ((thisArgument != null) || (thatArgument != null)) {
				if ((thisArgument == null) || (thatArgument == null)) {
					return null;			// Null arguments should never happen
				}
				Boolean equivalence = thisArgument.isEquivalentTo(thatArgument);
				if (equivalence != Boolean.TRUE) {
					return null;			// Different arguments do not guarantee different results
				}
			}
		}
		return Boolean.TRUE;
	}

	public static @Nullable Boolean isEquivalent(@NonNull CGNavigationCallExp thisValue, @NonNull CGNavigationCallExp thatValue) {
		if (thisValue == thatValue) {
			return Boolean.TRUE;
		}
		Element thisAST = thisValue.getAst();
		Element thatAST = thatValue.getAst();
		if (!(thisAST instanceof NavigationCallExp) || !(thatAST instanceof NavigationCallExp)) {
			return null;			// Null ASTs should never happen
		}
		if (thisAST.eClass() != thatAST.eClass()) {
			return null;			// Different directions do not guarantee different results
		}
		Property thisProperty = thisAST instanceof PropertyCallExp ? ((PropertyCallExp)thisAST).getReferredProperty() : ((OppositePropertyCallExp)thisAST).getReferredProperty();
		Property thatProperty = thatAST instanceof PropertyCallExp ? ((PropertyCallExp)thatAST).getReferredProperty() : ((OppositePropertyCallExp)thatAST).getReferredProperty();
		if (thisProperty != thatProperty) {
			return null;			// Different properties do not guarantee different results
		}
		// FIXME non-conformant return types can be guaranteed to be different
		CGValuedElement thisSource = thisValue.getSource();
		CGValuedElement thatSource = thatValue.getSource();
		if ((thisSource != null) || (thatSource != null)) {
			if ((thisSource == null) || (thatSource == null)) {
				return null;			// Inconsistently null sources should never happen
			}
			Boolean equivalence = thisSource.isEquivalentTo(thatSource);
			if (equivalence != Boolean.TRUE) {
				return null;			// Different sources do not guarantee different results
			}
		}
		return Boolean.TRUE;
	}

	public static @Nullable Boolean isEquivalent(@NonNull CGShadowExp thisValue, @NonNull CGShadowExp thatValue) {
		if (thisValue == thatValue) {
			return Boolean.TRUE;
		}
		Element thisAST = thisValue.getAst();
		Element thatAST = thatValue.getAst();
		if (!(thisAST instanceof ShadowExp) || !(thatAST instanceof ShadowExp)) {
			return null;					// Null ASTs should never happen
		}
		if (((ShadowExp)thisAST).getTypeId() != ((ShadowExp)thatAST).getTypeId()) {
			return Boolean.FALSE;			// Distinct typeids are necessarily not equal
		}
		List<CGShadowPart> theseParts = thisValue.getParts();
		List<CGShadowPart> thoseParts = thatValue.getParts();
		int iSize = theseParts.size();
		if (iSize != thoseParts.size()) {
			return Boolean.FALSE;			// Distinct part lists are necessarily not equal
		}
		for (int i = 0; i < iSize; i++) {
			CGShadowPart thisPart = theseParts.get(i);
			CGShadowPart thatPart = thoseParts.get(i);
			if ((thisPart == null) || (thatPart == null)) {
				return null;				// Null parts should never happen
			}
			Boolean equivalence = thisPart.isEquivalentTo(thatPart);
			if (equivalence != Boolean.TRUE) {
				return equivalence;			// Distinct parts are necessarily not equal
			}
		}
		return Boolean.TRUE;
	}

	public static @Nullable Boolean isEquivalent(@NonNull CGShadowPart thisValue, @NonNull CGShadowPart thatValue) {
		if (thisValue == thatValue) {
			return Boolean.TRUE;
		}
		Element thisAST = thisValue.getAst();
		Element thatAST = thatValue.getAst();
		if (!(thisAST instanceof ShadowPart) || !(thatAST instanceof ShadowPart)) {
			return null;					// Null ASTs should never happen
		}
		if (((ShadowPart)thisAST).getTypeId() != ((ShadowPart)thatAST).getTypeId()) {
			return Boolean.FALSE;			// Distinct typeids are necessarily not equal
		}
		CGValuedElement thisPartInit = thisValue.getInit();
		CGValuedElement thatPartInit = thatValue.getInit();
		if ((thisPartInit == null) || (thatPartInit == null)) {
			return null;			// Null inits should never happen
		}
		return thisPartInit.isEquivalentTo(thatPartInit);
	}

	public static @Nullable Boolean isEquivalent(@NonNull CGTupleExp thisValue, @NonNull CGTupleExp thatValue) {
		if (thisValue == thatValue) {
			return Boolean.TRUE;
		}
		Element thisAST = thisValue.getAst();
		Element thatAST = thatValue.getAst();
		if (!(thisAST instanceof TupleLiteralExp) || !(thatAST instanceof TupleLiteralExp)) {
			return null;					// Null ASTs should never happen
		}
		if (((TupleLiteralExp)thisAST).getTypeId() != ((TupleLiteralExp)thatAST).getTypeId()) {
			return Boolean.FALSE;			// Distinct typeids are necessarily not equal
		}
		List<CGTuplePart> theseParts = thisValue.getParts();
		List<CGTuplePart> thoseParts = thatValue.getParts();
		int iSize = theseParts.size();
		if (iSize != thoseParts.size()) {
			return Boolean.FALSE;			// Distinct part lists are necessarily not equal
		}
		for (int i = 0; i < iSize; i++) {
			CGTuplePart thisPart = theseParts.get(i);
			CGTuplePart thatPart = thoseParts.get(i);
			if ((thisPart == null) || (thatPart == null)) {
				return null;				// Null parts should never happen
			}
			Boolean equivalence = thisPart.isEquivalentTo(thatPart);
			if (equivalence != Boolean.TRUE) {
				return equivalence;			// Distinct parts are necessarily not equal
			}
		}
		return Boolean.TRUE;
	}

	public static @Nullable Boolean isEquivalent(@NonNull CGTuplePart thisValue, @NonNull CGTuplePart thatValue) {
		if (thisValue == thatValue) {
			return Boolean.TRUE;
		}
		Element thisAST = thisValue.getAst();
		Element thatAST = thatValue.getAst();
		if (!(thisAST instanceof TupleLiteralPart) || !(thatAST instanceof TupleLiteralPart)) {
			return null;					// Null ASTs should never happen
		}
		if (((TupleLiteralPart)thisAST).getTypeId() != ((TupleLiteralPart)thatAST).getTypeId()) {
			return Boolean.FALSE;			// Distinct typeids are necessarily not equal
		}
		CGValuedElement thisPartInit = thisValue.getInit();
		CGValuedElement thatPartInit = thatValue.getInit();
		if ((thisPartInit == null) || (thatPartInit == null)) {
			return null;			// Null inits should never happen
		}
		return thisPartInit.isEquivalentTo(thatPartInit);
	}
}