ProcessInterfaceTypes Method.
184798
public String processInterfaceTypes(TDefinitions descriptionType, boolean addAddress)
    {
        String allAddress = DBConstants.BLANK;
        
        for (TDocumented nextElement : descriptionType.getAnyTopLevelOptionalElement())
        {
            // Create the service type
            if (nextElement instanceof TPortType)
            {
                String address = this.processPortType(descriptionType, (TPortType)nextElement, addAddress);
                if (allAddress != null)
                {
                    if (allAddress == DBConstants.BLANK)
                        allAddress = address;
                    else if (!allAddress.equalsIgnoreCase(address))
                        allAddress = null;  // null = not all address are the same
                }
            }
        }
        
        return allAddress;
    }
1182249
def GetInterfaceDescription(self, interface):
        """"""
        try:
            i = self.interfaces[interface]
        except KeyError:
            raise InterfaceNotFound(interface)

        return {'description': i.description}
193196
private static void addInterfaces(Object obj, Set<Class<?>> interfaces) {

		Class<?>[] generatorInterfaces = null;
		Class<?> superClass = null;
		if (obj instanceof Class) {
			generatorInterfaces = ((Class<?>) obj).getInterfaces();
			superClass = ((Class<?>) obj).getSuperclass();
		} else {
			generatorInterfaces = obj.getClass().getInterfaces();
			superClass = obj.getClass().getSuperclass();
		}
		for (Class<?> generatorInterface : generatorInterfaces) {
			interfaces.add(generatorInterface);
			addInterfaces(generatorInterface, interfaces);
		}

		if (superClass != null && superClass != Object.class) {
			addInterfaces(superClass, interfaces);
		}
	}
128106
private static List<String> getAllInterfaceMethodInfo(List<InterfaceInfo> interfaceInfoList) {
        List<String> names = new ArrayList<>();

        if (interfaceInfoList == null || interfaceInfoList.isEmpty()){
            return names;
        }

        interfaceInfoList.forEach((InterfaceInfo interfaceInfo) -> {
            if (interfaceInfo.getMethodNames() != null && !interfaceInfo.getMethodNames().isEmpty()){
                names.addAll(interfaceInfo.getMethodNames());
            }

            names.addAll(getAllInterfaceMethodInfo(interfaceInfo.getExtendedInterfaces()));
        });

        return names;
    }
597795
public static Class[] resolveInterfaceTypeArguments(Class<?> type, Class<?> interfaceType) {
        Optional<Type> resolvedType = getAllGenericInterfaces(type)
                .stream()
                .filter(t -> {
                            if (t instanceof ParameterizedType) {
                                ParameterizedType pt = (ParameterizedType) t;
                                return pt.getRawType() == interfaceType;
                            }
                            return false;
                        }
                )
                .findFirst();
        return resolvedType.map(GenericTypeUtils::resolveTypeArguments)
                .orElse(ReflectionUtils.EMPTY_CLASS_ARRAY);
    }
867326
public void visitInterceptorTypes(Object... interceptorTypes) {
        if (interceptorTypes != null) {
            this.interceptorTypes.addAll(Arrays.asList(interceptorTypes));
        }
    }
1324732
void addInterfaces(Deque<String> intfs, ClassFile cf)
            throws ConstantPoolException {
        int count = cf.interfaces.length;
        for (int i = 0; i < count; i++) {
            intfs.addLast(cf.getInterfaceName(i));
        }
    }
193521
function processObjectType(object: GraphQLObjectType) {
  return reduce(
    object._typeConfig,
    (def, value, key) => {
      return setDef(
        def,
        key,
        value,
        [
          'description',
          'interfaces',
          'fields',
          'isTypeOf',
          'astNode',
          'onConflict',
        ],
        object,
      );
    },
    { type: 'Object' },
    true,
  );
}
285678
protected function detectType()
    {
        if (property_exists($this, 'allow')) {
            return $this->allow;
        }

        $interfaces = (new ReflectionClass($this))->getInterfaceNames();

        if ($interfaces) {
            return $interfaces[0];
        }

        return get_class($this);
    }
463976
void writeInterfaces(final XMLExtendedStreamWriter writer, final ModelNode modelNode) throws XMLStreamException {
        writer.writeStartElement(Element.INTERFACES.getLocalName());
        final Set<String> interfaces = modelNode.keys();
        for (String ifaceName : interfaces) {
            final ModelNode iface = modelNode.get(ifaceName);
            writer.writeStartElement(Element.INTERFACE.getLocalName());
            writeAttribute(writer, Attribute.NAME, ifaceName);
            // <any-* /> is just handled at the root
            if (iface.get(Element.ANY_ADDRESS.getLocalName()).asBoolean(false)) {
                writer.writeEmptyElement(Element.ANY_ADDRESS.getLocalName());
            } else {
                // Write the other criteria elements
                writeInterfaceCriteria(writer, iface, false);
            }
            writer.writeEndElement();
        }
        writer.writeEndElement();
    }
964844
void processSpecialNodeTypes(NodeWithType<?, Type> node, String name) {
        Type type = node.getType();
        if (node instanceof MethodDeclaration && ("newBufferAndOffset".equals(name) || "nextArrayOffset".equals(name))) {
            node.setType(PrimitiveType.intType());
        } else if (PrimitiveType.longType().equals(type)) {
            switch(name) {
            case "offset":
            case "offsetInNew":
            case "offsetInOld":
            case "lookAheadElementOffset":
                node.setType(PrimitiveType.intType());
            }
        } else if (isRefType(type, "LinkedQueueNode")) {
            node.setType(simpleParametricType("LinkedQueueAtomicNode", "E"));
        } else if (isRefArray(type, "E")) {
            node.setType(atomicRefArrayType((ArrayType) type));
        }
    }
944479
public void processAfterTypeDiscovery(@Observes AfterTypeDiscovery event) {
        if (!event.getInterceptors().contains(SwaggerRestApplicationInterceptor.class)) {
            event.getInterceptors().add(SwaggerRestApplicationInterceptor.class);
        }
    }
777246
@Override
   protected void implementInterface(InterfaceCapableSource<?> source, Iterable<String> value, JavaSourceFacet facet)
   {
      for (String type : value)
      {
         source.addInterface(type);
      }
   }
1213821
public static String[] discoverInterfaces(byte[] classbytes) {
		ClassReader cr = new ClassReader(classbytes);
		InterfaceCollectingClassVisitor f = new InterfaceCollectingClassVisitor();
		cr.accept(f, 0);
		return f.interfaces;
	}
965123
def releaseInterface(self):
        """
        util.release_interface(self.dev, self.__claimed_interface)
        self.__claimed_interface = -1
165782
private void processMethodCall() {
        if ("invoke".equals(getNameConstantOperand()) && "java/lang/reflect/Method".equals(getClassConstantOperand())) {
            return;
        }
        String sig = getSigConstantOperand();
        List<String> args = SignatureUtils.getParameterSignatures(sig);
        if (stack.getStackDepth() >= args.size()) {
            for (int i = 0; i < args.size(); i++) {
                String argSig = args.get(i);
                if (argSig.startsWith(Values.SIG_ARRAY_PREFIX)) {
                    OpcodeStack.Item itm = stack.getStackItem(args.size() - i - 1);
                    int arrayReg = itm.getRegisterNumber();
                    WrapperInfo wi = wrappers.get(Integer.valueOf(arrayReg));
                    if (wi != null) {
                        wi.wasArg = true;
                    }
                }
            }
        }
    }
712726
private static void collectAllInterfaces(final ClassNode node, final Set<ClassNode> out) {
        if (node == null) return;
        Set<ClassNode> allInterfaces = node.getAllInterfaces();
        out.addAll(allInterfaces);
        collectAllInterfaces(node.getSuperClass(), out);
    }