Answer the TableAlias for aPath
@param aPath
@param hintClasses
@return TableAlias, null if none
510747
private TableAlias getTableAliasForPath(String aPath, List hintClasses)
    {
        return (TableAlias) m_pathToAlias.get(buildAliasKey(aPath, hintClasses));
    }
567543
def table_name(cls):
        
        if cls._prefix is None:
            raise AttributeError('Class prefix is not defined!')
        return cls._prefix + from_camel_case(cls.__name__)
776648
public static @CheckForNull <T extends Descriptor> T findByDescribableClassName(Collection<? extends T> list, String className) {
        for (T d : list) {
            if(d.clazz.getName().equals(className))
                return d;
        }
        return null;
    }
1184907
@Override
	public ZooClassDef getSchema(Class<?> cls, Node node) {
		ZooClassDef ret = nodeSchemata.get(node).get(cls);
		if (ret == null) {
			if (cls == null) {
				return null;
			}
			//Try virtual/generic schemata
			ret = getSchema(cls.getName());
			if (ret != null) {
				//check (associate also checks compatibility)
				ret.associateJavaTypes(true);
				nodeSchemata.get(node).put(cls, ret);
			}
		}
		return ret;
	}
849787
private Table findTable(String alias) {
		List<String> names = null;
		if (tableScope == null) {
			// no tables to find
			return null;
		}

		for (ScopeChild child : tableScope.children) {
			if (catalogReader.nameMatcher().matches(child.name, alias)) {
				names = ((SqlIdentifier) child.namespace.getNode()).names;
				break;
			}
		}
		if (names == null || names.size() == 0) {
			return null;
		} else if (names.size() == 1) {
			return findTable(catalogReader.getRootSchema(), names.get(0),
				catalogReader.nameMatcher().isCaseSensitive());
		}

		CalciteSchema.TableEntry entry =
			SqlValidatorUtil.getTableEntry(catalogReader, names);

		return entry == null ? null : entry.getTable();
	}
1290828
@edu.umd.cs.findbugs.annotations.SuppressWarnings(
      value="NP_PARAMETER_MUST_BE_NONNULL_BUT_MARKED_AS_NULLABLE",
      justification="Checked in precondition")
  static Path pathForDataset(Path root, @Nullable String namespace, @Nullable String name) {
    Preconditions.checkNotNull(namespace, "Namespace cannot be null");
    Preconditions.checkNotNull(name, "Dataset name cannot be null");

    // Why replace '.' here? Is this a namespacing hack?
    return new Path(root, new Path(namespace, name.replace('.', Path.SEPARATOR_CHAR)));
  }
1347415
protected void buildSuperJoinTree(TableAlias left, ClassDescriptor cld, String name, boolean useOuterJoin)
    {
        ClassDescriptor superCld = cld.getSuperClassDescriptor();
        if (superCld != null)
        {
            SuperReferenceDescriptor superRef = cld.getSuperReference();
            FieldDescriptor[] leftFields = superRef.getForeignKeyFieldDescriptors(cld);
            TableAlias base_alias = getTableAliasForPath(name, null, null);
            String aliasName = String.valueOf(getAliasChar()) + m_aliasCount++;
            TableAlias right = new TableAlias(superCld, aliasName, useOuterJoin, null);

            Join join1to1 = new Join(left, leftFields, right, superCld.getPkFields(), useOuterJoin, "superClass");
            base_alias.addJoin(join1to1);

            buildSuperJoinTree(right, superCld, name, useOuterJoin);
        }
    }
948866
private FieldDescriptor getFldFromJoin(TableAlias aTableAlias, String aColName)
    {
        FieldDescriptor fld = null;

        // Search Join Structure for attribute
        if (aTableAlias.joins != null)
        {
            Iterator itr = aTableAlias.joins.iterator();
            while (itr.hasNext())
            {
                Join join = (Join) itr.next();
                ClassDescriptor cld = join.right.cld;

                if (cld != null)
                {
                    fld = cld.getFieldDescriptorByName(aColName);
                    if (fld != null)
                    {
                        break;
                    }

                }
            }
        }
        return fld;
    }
1141329
public <T extends Enum<T>> T answer(final Class<T> enumClass) {
        return answer(enumClass, "unknown value");
    }
32188
public void setHint(final String hint, final Serializable... args) {
		Serializable currHint = getComponentModel().hint;
		Serializable hintToBeSet = I18nUtilities.asMessage(hint, args);

		if (!Objects.equals(hintToBeSet, currHint)) {
			getOrCreateComponentModel().hint = hintToBeSet;
		}
	}
667263
private static String firstFoundTableName(PersistenceBroker brokerForClass, ClassDescriptor cld)
    {
        String name = null;
        if (!cld.isInterface() && cld.getFullTableName() != null)
        {
            return cld.getFullTableName();
        }
        if (cld.isExtent())
        {
            Collection extentClasses = cld.getExtentClasses();
            for (Iterator iterator = extentClasses.iterator(); iterator.hasNext();)
            {
                name = firstFoundTableName(brokerForClass, brokerForClass.getClassDescriptor((Class) iterator.next()));
                // System.out.println("## " + cld.getClassNameOfObject()+" - name: "+name);
                if (name != null) break;
            }
        }
        return name;
    }
572422
private ClassDescriptor getNullnessAnnotationClassDescriptor(NullnessAnnotation n) {
        if (n == NullnessAnnotation.CHECK_FOR_NULL) {
            return JSR305NullnessAnnotations.CHECK_FOR_NULL;
        } else if (n == NullnessAnnotation.NONNULL) {
            return JSR305NullnessAnnotations.NONNULL;
        } else if (n == NullnessAnnotation.NULLABLE) {
            return JSR305NullnessAnnotations.NULLABLE;
        } else if (n == NullnessAnnotation.UNKNOWN_NULLNESS) {
            return JSR305NullnessAnnotations.NULLABLE;
        } else {
            throw new IllegalArgumentException("Unknown NullnessAnnotation: " + n);
        }
    }
1237940
private StmtTableScan resolveStmtTableScanByAlias(String tableAlias) {
        StmtTableScan tableScan = getStmtTableScanByAlias(tableAlias);
        if (tableScan != null) {
            return tableScan;
        }
        if (m_parentStmt != null) {
            // This may be a correlated subquery
            return m_parentStmt.resolveStmtTableScanByAlias(tableAlias);
        }
        return null;
    }
827475
public Optional<String> staticTableNameFor(Class<?> entityClass) {

        final Optional<String> tableName = entityProperties
                .stream()
                .filter(x -> x.entityClass.equals(entityClass))
                .map(x -> x.getKeyspace().map(ks -> ks + "." + x.getTableOrViewName()).orElseGet(x::getTableOrViewName))
                .findFirst();

        if (LOGGER.isTraceEnabled()) {
            LOGGER.trace(format("Determining table name for entity type %s : %s",
                    entityClass.getCanonicalName(), tableName));
        }

        return tableName;
    }
1164984
public static void xmlClassExistent(String path, Class<?> aClass){
		throw new XmlMappingClassExistException (MSG.INSTANCE.message(xmlMappingClassExistException1,aClass.getSimpleName(),path));
	}
1209441
public String getClassAlias(Class clazz) {
        if (clazz == null)
            return null;

        TypeEncoder<?, U> encoder = classMapping.get(clazz);
        if (encoder != null)
            return encoder.getAlias();

        return null;
    }
52756
private int compareClassesAllowingNull(ClassAnnotation lhs, ClassAnnotation rhs) {
        if (lhs == null || rhs == null) {
            return compareNullElements(lhs, rhs);
        }

        String lhsClassName = classNameRewriter.rewriteClassName(lhs.getClassName());
        String rhsClassName = classNameRewriter.rewriteClassName(rhs.getClassName());

        if (DEBUG) {
            System.err.println("Comparing " + lhsClassName + " and " + rhsClassName);
        }

        int cmp = lhsClassName.compareTo(rhsClassName);
        if (DEBUG) {
            System.err.println("\t==> " + cmp);
        }
        return cmp;
    }