org.umlg.rootallinstances.TopRoot Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of umlg-test-blueprints Show documentation
The newest version!
package org.umlg.rootallinstances;

import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.text.StringEscapeUtils;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.umlg.rootallinstances.TopRootChild.TopRootChildRuntimePropertyEnum;
import org.umlg.runtime.adaptor.UMLG;
import org.umlg.runtime.adaptor.UmlgLabelConverterFactory;
import org.umlg.runtime.collection.Filter;
import org.umlg.runtime.collection.Qualifier;
import org.umlg.runtime.collection.UmlgCollection;
import org.umlg.runtime.collection.UmlgRuntimeProperty;
import org.umlg.runtime.collection.UmlgSet;
import org.umlg.runtime.collection.memory.UmlgMemorySet;
import org.umlg.runtime.collection.persistent.PropertyTree;
import org.umlg.runtime.collection.persistent.UmlgSetImpl;
import org.umlg.runtime.domain.CompositionNode;
import org.umlg.runtime.domain.DataTypeEnum;
import org.umlg.runtime.domain.UmlgNode;
import org.umlg.runtime.domain.UmlgRootNode;
import org.umlg.runtime.util.ObjectMapperFactory;
import org.umlg.runtime.util.UmlgFormatter;
import org.umlg.runtime.validation.UmlgConstraintViolation;
import org.umlg.runtime.validation.UmlgConstraintViolationException;
import org.umlg.runtime.validation.UmlgValidation;
import org.umlg.runtime.validation.UmlgValidator;

public class TopRoot extends MiddleRoot implements UmlgRootNode, CompositionNode {
	static final public long serialVersionUID = 1L;
	private UmlgSet indexedName;
	private UmlgSet indexedNonUniqueName;
	private UmlgSet indexUniqueInteger;
	private UmlgSet indexNonUniqueInteger;
	private UmlgSet indexUniqueUnlimitedNatural;
	private UmlgSet indexNonUniqueUnlimitedNatural;
	private UmlgSet indexUniqueReal;
	private UmlgSet indexNonUniqueReal;
	private UmlgSet indexNonUniqueBoolean;
	private UmlgSet topRootChild;

	/**
	 * constructor for TopRoot
	 * 
	 * @param id 
	 */
	public TopRoot(Object id)  {
		super(id);
	}
	
	/**
	 * constructor for TopRoot
	 * 
	 * @param vertex 
	 */
	public TopRoot(Vertex vertex)  {
		super(vertex);
	}
	
	/**
	 * default constructor for TopRoot
	 */
	public TopRoot()  {
		this(true);
	}
	
	/**
	 * constructor for TopRoot
	 * 
	 * @param persistent 
	 */
	public TopRoot(Boolean persistent)  {
		super(persistent);
	}

	public void addToIndexNonUniqueBoolean(Boolean indexNonUniqueBoolean) {
		if ( !this.indexNonUniqueBoolean.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexNonUniqueBoolean != null ) {
			List violations = validateIndexNonUniqueBoolean(indexNonUniqueBoolean);
			if ( violations.isEmpty() ) {
				this.indexNonUniqueBoolean.add(indexNonUniqueBoolean);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToIndexNonUniqueBooleanIgnoreInverse(Boolean indexNonUniqueBoolean) {
		if ( !this.indexNonUniqueBoolean.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexNonUniqueBoolean != null ) {
			List violations = validateIndexNonUniqueBoolean(indexNonUniqueBoolean);
			if ( violations.isEmpty() ) {
				this.indexNonUniqueBoolean.add(indexNonUniqueBoolean);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToIndexNonUniqueInteger(Integer indexNonUniqueInteger) {
		if ( !this.indexNonUniqueInteger.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexNonUniqueInteger != null ) {
			List violations = validateIndexNonUniqueInteger(indexNonUniqueInteger);
			if ( violations.isEmpty() ) {
				this.indexNonUniqueInteger.add(indexNonUniqueInteger);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToIndexNonUniqueIntegerIgnoreInverse(Integer indexNonUniqueInteger) {
		if ( !this.indexNonUniqueInteger.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexNonUniqueInteger != null ) {
			List violations = validateIndexNonUniqueInteger(indexNonUniqueInteger);
			if ( violations.isEmpty() ) {
				this.indexNonUniqueInteger.add(indexNonUniqueInteger);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToIndexNonUniqueReal(Double indexNonUniqueReal) {
		if ( !this.indexNonUniqueReal.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexNonUniqueReal != null ) {
			List violations = validateIndexNonUniqueReal(indexNonUniqueReal);
			if ( violations.isEmpty() ) {
				this.indexNonUniqueReal.add(indexNonUniqueReal);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToIndexNonUniqueRealIgnoreInverse(Double indexNonUniqueReal) {
		if ( !this.indexNonUniqueReal.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexNonUniqueReal != null ) {
			List violations = validateIndexNonUniqueReal(indexNonUniqueReal);
			if ( violations.isEmpty() ) {
				this.indexNonUniqueReal.add(indexNonUniqueReal);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToIndexNonUniqueUnlimitedNatural(Integer indexNonUniqueUnlimitedNatural) {
		if ( !this.indexNonUniqueUnlimitedNatural.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexNonUniqueUnlimitedNatural != null ) {
			List violations = validateIndexNonUniqueUnlimitedNatural(indexNonUniqueUnlimitedNatural);
			if ( violations.isEmpty() ) {
				this.indexNonUniqueUnlimitedNatural.add(indexNonUniqueUnlimitedNatural);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToIndexNonUniqueUnlimitedNaturalIgnoreInverse(Integer indexNonUniqueUnlimitedNatural) {
		if ( !this.indexNonUniqueUnlimitedNatural.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexNonUniqueUnlimitedNatural != null ) {
			List violations = validateIndexNonUniqueUnlimitedNatural(indexNonUniqueUnlimitedNatural);
			if ( violations.isEmpty() ) {
				this.indexNonUniqueUnlimitedNatural.add(indexNonUniqueUnlimitedNatural);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToIndexUniqueInteger(Integer indexUniqueInteger) {
		if ( !this.indexUniqueInteger.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexUniqueInteger != null ) {
			List violations = validateIndexUniqueInteger(indexUniqueInteger);
			if ( violations.isEmpty() ) {
				this.indexUniqueInteger.add(indexUniqueInteger);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToIndexUniqueIntegerIgnoreInverse(Integer indexUniqueInteger) {
		if ( !this.indexUniqueInteger.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexUniqueInteger != null ) {
			List violations = validateIndexUniqueInteger(indexUniqueInteger);
			if ( violations.isEmpty() ) {
				this.indexUniqueInteger.add(indexUniqueInteger);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToIndexUniqueReal(Double indexUniqueReal) {
		if ( !this.indexUniqueReal.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexUniqueReal != null ) {
			List violations = validateIndexUniqueReal(indexUniqueReal);
			if ( violations.isEmpty() ) {
				this.indexUniqueReal.add(indexUniqueReal);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToIndexUniqueRealIgnoreInverse(Double indexUniqueReal) {
		if ( !this.indexUniqueReal.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexUniqueReal != null ) {
			List violations = validateIndexUniqueReal(indexUniqueReal);
			if ( violations.isEmpty() ) {
				this.indexUniqueReal.add(indexUniqueReal);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToIndexUniqueUnlimitedNatural(Integer indexUniqueUnlimitedNatural) {
		if ( !this.indexUniqueUnlimitedNatural.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexUniqueUnlimitedNatural != null ) {
			List violations = validateIndexUniqueUnlimitedNatural(indexUniqueUnlimitedNatural);
			if ( violations.isEmpty() ) {
				this.indexUniqueUnlimitedNatural.add(indexUniqueUnlimitedNatural);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToIndexUniqueUnlimitedNaturalIgnoreInverse(Integer indexUniqueUnlimitedNatural) {
		if ( !this.indexUniqueUnlimitedNatural.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexUniqueUnlimitedNatural != null ) {
			List violations = validateIndexUniqueUnlimitedNatural(indexUniqueUnlimitedNatural);
			if ( violations.isEmpty() ) {
				this.indexUniqueUnlimitedNatural.add(indexUniqueUnlimitedNatural);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToIndexedName(String indexedName) {
		if ( !this.indexedName.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexedName != null ) {
			List violations = validateIndexedName(indexedName);
			if ( violations.isEmpty() ) {
				this.indexedName.add(indexedName);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToIndexedNameIgnoreInverse(String indexedName) {
		if ( !this.indexedName.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexedName != null ) {
			List violations = validateIndexedName(indexedName);
			if ( violations.isEmpty() ) {
				this.indexedName.add(indexedName);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToIndexedNonUniqueName(String indexedNonUniqueName) {
		if ( !this.indexedNonUniqueName.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexedNonUniqueName != null ) {
			List violations = validateIndexedNonUniqueName(indexedNonUniqueName);
			if ( violations.isEmpty() ) {
				this.indexedNonUniqueName.add(indexedNonUniqueName);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToIndexedNonUniqueNameIgnoreInverse(String indexedNonUniqueName) {
		if ( !this.indexedNonUniqueName.isEmpty() ) {
			throw new RuntimeException("Property is a one and already has value, first clear it before adding!");
		}
		if ( indexedNonUniqueName != null ) {
			List violations = validateIndexedNonUniqueName(indexedNonUniqueName);
			if ( violations.isEmpty() ) {
				this.indexedNonUniqueName.add(indexedNonUniqueName);
			} else {
				throw new UmlgConstraintViolationException(violations);
			}
		}
	}
	
	public void addToTopRootChild(TopRootChild topRootChild) {
		if ( topRootChild != null ) {
			topRootChild.clearTopRoot();
			topRootChild.initialiseProperty(TopRootChildRuntimePropertyEnum.topRoot, false, true);
			removeFromTopRootChild(topRootChild);
		}
		if ( topRootChild != null ) {
			this.topRootChild.add(topRootChild);
		}
	}
	
	public void addToTopRootChild(UmlgSet topRootChild) {
		if ( !topRootChild.isEmpty() ) {
			this.topRootChild.addAll(topRootChild);
		}
	}
	
	public void addToTopRootChildIgnoreInverse(TopRootChild topRootChild) {
		if ( topRootChild != null ) {
			topRootChild.clearTopRoot();
			topRootChild.initialiseProperty(TopRootChildRuntimePropertyEnum.topRoot, false, true);
			removeFromTopRootChild(topRootChild);
		}
		if ( topRootChild != null ) {
			this.topRootChild.addIgnoreInverse(topRootChild);
		}
	}
	
	static public UmlgSet allInstances(Filter filter) {
		UmlgSet result = new UmlgMemorySet();
		result.addAll(UMLG.get().allInstances(TopRoot.class.getName(), filter));
		return result;
	}
	
	static public UmlgSet allInstances() {
		UmlgSet result = new UmlgMemorySet();
		result.addAll(UMLG.get().allInstances(TopRoot.class.getName()));
		return result;
	}
	
	@Override
	public List checkClassConstraints() {
		List result = new ArrayList();
		result.addAll(super.checkClassConstraints());
		return result;
	}
	
	public void clearIndexNonUniqueBoolean() {
		this.indexNonUniqueBoolean.clear();
	}
	
	public void clearIndexNonUniqueInteger() {
		this.indexNonUniqueInteger.clear();
	}
	
	public void clearIndexNonUniqueReal() {
		this.indexNonUniqueReal.clear();
	}
	
	public void clearIndexNonUniqueUnlimitedNatural() {
		this.indexNonUniqueUnlimitedNatural.clear();
	}
	
	public void clearIndexUniqueInteger() {
		this.indexUniqueInteger.clear();
	}
	
	public void clearIndexUniqueReal() {
		this.indexUniqueReal.clear();
	}
	
	public void clearIndexUniqueUnlimitedNatural() {
		this.indexUniqueUnlimitedNatural.clear();
	}
	
	public void clearIndexedName() {
		this.indexedName.clear();
	}
	
	public void clearIndexedNonUniqueName() {
		this.indexedNonUniqueName.clear();
	}
	
	public void clearTopRootChild() {
		this.topRootChild.clear();
	}
	
	@Override
	public void delete() {
		for ( TopRootChild child : getTopRootChild() ) {
			child.delete();
		}
		super.delete();
	}
	
	@Override
	public void fromJson(Map propertyMap) {
		fromJsonDataTypeAndComposite(propertyMap);
		fromJsonNonCompositeOne(propertyMap);
		fromJsonNonCompositeRequiredMany(propertyMap);
	}
	
	@Override
	public void fromJson(String json) {
		ObjectMapper mapper = ObjectMapperFactory.INSTANCE.getObjectMapper();
		try {
			@SuppressWarnings(	"unchecked")
			 Map propertyMap = mapper.readValue(json, Map.class);
			fromJson(propertyMap);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	
	@Override
	public void fromJsonDataTypeAndComposite(Map propertyMap) {
		Number indexNonUniqueIntegerAsNumber = (Number)propertyMap.get("indexNonUniqueInteger");
		Number indexUniqueUnlimitedNaturalAsNumber = (Number)propertyMap.get("indexUniqueUnlimitedNatural");
		Number indexUniqueIntegerAsNumber = (Number)propertyMap.get("indexUniqueInteger");
		Number indexNonUniqueRealAsNumber = (Number)propertyMap.get("indexNonUniqueReal");
		Number indexNonUniqueUnlimitedNaturalAsNumber = (Number)propertyMap.get("indexNonUniqueUnlimitedNatural");
		Number indexUniqueRealAsNumber = (Number)propertyMap.get("indexUniqueReal");
		super.fromJsonDataTypeAndComposite(propertyMap);
		if ( propertyMap.containsKey("indexNonUniqueInteger") ) {
			if ( propertyMap.get("indexNonUniqueInteger") != null ) {
				Integer indexNonUniqueInteger = indexNonUniqueIntegerAsNumber != null ? indexNonUniqueIntegerAsNumber.intValue() : null;
				setIndexNonUniqueInteger(indexNonUniqueInteger);
			} else {
				setIndexNonUniqueInteger(null);
			}
		}
		if ( propertyMap.containsKey("indexedNonUniqueName") ) {
			if ( propertyMap.get("indexedNonUniqueName") != null ) {
				String indexedNonUniqueName = (String)propertyMap.get("indexedNonUniqueName");
				setIndexedNonUniqueName(indexedNonUniqueName);
			} else {
				setIndexedNonUniqueName(null);
			}
		}
		if ( propertyMap.containsKey("indexUniqueUnlimitedNatural") ) {
			if ( propertyMap.get("indexUniqueUnlimitedNatural") != null ) {
				Integer indexUniqueUnlimitedNatural = indexUniqueUnlimitedNaturalAsNumber != null ? indexUniqueUnlimitedNaturalAsNumber.intValue() : null;
				setIndexUniqueUnlimitedNatural(indexUniqueUnlimitedNatural);
			} else {
				setIndexUniqueUnlimitedNatural(null);
			}
		}
		if ( propertyMap.containsKey("indexNonUniqueBoolean") ) {
			if ( propertyMap.get("indexNonUniqueBoolean") != null ) {
				Boolean indexNonUniqueBoolean = (Boolean)propertyMap.get("indexNonUniqueBoolean");
				setIndexNonUniqueBoolean(indexNonUniqueBoolean);
			} else {
				setIndexNonUniqueBoolean(null);
			}
		}
		if ( propertyMap.containsKey("indexUniqueInteger") ) {
			if ( propertyMap.get("indexUniqueInteger") != null ) {
				Integer indexUniqueInteger = indexUniqueIntegerAsNumber != null ? indexUniqueIntegerAsNumber.intValue() : null;
				setIndexUniqueInteger(indexUniqueInteger);
			} else {
				setIndexUniqueInteger(null);
			}
		}
		if ( propertyMap.containsKey("indexNonUniqueReal") ) {
			if ( propertyMap.get("indexNonUniqueReal") != null ) {
				Double indexNonUniqueReal = indexNonUniqueRealAsNumber != null ? indexNonUniqueRealAsNumber.doubleValue() : null;
				setIndexNonUniqueReal(indexNonUniqueReal);
			} else {
				setIndexNonUniqueReal(null);
			}
		}
		if ( propertyMap.containsKey("indexedName") ) {
			if ( propertyMap.get("indexedName") != null ) {
				String indexedName = (String)propertyMap.get("indexedName");
				setIndexedName(indexedName);
			} else {
				setIndexedName(null);
			}
		}
		if ( propertyMap.containsKey("indexNonUniqueUnlimitedNatural") ) {
			if ( propertyMap.get("indexNonUniqueUnlimitedNatural") != null ) {
				Integer indexNonUniqueUnlimitedNatural = indexNonUniqueUnlimitedNaturalAsNumber != null ? indexNonUniqueUnlimitedNaturalAsNumber.intValue() : null;
				setIndexNonUniqueUnlimitedNatural(indexNonUniqueUnlimitedNatural);
			} else {
				setIndexNonUniqueUnlimitedNatural(null);
			}
		}
		if ( propertyMap.containsKey("indexUniqueReal") ) {
			if ( propertyMap.get("indexUniqueReal") != null ) {
				Double indexUniqueReal = indexUniqueRealAsNumber != null ? indexUniqueRealAsNumber.doubleValue() : null;
				setIndexUniqueReal(indexUniqueReal);
			} else {
				setIndexUniqueReal(null);
			}
		}
	}
	
	@Override
	public void fromJsonNonCompositeOne(Map propertyMap) {
		super.fromJsonNonCompositeOne(propertyMap);
	}
	
	@Override
	public void fromJsonNonCompositeRequiredMany(Map propertyMap) {
		super.fromJsonNonCompositeRequiredMany(propertyMap);
	}
	
	public Boolean getIndexNonUniqueBoolean() {
		UmlgSet tmp = this.indexNonUniqueBoolean;
		if ( !tmp.isEmpty() ) {
			return tmp.iterator().next();
		} else {
			return null;
		}
	}
	
	public Integer getIndexNonUniqueInteger() {
		UmlgSet tmp = this.indexNonUniqueInteger;
		if ( !tmp.isEmpty() ) {
			return tmp.iterator().next();
		} else {
			return null;
		}
	}
	
	public Double getIndexNonUniqueReal() {
		UmlgSet tmp = this.indexNonUniqueReal;
		if ( !tmp.isEmpty() ) {
			return tmp.iterator().next();
		} else {
			return null;
		}
	}
	
	public Integer getIndexNonUniqueUnlimitedNatural() {
		UmlgSet tmp = this.indexNonUniqueUnlimitedNatural;
		if ( !tmp.isEmpty() ) {
			return tmp.iterator().next();
		} else {
			return null;
		}
	}
	
	public Integer getIndexUniqueInteger() {
		UmlgSet tmp = this.indexUniqueInteger;
		if ( !tmp.isEmpty() ) {
			return tmp.iterator().next();
		} else {
			return null;
		}
	}
	
	public Double getIndexUniqueReal() {
		UmlgSet tmp = this.indexUniqueReal;
		if ( !tmp.isEmpty() ) {
			return tmp.iterator().next();
		} else {
			return null;
		}
	}
	
	public Integer getIndexUniqueUnlimitedNatural() {
		UmlgSet tmp = this.indexUniqueUnlimitedNatural;
		if ( !tmp.isEmpty() ) {
			return tmp.iterator().next();
		} else {
			return null;
		}
	}
	
	public String getIndexedName() {
		UmlgSet tmp = this.indexedName;
		if ( !tmp.isEmpty() ) {
			return tmp.iterator().next();
		} else {
			return null;
		}
	}
	
	public String getIndexedNonUniqueName() {
		UmlgSet tmp = this.indexedNonUniqueName;
		if ( !tmp.isEmpty() ) {
			return tmp.iterator().next();
		} else {
			return null;
		}
	}
	
	@Override
	public String getMetaDataAsJson() {
		return TopRoot.TopRootRuntimePropertyEnum.asJson();
	}
	
	@Override
	public UmlgNode getOwningObject() {
		return null;
	}
	
	@Override
	public String getQualifiedName() {
		return "umlgtest::org::umlg::rootallinstances::TopRoot";
	}
	
	/**
	 * getQualifiers is called from the collection in order to update the index used to implement the qualifier
	 * 
	 * @param tumlRuntimeProperty 
	 * @param node 
	 * @param inverse 
	 */
	@Override
	public List getQualifiers(UmlgRuntimeProperty tumlRuntimeProperty, UmlgNode node, boolean inverse) {
		List result = super.getQualifiers(tumlRuntimeProperty, node, inverse);
		TopRootRuntimePropertyEnum runtimeProperty;
		if ( !inverse ) {
			runtimeProperty = TopRootRuntimePropertyEnum.fromQualifiedName(tumlRuntimeProperty.getQualifiedName());
		} else {
			runtimeProperty = TopRootRuntimePropertyEnum.fromQualifiedName(tumlRuntimeProperty.getInverseQualifiedName());
		}
		if ( runtimeProperty != null && result.isEmpty() ) {
			switch ( runtimeProperty ) {
				default:
					result = Collections.emptyList();
			}
		
		}
		return result;
	}
	
	/**
	 * getSize is called from the BaseCollection.addInternal in order to save the size of the inverse collection to update the edge's sequence order
	 * 
	 * @param inverse 
	 * @param tumlRuntimeProperty 
	 */
	@Override
	public int getSize(boolean inverse, UmlgRuntimeProperty tumlRuntimeProperty) {
		int result = super.getSize(inverse, tumlRuntimeProperty);
		TopRootRuntimePropertyEnum runtimeProperty;
		if ( !inverse ) {
			runtimeProperty = TopRootRuntimePropertyEnum.fromQualifiedName(tumlRuntimeProperty.getQualifiedName());
		} else {
			runtimeProperty = TopRootRuntimePropertyEnum.fromQualifiedName(tumlRuntimeProperty.getInverseQualifiedName());
		}
		if ( runtimeProperty != null && result == 0 ) {
			switch ( runtimeProperty ) {
				case indexNonUniqueInteger:
					result = indexNonUniqueInteger.size();
					break;
			
				case indexedNonUniqueName:
					result = indexedNonUniqueName.size();
					break;
			
				case indexUniqueUnlimitedNatural:
					result = indexUniqueUnlimitedNatural.size();
					break;
			
				case indexNonUniqueBoolean:
					result = indexNonUniqueBoolean.size();
					break;
			
				case indexUniqueInteger:
					result = indexUniqueInteger.size();
					break;
			
				case indexNonUniqueReal:
					result = indexNonUniqueReal.size();
					break;
			
				case indexedName:
					result = indexedName.size();
					break;
			
				case indexNonUniqueUnlimitedNatural:
					result = indexNonUniqueUnlimitedNatural.size();
					break;
			
				case topRootChild:
					result = topRootChild.size();
					break;
			
				case indexUniqueReal:
					result = indexUniqueReal.size();
					break;
			
				default:
					result = 0;
			}
		
		}
		return result;
	}
	
	public UmlgSet getTopRootChild() {
		return this.topRootChild;
	}
	
	@Override
	public boolean hasOnlyOneCompositeParent() {
		int result = 0;
		return result == 1;
	}
	
	public void initDataTypeVariablesWithDefaultValues() {
		super.initDataTypeVariablesWithDefaultValues();
	}
	
	public void initVariables() {
		super.initVariables();
	}
	
	/**
	 * boolean properties' default values are initialized in the constructor via z_internalBooleanProperties
	 * 
	 * @param loaded 
	 */
	@Override
	public void initialiseProperties(boolean loaded) {
		super.initialiseProperties(loaded);
		this.indexNonUniqueInteger =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexNonUniqueInteger), loaded);
		this.indexedNonUniqueName =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexedNonUniqueName), loaded);
		this.indexUniqueUnlimitedNatural =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexUniqueUnlimitedNatural), loaded);
		this.indexNonUniqueBoolean =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexNonUniqueBoolean), loaded);
		this.indexUniqueInteger =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexUniqueInteger), loaded);
		this.indexNonUniqueReal =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexNonUniqueReal), loaded);
		this.indexedName =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexedName), loaded);
		this.indexNonUniqueUnlimitedNatural =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexNonUniqueUnlimitedNatural), loaded);
		this.topRootChild =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.topRootChild), loaded);
		this.indexUniqueReal =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexUniqueReal), loaded);
	}
	
	@Override
	public void initialiseProperty(UmlgRuntimeProperty tumlRuntimeProperty, boolean inverse, boolean loaded) {
		TopRootRuntimePropertyEnum runtimeProperty;
		super.initialiseProperty(tumlRuntimeProperty, inverse, loaded);
		if ( !inverse ) {
			runtimeProperty = (TopRootRuntimePropertyEnum.fromQualifiedName(tumlRuntimeProperty.getQualifiedName()));
		} else {
			runtimeProperty = (TopRootRuntimePropertyEnum.fromQualifiedName(tumlRuntimeProperty.getInverseQualifiedName()));
		}
		if ( runtimeProperty != null ) {
			switch ( runtimeProperty ) {
				case indexNonUniqueInteger:
					this.indexNonUniqueInteger =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexNonUniqueInteger), loaded);
					break;
			
				case indexedNonUniqueName:
					this.indexedNonUniqueName =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexedNonUniqueName), loaded);
					break;
			
				case indexUniqueUnlimitedNatural:
					this.indexUniqueUnlimitedNatural =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexUniqueUnlimitedNatural), loaded);
					break;
			
				case indexNonUniqueBoolean:
					this.indexNonUniqueBoolean =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexNonUniqueBoolean), loaded);
					break;
			
				case indexUniqueInteger:
					this.indexUniqueInteger =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexUniqueInteger), loaded);
					break;
			
				case indexNonUniqueReal:
					this.indexNonUniqueReal =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexNonUniqueReal), loaded);
					break;
			
				case indexedName:
					this.indexedName =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexedName), loaded);
					break;
			
				case indexNonUniqueUnlimitedNatural:
					this.indexNonUniqueUnlimitedNatural =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexNonUniqueUnlimitedNatural), loaded);
					break;
			
				case topRootChild:
					this.topRootChild =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.topRootChild), loaded);
					break;
			
				case indexUniqueReal:
					this.indexUniqueReal =  new UmlgSetImpl(this, PropertyTree.from(TopRootRuntimePropertyEnum.indexUniqueReal), loaded);
					break;
			
			}
		
		}
	}
	
	@Override
	public UmlgRuntimeProperty inverseAdder(UmlgRuntimeProperty tumlRuntimeProperty, boolean inverse, UmlgNode umlgNode) {
		UmlgRuntimeProperty fromSuperRuntimeProperty = super.inverseAdder(tumlRuntimeProperty, inverse, umlgNode);
		TopRootRuntimePropertyEnum runtimeProperty;
		if ( fromSuperRuntimeProperty != null ) {
			return fromSuperRuntimeProperty;
		} else {
			if ( !inverse ) {
				runtimeProperty = (TopRootRuntimePropertyEnum.fromQualifiedName(tumlRuntimeProperty.getQualifiedName()));
			} else {
				runtimeProperty = (TopRootRuntimePropertyEnum.fromQualifiedName(tumlRuntimeProperty.getInverseQualifiedName()));
			}
			if ( runtimeProperty != null ) {
				switch ( runtimeProperty ) {
					case topRootChild:
						this.topRootChild.inverseAdder((TopRootChild)umlgNode);
						break;
				
				}
				
				return runtimeProperty;
			} else {
				return null;
			}
		}
	}
	
	@Override
	public boolean isTinkerRoot() {
		return true;
	}
	
	public void removeFromIndexNonUniqueBoolean(Boolean indexNonUniqueBoolean) {
		if ( indexNonUniqueBoolean != null ) {
			this.indexNonUniqueBoolean.remove(indexNonUniqueBoolean);
		}
	}
	
	public void removeFromIndexNonUniqueBoolean(UmlgSet indexNonUniqueBoolean) {
		if ( !indexNonUniqueBoolean.isEmpty() ) {
			this.indexNonUniqueBoolean.removeAll(indexNonUniqueBoolean);
		}
	}
	
	public void removeFromIndexNonUniqueInteger(Integer indexNonUniqueInteger) {
		if ( indexNonUniqueInteger != null ) {
			this.indexNonUniqueInteger.remove(indexNonUniqueInteger);
		}
	}
	
	public void removeFromIndexNonUniqueInteger(UmlgSet indexNonUniqueInteger) {
		if ( !indexNonUniqueInteger.isEmpty() ) {
			this.indexNonUniqueInteger.removeAll(indexNonUniqueInteger);
		}
	}
	
	public void removeFromIndexNonUniqueReal(Double indexNonUniqueReal) {
		if ( indexNonUniqueReal != null ) {
			this.indexNonUniqueReal.remove(indexNonUniqueReal);
		}
	}
	
	public void removeFromIndexNonUniqueReal(UmlgSet indexNonUniqueReal) {
		if ( !indexNonUniqueReal.isEmpty() ) {
			this.indexNonUniqueReal.removeAll(indexNonUniqueReal);
		}
	}
	
	public void removeFromIndexNonUniqueUnlimitedNatural(Integer indexNonUniqueUnlimitedNatural) {
		if ( indexNonUniqueUnlimitedNatural != null ) {
			this.indexNonUniqueUnlimitedNatural.remove(indexNonUniqueUnlimitedNatural);
		}
	}
	
	public void removeFromIndexNonUniqueUnlimitedNatural(UmlgSet indexNonUniqueUnlimitedNatural) {
		if ( !indexNonUniqueUnlimitedNatural.isEmpty() ) {
			this.indexNonUniqueUnlimitedNatural.removeAll(indexNonUniqueUnlimitedNatural);
		}
	}
	
	public void removeFromIndexUniqueInteger(Integer indexUniqueInteger) {
		if ( indexUniqueInteger != null ) {
			this.indexUniqueInteger.remove(indexUniqueInteger);
		}
	}
	
	public void removeFromIndexUniqueInteger(UmlgSet indexUniqueInteger) {
		if ( !indexUniqueInteger.isEmpty() ) {
			this.indexUniqueInteger.removeAll(indexUniqueInteger);
		}
	}
	
	public void removeFromIndexUniqueReal(Double indexUniqueReal) {
		if ( indexUniqueReal != null ) {
			this.indexUniqueReal.remove(indexUniqueReal);
		}
	}
	
	public void removeFromIndexUniqueReal(UmlgSet indexUniqueReal) {
		if ( !indexUniqueReal.isEmpty() ) {
			this.indexUniqueReal.removeAll(indexUniqueReal);
		}
	}
	
	public void removeFromIndexUniqueUnlimitedNatural(Integer indexUniqueUnlimitedNatural) {
		if ( indexUniqueUnlimitedNatural != null ) {
			this.indexUniqueUnlimitedNatural.remove(indexUniqueUnlimitedNatural);
		}
	}
	
	public void removeFromIndexUniqueUnlimitedNatural(UmlgSet indexUniqueUnlimitedNatural) {
		if ( !indexUniqueUnlimitedNatural.isEmpty() ) {
			this.indexUniqueUnlimitedNatural.removeAll(indexUniqueUnlimitedNatural);
		}
	}
	
	public void removeFromIndexedName(String indexedName) {
		if ( indexedName != null ) {
			this.indexedName.remove(indexedName);
		}
	}
	
	public void removeFromIndexedName(UmlgSet indexedName) {
		if ( !indexedName.isEmpty() ) {
			this.indexedName.removeAll(indexedName);
		}
	}
	
	public void removeFromIndexedNonUniqueName(String indexedNonUniqueName) {
		if ( indexedNonUniqueName != null ) {
			this.indexedNonUniqueName.remove(indexedNonUniqueName);
		}
	}
	
	public void removeFromIndexedNonUniqueName(UmlgSet indexedNonUniqueName) {
		if ( !indexedNonUniqueName.isEmpty() ) {
			this.indexedNonUniqueName.removeAll(indexedNonUniqueName);
		}
	}
	
	public void removeFromTopRootChild(TopRootChild topRootChild) {
		if ( topRootChild != null ) {
			this.topRootChild.remove(topRootChild);
		}
	}
	
	public void removeFromTopRootChild(UmlgSet topRootChild) {
		if ( !topRootChild.isEmpty() ) {
			this.topRootChild.removeAll(topRootChild);
		}
	}
	
	public void setIndexNonUniqueBoolean(Boolean indexNonUniqueBoolean) {
		if ( indexNonUniqueBoolean == null ) {
			clearIndexNonUniqueBoolean();
		} else {
			z_internalClearIndexNonUniqueBoolean();
		}
		addToIndexNonUniqueBoolean(indexNonUniqueBoolean);
	}
	
	public void setIndexNonUniqueInteger(Integer indexNonUniqueInteger) {
		if ( indexNonUniqueInteger == null ) {
			clearIndexNonUniqueInteger();
		} else {
			z_internalClearIndexNonUniqueInteger();
		}
		addToIndexNonUniqueInteger(indexNonUniqueInteger);
	}
	
	public void setIndexNonUniqueReal(Double indexNonUniqueReal) {
		if ( indexNonUniqueReal == null ) {
			clearIndexNonUniqueReal();
		} else {
			z_internalClearIndexNonUniqueReal();
		}
		addToIndexNonUniqueReal(indexNonUniqueReal);
	}
	
	public void setIndexNonUniqueUnlimitedNatural(Integer indexNonUniqueUnlimitedNatural) {
		if ( indexNonUniqueUnlimitedNatural == null ) {
			clearIndexNonUniqueUnlimitedNatural();
		} else {
			z_internalClearIndexNonUniqueUnlimitedNatural();
		}
		addToIndexNonUniqueUnlimitedNatural(indexNonUniqueUnlimitedNatural);
	}
	
	public void setIndexUniqueInteger(Integer indexUniqueInteger) {
		if ( indexUniqueInteger != null && !indexUniqueInteger.equals(getIndexUniqueInteger()) && UMLG.get().getFromUniqueIndex(TopRoot.class.getSimpleName(), UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexUniqueInteger"), indexUniqueInteger) != null ) {
			throw new IllegalStateException("Unique indexed property umlgtest::org::umlg::rootallinstances::TopRoot::indexUniqueInteger already has a value of '" + indexUniqueInteger + "'");
		}
		if ( indexUniqueInteger == null ) {
			clearIndexUniqueInteger();
		} else {
			z_internalClearIndexUniqueInteger();
		}
		addToIndexUniqueInteger(indexUniqueInteger);
	}
	
	public void setIndexUniqueReal(Double indexUniqueReal) {
		if ( indexUniqueReal != null && !indexUniqueReal.equals(getIndexUniqueReal()) && UMLG.get().getFromUniqueIndex(TopRoot.class.getSimpleName(), UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexUniqueReal"), indexUniqueReal) != null ) {
			throw new IllegalStateException("Unique indexed property umlgtest::org::umlg::rootallinstances::TopRoot::indexUniqueReal already has a value of '" + indexUniqueReal + "'");
		}
		if ( indexUniqueReal == null ) {
			clearIndexUniqueReal();
		} else {
			z_internalClearIndexUniqueReal();
		}
		addToIndexUniqueReal(indexUniqueReal);
	}
	
	public void setIndexUniqueUnlimitedNatural(Integer indexUniqueUnlimitedNatural) {
		if ( indexUniqueUnlimitedNatural != null && !indexUniqueUnlimitedNatural.equals(getIndexUniqueUnlimitedNatural()) && UMLG.get().getFromUniqueIndex(TopRoot.class.getSimpleName(), UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexUniqueUnlimitedNatural"), indexUniqueUnlimitedNatural) != null ) {
			throw new IllegalStateException("Unique indexed property umlgtest::org::umlg::rootallinstances::TopRoot::indexUniqueUnlimitedNatural already has a value of '" + indexUniqueUnlimitedNatural + "'");
		}
		if ( indexUniqueUnlimitedNatural == null ) {
			clearIndexUniqueUnlimitedNatural();
		} else {
			z_internalClearIndexUniqueUnlimitedNatural();
		}
		addToIndexUniqueUnlimitedNatural(indexUniqueUnlimitedNatural);
	}
	
	public void setIndexedName(String indexedName) {
		if ( indexedName != null && !indexedName.equals(getIndexedName()) && UMLG.get().getFromUniqueIndex(TopRoot.class.getSimpleName(), UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexedName"), indexedName) != null ) {
			throw new IllegalStateException("Unique indexed property umlgtest::org::umlg::rootallinstances::TopRoot::indexedName already has a value of '" + indexedName + "'");
		}
		if ( indexedName == null ) {
			clearIndexedName();
		} else {
			z_internalClearIndexedName();
		}
		addToIndexedName(indexedName);
	}
	
	public void setIndexedNonUniqueName(String indexedNonUniqueName) {
		if ( indexedNonUniqueName == null ) {
			clearIndexedNonUniqueName();
		} else {
			z_internalClearIndexedNonUniqueName();
		}
		addToIndexedNonUniqueName(indexedNonUniqueName);
	}
	
	public void setTopRootChild(UmlgSet topRootChild) {
		clearTopRootChild();
		if ( topRootChild != null ) {
			addToTopRootChild(topRootChild);
		}
	}
	
	/**
	 * deep indicates that components also be serialized.
	 * 
	 * @param deep 
	 */
	@Override
	public String toJson(Boolean deep) {
		String result = super.toJson(deep);
		result = result.substring(1, result.length() - 1);
		StringBuilder sb = new StringBuilder(result);
		sb.append(", ");
		sb.append("\"indexNonUniqueInteger\": " + getIndexNonUniqueInteger() + "");
		sb.append(", ");
		sb.append("\"indexedNonUniqueName\": " + (getIndexedNonUniqueName() != null ? "\"" + StringEscapeUtils.escapeJson(getIndexedNonUniqueName()) + "\"" : null ));
		sb.append(", ");
		sb.append("\"indexUniqueUnlimitedNatural\": " + getIndexUniqueUnlimitedNatural() + "");
		sb.append(", ");
		sb.append("\"indexNonUniqueBoolean\": " + getIndexNonUniqueBoolean() + "");
		sb.append(", ");
		sb.append("\"indexUniqueInteger\": " + getIndexUniqueInteger() + "");
		sb.append(", ");
		sb.append("\"indexNonUniqueReal\": " + getIndexNonUniqueReal() + "");
		sb.append(", ");
		sb.append("\"indexedName\": " + (getIndexedName() != null ? "\"" + StringEscapeUtils.escapeJson(getIndexedName()) + "\"" : null ));
		sb.append(", ");
		sb.append("\"indexNonUniqueUnlimitedNatural\": " + getIndexNonUniqueUnlimitedNatural() + "");
		sb.append(", ");
		sb.append("\"indexUniqueReal\": " + getIndexUniqueReal() + "");
		sb.insert(0, "{");
		sb.append("}");
		return sb.toString();
	}
	
	@Override
	public String toJson() {
		return toJson(false);
	}
	
	/**
	 * deep indicates that components also be serialized.
	 * 
	 * @param deep 
	 */
	@Override
	public String toJsonWithoutCompositeParent(Boolean deep) {
		String result = super.toJsonWithoutCompositeParent(deep);
		result = result.substring(1, result.length() - 1);
		StringBuilder sb = new StringBuilder(result);
		sb.append(", ");
		sb.append("\"indexNonUniqueInteger\": " + getIndexNonUniqueInteger() + "");
		sb.append(", ");
		sb.append("\"indexedNonUniqueName\": " + (getIndexedNonUniqueName() != null ? "\"" + StringEscapeUtils.escapeJson(getIndexedNonUniqueName()) + "\"" : null ));
		sb.append(", ");
		sb.append("\"indexUniqueUnlimitedNatural\": " + getIndexUniqueUnlimitedNatural() + "");
		sb.append(", ");
		sb.append("\"indexNonUniqueBoolean\": " + getIndexNonUniqueBoolean() + "");
		sb.append(", ");
		sb.append("\"indexUniqueInteger\": " + getIndexUniqueInteger() + "");
		sb.append(", ");
		sb.append("\"indexNonUniqueReal\": " + getIndexNonUniqueReal() + "");
		sb.append(", ");
		sb.append("\"indexedName\": " + (getIndexedName() != null ? "\"" + StringEscapeUtils.escapeJson(getIndexedName()) + "\"" : null ));
		sb.append(", ");
		sb.append("\"indexNonUniqueUnlimitedNatural\": " + getIndexNonUniqueUnlimitedNatural() + "");
		sb.append(", ");
		sb.append("\"indexUniqueReal\": " + getIndexUniqueReal() + "");
		sb.insert(0, "{");
		sb.append("}");
		return sb.toString();
	}
	
	@Override
	public String toJsonWithoutCompositeParent() {
		return toJsonWithoutCompositeParent(false);
	}
	
	static public List topRoot_findByIndexNonUniqueBoolean(Boolean indexNonUniqueBoolean) {
		List result = UMLG.get().getFromIndex("TopRoot", UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexNonUniqueBoolean"), indexNonUniqueBoolean);
		return result;
	}
	
	static public List topRoot_findByIndexNonUniqueInteger(Integer indexNonUniqueInteger) {
		List result = UMLG.get().getFromIndex("TopRoot", UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexNonUniqueInteger"), indexNonUniqueInteger);
		return result;
	}
	
	static public List topRoot_findByIndexNonUniqueReal(Double indexNonUniqueReal) {
		List result = UMLG.get().getFromIndex("TopRoot", UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexNonUniqueReal"), indexNonUniqueReal);
		return result;
	}
	
	static public List topRoot_findByIndexNonUniqueUnlimitedNatural(Integer indexNonUniqueUnlimitedNatural) {
		List result = UMLG.get().getFromIndex("TopRoot", UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexNonUniqueUnlimitedNatural"), indexNonUniqueUnlimitedNatural);
		return result;
	}
	
	static public TopRoot topRoot_findByIndexUniqueInteger(Integer indexUniqueInteger) {
		TopRoot result =  UMLG.get().getFromUniqueIndex("TopRoot", "indexUniqueInteger", indexUniqueInteger);
		if ( result != null ) {
			return result;
		}
		return result;
	}
	
	static public TopRoot topRoot_findByIndexUniqueReal(Double indexUniqueReal) {
		TopRoot result =  UMLG.get().getFromUniqueIndex("TopRoot", "indexUniqueReal", indexUniqueReal);
		if ( result != null ) {
			return result;
		}
		return result;
	}
	
	static public TopRoot topRoot_findByIndexUniqueUnlimitedNatural(Integer indexUniqueUnlimitedNatural) {
		TopRoot result =  UMLG.get().getFromUniqueIndex("TopRoot", "indexUniqueUnlimitedNatural", indexUniqueUnlimitedNatural);
		if ( result != null ) {
			return result;
		}
		return result;
	}
	
	static public TopRoot topRoot_findByIndexedName(String indexedName) {
		TopRoot result =  UMLG.get().getFromUniqueIndex("TopRoot", "indexedName", indexedName);
		if ( result != null ) {
			return result;
		}
		return result;
	}
	
	static public List topRoot_findByIndexedNonUniqueName(String indexedNonUniqueName) {
		List result = UMLG.get().getFromIndex("TopRoot", UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexedNonUniqueName"), indexedNonUniqueName);
		return result;
	}
	
	static public List topRoot_findByName(String name) {
		List result = UMLG.get().getFromIndex("TopRoot", UmlgLabelConverterFactory.getUmlgLabelConverter().convert("name"), name);
		return result;
	}
	
	static public TopRoot topRoot_findByNameUnique(String nameUnique) {
		TopRoot result =  UMLG.get().getFromUniqueIndex("TopRoot", "nameUnique", nameUnique);
		if ( result != null ) {
			return result;
		}
		return result;
	}
	
	public List validateIndexNonUniqueBoolean(Boolean indexNonUniqueBoolean) {
		List result = new ArrayList();
		return result;
	}
	
	public List validateIndexNonUniqueInteger(Integer indexNonUniqueInteger) {
		List result = new ArrayList();
		return result;
	}
	
	public List validateIndexNonUniqueReal(Double indexNonUniqueReal) {
		List result = new ArrayList();
		return result;
	}
	
	public List validateIndexNonUniqueUnlimitedNatural(Integer indexNonUniqueUnlimitedNatural) {
		List result = new ArrayList();
		if ( !UmlgValidator.validateValidUnlimitedNatural(indexNonUniqueUnlimitedNatural) ) {
			result.add(new UmlgConstraintViolation("UnlimitedNatural", "umlgtest::org::umlg::rootallinstances::TopRoot::indexNonUniqueUnlimitedNatural", " must be greater or equal to zero!"));
		}
		return result;
	}
	
	public List validateIndexUniqueInteger(Integer indexUniqueInteger) {
		List result = new ArrayList();
		return result;
	}
	
	public List validateIndexUniqueReal(Double indexUniqueReal) {
		List result = new ArrayList();
		return result;
	}
	
	public List validateIndexUniqueUnlimitedNatural(Integer indexUniqueUnlimitedNatural) {
		List result = new ArrayList();
		if ( !UmlgValidator.validateValidUnlimitedNatural(indexUniqueUnlimitedNatural) ) {
			result.add(new UmlgConstraintViolation("UnlimitedNatural", "umlgtest::org::umlg::rootallinstances::TopRoot::indexUniqueUnlimitedNatural", " must be greater or equal to zero!"));
		}
		return result;
	}
	
	public List validateIndexedName(String indexedName) {
		List result = new ArrayList();
		return result;
	}
	
	public List validateIndexedNonUniqueName(String indexedNonUniqueName) {
		List result = new ArrayList();
		return result;
	}
	
	@Override
	public List validateMultiplicities() {
		List result = new ArrayList();
		if ( getName() == null ) {
			result.add(new UmlgConstraintViolation("multiplicity", "umlgtest::org::umlg::rootallinstances::BaseRoot::name", "lower multiplicity is 1"));
		}
		if ( getIndexedName() == null ) {
			result.add(new UmlgConstraintViolation("multiplicity", "umlgtest::org::umlg::rootallinstances::TopRoot::indexedName", "lower multiplicity is 1"));
		}
		return result;
	}
	
	@Override
	public void z_internalAddPersistentValueToCollection(UmlgRuntimeProperty umlgRuntimeProperty, Object umlgNode) {
		TopRootRuntimePropertyEnum runtimeProperty;
		super.z_internalAddPersistentValueToCollection(umlgRuntimeProperty, umlgNode);
		runtimeProperty = (TopRootRuntimePropertyEnum.fromQualifiedName(umlgRuntimeProperty.getQualifiedName()));
		if ( runtimeProperty != null ) {
			switch ( runtimeProperty ) {
				case indexNonUniqueInteger:
					this.indexNonUniqueInteger.z_internalAdder((int)umlgNode);
					break;
			
				case indexedNonUniqueName:
					this.indexedNonUniqueName.z_internalAdder((String)umlgNode);
					break;
			
				case indexUniqueUnlimitedNatural:
					this.indexUniqueUnlimitedNatural.z_internalAdder((int)umlgNode);
					break;
			
				case indexNonUniqueBoolean:
					this.indexNonUniqueBoolean.z_internalAdder((boolean)umlgNode);
					break;
			
				case indexUniqueInteger:
					this.indexUniqueInteger.z_internalAdder((int)umlgNode);
					break;
			
				case indexNonUniqueReal:
					this.indexNonUniqueReal.z_internalAdder((double)umlgNode);
					break;
			
				case indexedName:
					this.indexedName.z_internalAdder((String)umlgNode);
					break;
			
				case indexNonUniqueUnlimitedNatural:
					this.indexNonUniqueUnlimitedNatural.z_internalAdder((int)umlgNode);
					break;
			
				case topRootChild:
					this.topRootChild.z_internalAdder((TopRootChild)umlgNode);
					break;
			
				case indexUniqueReal:
					this.indexUniqueReal.z_internalAdder((double)umlgNode);
					break;
			
			}
		
		}
	}
	
	@Override
	public void z_internalAddToCollection(UmlgRuntimeProperty umlgRuntimeProperty, Object umlgNode) {
		TopRootRuntimePropertyEnum runtimeProperty;
		super.z_internalAddToCollection(umlgRuntimeProperty, umlgNode);
		runtimeProperty = (TopRootRuntimePropertyEnum.fromQualifiedName(umlgRuntimeProperty.getQualifiedName()));
		if ( runtimeProperty != null ) {
			switch ( runtimeProperty ) {
				case indexNonUniqueInteger:
					this.indexNonUniqueInteger.z_internalAdder((Integer)umlgNode);
					break;
			
				case indexedNonUniqueName:
					this.indexedNonUniqueName.z_internalAdder((String)umlgNode);
					break;
			
				case indexUniqueUnlimitedNatural:
					this.indexUniqueUnlimitedNatural.z_internalAdder((Integer)umlgNode);
					break;
			
				case indexNonUniqueBoolean:
					this.indexNonUniqueBoolean.z_internalAdder((Boolean)umlgNode);
					break;
			
				case indexUniqueInteger:
					this.indexUniqueInteger.z_internalAdder((Integer)umlgNode);
					break;
			
				case indexNonUniqueReal:
					this.indexNonUniqueReal.z_internalAdder((Double)umlgNode);
					break;
			
				case indexedName:
					this.indexedName.z_internalAdder((String)umlgNode);
					break;
			
				case indexNonUniqueUnlimitedNatural:
					this.indexNonUniqueUnlimitedNatural.z_internalAdder((Integer)umlgNode);
					break;
			
				case topRootChild:
					this.topRootChild.z_internalAdder((TopRootChild)umlgNode);
					break;
			
				case indexUniqueReal:
					this.indexUniqueReal.z_internalAdder((Double)umlgNode);
					break;
			
			}
		
		}
	}
	
	@Override
	public Set z_internalBooleanProperties() {
		Set result = super.z_internalBooleanProperties();
		result.add(TopRootRuntimePropertyEnum.indexNonUniqueBoolean);
		return result;
	}
	
	public void z_internalClearIndexNonUniqueBoolean() {
		this.indexNonUniqueBoolean.z_internalClear();
	}
	
	public void z_internalClearIndexNonUniqueInteger() {
		this.indexNonUniqueInteger.z_internalClear();
	}
	
	public void z_internalClearIndexNonUniqueReal() {
		this.indexNonUniqueReal.z_internalClear();
	}
	
	public void z_internalClearIndexNonUniqueUnlimitedNatural() {
		this.indexNonUniqueUnlimitedNatural.z_internalClear();
	}
	
	public void z_internalClearIndexUniqueInteger() {
		this.indexUniqueInteger.z_internalClear();
	}
	
	public void z_internalClearIndexUniqueReal() {
		this.indexUniqueReal.z_internalClear();
	}
	
	public void z_internalClearIndexUniqueUnlimitedNatural() {
		this.indexUniqueUnlimitedNatural.z_internalClear();
	}
	
	public void z_internalClearIndexedName() {
		this.indexedName.z_internalClear();
	}
	
	public void z_internalClearIndexedNonUniqueName() {
		this.indexedNonUniqueName.z_internalClear();
	}
	
	public void z_internalClearTopRootChild() {
		this.topRootChild.z_internalClear();
	}
	
	@Override
	public Set z_internalDataTypeProperties() {
		Set result = super.z_internalDataTypeProperties();
		result.add(TopRootRuntimePropertyEnum.indexNonUniqueInteger);
		result.add(TopRootRuntimePropertyEnum.indexedNonUniqueName);
		result.add(TopRootRuntimePropertyEnum.indexUniqueUnlimitedNatural);
		result.add(TopRootRuntimePropertyEnum.indexNonUniqueBoolean);
		result.add(TopRootRuntimePropertyEnum.indexUniqueInteger);
		result.add(TopRootRuntimePropertyEnum.indexNonUniqueReal);
		result.add(TopRootRuntimePropertyEnum.indexedName);
		result.add(TopRootRuntimePropertyEnum.indexNonUniqueUnlimitedNatural);
		result.add(TopRootRuntimePropertyEnum.indexUniqueReal);
		return result;
	}
	
	@Override
	public Map z_internalDataTypePropertiesWithDefaultValues() {
		Map result = super.z_internalDataTypePropertiesWithDefaultValues();
		return result;
	}
	
	@Override
	public UmlgCollection z_internalGetCollectionFor(UmlgRuntimeProperty tumlRuntimeProperty, boolean inverse) {
		UmlgCollection result = null;
		result = super.z_internalGetCollectionFor(tumlRuntimeProperty, inverse);
		if ( result == null ) {
			TopRootRuntimePropertyEnum runtimeProperty;
			if ( !inverse ) {
				runtimeProperty = (TopRootRuntimePropertyEnum.fromQualifiedName(tumlRuntimeProperty.getQualifiedName()));
			} else {
				runtimeProperty = (TopRootRuntimePropertyEnum.fromQualifiedName(tumlRuntimeProperty.getInverseQualifiedName()));
			}
			if ( runtimeProperty != null ) {
				switch ( runtimeProperty ) {
					case indexNonUniqueInteger:
						result = this.indexNonUniqueInteger;
						break;
				
					case indexedNonUniqueName:
						result = this.indexedNonUniqueName;
						break;
				
					case indexUniqueUnlimitedNatural:
						result = this.indexUniqueUnlimitedNatural;
						break;
				
					case indexNonUniqueBoolean:
						result = this.indexNonUniqueBoolean;
						break;
				
					case indexUniqueInteger:
						result = this.indexUniqueInteger;
						break;
				
					case indexNonUniqueReal:
						result = this.indexNonUniqueReal;
						break;
				
					case indexedName:
						result = this.indexedName;
						break;
				
					case indexNonUniqueUnlimitedNatural:
						result = this.indexNonUniqueUnlimitedNatural;
						break;
				
					case topRootChild:
						result = this.topRootChild;
						break;
				
					case indexUniqueReal:
						result = this.indexUniqueReal;
						break;
				
				}
			
			}
		}
		return result;
	}
	
	@Override
	public UmlgRuntimeProperty z_internalInverseAdder(UmlgRuntimeProperty tumlRuntimeProperty, boolean inverse, UmlgNode umlgNode) {
		UmlgRuntimeProperty fromSuperRuntimeProperty = super.inverseAdder(tumlRuntimeProperty, inverse, umlgNode);
		TopRootRuntimePropertyEnum runtimeProperty;
		if ( fromSuperRuntimeProperty != null ) {
			return fromSuperRuntimeProperty;
		} else {
			if ( !inverse ) {
				runtimeProperty = (TopRootRuntimePropertyEnum.fromQualifiedName(tumlRuntimeProperty.getQualifiedName()));
			} else {
				runtimeProperty = (TopRootRuntimePropertyEnum.fromQualifiedName(tumlRuntimeProperty.getInverseQualifiedName()));
			}
			if ( runtimeProperty != null ) {
				switch ( runtimeProperty ) {
					case topRootChild:
						this.topRootChild.z_internalAdder((TopRootChild)umlgNode);
						break;
				
				}
				
				return runtimeProperty;
			} else {
				return null;
			}
		}
	}
	
	@Override
	public void z_internalMarkCollectionLoaded(UmlgRuntimeProperty umlgRuntimeProperty, boolean loaded) {
		TopRootRuntimePropertyEnum runtimeProperty;
		super.z_internalMarkCollectionLoaded(umlgRuntimeProperty, loaded);
		runtimeProperty = (TopRootRuntimePropertyEnum.fromQualifiedName(umlgRuntimeProperty.getQualifiedName()));
		if ( runtimeProperty != null ) {
			switch ( runtimeProperty ) {
				case indexNonUniqueInteger:
					this.indexNonUniqueInteger.setLoaded(loaded);
					break;
			
				case indexedNonUniqueName:
					this.indexedNonUniqueName.setLoaded(loaded);
					break;
			
				case indexUniqueUnlimitedNatural:
					this.indexUniqueUnlimitedNatural.setLoaded(loaded);
					break;
			
				case indexNonUniqueBoolean:
					this.indexNonUniqueBoolean.setLoaded(loaded);
					break;
			
				case indexUniqueInteger:
					this.indexUniqueInteger.setLoaded(loaded);
					break;
			
				case indexNonUniqueReal:
					this.indexNonUniqueReal.setLoaded(loaded);
					break;
			
				case indexedName:
					this.indexedName.setLoaded(loaded);
					break;
			
				case indexNonUniqueUnlimitedNatural:
					this.indexNonUniqueUnlimitedNatural.setLoaded(loaded);
					break;
			
				case topRootChild:
					this.topRootChild.setLoaded(loaded);
					break;
			
				case indexUniqueReal:
					this.indexUniqueReal.setLoaded(loaded);
					break;
			
			}
		
		}
	}

	static public enum TopRootRuntimePropertyEnum implements UmlgRuntimeProperty {
		indexNonUniqueInteger(/* qualifiedName */ "umlgtest::org::umlg::rootallinstances::TopRoot::indexNonUniqueInteger",/* persistentName */ "indexNonUniqueInteger",/* inverseName */ "inverseOf::indexNonUniqueInteger",/* inverseQualifiedName */ "inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexNonUniqueInteger",/* isAssociationClassOne */ false,/* isMemberEndOfAssociationClass */ false,/* associationClassPropertyNameField */ "null",/* inverseAssociationClassPropertyNameField */ "null",/* isAssociationClassProperty */ false,/* isOnePrimitivePropertyOfAssociationClass */ false,/* isOnePrimitive */ true,/* isReadOnly */ false,/* dataTypeEnum */ null,/* validations */ Collections.emptyList(),/* isManyPrimitive */ false,/* oneEnumeration */ false,/* manyEnumeration */ false,/* isControllingSide */ true,/* isComposite */ false,/* isInverseComposite */ false,/* label */ UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexNonUniqueInteger"),/* isOneToOne */ false,/* isOneToMany */ false,/* isManyToOne */ true,/* isManyToMany */ false,/* upper */ 1,/* lower */ 0,/* inverseUpper */ 1,/* isQualified */ false,/* isInverseQualified */ false,/* isOrdered */ false,/* isInverseOrdered */ false,/* isUnique */ true,/* isInverseUnique */ false,/* isDerived */ false,/* isNavigable */ true,/* propertyType */ Integer.class,/* json */ "{\"name\": \"indexNonUniqueInteger\", \"associationClassOne\": false, \"memberEndOfAssociationClass\": false, \"associationClassPropertyName\": null, \"inverseAssociationClassPropertyName\": null, \"associationClassProperty\": false, \"onePrimitivePropertyOfAssociationClass\": false, \"onePrimitive\": true, \"readOnly\": false, \"dataTypeEnum\": null, \"validations\": null, \"qualifiedName\": \"umlgtest::org::umlg::rootallinstances::TopRoot::indexNonUniqueInteger\", \"persistentName\": \"indexNonUniqueInteger\", \"inverseName\": \"inverseOf::indexNonUniqueInteger\", \"inverseQualifiedName\": \"inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexNonUniqueInteger\", \"manyPrimitive\": false, \"oneEnumeration\": false, \"manyEnumeration\": false, \"controllingSide\": true, \"composite\": false, \"inverseComposite\": false, \"oneToOne\": false, \"oneToMany\": false, \"manyToOne\": true, \"manyToMany\": false, \"upper\": 1, \"lower\": 0, \"inverseUpper\": 1, \"label\": \"indexNonUniqueInteger\", \"qualified\": false, \"inverseQualified\": false, \"ordered\": false, \"inverseOrdered\": false, \"unique\": true, \"inverseUnique\": false, \"derived\": false, \"navigable\": true}",/* isChangeListenerAttribute */ false),
		indexedNonUniqueName(/* qualifiedName */ "umlgtest::org::umlg::rootallinstances::TopRoot::indexedNonUniqueName",/* persistentName */ "indexedNonUniqueName",/* inverseName */ "inverseOf::indexedNonUniqueName",/* inverseQualifiedName */ "inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexedNonUniqueName",/* isAssociationClassOne */ false,/* isMemberEndOfAssociationClass */ false,/* associationClassPropertyNameField */ "null",/* inverseAssociationClassPropertyNameField */ "null",/* isAssociationClassProperty */ false,/* isOnePrimitivePropertyOfAssociationClass */ false,/* isOnePrimitive */ true,/* isReadOnly */ false,/* dataTypeEnum */ null,/* validations */ Collections.emptyList(),/* isManyPrimitive */ false,/* oneEnumeration */ false,/* manyEnumeration */ false,/* isControllingSide */ true,/* isComposite */ false,/* isInverseComposite */ false,/* label */ UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexedNonUniqueName"),/* isOneToOne */ false,/* isOneToMany */ false,/* isManyToOne */ true,/* isManyToMany */ false,/* upper */ 1,/* lower */ 0,/* inverseUpper */ 1,/* isQualified */ false,/* isInverseQualified */ false,/* isOrdered */ false,/* isInverseOrdered */ false,/* isUnique */ true,/* isInverseUnique */ false,/* isDerived */ false,/* isNavigable */ true,/* propertyType */ String.class,/* json */ "{\"name\": \"indexedNonUniqueName\", \"associationClassOne\": false, \"memberEndOfAssociationClass\": false, \"associationClassPropertyName\": null, \"inverseAssociationClassPropertyName\": null, \"associationClassProperty\": false, \"onePrimitivePropertyOfAssociationClass\": false, \"onePrimitive\": true, \"readOnly\": false, \"dataTypeEnum\": null, \"validations\": null, \"qualifiedName\": \"umlgtest::org::umlg::rootallinstances::TopRoot::indexedNonUniqueName\", \"persistentName\": \"indexedNonUniqueName\", \"inverseName\": \"inverseOf::indexedNonUniqueName\", \"inverseQualifiedName\": \"inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexedNonUniqueName\", \"manyPrimitive\": false, \"oneEnumeration\": false, \"manyEnumeration\": false, \"controllingSide\": true, \"composite\": false, \"inverseComposite\": false, \"oneToOne\": false, \"oneToMany\": false, \"manyToOne\": true, \"manyToMany\": false, \"upper\": 1, \"lower\": 0, \"inverseUpper\": 1, \"label\": \"indexedNonUniqueName\", \"qualified\": false, \"inverseQualified\": false, \"ordered\": false, \"inverseOrdered\": false, \"unique\": true, \"inverseUnique\": false, \"derived\": false, \"navigable\": true}",/* isChangeListenerAttribute */ false),
		indexUniqueUnlimitedNatural(/* qualifiedName */ "umlgtest::org::umlg::rootallinstances::TopRoot::indexUniqueUnlimitedNatural",/* persistentName */ "indexUniqueUnlimitedNatural",/* inverseName */ "inverseOf::indexUniqueUnlimitedNatural",/* inverseQualifiedName */ "inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexUniqueUnlimitedNatural",/* isAssociationClassOne */ false,/* isMemberEndOfAssociationClass */ false,/* associationClassPropertyNameField */ "null",/* inverseAssociationClassPropertyNameField */ "null",/* isAssociationClassProperty */ false,/* isOnePrimitivePropertyOfAssociationClass */ false,/* isOnePrimitive */ true,/* isReadOnly */ false,/* dataTypeEnum */ null,/* validations */ Collections.emptyList(),/* isManyPrimitive */ false,/* oneEnumeration */ false,/* manyEnumeration */ false,/* isControllingSide */ true,/* isComposite */ false,/* isInverseComposite */ false,/* label */ UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexUniqueUnlimitedNatural"),/* isOneToOne */ false,/* isOneToMany */ false,/* isManyToOne */ true,/* isManyToMany */ false,/* upper */ 1,/* lower */ 0,/* inverseUpper */ 1,/* isQualified */ false,/* isInverseQualified */ false,/* isOrdered */ false,/* isInverseOrdered */ false,/* isUnique */ true,/* isInverseUnique */ false,/* isDerived */ false,/* isNavigable */ true,/* propertyType */ Integer.class,/* json */ "{\"name\": \"indexUniqueUnlimitedNatural\", \"associationClassOne\": false, \"memberEndOfAssociationClass\": false, \"associationClassPropertyName\": null, \"inverseAssociationClassPropertyName\": null, \"associationClassProperty\": false, \"onePrimitivePropertyOfAssociationClass\": false, \"onePrimitive\": true, \"readOnly\": false, \"dataTypeEnum\": null, \"validations\": null, \"qualifiedName\": \"umlgtest::org::umlg::rootallinstances::TopRoot::indexUniqueUnlimitedNatural\", \"persistentName\": \"indexUniqueUnlimitedNatural\", \"inverseName\": \"inverseOf::indexUniqueUnlimitedNatural\", \"inverseQualifiedName\": \"inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexUniqueUnlimitedNatural\", \"manyPrimitive\": false, \"oneEnumeration\": false, \"manyEnumeration\": false, \"controllingSide\": true, \"composite\": false, \"inverseComposite\": false, \"oneToOne\": false, \"oneToMany\": false, \"manyToOne\": true, \"manyToMany\": false, \"upper\": 1, \"lower\": 0, \"inverseUpper\": 1, \"label\": \"indexUniqueUnlimitedNatural\", \"qualified\": false, \"inverseQualified\": false, \"ordered\": false, \"inverseOrdered\": false, \"unique\": true, \"inverseUnique\": false, \"derived\": false, \"navigable\": true}",/* isChangeListenerAttribute */ false),
		indexNonUniqueBoolean(/* qualifiedName */ "umlgtest::org::umlg::rootallinstances::TopRoot::indexNonUniqueBoolean",/* persistentName */ "indexNonUniqueBoolean",/* inverseName */ "inverseOf::indexNonUniqueBoolean",/* inverseQualifiedName */ "inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexNonUniqueBoolean",/* isAssociationClassOne */ false,/* isMemberEndOfAssociationClass */ false,/* associationClassPropertyNameField */ "null",/* inverseAssociationClassPropertyNameField */ "null",/* isAssociationClassProperty */ false,/* isOnePrimitivePropertyOfAssociationClass */ false,/* isOnePrimitive */ true,/* isReadOnly */ false,/* dataTypeEnum */ null,/* validations */ Collections.emptyList(),/* isManyPrimitive */ false,/* oneEnumeration */ false,/* manyEnumeration */ false,/* isControllingSide */ true,/* isComposite */ false,/* isInverseComposite */ false,/* label */ UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexNonUniqueBoolean"),/* isOneToOne */ false,/* isOneToMany */ false,/* isManyToOne */ true,/* isManyToMany */ false,/* upper */ 1,/* lower */ 0,/* inverseUpper */ 1,/* isQualified */ false,/* isInverseQualified */ false,/* isOrdered */ false,/* isInverseOrdered */ false,/* isUnique */ true,/* isInverseUnique */ false,/* isDerived */ false,/* isNavigable */ true,/* propertyType */ Boolean.class,/* json */ "{\"name\": \"indexNonUniqueBoolean\", \"associationClassOne\": false, \"memberEndOfAssociationClass\": false, \"associationClassPropertyName\": null, \"inverseAssociationClassPropertyName\": null, \"associationClassProperty\": false, \"onePrimitivePropertyOfAssociationClass\": false, \"onePrimitive\": true, \"readOnly\": false, \"dataTypeEnum\": null, \"validations\": null, \"qualifiedName\": \"umlgtest::org::umlg::rootallinstances::TopRoot::indexNonUniqueBoolean\", \"persistentName\": \"indexNonUniqueBoolean\", \"inverseName\": \"inverseOf::indexNonUniqueBoolean\", \"inverseQualifiedName\": \"inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexNonUniqueBoolean\", \"manyPrimitive\": false, \"oneEnumeration\": false, \"manyEnumeration\": false, \"controllingSide\": true, \"composite\": false, \"inverseComposite\": false, \"oneToOne\": false, \"oneToMany\": false, \"manyToOne\": true, \"manyToMany\": false, \"upper\": 1, \"lower\": 0, \"inverseUpper\": 1, \"label\": \"indexNonUniqueBoolean\", \"qualified\": false, \"inverseQualified\": false, \"ordered\": false, \"inverseOrdered\": false, \"unique\": true, \"inverseUnique\": false, \"derived\": false, \"navigable\": true}",/* isChangeListenerAttribute */ false),
		nameUnique(/* qualifiedName */ "umlgtest::org::umlg::rootallinstances::BaseRoot::nameUnique",/* persistentName */ "nameUnique",/* inverseName */ "inverseOf::nameUnique",/* inverseQualifiedName */ "inverseOf::umlgtest::org::umlg::rootallinstances::BaseRoot::nameUnique",/* isAssociationClassOne */ false,/* isMemberEndOfAssociationClass */ false,/* associationClassPropertyNameField */ "null",/* inverseAssociationClassPropertyNameField */ "null",/* isAssociationClassProperty */ false,/* isOnePrimitivePropertyOfAssociationClass */ false,/* isOnePrimitive */ true,/* isReadOnly */ false,/* dataTypeEnum */ null,/* validations */ Collections.emptyList(),/* isManyPrimitive */ false,/* oneEnumeration */ false,/* manyEnumeration */ false,/* isControllingSide */ true,/* isComposite */ false,/* isInverseComposite */ false,/* label */ UmlgLabelConverterFactory.getUmlgLabelConverter().convert("nameUnique"),/* isOneToOne */ false,/* isOneToMany */ false,/* isManyToOne */ true,/* isManyToMany */ false,/* upper */ 1,/* lower */ 0,/* inverseUpper */ 1,/* isQualified */ false,/* isInverseQualified */ false,/* isOrdered */ false,/* isInverseOrdered */ false,/* isUnique */ true,/* isInverseUnique */ false,/* isDerived */ false,/* isNavigable */ true,/* propertyType */ String.class,/* json */ "{\"name\": \"nameUnique\", \"associationClassOne\": false, \"memberEndOfAssociationClass\": false, \"associationClassPropertyName\": null, \"inverseAssociationClassPropertyName\": null, \"associationClassProperty\": false, \"onePrimitivePropertyOfAssociationClass\": false, \"onePrimitive\": true, \"readOnly\": false, \"dataTypeEnum\": null, \"validations\": null, \"qualifiedName\": \"umlgtest::org::umlg::rootallinstances::BaseRoot::nameUnique\", \"persistentName\": \"nameUnique\", \"inverseName\": \"inverseOf::nameUnique\", \"inverseQualifiedName\": \"inverseOf::umlgtest::org::umlg::rootallinstances::BaseRoot::nameUnique\", \"manyPrimitive\": false, \"oneEnumeration\": false, \"manyEnumeration\": false, \"controllingSide\": true, \"composite\": false, \"inverseComposite\": false, \"oneToOne\": false, \"oneToMany\": false, \"manyToOne\": true, \"manyToMany\": false, \"upper\": 1, \"lower\": 0, \"inverseUpper\": 1, \"label\": \"nameUnique\", \"qualified\": false, \"inverseQualified\": false, \"ordered\": false, \"inverseOrdered\": false, \"unique\": true, \"inverseUnique\": false, \"derived\": false, \"navigable\": true}",/* isChangeListenerAttribute */ false),
		indexUniqueInteger(/* qualifiedName */ "umlgtest::org::umlg::rootallinstances::TopRoot::indexUniqueInteger",/* persistentName */ "indexUniqueInteger",/* inverseName */ "inverseOf::indexUniqueInteger",/* inverseQualifiedName */ "inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexUniqueInteger",/* isAssociationClassOne */ false,/* isMemberEndOfAssociationClass */ false,/* associationClassPropertyNameField */ "null",/* inverseAssociationClassPropertyNameField */ "null",/* isAssociationClassProperty */ false,/* isOnePrimitivePropertyOfAssociationClass */ false,/* isOnePrimitive */ true,/* isReadOnly */ false,/* dataTypeEnum */ null,/* validations */ Collections.emptyList(),/* isManyPrimitive */ false,/* oneEnumeration */ false,/* manyEnumeration */ false,/* isControllingSide */ true,/* isComposite */ false,/* isInverseComposite */ false,/* label */ UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexUniqueInteger"),/* isOneToOne */ false,/* isOneToMany */ false,/* isManyToOne */ true,/* isManyToMany */ false,/* upper */ 1,/* lower */ 0,/* inverseUpper */ 1,/* isQualified */ false,/* isInverseQualified */ false,/* isOrdered */ false,/* isInverseOrdered */ false,/* isUnique */ true,/* isInverseUnique */ false,/* isDerived */ false,/* isNavigable */ true,/* propertyType */ Integer.class,/* json */ "{\"name\": \"indexUniqueInteger\", \"associationClassOne\": false, \"memberEndOfAssociationClass\": false, \"associationClassPropertyName\": null, \"inverseAssociationClassPropertyName\": null, \"associationClassProperty\": false, \"onePrimitivePropertyOfAssociationClass\": false, \"onePrimitive\": true, \"readOnly\": false, \"dataTypeEnum\": null, \"validations\": null, \"qualifiedName\": \"umlgtest::org::umlg::rootallinstances::TopRoot::indexUniqueInteger\", \"persistentName\": \"indexUniqueInteger\", \"inverseName\": \"inverseOf::indexUniqueInteger\", \"inverseQualifiedName\": \"inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexUniqueInteger\", \"manyPrimitive\": false, \"oneEnumeration\": false, \"manyEnumeration\": false, \"controllingSide\": true, \"composite\": false, \"inverseComposite\": false, \"oneToOne\": false, \"oneToMany\": false, \"manyToOne\": true, \"manyToMany\": false, \"upper\": 1, \"lower\": 0, \"inverseUpper\": 1, \"label\": \"indexUniqueInteger\", \"qualified\": false, \"inverseQualified\": false, \"ordered\": false, \"inverseOrdered\": false, \"unique\": true, \"inverseUnique\": false, \"derived\": false, \"navigable\": true}",/* isChangeListenerAttribute */ false),
		indexNonUniqueReal(/* qualifiedName */ "umlgtest::org::umlg::rootallinstances::TopRoot::indexNonUniqueReal",/* persistentName */ "indexNonUniqueReal",/* inverseName */ "inverseOf::indexNonUniqueReal",/* inverseQualifiedName */ "inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexNonUniqueReal",/* isAssociationClassOne */ false,/* isMemberEndOfAssociationClass */ false,/* associationClassPropertyNameField */ "null",/* inverseAssociationClassPropertyNameField */ "null",/* isAssociationClassProperty */ false,/* isOnePrimitivePropertyOfAssociationClass */ false,/* isOnePrimitive */ true,/* isReadOnly */ false,/* dataTypeEnum */ null,/* validations */ Collections.emptyList(),/* isManyPrimitive */ false,/* oneEnumeration */ false,/* manyEnumeration */ false,/* isControllingSide */ true,/* isComposite */ false,/* isInverseComposite */ false,/* label */ UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexNonUniqueReal"),/* isOneToOne */ false,/* isOneToMany */ false,/* isManyToOne */ true,/* isManyToMany */ false,/* upper */ 1,/* lower */ 0,/* inverseUpper */ 1,/* isQualified */ false,/* isInverseQualified */ false,/* isOrdered */ false,/* isInverseOrdered */ false,/* isUnique */ true,/* isInverseUnique */ false,/* isDerived */ false,/* isNavigable */ true,/* propertyType */ Double.class,/* json */ "{\"name\": \"indexNonUniqueReal\", \"associationClassOne\": false, \"memberEndOfAssociationClass\": false, \"associationClassPropertyName\": null, \"inverseAssociationClassPropertyName\": null, \"associationClassProperty\": false, \"onePrimitivePropertyOfAssociationClass\": false, \"onePrimitive\": true, \"readOnly\": false, \"dataTypeEnum\": null, \"validations\": null, \"qualifiedName\": \"umlgtest::org::umlg::rootallinstances::TopRoot::indexNonUniqueReal\", \"persistentName\": \"indexNonUniqueReal\", \"inverseName\": \"inverseOf::indexNonUniqueReal\", \"inverseQualifiedName\": \"inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexNonUniqueReal\", \"manyPrimitive\": false, \"oneEnumeration\": false, \"manyEnumeration\": false, \"controllingSide\": true, \"composite\": false, \"inverseComposite\": false, \"oneToOne\": false, \"oneToMany\": false, \"manyToOne\": true, \"manyToMany\": false, \"upper\": 1, \"lower\": 0, \"inverseUpper\": 1, \"label\": \"indexNonUniqueReal\", \"qualified\": false, \"inverseQualified\": false, \"ordered\": false, \"inverseOrdered\": false, \"unique\": true, \"inverseUnique\": false, \"derived\": false, \"navigable\": true}",/* isChangeListenerAttribute */ false),
		name(/* qualifiedName */ "umlgtest::org::umlg::rootallinstances::BaseRoot::name",/* persistentName */ "name",/* inverseName */ "inverseOf::name",/* inverseQualifiedName */ "inverseOf::umlgtest::org::umlg::rootallinstances::BaseRoot::name",/* isAssociationClassOne */ false,/* isMemberEndOfAssociationClass */ false,/* associationClassPropertyNameField */ "null",/* inverseAssociationClassPropertyNameField */ "null",/* isAssociationClassProperty */ false,/* isOnePrimitivePropertyOfAssociationClass */ false,/* isOnePrimitive */ true,/* isReadOnly */ false,/* dataTypeEnum */ null,/* validations */ Collections.emptyList(),/* isManyPrimitive */ false,/* oneEnumeration */ false,/* manyEnumeration */ false,/* isControllingSide */ true,/* isComposite */ false,/* isInverseComposite */ false,/* label */ UmlgLabelConverterFactory.getUmlgLabelConverter().convert("name"),/* isOneToOne */ false,/* isOneToMany */ false,/* isManyToOne */ true,/* isManyToMany */ false,/* upper */ 1,/* lower */ 1,/* inverseUpper */ 1,/* isQualified */ false,/* isInverseQualified */ false,/* isOrdered */ false,/* isInverseOrdered */ false,/* isUnique */ true,/* isInverseUnique */ false,/* isDerived */ false,/* isNavigable */ true,/* propertyType */ String.class,/* json */ "{\"name\": \"name\", \"associationClassOne\": false, \"memberEndOfAssociationClass\": false, \"associationClassPropertyName\": null, \"inverseAssociationClassPropertyName\": null, \"associationClassProperty\": false, \"onePrimitivePropertyOfAssociationClass\": false, \"onePrimitive\": true, \"readOnly\": false, \"dataTypeEnum\": null, \"validations\": null, \"qualifiedName\": \"umlgtest::org::umlg::rootallinstances::BaseRoot::name\", \"persistentName\": \"name\", \"inverseName\": \"inverseOf::name\", \"inverseQualifiedName\": \"inverseOf::umlgtest::org::umlg::rootallinstances::BaseRoot::name\", \"manyPrimitive\": false, \"oneEnumeration\": false, \"manyEnumeration\": false, \"controllingSide\": true, \"composite\": false, \"inverseComposite\": false, \"oneToOne\": false, \"oneToMany\": false, \"manyToOne\": true, \"manyToMany\": false, \"upper\": 1, \"lower\": 1, \"inverseUpper\": 1, \"label\": \"name\", \"qualified\": false, \"inverseQualified\": false, \"ordered\": false, \"inverseOrdered\": false, \"unique\": true, \"inverseUnique\": false, \"derived\": false, \"navigable\": true}",/* isChangeListenerAttribute */ false),
		indexedName(/* qualifiedName */ "umlgtest::org::umlg::rootallinstances::TopRoot::indexedName",/* persistentName */ "indexedName",/* inverseName */ "inverseOf::indexedName",/* inverseQualifiedName */ "inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexedName",/* isAssociationClassOne */ false,/* isMemberEndOfAssociationClass */ false,/* associationClassPropertyNameField */ "null",/* inverseAssociationClassPropertyNameField */ "null",/* isAssociationClassProperty */ false,/* isOnePrimitivePropertyOfAssociationClass */ false,/* isOnePrimitive */ true,/* isReadOnly */ false,/* dataTypeEnum */ null,/* validations */ Collections.emptyList(),/* isManyPrimitive */ false,/* oneEnumeration */ false,/* manyEnumeration */ false,/* isControllingSide */ true,/* isComposite */ false,/* isInverseComposite */ false,/* label */ UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexedName"),/* isOneToOne */ false,/* isOneToMany */ false,/* isManyToOne */ true,/* isManyToMany */ false,/* upper */ 1,/* lower */ 1,/* inverseUpper */ 1,/* isQualified */ false,/* isInverseQualified */ false,/* isOrdered */ false,/* isInverseOrdered */ false,/* isUnique */ true,/* isInverseUnique */ false,/* isDerived */ false,/* isNavigable */ true,/* propertyType */ String.class,/* json */ "{\"name\": \"indexedName\", \"associationClassOne\": false, \"memberEndOfAssociationClass\": false, \"associationClassPropertyName\": null, \"inverseAssociationClassPropertyName\": null, \"associationClassProperty\": false, \"onePrimitivePropertyOfAssociationClass\": false, \"onePrimitive\": true, \"readOnly\": false, \"dataTypeEnum\": null, \"validations\": null, \"qualifiedName\": \"umlgtest::org::umlg::rootallinstances::TopRoot::indexedName\", \"persistentName\": \"indexedName\", \"inverseName\": \"inverseOf::indexedName\", \"inverseQualifiedName\": \"inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexedName\", \"manyPrimitive\": false, \"oneEnumeration\": false, \"manyEnumeration\": false, \"controllingSide\": true, \"composite\": false, \"inverseComposite\": false, \"oneToOne\": false, \"oneToMany\": false, \"manyToOne\": true, \"manyToMany\": false, \"upper\": 1, \"lower\": 1, \"inverseUpper\": 1, \"label\": \"indexedName\", \"qualified\": false, \"inverseQualified\": false, \"ordered\": false, \"inverseOrdered\": false, \"unique\": true, \"inverseUnique\": false, \"derived\": false, \"navigable\": true}",/* isChangeListenerAttribute */ false),
		indexNonUniqueUnlimitedNatural(/* qualifiedName */ "umlgtest::org::umlg::rootallinstances::TopRoot::indexNonUniqueUnlimitedNatural",/* persistentName */ "indexNonUniqueUnlimitedNatural",/* inverseName */ "inverseOf::indexNonUniqueUnlimitedNatural",/* inverseQualifiedName */ "inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexNonUniqueUnlimitedNatural",/* isAssociationClassOne */ false,/* isMemberEndOfAssociationClass */ false,/* associationClassPropertyNameField */ "null",/* inverseAssociationClassPropertyNameField */ "null",/* isAssociationClassProperty */ false,/* isOnePrimitivePropertyOfAssociationClass */ false,/* isOnePrimitive */ true,/* isReadOnly */ false,/* dataTypeEnum */ null,/* validations */ Collections.emptyList(),/* isManyPrimitive */ false,/* oneEnumeration */ false,/* manyEnumeration */ false,/* isControllingSide */ true,/* isComposite */ false,/* isInverseComposite */ false,/* label */ UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexNonUniqueUnlimitedNatural"),/* isOneToOne */ false,/* isOneToMany */ false,/* isManyToOne */ true,/* isManyToMany */ false,/* upper */ 1,/* lower */ 0,/* inverseUpper */ 1,/* isQualified */ false,/* isInverseQualified */ false,/* isOrdered */ false,/* isInverseOrdered */ false,/* isUnique */ true,/* isInverseUnique */ false,/* isDerived */ false,/* isNavigable */ true,/* propertyType */ Integer.class,/* json */ "{\"name\": \"indexNonUniqueUnlimitedNatural\", \"associationClassOne\": false, \"memberEndOfAssociationClass\": false, \"associationClassPropertyName\": null, \"inverseAssociationClassPropertyName\": null, \"associationClassProperty\": false, \"onePrimitivePropertyOfAssociationClass\": false, \"onePrimitive\": true, \"readOnly\": false, \"dataTypeEnum\": null, \"validations\": null, \"qualifiedName\": \"umlgtest::org::umlg::rootallinstances::TopRoot::indexNonUniqueUnlimitedNatural\", \"persistentName\": \"indexNonUniqueUnlimitedNatural\", \"inverseName\": \"inverseOf::indexNonUniqueUnlimitedNatural\", \"inverseQualifiedName\": \"inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexNonUniqueUnlimitedNatural\", \"manyPrimitive\": false, \"oneEnumeration\": false, \"manyEnumeration\": false, \"controllingSide\": true, \"composite\": false, \"inverseComposite\": false, \"oneToOne\": false, \"oneToMany\": false, \"manyToOne\": true, \"manyToMany\": false, \"upper\": 1, \"lower\": 0, \"inverseUpper\": 1, \"label\": \"indexNonUniqueUnlimitedNatural\", \"qualified\": false, \"inverseQualified\": false, \"ordered\": false, \"inverseOrdered\": false, \"unique\": true, \"inverseUnique\": false, \"derived\": false, \"navigable\": true}",/* isChangeListenerAttribute */ false),
		topRootChild(/* qualifiedName */ "umlgtest::org::umlg::rootallinstances::TopRoot::topRootChild",/* persistentName */ "topRootChild",/* inverseName */ "topRoot",/* inverseQualifiedName */ "umlgtest::org::umlg::rootallinstances::topRoot_topRootChild::topRoot",/* isAssociationClassOne */ false,/* isMemberEndOfAssociationClass */ false,/* associationClassPropertyNameField */ "null",/* inverseAssociationClassPropertyNameField */ "null",/* isAssociationClassProperty */ false,/* isOnePrimitivePropertyOfAssociationClass */ false,/* isOnePrimitive */ false,/* isReadOnly */ false,/* dataTypeEnum */ null,/* validations */ Collections.emptyList(),/* isManyPrimitive */ false,/* oneEnumeration */ false,/* manyEnumeration */ false,/* isControllingSide */ true,/* isComposite */ true,/* isInverseComposite */ false,/* label */ UmlgLabelConverterFactory.getUmlgLabelConverter().convert("topRoot_topRootChild"),/* isOneToOne */ false,/* isOneToMany */ true,/* isManyToOne */ false,/* isManyToMany */ false,/* upper */ -1,/* lower */ 0,/* inverseUpper */ 1,/* isQualified */ false,/* isInverseQualified */ false,/* isOrdered */ false,/* isInverseOrdered */ false,/* isUnique */ true,/* isInverseUnique */ true,/* isDerived */ false,/* isNavigable */ true,/* propertyType */ TopRootChild.class,/* json */ "{\"name\": \"topRootChild\", \"associationClassOne\": false, \"memberEndOfAssociationClass\": false, \"associationClassPropertyName\": null, \"inverseAssociationClassPropertyName\": null, \"associationClassProperty\": false, \"onePrimitivePropertyOfAssociationClass\": false, \"onePrimitive\": false, \"readOnly\": false, \"dataTypeEnum\": null, \"validations\": null, \"qualifiedName\": \"umlgtest::org::umlg::rootallinstances::TopRoot::topRootChild\", \"persistentName\": \"topRootChild\", \"inverseName\": \"topRoot\", \"inverseQualifiedName\": \"umlgtest::org::umlg::rootallinstances::topRoot_topRootChild::topRoot\", \"manyPrimitive\": false, \"oneEnumeration\": false, \"manyEnumeration\": false, \"controllingSide\": true, \"composite\": true, \"inverseComposite\": false, \"oneToOne\": false, \"oneToMany\": true, \"manyToOne\": false, \"manyToMany\": false, \"upper\": -1, \"lower\": 0, \"inverseUpper\": 1, \"label\": \"topRoot_topRootChild\", \"qualified\": false, \"inverseQualified\": false, \"ordered\": false, \"inverseOrdered\": false, \"unique\": true, \"inverseUnique\": true, \"derived\": false, \"navigable\": true}",/* isChangeListenerAttribute */ false),
		indexUniqueReal(/* qualifiedName */ "umlgtest::org::umlg::rootallinstances::TopRoot::indexUniqueReal",/* persistentName */ "indexUniqueReal",/* inverseName */ "inverseOf::indexUniqueReal",/* inverseQualifiedName */ "inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexUniqueReal",/* isAssociationClassOne */ false,/* isMemberEndOfAssociationClass */ false,/* associationClassPropertyNameField */ "null",/* inverseAssociationClassPropertyNameField */ "null",/* isAssociationClassProperty */ false,/* isOnePrimitivePropertyOfAssociationClass */ false,/* isOnePrimitive */ true,/* isReadOnly */ false,/* dataTypeEnum */ null,/* validations */ Collections.emptyList(),/* isManyPrimitive */ false,/* oneEnumeration */ false,/* manyEnumeration */ false,/* isControllingSide */ true,/* isComposite */ false,/* isInverseComposite */ false,/* label */ UmlgLabelConverterFactory.getUmlgLabelConverter().convert("indexUniqueReal"),/* isOneToOne */ false,/* isOneToMany */ false,/* isManyToOne */ true,/* isManyToMany */ false,/* upper */ 1,/* lower */ 0,/* inverseUpper */ 1,/* isQualified */ false,/* isInverseQualified */ false,/* isOrdered */ false,/* isInverseOrdered */ false,/* isUnique */ true,/* isInverseUnique */ false,/* isDerived */ false,/* isNavigable */ true,/* propertyType */ Double.class,/* json */ "{\"name\": \"indexUniqueReal\", \"associationClassOne\": false, \"memberEndOfAssociationClass\": false, \"associationClassPropertyName\": null, \"inverseAssociationClassPropertyName\": null, \"associationClassProperty\": false, \"onePrimitivePropertyOfAssociationClass\": false, \"onePrimitive\": true, \"readOnly\": false, \"dataTypeEnum\": null, \"validations\": null, \"qualifiedName\": \"umlgtest::org::umlg::rootallinstances::TopRoot::indexUniqueReal\", \"persistentName\": \"indexUniqueReal\", \"inverseName\": \"inverseOf::indexUniqueReal\", \"inverseQualifiedName\": \"inverseOf::umlgtest::org::umlg::rootallinstances::TopRoot::indexUniqueReal\", \"manyPrimitive\": false, \"oneEnumeration\": false, \"manyEnumeration\": false, \"controllingSide\": true, \"composite\": false, \"inverseComposite\": false, \"oneToOne\": false, \"oneToMany\": false, \"manyToOne\": true, \"manyToMany\": false, \"upper\": 1, \"lower\": 0, \"inverseUpper\": 1, \"label\": \"indexUniqueReal\", \"qualified\": false, \"inverseQualified\": false, \"ordered\": false, \"inverseOrdered\": false, \"unique\": true, \"inverseUnique\": false, \"derived\": false, \"navigable\": true}",/* isChangeListenerAttribute */ false),
		umlgtest(/* qualifiedName */ "umlgtest",/* persistentName */ "umlgtest",/* inverseName */ "inverseOfumlgtest",/* inverseQualifiedName */ "inverseOfumlgtest",/* isAssociationClassOne */ false,/* isMemberEndOfAssociationClass */ false,/* associationClassPropertyNameField */ "null",/* inverseAssociationClassPropertyNameField */ "null",/* isAssociationClassProperty */ false,/* isOnePrimitivePropertyOfAssociationClass */ false,/* isOnePrimitive */ false,/* isReadOnly */ false,/* dataTypeEnum */ null,/* validations */ Collections.emptyList(),/* isManyPrimitive */ false,/* oneEnumeration */ false,/* manyEnumeration */ false,/* isControllingSide */ true,/* isComposite */ false,/* isInverseComposite */ true,/* label */ UmlgLabelConverterFactory.getUmlgLabelConverter().convert("rootTopRoot"),/* isOneToOne */ true,/* isOneToMany */ false,/* isManyToOne */ false,/* isManyToMany */ false,/* upper */ -1,/* lower */ 0,/* inverseUpper */ 1,/* isQualified */ false,/* isInverseQualified */ false,/* isOrdered */ false,/* isInverseOrdered */ false,/* isUnique */ false,/* isInverseUnique */ false,/* isDerived */ false,/* isNavigable */ false,/* propertyType */ Object.class,/* json */ "{\"name\": \"umlgtest\", \"associationClassOne\": false, \"memberEndOfAssociationClass\": false, \"associationClassPropertyName\": null, \"inverseAssociationClassPropertyName\": null, \"associationClassProperty\": false, \"onePrimitivePropertyOfAssociationClass\": false, \"onePrimitive\": false, \"readOnly\": false, \"dataTypeEnum\": null, \"validations\": null, \"qualifiedName\": \"umlgtest\", \"persistentName\": \"umlgtest\", \"inverseName\": \"inverseOfumlgtest\", \"inverseQualifiedName\": \"inverseOfumlgtest\", \"manyPrimitive\": false, \"oneEnumeration\": false, \"manyEnumeration\": false, \"controllingSide\": true, \"composite\": false, \"inverseComposite\": true, \"oneToOne\": true, \"oneToMany\": false, \"manyToOne\": false, \"manyToMany\": false, \"upper\": -1, \"lower\": 0, \"inverseUpper\": 1, \"label\": \"rootTopRoot\", \"qualified\": false, \"inverseQualified\": false, \"ordered\": false, \"inverseOrdered\": false, \"unique\": false, \"inverseUnique\": false, \"derived\": false, \"navigable\": false}",/* isChangeListenerAttribute */ false);
		private String _qualifiedName;
		private String _persistentName;
		private String _inverseName;
		private String _inverseQualifiedName;
		private boolean _associationClassOne;
		private boolean _memberEndOfAssociationClass;
		private String _associationClassPropertyName;
		private String _inverseAssociationClassPropertyName;
		private boolean _associationClassProperty;
		private boolean _onePrimitivePropertyOfAssociationClass;
		private boolean _onePrimitive;
		private Boolean _readOnly;
		private DataTypeEnum dataTypeEnum;
		private List validations;
		private boolean _manyPrimitive;
		private boolean _oneEnumeration;
		private boolean _manyEnumeration;
		private boolean _controllingSide;
		private boolean _composite;
		private boolean _inverseComposite;
		private String _label;
		private boolean _oneToOne;
		private boolean _oneToMany;
		private boolean _manyToOne;
		private boolean _manyToMany;
		private int _upper;
		private int _lower;
		private int _inverseUpper;
		private boolean _qualified;
		private boolean _inverseQualified;
		private boolean _ordered;
		private boolean _inverseOrdered;
		private boolean _unique;
		private boolean _inverseUnique;
		private boolean _derived;
		private boolean _navigability;
		private Class _propertyType;
		private String _json;
		private boolean _changeListener;
		/**
		 * constructor for TopRootRuntimePropertyEnum
		 * 
		 * @param _qualifiedName 
		 * @param _persistentName 
		 * @param _inverseName 
		 * @param _inverseQualifiedName 
		 * @param _associationClassOne 
		 * @param _memberEndOfAssociationClass 
		 * @param _associationClassPropertyName 
		 * @param _inverseAssociationClassPropertyName 
		 * @param _associationClassProperty 
		 * @param _onePrimitivePropertyOfAssociationClass 
		 * @param _onePrimitive 
		 * @param _readOnly 
		 * @param dataTypeEnum 
		 * @param validations 
		 * @param _manyPrimitive 
		 * @param _oneEnumeration 
		 * @param _manyEnumeration 
		 * @param _controllingSide 
		 * @param _composite 
		 * @param _inverseComposite 
		 * @param _label 
		 * @param _oneToOne 
		 * @param _oneToMany 
		 * @param _manyToOne 
		 * @param _manyToMany 
		 * @param _upper 
		 * @param _lower 
		 * @param _inverseUpper 
		 * @param _qualified 
		 * @param _inverseQualified 
		 * @param _ordered 
		 * @param _inverseOrdered 
		 * @param _unique 
		 * @param _inverseUnique 
		 * @param _derived 
		 * @param _navigability 
		 * @param _propertyType 
		 * @param _json 
		 * @param _changeListener 
		 */
		private TopRootRuntimePropertyEnum(String _qualifiedName, String _persistentName, String _inverseName, String _inverseQualifiedName, boolean _associationClassOne, boolean _memberEndOfAssociationClass, String _associationClassPropertyName, String _inverseAssociationClassPropertyName, boolean _associationClassProperty, boolean _onePrimitivePropertyOfAssociationClass, boolean _onePrimitive, Boolean _readOnly, DataTypeEnum dataTypeEnum, List validations, boolean _manyPrimitive, boolean _oneEnumeration, boolean _manyEnumeration, boolean _controllingSide, boolean _composite, boolean _inverseComposite, String _label, boolean _oneToOne, boolean _oneToMany, boolean _manyToOne, boolean _manyToMany, int _upper, int _lower, int _inverseUpper, boolean _qualified, boolean _inverseQualified, boolean _ordered, boolean _inverseOrdered, boolean _unique, boolean _inverseUnique, boolean _derived, boolean _navigability, Class _propertyType, String _json, boolean _changeListener)  {
			this._qualifiedName = _qualifiedName;
			this._persistentName = _persistentName;
			this._inverseName = _inverseName;
			this._inverseQualifiedName = _inverseQualifiedName;
			this._associationClassOne = _associationClassOne;
			this._memberEndOfAssociationClass = _memberEndOfAssociationClass;
			this._associationClassPropertyName = _associationClassPropertyName;
			this._inverseAssociationClassPropertyName = _inverseAssociationClassPropertyName;
			this._associationClassProperty = _associationClassProperty;
			this._onePrimitivePropertyOfAssociationClass = _onePrimitivePropertyOfAssociationClass;
			this._onePrimitive = _onePrimitive;
			this._readOnly = _readOnly;
			this.dataTypeEnum = dataTypeEnum;
			this.validations = validations;
			this._manyPrimitive = _manyPrimitive;
			this._oneEnumeration = _oneEnumeration;
			this._manyEnumeration = _manyEnumeration;
			this._controllingSide = _controllingSide;
			this._composite = _composite;
			this._inverseComposite = _inverseComposite;
			this._label = _label;
			this._oneToOne = _oneToOne;
			this._oneToMany = _oneToMany;
			this._manyToOne = _manyToOne;
			this._manyToMany = _manyToMany;
			this._upper = _upper;
			this._lower = _lower;
			this._inverseUpper = _inverseUpper;
			this._qualified = _qualified;
			this._inverseQualified = _inverseQualified;
			this._ordered = _ordered;
			this._inverseOrdered = _inverseOrdered;
			this._unique = _unique;
			this._inverseUnique = _inverseUnique;
			this._derived = _derived;
			this._navigability = _navigability;
			this._propertyType = _propertyType;
			this._json = _json;
			this._changeListener = _changeListener;
		}
	
		static public String asJson() {
			int count = 1;
			StringBuilder sb = new StringBuilder();;
			sb.append("{\"name\": \"TopRoot\", ");
			sb.append("\"qualifiedName\": \"umlgtest::org::umlg::rootallinstances::TopRoot\", ");
			sb.append("\"uri\": \"TODO\", ");
			sb.append("\"properties\": [");
			for ( TopRootRuntimePropertyEnum l : TopRootRuntimePropertyEnum.values() ) {
				sb.append(l.toJson());
				if ( count < TopRootRuntimePropertyEnum.values().length ) {
					count++;
					sb.append(",");
				}
			}
			sb.append("]}");
			return sb.toString();
		}
		
		static public TopRootRuntimePropertyEnum fromInverseQualifiedName(String inverseQualifiedName) {
			if ( umlgtest.getInverseQualifiedName().equals(inverseQualifiedName) ) {
				return umlgtest;
			}
			if ( indexUniqueReal.getInverseQualifiedName().equals(inverseQualifiedName) ) {
				return indexUniqueReal;
			}
			if ( topRootChild.getInverseQualifiedName().equals(inverseQualifiedName) ) {
				return topRootChild;
			}
			if ( indexNonUniqueUnlimitedNatural.getInverseQualifiedName().equals(inverseQualifiedName) ) {
				return indexNonUniqueUnlimitedNatural;
			}
			if ( indexedName.getInverseQualifiedName().equals(inverseQualifiedName) ) {
				return indexedName;
			}
			if ( name.getInverseQualifiedName().equals(inverseQualifiedName) ) {
				return name;
			}
			if ( indexNonUniqueReal.getInverseQualifiedName().equals(inverseQualifiedName) ) {
				return indexNonUniqueReal;
			}
			if ( indexUniqueInteger.getInverseQualifiedName().equals(inverseQualifiedName) ) {
				return indexUniqueInteger;
			}
			if ( nameUnique.getInverseQualifiedName().equals(inverseQualifiedName) ) {
				return nameUnique;
			}
			if ( indexNonUniqueBoolean.getInverseQualifiedName().equals(inverseQualifiedName) ) {
				return indexNonUniqueBoolean;
			}
			if ( indexUniqueUnlimitedNatural.getInverseQualifiedName().equals(inverseQualifiedName) ) {
				return indexUniqueUnlimitedNatural;
			}
			if ( indexedNonUniqueName.getInverseQualifiedName().equals(inverseQualifiedName) ) {
				return indexedNonUniqueName;
			}
			if ( indexNonUniqueInteger.getInverseQualifiedName().equals(inverseQualifiedName) ) {
				return indexNonUniqueInteger;
			}
			return null;
		}
		
		static public TopRootRuntimePropertyEnum fromLabel(String _label) {
			if ( umlgtest.getLabel().equals(_label) ) {
				return umlgtest;
			}
			if ( indexUniqueReal.getLabel().equals(_label) ) {
				return indexUniqueReal;
			}
			if ( topRootChild.getLabel().equals(_label) ) {
				return topRootChild;
			}
			if ( indexNonUniqueUnlimitedNatural.getLabel().equals(_label) ) {
				return indexNonUniqueUnlimitedNatural;
			}
			if ( indexedName.getLabel().equals(_label) ) {
				return indexedName;
			}
			if ( name.getLabel().equals(_label) ) {
				return name;
			}
			if ( indexNonUniqueReal.getLabel().equals(_label) ) {
				return indexNonUniqueReal;
			}
			if ( indexUniqueInteger.getLabel().equals(_label) ) {
				return indexUniqueInteger;
			}
			if ( nameUnique.getLabel().equals(_label) ) {
				return nameUnique;
			}
			if ( indexNonUniqueBoolean.getLabel().equals(_label) ) {
				return indexNonUniqueBoolean;
			}
			if ( indexUniqueUnlimitedNatural.getLabel().equals(_label) ) {
				return indexUniqueUnlimitedNatural;
			}
			if ( indexedNonUniqueName.getLabel().equals(_label) ) {
				return indexedNonUniqueName;
			}
			if ( indexNonUniqueInteger.getLabel().equals(_label) ) {
				return indexNonUniqueInteger;
			}
			return null;
		}
		
		static public TopRootRuntimePropertyEnum fromQualifiedName(String qualifiedName) {
			if ( umlgtest.getQualifiedName().equals(qualifiedName) ) {
				return umlgtest;
			}
			if ( indexUniqueReal.getQualifiedName().equals(qualifiedName) ) {
				return indexUniqueReal;
			}
			if ( topRootChild.getQualifiedName().equals(qualifiedName) ) {
				return topRootChild;
			}
			if ( indexNonUniqueUnlimitedNatural.getQualifiedName().equals(qualifiedName) ) {
				return indexNonUniqueUnlimitedNatural;
			}
			if ( indexedName.getQualifiedName().equals(qualifiedName) ) {
				return indexedName;
			}
			if ( name.getQualifiedName().equals(qualifiedName) ) {
				return name;
			}
			if ( indexNonUniqueReal.getQualifiedName().equals(qualifiedName) ) {
				return indexNonUniqueReal;
			}
			if ( indexUniqueInteger.getQualifiedName().equals(qualifiedName) ) {
				return indexUniqueInteger;
			}
			if ( nameUnique.getQualifiedName().equals(qualifiedName) ) {
				return nameUnique;
			}
			if ( indexNonUniqueBoolean.getQualifiedName().equals(qualifiedName) ) {
				return indexNonUniqueBoolean;
			}
			if ( indexUniqueUnlimitedNatural.getQualifiedName().equals(qualifiedName) ) {
				return indexUniqueUnlimitedNatural;
			}
			if ( indexedNonUniqueName.getQualifiedName().equals(qualifiedName) ) {
				return indexedNonUniqueName;
			}
			if ( indexNonUniqueInteger.getQualifiedName().equals(qualifiedName) ) {
				return indexNonUniqueInteger;
			}
			return null;
		}
		
		public String getAssociationClassPropertyName() {
			return this._associationClassPropertyName;
		}
		
		public DataTypeEnum getDataTypeEnum() {
			return this.dataTypeEnum;
		}
		
		public String getInverseAssociationClassPropertyName() {
			return this._inverseAssociationClassPropertyName;
		}
		
		public String getInverseName() {
			return this._inverseName;
		}
		
		public String getInverseQualifiedName() {
			return this._inverseQualifiedName;
		}
		
		public int getInverseUpper() {
			return this._inverseUpper;
		}
		
		public String getJson() {
			return this._json;
		}
		
		public String getLabel() {
			return this._label;
		}
		
		public int getLower() {
			return this._lower;
		}
		
		public String getPersistentName() {
			return this._persistentName;
		}
		
		public Class getPropertyType() {
			return this._propertyType;
		}
		
		public String getQualifiedName() {
			return this._qualifiedName;
		}
		
		public Boolean getReadOnly() {
			return this._readOnly;
		}
		
		public int getUpper() {
			return this._upper;
		}
		
		public List getValidations() {
			return this.validations;
		}
		
		public boolean isAssociationClassOne() {
			return this._associationClassOne;
		}
		
		public boolean isAssociationClassProperty() {
			return this._associationClassProperty;
		}
		
		public boolean isChangeListener() {
			return this._changeListener;
		}
		
		public boolean isComposite() {
			return this._composite;
		}
		
		public boolean isControllingSide() {
			return this._controllingSide;
		}
		
		public boolean isDerived() {
			return this._derived;
		}
		
		public boolean isInverseComposite() {
			return this._inverseComposite;
		}
		
		public boolean isInverseOrdered() {
			return this._inverseOrdered;
		}
		
		public boolean isInverseQualified() {
			return this._inverseQualified;
		}
		
		public boolean isInverseUnique() {
			return this._inverseUnique;
		}
		
		public boolean isManyEnumeration() {
			return this._manyEnumeration;
		}
		
		public boolean isManyPrimitive() {
			return this._manyPrimitive;
		}
		
		public boolean isManyToMany() {
			return this._manyToMany;
		}
		
		public boolean isManyToOne() {
			return this._manyToOne;
		}
		
		public boolean isMemberEndOfAssociationClass() {
			return this._memberEndOfAssociationClass;
		}
		
		public boolean isNavigability() {
			return this._navigability;
		}
		
		public boolean isOneEnumeration() {
			return this._oneEnumeration;
		}
		
		public boolean isOnePrimitive() {
			return this._onePrimitive;
		}
		
		public boolean isOnePrimitivePropertyOfAssociationClass() {
			return this._onePrimitivePropertyOfAssociationClass;
		}
		
		public boolean isOneToMany() {
			return this._oneToMany;
		}
		
		public boolean isOneToOne() {
			return this._oneToOne;
		}
		
		public boolean isOrdered() {
			return this._ordered;
		}
		
		public boolean isQualified() {
			return this._qualified;
		}
		
		public boolean isUnique() {
			return this._unique;
		}
		
		@Override
		public boolean isValid(int elementCount) {
			if ( isQualified() ) {
				return elementCount >= getLower();
			} else {
				return (getUpper() == -1 || elementCount <= getUpper()) && elementCount >= getLower();
			}
		}
		
		@Override
		public String toJson() {
			return getJson();
		}
	
	
	}
}