Check if there is an attribute which tells us which concrete class is to be instantiated.
359536
protected ClassDescriptor selectClassDescriptor(Map row) throws PersistenceBrokerException
    {
        ClassDescriptor result = m_cld;
        Class ojbConcreteClass = (Class) row.get(OJB_CONCRETE_CLASS_KEY);
        if(ojbConcreteClass != null)
        {
            result = m_cld.getRepository().getDescriptorFor(ojbConcreteClass);
            // if we can't find class-descriptor for concrete class, something wrong with mapping
            if (result == null)
            {
                throw new PersistenceBrokerException("Can't find class-descriptor for ojbConcreteClass '"
                        + ojbConcreteClass + "', the main class was " + m_cld.getClassNameOfObject());
            }
        }
        return result;
    }
941564
function _gpfAttributesGetFromClass (classConstructor, baseAttributeClass) {
    var entityDefinition = _gpfDefineEntitiesFindByConstructor(classConstructor);
    if (entityDefinition) {
        return entityDefinition.getAttributes(baseAttributeClass);
    }
    return {};
}
1172081
def issubclass(cls, ifaces):
    """"""
    ifaces = _ensure_ifaces_tuple(ifaces)
    for iface in ifaces:

        return all((
            _check_for_definition(
                iface,
                cls,
                '__iclassattribute__',
                _is_attribute,
            ),
            _check_for_definition(
                iface,
                cls,
                '__iproperty__',
                _is_property,
            ),
            _check_for_definition(
                iface,
                cls,
                '__imethod__',
                _is_method,
            ),
            _check_for_definition(
                iface,
                cls,
                '__iclassmethod__',
                _is_classmethod,
            ),
        ))
923235
def _new_cls_attr(self, clazz, name, cls=None, mult=MULT_ONE, cont=True,
                      ref=False, bool_assignment=False, position=0):
        """"""
        attr = MetaAttr(name, cls, mult, cont, ref, bool_assignment,
                        position)
        clazz._tx_attrs[name] = attr
        return attr
649475
def is_resource_class_collection_attribute(rc, attr_name):
    
    attr = get_resource_class_attribute(rc, attr_name)
    return attr.kind == RESOURCE_ATTRIBUTE_KINDS.COLLECTION
422670
def is_resource_class_resource_attribute(rc, attr_name):
    
    attr = get_resource_class_attribute(rc, attr_name)
    return attr != RESOURCE_ATTRIBUTE_KINDS.TERMINAL
1164463
public static boolean isConcrete( Class<?> clazz ) {
        return !Modifier.isAbstract(clazz.getModifiers()) &&
                !Modifier.isInterface(clazz.getModifiers());
    }
1349212
def _has_attr(cls, ds, attr, concept_name, priority=BaseCheck.HIGH):
        
        val = cls.std_check(ds, attr)
        msgs = []

        if not val:
            msgs.append("Attr '{}' (IOOS concept: '{}') not found in dataset".format(attr, concept_name))

        return Result(priority, val, concept_name, msgs)
846398
def is_instance_or_subclass(val, class_):
    """"""
    try:
        return issubclass(val, class_)
    except TypeError:
        return isinstance(val, class_)
723908
def check_class(klass)
      unless klass.method_defined?(name)
        raise NotImplementedErrorCheckError.new(self,
            "method '#{name}' not implemented in #{klass}")
      end
      check_method = klass.instance_method(name)
      if arity and (check_arity = check_method.arity) != arity
        raise ArgumentErrorCheckError.new(self,
              "wrong number of arguments for protocol"\
              " in method '#{name}' (#{check_arity} for #{arity}) of #{klass}")
      end
      if block_expected?
        modul = Utilities.find_method_module(name, klass.ancestors)
        parser = MethodParser.new(modul, name)
        parser.block_arg? or raise BlockCheckError.new(self,
          "expected a block argument for #{klass}")
      end
      arity and wrap_method(klass)
      true
    end
539211
def is_callable(instance, attribute, value):
    """"""

    if not callable(value):
        raise TypeError("'{}' must be callable".format(attribute.name))
657128
def instance_of(cls):
    
    def check(value):
        return (
            isinstance(value, cls),
            u"{value!r} is instance of {actual!s}, required {required!s}".format(
                value=value,
                actual=fullyQualifiedName(type(value)),
                required=fullyQualifiedName(cls),
            ),
        )
    return check
1172428
def has_attribute(module_name, attribute_name):
    """"""
    init_file = '%s/__init__.py' % module_name
    return any(
        [attribute_name in init_line for init_line in open(init_file).readlines()]
    )
400444
private boolean isImplementationOf(JavaClass cls, JavaClass inf) {
        try {
            if (cls == null) {
                return false;
            }
            if (cls.implementationOf(inf)) {
                return true;
            }
        } catch (ClassNotFoundException cnfe) {
            bugReporter.reportMissingClass(cnfe);
        }
        return false;
    }
515267
private void checkInnerClass(ClassDeclaration jclass)
            throws FatalCompileTimeException
    {
        boolean noFormBeanAnnotation = true;
        if (CompilerUtils.getAnnotation(jclass, FORM_BEAN_TAG_NAME, true) != null) {
            noFormBeanAnnotation = false;
        }
        else {
            //
            // check the methods for validatable property annotations that
            // would be processed elsewhere.
            //
            MethodDeclaration[] methods = CompilerUtils.getClassMethods(jclass, null);
            for (int i = 0; i < methods.length && noFormBeanAnnotation; i++) {
                MethodDeclaration method = methods[i];
                if (CompilerUtils.getAnnotation(method, VALIDATABLE_PROPERTY_TAG_NAME) != null) {
                    noFormBeanAnnotation = false;
                }
            }
        }

        if (noFormBeanAnnotation) {
            _formBeanChecker.check(jclass);
        }
    }
902975
def has_copy_constructor(class_):
    """"""
    class_ = class_traits.get_declaration(class_)
    copy_constructor = find_copy_constructor(class_)
    if copy_constructor and copy_constructor.access_type == 'public':
        return copy_constructor
401495
protected void visitGetClassForType(Type classType) {
        if (isLdcFromClassTypeAllowed()) {
            visitLdcInsn(classType);
        } else {
            mv.visitLdcInsn(classType.getClassName());
            mv.visitMethodInsn(
                               INVOKESTATIC,
                               Type.getInternalName(Class.class),
                               "forName",
                               Type.getMethodDescriptor(Type.getType(Class.class), new Type[] { Type.getType(String.class) }), false);
        }
    }