Returns all the constructors defined in this class.
960319
public MethodInfo[] getConstructors() {
        int size = mMethods.size();
        List<MethodInfo> ctorsOnly = new ArrayList<MethodInfo>(size);

        for (int i=0; i<size; i++) {
            MethodInfo method = mMethods.get(i);
            if ("<init>".equals(method.getName())) {
                ctorsOnly.add(method);
            }
        }

        MethodInfo[] ctorsArray = new MethodInfo[ctorsOnly.size()];
        return ctorsOnly.toArray(ctorsArray);
    }
624316
public static Constructor<?>[] getConstructorsDirectly(Class<?> beanClass) throws SecurityException {
		Assert.notNull(beanClass);
		return beanClass.getDeclaredConstructors();
	}
209200
function Constructor() {
                // All construction is actually done in the init method.
                if (!initializing) {
                    return this.constructor !== Constructor && arguments.length ?
                    // We are being called without `new` or we are extending.
                    arguments.callee.extend.apply(arguments.callee, arguments) :
                    // We are being called with `new`.
                    this.constructor.newInstance.apply(this.constructor, arguments);
                }
            }
523993
public Set<Constructor> getConstructorsAnnotatedWith(final Class<? extends Annotation> annotation) {
        Iterable<String> methods = store.get(index(MethodAnnotationsScanner.class), annotation.getName());
        return getConstructorsFromDescriptors(methods, loaders());
    }
24660
public List<JavaClass> getAllClasses() {
        ClassDumpSegment classDumpBounds;

        if (heapDumpSegment == null) {
            return Collections.emptyList();
        }

        classDumpBounds = getClassDumpSegment();

        if (classDumpBounds == null) {
            return Collections.emptyList();
        }

        return classDumpBounds.createClassCollection();
    }
229620
def get_constructor(self):
        
        if self.parameters:
            return lambda *params: lambda *qubits: \
                Gate(name=self.name, params=list(params), qubits=list(map(unpack_qubit, qubits)))
        else:
            return lambda *qubits: Gate(name=self.name, params=[], qubits=list(map(unpack_qubit, qubits)))
163633
public static List<MethodTree> getConstructors(ClassTree classTree) {
    List<MethodTree> constructors = new ArrayList<>();
    for (Tree member : classTree.getMembers()) {
      if (member instanceof MethodTree) {
        MethodTree methodTree = (MethodTree) member;
        if (getSymbol(methodTree).isConstructor()) {
          constructors.add(methodTree);
        }
      }
    }
    return constructors;
  }
1286707
def get_all():
    

    _import_all_importer_files()

    for module in (value for key, value in globals().items()
                   if key in __all__):
        for klass_name, klass in inspect.getmembers(module, inspect.isclass):
            if klass is not BaseImporter and issubclass(klass, BaseImporter):
                yield klass

    for klass in _get_importers_from_entry_points():
        yield klass
1163050
private List<ClassDocImpl> getClasses(boolean filtered) {
        if (allClasses != null && !filtered) {
            return allClasses;
        }
        if (allClassesFiltered != null && filtered) {
            return allClassesFiltered;
        }
        ListBuffer<ClassDocImpl> classes = new ListBuffer<>();
        for (Symbol enumerated : sym.members().getSymbols(NON_RECURSIVE)) {
            if (enumerated != null) {
                ClassSymbol s = (ClassSymbol)enumerated;
                ClassDocImpl c = env.getClassDoc(s);
                if (c != null && !c.isSynthetic())
                    c.addAllClasses(classes, filtered);
            }
        }
        if (filtered)
            return allClassesFiltered = classes.toList();
        else
            return allClasses = classes.toList();
    }
1064827
private static Constructor<?> findConstructorForInnerClass(final Class<?> klazz, final Class<?> declaringClass) {
    final Constructor<?>[] constructors = klazz.getDeclaredConstructors();
    if (constructors.length == 1) {
      return constructors[0];
    }
    for (final Constructor<?> c : constructors) {
      final Class<?>[] params = c.getParameterTypes();
      if (params.length == 1 && params[0] == declaringClass) {
        return c;
      }
    }
    return constructors[0];
  }
197837
private static Object[] makeStubForConstructor(final Class<?>[] constructorParamTypes) {
    if (constructorParamTypes.length == 0) {
      return EMPTY_OBJECT_ARRAY;
    }
    final Object[] result = new Object[constructorParamTypes.length];
    for (int i = 0; i < constructorParamTypes.length; i++) {
      final Class<?> arg = constructorParamTypes[i];
      final Object obj;
      if (arg.isArray()) {
        obj = null;
      } else {
        if (arg == byte.class) {
          obj = (byte) 0;
        } else if (arg == char.class) {
          obj = 'a';
        } else if (arg == short.class) {
          obj = (short) 0;
        } else if (arg == boolean.class) {
          obj = Boolean.FALSE;
        } else if (arg == int.class) {
          obj = 0;
        } else if (arg == long.class) {
          obj = 0L;
        } else if (arg == double.class) {
          obj = 0.0d;
        } else if (arg == float.class) {
          obj = 0.0f;
        } else {
          obj = null;
        }
      }
      result[i] = obj;
    }
    return result;
  }
960485
private static Constructor<?> findConstructorForStaticClass(final Class<?> klazz) {
    final Constructor<?>[] constructors = klazz.getDeclaredConstructors();
    if (constructors.length == 1) {
      return constructors[0];
    }
    for (final Constructor<?> c : constructors) {
      final Class<?>[] params = c.getParameterTypes();
      if (params.length == 0) {
        return c;
      }
    }
    return constructors[0];
  }
514662
public List<ConstructorResult<SqlResultSetMapping<T>>> getAllConstructorResult()
   {
      List<ConstructorResult<SqlResultSetMapping<T>>> list = new ArrayList<ConstructorResult<SqlResultSetMapping<T>>>();
      List<Node> nodeList = childNode.get("constructor-result");
      for(Node node: nodeList)
      {
         ConstructorResult<SqlResultSetMapping<T>>  type = new ConstructorResultImpl<SqlResultSetMapping<T>>(this, "constructor-result", childNode, node);
         list.add(type);
      }
      return list;
   }
339991
public static Iterable<Function<Object[], Object[]>> getTransformers(Constructor<?> constructor) {
        Iterable<ArgumentTransformer> transformers = Lists.newArrayList(
                new PrimitiveAwareVarArgsTransformer(constructor),
                new PrimitiveTransformer(constructor),
                new VarArgsTransformer(constructor));

        return ImmutableList
                .<Function<Object[], Object[]>>copyOf(filter(transformers, applicableFilter));
    }
800704
def builder_types(cls) -> List[Type[ParameterBuilder]]:
        
        return [
            entry_point.load()
            for entry_point in iter_entry_points(ENTRY_POINT)
        ]
163925
Set<Class<?>> allClasses() {
        final Set<Class<?>> allClasses = new HashSet<>(getClasses());
        for (Object singleton : getSingletons()) {
            allClasses.add(singleton.getClass());
        }
        return allClasses;
    }
802231
public GroovyConstructorDoc[] constructors() {
        Collections.sort(constructors);
        return constructors.toArray(new GroovyConstructorDoc[constructors.size()]);
    }