klass.model.meta.domain.ClassifierFinder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of klass-model-bootstrapped-reladomo-pojos Show documentation
The newest version!
package klass.model.meta.domain;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.util.*;
import java.io.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.gs.fw.common.mithra.*;
import com.gs.fw.common.mithra.attribute.*;
import com.gs.fw.common.mithra.util.*;
import com.gs.fw.common.mithra.notification.*;
import com.gs.fw.common.mithra.notification.listener.*;
import com.gs.fw.common.mithra.list.cursor.Cursor;
import com.gs.fw.common.mithra.bulkloader.*;
import com.gs.fw.common.mithra.*;
import com.gs.fw.common.mithra.attribute.*;
import com.gs.fw.common.mithra.attribute.calculator.procedure.ObjectProcedure;
import com.gs.fw.common.mithra.behavior.txparticipation.*;
import com.gs.fw.common.mithra.cache.Cache;
import com.gs.fw.common.mithra.cache.bean.*;
import com.gs.fw.common.mithra.extractor.*;
import com.gs.fw.common.mithra.finder.*;
import com.gs.fw.common.mithra.finder.booleanop.*;
import com.gs.fw.common.mithra.finder.integer.*;
import com.gs.fw.common.mithra.finder.longop.*;
import com.gs.fw.common.mithra.finder.orderby.OrderBy;
import com.gs.fw.common.mithra.finder.string.*;
import com.gs.fw.common.mithra.extractor.NormalAndListValueSelector;
import com.gs.fw.common.mithra.list.NulledRelation;
import com.gs.fw.common.mithra.querycache.CachedQuery;
import com.gs.fw.common.mithra.querycache.QueryCache;
import com.gs.fw.common.mithra.portal.*;
import com.gs.fw.common.mithra.remote.*;
import com.gs.fw.common.mithra.transaction.MithraObjectPersister;
import com.gs.fw.common.mithra.util.TimestampPool;
import org.eclipse.collections.impl.map.mutable.UnifiedMap;
import java.io.Serializable;
/**
* This file was automatically generated using Mithra 18.0.0. Please do not modify it.
* Add custom logic to its subclass instead.
*/
public class ClassifierFinder
{
	private static final String IMPL_CLASS_NAME_WITH_SLASHES = "klass/model/meta/domain/Classifier";
	private static final String BUSINESS_CLASS_NAME_WITH_DOTS = "klass.model.meta.domain.Classifier";
	private static final FinderMethodMap finderMethodMap;
	private static boolean isFullCache;
	private static boolean isOffHeap;
	private static volatile MithraObjectPortal objectPortal = new UninitializedPortal("klass.model.meta.domain.Classifier");
	private static final ClassifierSingleFinder finder = new ClassifierSingleFinder();
	private static ConstantStringSet[] constantStringSets = new ConstantStringSet[0];
	private static ConstantIntSet[] constantIntSets = new ConstantIntSet[0];
	private static ConstantShortSet[] constantShortSets = new ConstantShortSet[0];
	static
	{
		finderMethodMap = new FinderMethodMap(ClassifierFinder.ClassifierRelatedFinder.class);
		finderMethodMap.addNormalAttributeName("name");
		finderMethodMap.addRelationshipName("superInterfaces");
		finderMethodMap.addRelationshipName("classifierModifiers");
		finderMethodMap.addRelationshipName("dataTypeProperties");
		finderMethodMap.addRelationshipName("interfaceSubClass");
		finderMethodMap.addRelationshipName("klassSubClass");
		finderMethodMap.addRelationshipName("packageableElementSuperClass");
		finderMethodMap.addRelationshipName("projections");
	}

	public static Attribute[] allPersistentAttributes()
	{
		return finder.getPersistentAttributes();
	}

	public static List allRelatedFinders()
	{
		return finder.getRelationshipFinders();
	}

	public static List allDependentRelatedFinders()
	{
		return finder.getDependentRelationshipFinders();
	}

	public static ConstantStringSet zGetConstantStringSet(int index)
	{
		return constantStringSets[index];
	}

	public static ConstantIntSet zGetConstantIntSet(int index)
	{
		return constantIntSets[index];
	}

	public static ConstantShortSet zGetConstantShortSet(int index)
	{
		return constantShortSets[index];
	}

	public static Mapper zGetConstantJoin(int index)
	{
		return getConstantJoinPool()[index];
	}

	private static Mapper[] constantJoinPool;
	private static Mapper[] getConstantJoinPool()
	{
		if (constantJoinPool == null)
		{
			Mapper[] result = new Mapper[10];
			result[0] = ClassifierFinder.name().constructEqualityMapper(ClassifierInterfaceMappingFinder.classifierName());
			result[1] = ClassifierInterfaceMappingFinder.classifierName().constructEqualityMapper(ClassifierFinder.name());
			result[2] = ClassifierFinder.name().constructEqualityMapper(ClassifierModifierFinder.classifierName());
			result[3] = ClassifierModifierFinder.classifierName().constructEqualityMapper(ClassifierFinder.name());
			result[4] = ClassifierFinder.name().constructEqualityMapper(DataTypePropertyFinder.classifierName());
			result[5] = DataTypePropertyFinder.classifierName().constructEqualityMapper(ClassifierFinder.name());
			result[6] = ClassifierFinder.name().constructEqualityMapper(InterfaceFinder.name());
			result[7] = InterfaceFinder.name().constructEqualityMapper(ClassifierFinder.name());
			result[8] = ClassifierFinder.name().constructEqualityMapper(KlassFinder.name());
			result[9] = KlassFinder.name().constructEqualityMapper(ClassifierFinder.name());
			constantJoinPool = result;
		}

		return constantJoinPool;
	}

	public static SourceAttributeType getSourceAttributeType()
	{
		return null;
	}

	public static Classifier findOne(com.gs.fw.finder.Operation operation)
	{
		return findOne(operation, false);
	}

	public static Classifier findOneBypassCache(com.gs.fw.finder.Operation operation)
	{
		return findOne(operation, true);
	}

	public static ClassifierList findMany(com.gs.fw.finder.Operation operation)
	{
		return (ClassifierList) finder.findMany(operation);
	}

	public static ClassifierList findManyBypassCache(com.gs.fw.finder.Operation operation)
	{
		return (ClassifierList) finder.findManyBypassCache(operation);
	}

	private static Classifier findOne(com.gs.fw.finder.Operation operation, boolean bypassCache)
	{
		List found = getMithraObjectPortal().find((Operation) operation, bypassCache);
		return (Classifier) FinderUtils.findOne(found);
	}

	public static Classifier findByPrimaryKey(String name)
	{
		return finder.findByPrimaryKey(name);
	}

	private static final RelationshipHashStrategy forPrimaryKey = new PrimaryKeyRhs();
	private static final class PrimaryKeyRhs implements RelationshipHashStrategy
	{
		public boolean equalsForRelationship(Object _srcObject, Object _srcData, Object _targetData, Timestamp _asOfDate0, Timestamp _asOfDate1)
		{
			I3O3L3 _bean = (I3O3L3) _srcData;
			ClassifierData _castedTargetData = (ClassifierData) _targetData;
			if (_bean.getO1AsString().equals(_castedTargetData.getName()))
			{
				return true;
			}

			return false;
		}

		public int computeHashCodeFromRelated(Object _srcObject, Object _srcData)
		{
			I3O3L3 _bean = (I3O3L3) _srcData;
			return HashUtil.hash(_bean.getO1AsString());
		}

		public int computeOffHeapHashCodeFromRelated(Object _srcObject, Object _srcData)
		{
			I3O3L3 _bean = (I3O3L3) _srcData;
			return HashUtil.offHeapHash(_bean.getO1AsString());
		}
	}

	public static Classifier zFindOneForRelationship(Operation operation)
	{
		List found = getMithraObjectPortal().findAsCachedQuery(operation, null, false, true, 0).getResult();
		return (Classifier) FinderUtils.findOne(found);
	}

	public static MithraObjectPortal getMithraObjectPortal()
	{
		return objectPortal.getInitializedPortal();
	}

	public static void clearQueryCache()
	{
		objectPortal.clearQueryCache();
	}

	public static void reloadCache()
	{
		objectPortal.reloadCache();
	}

	public static class ClassifierRelatedFinder extends AbstractRelatedFinder
	{
		private List relationshipFinders;
		private List dependentRelationshipFinders;
		private StringAttribute name;
		private ClassifierSuperInterfacesFinderSubclass superInterfaces;
		private ClassifierClassifierModifiersFinderSubclass classifierModifiers;
		private ClassifierDataTypePropertiesFinderSubclass dataTypeProperties;
		private ClassifierInterfaceSubClassFinderSubclass interfaceSubClass;
		private ClassifierKlassSubClassFinderSubclass klassSubClass;
		private ClassifierPackageableElementSuperClassFinderSubclass packageableElementSuperClass;
		private ClassifierProjectionsFinderSubclass projections;
		public ClassifierRelatedFinder()
		{
			super();
		}

		public ClassifierRelatedFinder(Mapper mapper)
		{
			super(mapper);
		}

		public String getFinderClassName()
		{
			return "klass.model.meta.domain.ClassifierFinder";
		}

		public RelatedFinder getRelationshipFinderByName(String relationshipName)
		{
			return ClassifierFinder.finderMethodMap.getRelationshipFinderByName(relationshipName, this);
		}

		public Attribute getAttributeByName(String attributeName)
		{
			return ClassifierFinder.finderMethodMap.getAttributeByName(attributeName, this);
		}

		public com.gs.fw.common.mithra.extractor.Function getAttributeOrRelationshipSelector(String attributeName)
		{
			return ClassifierFinder.finderMethodMap.getAttributeOrRelationshipSelectorFunction(attributeName, this);
		}

		public Attribute[] getPersistentAttributes()
		{
			Attribute[] attributes = new Attribute[1];
			attributes[0] = this.name();
			return attributes;
		}

		public List getRelationshipFinders()
		{
			if (relationshipFinders == null)
			{
				List relatedFinders = new ArrayList(7);
				relatedFinders.add(this.superInterfaces());
				relatedFinders.add(this.classifierModifiers());
				relatedFinders.add(this.dataTypeProperties());
				relatedFinders.add(this.interfaceSubClass());
				relatedFinders.add(this.klassSubClass());
				relatedFinders.add(this.packageableElementSuperClass());
				relatedFinders.add(this.projections());
				relationshipFinders = Collections.unmodifiableList(relatedFinders);
			}

			return relationshipFinders;
		}

		public List getDependentRelationshipFinders()
		{
			if (dependentRelationshipFinders == null)
			{
				List dependentRelatedFinders = new ArrayList(5);
				dependentRelatedFinders.add(this.superInterfaces());
				dependentRelatedFinders.add(this.classifierModifiers());
				dependentRelatedFinders.add(this.dataTypeProperties());
				dependentRelatedFinders.add(this.interfaceSubClass());
				dependentRelatedFinders.add(this.klassSubClass());
				dependentRelationshipFinders = Collections.unmodifiableList(dependentRelatedFinders);
			}

			return dependentRelationshipFinders;
		}

		public Classifier findOne(com.gs.fw.finder.Operation operation)
		{
			return ClassifierFinder.findOne(operation, false);
		}

		public Classifier findOneBypassCache(com.gs.fw.finder.Operation operation)
		{
			return ClassifierFinder.findOne(operation, true);
		}

		public MithraList findMany(com.gs.fw.finder.Operation operation)
		{
			return new ClassifierList((Operation) operation);
		}

		public MithraList findManyBypassCache(com.gs.fw.finder.Operation operation)
		{
			ClassifierList result = (ClassifierList) this.findMany(operation);
			result.setBypassCache(true);
			return result;
		}

		public MithraList constructEmptyList()
		{
			return new ClassifierList();
		}

		public int getSerialVersionId()
		{
			return 328511091;
		}

		public boolean isPure()
		{
			return false;
		}

		public boolean isTemporary()
		{
			return false;
		}

		public int getHierarchyDepth()
		{
			return 0;
		}

		public StringAttribute name()
		{
			StringAttribute result = this.name;
			if (result == null)
			{
				result = mapper == null ? SingleColumnStringAttribute.generate("\"NAME\"","","name",BUSINESS_CLASS_NAME_WITH_DOTS,IMPL_CLASS_NAME_WITH_SLASHES,false,false,this,null,true,false,-1,-1,-1,256,false, false) :
					new MappedStringAttribute(ClassifierFinder.name(), this.mapper, this.zGetValueSelector());
				result.zSetOwningRelationship("packageableElementSuperClass");
				result.zSetOwningReverseRelationship("klass.model.meta.domain", "PackageableElement", "classifierSubClass");
				this.name = result;
			}

			return result;
		}

		public ClassifierInterfaceMappingFinder.ClassifierInterfaceMappingCollectionFinderForRelatedClasses superInterfaces()
		{
			ClassifierSuperInterfacesFinderSubclass result = this.superInterfaces;
			if (result == null)
			{
				Mapper newMapper = combineWithMapperIfExists(ClassifierFinder.zGetClassifierSuperInterfacesReverseMapper());
				newMapper.setToMany(true);
				result = new ClassifierSuperInterfacesFinderSubclass(newMapper , this.zGetValueSelector() );
				this.superInterfaces = result;
			}

			return result;
		}

		public ClassifierModifierFinder.ClassifierModifierCollectionFinderForRelatedClasses classifierModifiers()
		{
			ClassifierClassifierModifiersFinderSubclass result = this.classifierModifiers;
			if (result == null)
			{
				Mapper newMapper = combineWithMapperIfExists(ClassifierFinder.zGetClassifierClassifierModifiersReverseMapper());
				newMapper.setToMany(true);
				result = new ClassifierClassifierModifiersFinderSubclass(newMapper , this.zGetValueSelector() );
				this.classifierModifiers = result;
			}

			return result;
		}

		public DataTypePropertyFinder.DataTypePropertyCollectionFinderForRelatedClasses dataTypeProperties()
		{
			ClassifierDataTypePropertiesFinderSubclass result = this.dataTypeProperties;
			if (result == null)
			{
				Mapper newMapper = combineWithMapperIfExists(ClassifierFinder.zGetClassifierDataTypePropertiesReverseMapper());
				newMapper.setToMany(true);
				result = new ClassifierDataTypePropertiesFinderSubclass(newMapper , this.zGetValueSelector() );
				this.dataTypeProperties = result;
			}

			return result;
		}

		public InterfaceFinder.InterfaceSingleFinderForRelatedClasses interfaceSubClass()
		{
			ClassifierInterfaceSubClassFinderSubclass result = this.interfaceSubClass;
			if (result == null)
			{
				Mapper newMapper = combineWithMapperIfExists(ClassifierFinder.zGetClassifierInterfaceSubClassReverseMapper());
				newMapper.setToMany(false);
				result = new ClassifierInterfaceSubClassFinderSubclass(newMapper , this.zGetValueSelector() );
				this.interfaceSubClass = result;
			}

			return result;
		}

		public KlassFinder.KlassSingleFinderForRelatedClasses klassSubClass()
		{
			ClassifierKlassSubClassFinderSubclass result = this.klassSubClass;
			if (result == null)
			{
				Mapper newMapper = combineWithMapperIfExists(ClassifierFinder.zGetClassifierKlassSubClassReverseMapper());
				newMapper.setToMany(false);
				result = new ClassifierKlassSubClassFinderSubclass(newMapper , this.zGetValueSelector() );
				this.klassSubClass = result;
			}

			return result;
		}

		public PackageableElementFinder.PackageableElementSingleFinderForRelatedClasses packageableElementSuperClass()
		{
			ClassifierPackageableElementSuperClassFinderSubclass result = this.packageableElementSuperClass;
			if (result == null)
			{
				Mapper newMapper = combineWithMapperIfExists(PackageableElementFinder.zGetPackageableElementClassifierSubClassMapper());
				newMapper.setToMany(false);
				result = new ClassifierPackageableElementSuperClassFinderSubclass(newMapper , this.zGetValueSelector() );
				this.packageableElementSuperClass = result;
			}

			return result;
		}

		public RootProjectionFinder.RootProjectionCollectionFinderForRelatedClasses projections()
		{
			ClassifierProjectionsFinderSubclass result = this.projections;
			if (result == null)
			{
				Mapper newMapper = combineWithMapperIfExists(RootProjectionFinder.zGetRootProjectionClassifierMapper());
				newMapper.setToMany(true);
				result = new ClassifierProjectionsFinderSubclass(newMapper , this.zGetValueSelector() );
				this.projections = result;
			}

			return result;
		}

		public Attribute getSourceAttribute()
		{
			return null;
		}

		private Mapper combineWithMapperIfExists(Mapper newMapper)
		{
			if (this.mapper != null)
			{
				return new LinkedMapper(this.mapper, newMapper);
			}

			return newMapper;
		}

		public Attribute[] getPrimaryKeyAttributes()
		{
			return ClassifierFinder.getPrimaryKeyAttributes();
		}

		public VersionAttribute getVersionAttribute()
		{
			return null;
		}

		public MithraObjectPortal getMithraObjectPortal()
		{
			return ClassifierFinder.getMithraObjectPortal();
		}
	}

	public static class ClassifierCollectionFinder extends ClassifierRelatedFinder
	{
		public ClassifierCollectionFinder(Mapper mapper)
		{
			super(mapper);
		}
	}

	public static abstract class ClassifierCollectionFinderForRelatedClasses
	extends ClassifierCollectionFinder
	implements DeepRelationshipAttribute
	{
		public ClassifierCollectionFinderForRelatedClasses(Mapper mapper)
		{
			super(mapper);
		}

		protected NormalAndListValueSelector zGetValueSelector()
		{
			return this;
		}
	}

	public static class ClassifierSingleFinder extends ClassifierRelatedFinder
	implements ToOneFinder
	{
		public ClassifierSingleFinder(Mapper mapper)
		{
			super(mapper);
		}

		public ClassifierSingleFinder()
		{
			super(null);
		}

		public Operation eq(Classifier other)
		{
			return this.name().eq(other.getName())
			;
		}
		// this implementation uses private API. Do NOT copy to application code. Application code must use normal operations for lookups.
		public Classifier findByPrimaryKey(String name)
		{
			Classifier _result = null;
			Operation _op = null;
			Object _related = null;
			if (name != null)
			{
				I3O3L3 _bean = I3O3L3.POOL.getOrConstruct();
				_bean.setO1(name);
				MithraObjectPortal _portal = this.getMithraObjectPortal();
				_related = _portal.getAsOneFromCacheForFind(_bean, _bean, forPrimaryKey, null, null);
				_bean.release();
			}

			if (!(_related instanceof NulledRelation)) _result = (Classifier) _related;
			if (_related == null)
			{
				_op = this.name().eq(name);
			}

			if (_op != null)
			{
				_result = this.findOne(_op);
			}

			return _result;
		}
	}

	public static abstract class ClassifierSingleFinderForRelatedClasses extends ClassifierSingleFinder implements DeepRelationshipAttribute
	{
		public ClassifierSingleFinderForRelatedClasses(Mapper mapper)
		{
			super(mapper);
		}

		protected NormalAndListValueSelector zGetValueSelector()
		{
			return this;
		}
	}

	private static Mapper superInterfacesReverseMapper = null;
	public static Mapper zGetClassifierSuperInterfacesReverseMapper()
	{
		if (superInterfacesReverseMapper == null)
		{
			superInterfacesReverseMapper = zConstructClassifierSuperInterfacesReverseMapper();
		}

		return superInterfacesReverseMapper;
	}

	private static Mapper superInterfacesMapper = null;
	public static Mapper zGetClassifierSuperInterfacesMapper()
	{
		if (superInterfacesMapper == null)
		{
			superInterfacesMapper = zConstructClassifierSuperInterfacesMapper();
		}

		return superInterfacesMapper;
	}

	private static Mapper superInterfacesPureReverseMapper = null;
	public static Mapper zGetClassifierSuperInterfacesPureReverseMapper()
	{
		if (superInterfacesPureReverseMapper == null)
		{
			superInterfacesPureReverseMapper = zConstructClassifierSuperInterfacesPureReverseMapper();
		}

		return superInterfacesPureReverseMapper;
	}

	private static Mapper zConstructClassifierSuperInterfacesPureReverseMapper()
	{
		Mapper superInterfacesMapper = ClassifierFinder.zGetConstantJoin(0);
		superInterfacesMapper.setName("superInterfaces");
		return superInterfacesMapper;
	}

	private static Mapper zConstructClassifierSuperInterfacesReverseMapper()
	{
		Mapper superInterfacesMapper = ClassifierFinder.zGetConstantJoin(0);
		superInterfacesMapper.setName("superInterfaces");
		return superInterfacesMapper;
	}

	private static Mapper zConstructClassifierSuperInterfacesMapper()
	{
		Mapper superInterfacesMapper = ClassifierFinder.zGetConstantJoin(1);
		superInterfacesMapper.setName("subClassifier");
		return superInterfacesMapper;
	}

	private static Mapper classifierModifiersReverseMapper = null;
	public static Mapper zGetClassifierClassifierModifiersReverseMapper()
	{
		if (classifierModifiersReverseMapper == null)
		{
			classifierModifiersReverseMapper = zConstructClassifierClassifierModifiersReverseMapper();
		}

		return classifierModifiersReverseMapper;
	}

	private static Mapper classifierModifiersMapper = null;
	public static Mapper zGetClassifierClassifierModifiersMapper()
	{
		if (classifierModifiersMapper == null)
		{
			classifierModifiersMapper = zConstructClassifierClassifierModifiersMapper();
		}

		return classifierModifiersMapper;
	}

	private static Mapper classifierModifiersPureReverseMapper = null;
	public static Mapper zGetClassifierClassifierModifiersPureReverseMapper()
	{
		if (classifierModifiersPureReverseMapper == null)
		{
			classifierModifiersPureReverseMapper = zConstructClassifierClassifierModifiersPureReverseMapper();
		}

		return classifierModifiersPureReverseMapper;
	}

	private static Mapper zConstructClassifierClassifierModifiersPureReverseMapper()
	{
		Mapper classifierModifiersMapper = ClassifierFinder.zGetConstantJoin(2);
		classifierModifiersMapper.setName("classifierModifiers");
		return classifierModifiersMapper;
	}

	private static Mapper zConstructClassifierClassifierModifiersReverseMapper()
	{
		Mapper classifierModifiersMapper = ClassifierFinder.zGetConstantJoin(2);
		classifierModifiersMapper.setName("classifierModifiers");
		return classifierModifiersMapper;
	}

	private static Mapper zConstructClassifierClassifierModifiersMapper()
	{
		Mapper classifierModifiersMapper = ClassifierFinder.zGetConstantJoin(3);
		classifierModifiersMapper.setName("owningClassifier");
		return classifierModifiersMapper;
	}

	private static Mapper dataTypePropertiesReverseMapper = null;
	public static Mapper zGetClassifierDataTypePropertiesReverseMapper()
	{
		if (dataTypePropertiesReverseMapper == null)
		{
			dataTypePropertiesReverseMapper = zConstructClassifierDataTypePropertiesReverseMapper();
		}

		return dataTypePropertiesReverseMapper;
	}

	private static Mapper dataTypePropertiesMapper = null;
	public static Mapper zGetClassifierDataTypePropertiesMapper()
	{
		if (dataTypePropertiesMapper == null)
		{
			dataTypePropertiesMapper = zConstructClassifierDataTypePropertiesMapper();
		}

		return dataTypePropertiesMapper;
	}

	private static Mapper dataTypePropertiesPureReverseMapper = null;
	public static Mapper zGetClassifierDataTypePropertiesPureReverseMapper()
	{
		if (dataTypePropertiesPureReverseMapper == null)
		{
			dataTypePropertiesPureReverseMapper = zConstructClassifierDataTypePropertiesPureReverseMapper();
		}

		return dataTypePropertiesPureReverseMapper;
	}

	private static Mapper zConstructClassifierDataTypePropertiesPureReverseMapper()
	{
		Mapper dataTypePropertiesMapper = ClassifierFinder.zGetConstantJoin(4);
		dataTypePropertiesMapper.setName("dataTypeProperties");
		return dataTypePropertiesMapper;
	}

	private static Mapper zConstructClassifierDataTypePropertiesReverseMapper()
	{
		Mapper dataTypePropertiesMapper = ClassifierFinder.zGetConstantJoin(4);
		dataTypePropertiesMapper.setName("dataTypeProperties");
		return dataTypePropertiesMapper;
	}

	private static Mapper zConstructClassifierDataTypePropertiesMapper()
	{
		Mapper dataTypePropertiesMapper = ClassifierFinder.zGetConstantJoin(5);
		dataTypePropertiesMapper.setName("owningClassifier");
		return dataTypePropertiesMapper;
	}

	private static Mapper interfaceSubClassReverseMapper = null;
	public static Mapper zGetClassifierInterfaceSubClassReverseMapper()
	{
		if (interfaceSubClassReverseMapper == null)
		{
			interfaceSubClassReverseMapper = zConstructClassifierInterfaceSubClassReverseMapper();
		}

		return interfaceSubClassReverseMapper;
	}

	private static Mapper interfaceSubClassMapper = null;
	public static Mapper zGetClassifierInterfaceSubClassMapper()
	{
		if (interfaceSubClassMapper == null)
		{
			interfaceSubClassMapper = zConstructClassifierInterfaceSubClassMapper();
		}

		return interfaceSubClassMapper;
	}

	private static Mapper interfaceSubClassPureReverseMapper = null;
	public static Mapper zGetClassifierInterfaceSubClassPureReverseMapper()
	{
		if (interfaceSubClassPureReverseMapper == null)
		{
			interfaceSubClassPureReverseMapper = zConstructClassifierInterfaceSubClassPureReverseMapper();
		}

		return interfaceSubClassPureReverseMapper;
	}

	private static Mapper zConstructClassifierInterfaceSubClassPureReverseMapper()
	{
		Mapper interfaceSubClassMapper = ClassifierFinder.zGetConstantJoin(6);
		interfaceSubClassMapper.setName("interfaceSubClass");
		return interfaceSubClassMapper;
	}

	private static Mapper zConstructClassifierInterfaceSubClassReverseMapper()
	{
		Mapper interfaceSubClassMapper = ClassifierFinder.zGetConstantJoin(6);
		interfaceSubClassMapper.setName("interfaceSubClass");
		return interfaceSubClassMapper;
	}

	private static Mapper zConstructClassifierInterfaceSubClassMapper()
	{
		Mapper interfaceSubClassMapper = ClassifierFinder.zGetConstantJoin(7);
		interfaceSubClassMapper.setName("classifierSuperClass");
		return interfaceSubClassMapper;
	}

	private static Mapper klassSubClassReverseMapper = null;
	public static Mapper zGetClassifierKlassSubClassReverseMapper()
	{
		if (klassSubClassReverseMapper == null)
		{
			klassSubClassReverseMapper = zConstructClassifierKlassSubClassReverseMapper();
		}

		return klassSubClassReverseMapper;
	}

	private static Mapper klassSubClassMapper = null;
	public static Mapper zGetClassifierKlassSubClassMapper()
	{
		if (klassSubClassMapper == null)
		{
			klassSubClassMapper = zConstructClassifierKlassSubClassMapper();
		}

		return klassSubClassMapper;
	}

	private static Mapper klassSubClassPureReverseMapper = null;
	public static Mapper zGetClassifierKlassSubClassPureReverseMapper()
	{
		if (klassSubClassPureReverseMapper == null)
		{
			klassSubClassPureReverseMapper = zConstructClassifierKlassSubClassPureReverseMapper();
		}

		return klassSubClassPureReverseMapper;
	}

	private static Mapper zConstructClassifierKlassSubClassPureReverseMapper()
	{
		Mapper klassSubClassMapper = ClassifierFinder.zGetConstantJoin(8);
		klassSubClassMapper.setName("klassSubClass");
		return klassSubClassMapper;
	}

	private static Mapper zConstructClassifierKlassSubClassReverseMapper()
	{
		Mapper klassSubClassMapper = ClassifierFinder.zGetConstantJoin(8);
		klassSubClassMapper.setName("klassSubClass");
		return klassSubClassMapper;
	}

	private static Mapper zConstructClassifierKlassSubClassMapper()
	{
		Mapper klassSubClassMapper = ClassifierFinder.zGetConstantJoin(9);
		klassSubClassMapper.setName("classifierSuperClass");
		return klassSubClassMapper;
	}

	/** maps to \"CLASSIFIER\".\"NAME\" **/
	public static StringAttribute name()
	{
		return finder.name();
	}

	public static ClassifierInterfaceMappingFinder.ClassifierInterfaceMappingCollectionFinderForRelatedClasses superInterfaces()
	{
		return finder.superInterfaces();
	}

	public static class ClassifierSuperInterfacesFinderSubclass extends ClassifierInterfaceMappingFinder.ClassifierInterfaceMappingCollectionFinderForRelatedClasses
	{
		public ClassifierSuperInterfacesFinderSubclass(Mapper mapper, NormalAndListValueSelector parentSelector )
		{
			super(mapper);
			this._parentSelector = (AbstractRelatedFinder) parentSelector;
			this._orderBy = ClassifierInterfaceMappingFinder.ordinal().ascendingOrderBy();
			this._type = SIMPLE_TO_MANY;
			this._name = "superInterfaces";
		}

		public DeepRelationshipAttribute copy()
		{
			return new ClassifierSuperInterfacesFinderSubclass(zGetMapper(), (NormalAndListValueSelector) this._parentSelector
			);
		}

		public boolean isModifiedSinceDetachment(MithraTransactionalObject _obj)
		{
			return ((Classifier) _obj).isSuperInterfacesModifiedSinceDetachment();
		}

		protected ClassifierInterfaceMappingList plainValueOf(Classifier _obj)
		{
			return _obj.getSuperInterfaces();
		}

		protected ClassifierInterfaceMappingList plainListValueOf(Object _obj)
		{
			return ((ClassifierList)_obj).getSuperInterfaces();
		}
	}

	public static ClassifierModifierFinder.ClassifierModifierCollectionFinderForRelatedClasses classifierModifiers()
	{
		return finder.classifierModifiers();
	}

	public static class ClassifierClassifierModifiersFinderSubclass extends ClassifierModifierFinder.ClassifierModifierCollectionFinderForRelatedClasses
	{
		public ClassifierClassifierModifiersFinderSubclass(Mapper mapper, NormalAndListValueSelector parentSelector )
		{
			super(mapper);
			this._parentSelector = (AbstractRelatedFinder) parentSelector;
			this._orderBy = ClassifierModifierFinder.ordinal().ascendingOrderBy();
			this._type = SIMPLE_TO_MANY;
			this._name = "classifierModifiers";
		}

		public DeepRelationshipAttribute copy()
		{
			return new ClassifierClassifierModifiersFinderSubclass(zGetMapper(), (NormalAndListValueSelector) this._parentSelector
			);
		}

		public boolean isModifiedSinceDetachment(MithraTransactionalObject _obj)
		{
			return ((Classifier) _obj).isClassifierModifiersModifiedSinceDetachment();
		}

		protected ClassifierModifierList plainValueOf(Classifier _obj)
		{
			return _obj.getClassifierModifiers();
		}

		protected ClassifierModifierList plainListValueOf(Object _obj)
		{
			return ((ClassifierList)_obj).getClassifierModifiers();
		}
	}

	public static DataTypePropertyFinder.DataTypePropertyCollectionFinderForRelatedClasses dataTypeProperties()
	{
		return finder.dataTypeProperties();
	}

	public static class ClassifierDataTypePropertiesFinderSubclass extends DataTypePropertyFinder.DataTypePropertyCollectionFinderForRelatedClasses
	{
		public ClassifierDataTypePropertiesFinderSubclass(Mapper mapper, NormalAndListValueSelector parentSelector )
		{
			super(mapper);
			this._parentSelector = (AbstractRelatedFinder) parentSelector;
			this._orderBy = DataTypePropertyFinder.ordinal().ascendingOrderBy();
			this._type = SIMPLE_TO_MANY;
			this._name = "dataTypeProperties";
		}

		public DeepRelationshipAttribute copy()
		{
			return new ClassifierDataTypePropertiesFinderSubclass(zGetMapper(), (NormalAndListValueSelector) this._parentSelector
			);
		}

		public boolean isModifiedSinceDetachment(MithraTransactionalObject _obj)
		{
			return ((Classifier) _obj).isDataTypePropertiesModifiedSinceDetachment();
		}

		protected DataTypePropertyList plainValueOf(Classifier _obj)
		{
			return _obj.getDataTypeProperties();
		}

		protected DataTypePropertyList plainListValueOf(Object _obj)
		{
			return ((ClassifierList)_obj).getDataTypeProperties();
		}
	}

	public static InterfaceFinder.InterfaceSingleFinderForRelatedClasses interfaceSubClass()
	{
		return finder.interfaceSubClass();
	}

	public static class ClassifierInterfaceSubClassFinderSubclass extends InterfaceFinder.InterfaceSingleFinderForRelatedClasses
	{
		public ClassifierInterfaceSubClassFinderSubclass(Mapper mapper, NormalAndListValueSelector parentSelector )
		{
			super(mapper);
			this._parentSelector = (AbstractRelatedFinder) parentSelector;
			this._orderBy = null;
			this._type = SIMPLE_TO_ONE;
			this._name = "interfaceSubClass";
		}

		public DeepRelationshipAttribute copy()
		{
			return new ClassifierInterfaceSubClassFinderSubclass(zGetMapper(), (NormalAndListValueSelector) this._parentSelector
			);
		}

		public boolean isModifiedSinceDetachment(MithraTransactionalObject _obj)
		{
			return ((Classifier) _obj).isInterfaceSubClassModifiedSinceDetachment();
		}

		protected Interface plainValueOf(Classifier _obj)
		{
			return _obj.getInterfaceSubClass();
		}

		protected InterfaceList plainListValueOf(Object _obj)
		{
			return ((ClassifierList)_obj).getInterfaceSubClass();
		}
	}

	public static KlassFinder.KlassSingleFinderForRelatedClasses klassSubClass()
	{
		return finder.klassSubClass();
	}

	public static class ClassifierKlassSubClassFinderSubclass extends KlassFinder.KlassSingleFinderForRelatedClasses
	{
		public ClassifierKlassSubClassFinderSubclass(Mapper mapper, NormalAndListValueSelector parentSelector )
		{
			super(mapper);
			this._parentSelector = (AbstractRelatedFinder) parentSelector;
			this._orderBy = null;
			this._type = SIMPLE_TO_ONE;
			this._name = "klassSubClass";
		}

		public DeepRelationshipAttribute copy()
		{
			return new ClassifierKlassSubClassFinderSubclass(zGetMapper(), (NormalAndListValueSelector) this._parentSelector
			);
		}

		public boolean isModifiedSinceDetachment(MithraTransactionalObject _obj)
		{
			return ((Classifier) _obj).isKlassSubClassModifiedSinceDetachment();
		}

		protected Klass plainValueOf(Classifier _obj)
		{
			return _obj.getKlassSubClass();
		}

		protected KlassList plainListValueOf(Object _obj)
		{
			return ((ClassifierList)_obj).getKlassSubClass();
		}
	}

	public static PackageableElementFinder.PackageableElementSingleFinderForRelatedClasses packageableElementSuperClass()
	{
		return finder.packageableElementSuperClass();
	}

	public static class ClassifierPackageableElementSuperClassFinderSubclass extends PackageableElementFinder.PackageableElementSingleFinderForRelatedClasses
	{
		public ClassifierPackageableElementSuperClassFinderSubclass(Mapper mapper, NormalAndListValueSelector parentSelector )
		{
			super(mapper);
			this._parentSelector = (AbstractRelatedFinder) parentSelector;
			this._orderBy = null;
			this._type = SIMPLE_TO_ONE;
			this._name = "packageableElementSuperClass";
		}

		public DeepRelationshipAttribute copy()
		{
			return new ClassifierPackageableElementSuperClassFinderSubclass(zGetMapper(), (NormalAndListValueSelector) this._parentSelector
			);
		}

		protected PackageableElement plainValueOf(Classifier _obj)
		{
			return _obj.getPackageableElementSuperClass();
		}

		protected PackageableElementList plainListValueOf(Object _obj)
		{
			return ((ClassifierList)_obj).getPackageableElementSuperClass();
		}
	}

	public static RootProjectionFinder.RootProjectionCollectionFinderForRelatedClasses projections()
	{
		return finder.projections();
	}

	public static class ClassifierProjectionsFinderSubclass extends RootProjectionFinder.RootProjectionCollectionFinderForRelatedClasses
	{
		public ClassifierProjectionsFinderSubclass(Mapper mapper, NormalAndListValueSelector parentSelector )
		{
			super(mapper);
			this._parentSelector = (AbstractRelatedFinder) parentSelector;
			this._orderBy = null;
			this._type = SIMPLE_TO_MANY;
			this._name = "projections";
		}

		public DeepRelationshipAttribute copy()
		{
			return new ClassifierProjectionsFinderSubclass(zGetMapper(), (NormalAndListValueSelector) this._parentSelector
			);
		}

		protected RootProjectionList plainValueOf(Classifier _obj)
		{
			return _obj.getProjections();
		}

		protected RootProjectionList plainListValueOf(Object _obj)
		{
			return ((ClassifierList)_obj).getProjections();
		}
	}

	public static Operation eq(Classifier other)
	{
		return finder.eq(other);
	}

	public static Operation all()
	{
		return new All(name());
	}

	public static ClassifierSingleFinder getFinderInstance()
	{
		return finder;
	}

	public static Attribute[] getPrimaryKeyAttributes()
	{
		return new Attribute[] 
		{
			name()
		}

		;
	}

	public static Attribute[] getImmutableAttributes()
	{
		return new Attribute[] 
		{
			name()
			, name()
		}

		;
	}

	public static AsOfAttribute[] getAsOfAttributes()
	{
		return null;
	}

	protected static void initializeIndicies(Cache cache)
	{
	}

	protected static void initializePortal(MithraObjectDeserializer objectFactory, Cache cache,
		MithraConfigurationManager.Config config)
	{
		initializeIndicies(cache);
		isFullCache = cache.isFullCache();
		isOffHeap = cache.isOffHeap();
		MithraObjectPortal portal;
		if (config.isParticipatingInTx())
		{
			portal = new MithraTransactionalPortal(objectFactory, cache, getFinderInstance(),
				config.getRelationshipCacheSize(), config.getMinQueriesToKeep(), null,
				null, null, 0,
				(MithraObjectPersister) objectFactory);
		}
		else
		{
			portal = new MithraReadOnlyPortal(objectFactory, cache, getFinderInstance(),
				config.getRelationshipCacheSize(), config.getMinQueriesToKeep(), null,
				null, null, 0,
				(MithraObjectPersister) objectFactory);
		}

		portal.setParentFinders(new RelatedFinder[] 
		{
			PackageableElementFinder.getFinderInstance(),
		}

		);
		config.initializePortal(portal);
		objectPortal.destroy();
		objectPortal = portal;
	}

	protected static void initializeClientPortal(MithraObjectDeserializer objectFactory, Cache cache,
		MithraConfigurationManager.Config config)
	{
		initializeIndicies(cache);
		isFullCache = cache.isFullCache();
		isOffHeap = cache.isOffHeap();
		MithraObjectPortal portal;
		if (config.isParticipatingInTx())
		{
			portal = new MithraTransactionalPortal(objectFactory, cache, getFinderInstance(),
				config.getRelationshipCacheSize(), config.getMinQueriesToKeep(),
				null, null,
				null, 0,
				new RemoteMithraObjectPersister(config.getRemoteMithraService(), getFinderInstance(), false));
		}
		else
		{
			portal = new MithraReadOnlyPortal(objectFactory, cache, getFinderInstance(),
				config.getRelationshipCacheSize(), config.getMinQueriesToKeep(),
				null, null,
				null, 0,
				new RemoteMithraObjectPersister(config.getRemoteMithraService(), getFinderInstance(), false));
		}

		portal.setParentFinders(new RelatedFinder[] 
		{
			PackageableElementFinder.getFinderInstance(),
		}

		);
		config.initializePortal(portal);
		objectPortal.destroy();
		objectPortal = portal;
	}

	public static boolean isFullCache()
	{
		return isFullCache;
	}

	public static boolean isOffHeap()
	{
		return isOffHeap;
	}

	public static Attribute getAttributeByName(String attributeName)
	{
		return finder.getAttributeByName(attributeName);
	}

	public static com.gs.fw.common.mithra.extractor.Function getAttributeOrRelationshipSelector(String attributeName)
	{
		return finder.getAttributeOrRelationshipSelector(attributeName);
	}

	public static RelatedFinder getRelatedFinderByName(String relationshipName)
	{
		return finder.getRelationshipFinderByName(relationshipName);
	}

	public static DoubleAttribute[] zGetDoubleAttributes()
	{
		DoubleAttribute[] result = new DoubleAttribute[0];
		return result;
	}

	public static BigDecimalAttribute[] zGetBigDecimalAttributes()
	{
		BigDecimalAttribute[] result = new BigDecimalAttribute[0];
		return result;
	}

	public static void zResetPortal()
	{
		objectPortal.destroy();
		objectPortal = new UninitializedPortal("klass.model.meta.domain.Classifier");
		isFullCache = false;
		isOffHeap = false;
	}

	public static void setTransactionModeFullTransactionParticipation(MithraTransaction tx)
	{
		tx.setTxParticipationMode(objectPortal, FullTransactionalParticipationMode.getInstance());
	}

	public static void setTransactionModeReadCacheUpdateCausesRefreshAndLock(MithraTransaction tx)
	{
		tx.setTxParticipationMode(objectPortal, ReadCacheUpdateCausesRefreshAndLockTxParticipationMode.getInstance());
	}

	public static void registerForNotification(MithraApplicationClassLevelNotificationListener listener)
	{
		getMithraObjectPortal().registerForApplicationClassLevelNotification(listener);
	}
}