AddInterfaceType Method.
164315
public void addInterfaceType(DescriptionType descriptionType)
    {
        // Create the interfaces
        InterfaceType interfaceType = wsdlFactory.createInterfaceType();
        descriptionType.getImportOrIncludeOrTypes().add(wsdlFactory.createInterface(interfaceType));
        String interfaceName = this.getControlProperty(MessageControl.INTERFACE_NAME);
        interfaceType.setName(interfaceName);
        
        this.addInterfaceOperationTypes(interfaceType);
    }
238114
public void addInterfaceOperationType(String strVersion, InterfaceType interfaceType, MessageProcessInfo recMessageProcessInfo)
    {
        InterfaceOperationType interfaceOperationType = wsdlFactory.createInterfaceOperationType();
        interfaceType.getOperationOrFaultOrFeature().add(wsdlFactory.createInterfaceTypeOperation(interfaceOperationType));
        String name = this.fixName(recMessageProcessInfo.getField(MessageProcessInfo.DESCRIPTION).toString());
        interfaceOperationType.setName(name);
        String pattern = this.getURIProperty(MESSAGE_PATTERN_URI);
        interfaceOperationType.setPattern(pattern);
        boolean safe = SAFE_DEFAULT;
        String safeValue = ((PropertiesField)recMessageProcessInfo.getField(MessageProcessInfo.PROPERTIES)).getProperty(MessageProcessInfo.SAFE);
        if (safeValue != null)
            safe = Boolean.parseBoolean(safeValue);
        interfaceOperationType.setSafe(safe);
        String style = ((PropertiesField)recMessageProcessInfo.getField(MessageProcessInfo.PROPERTIES)).getProperty(MESSAGE_STYLE_URI);
        if (style == null)
            style = this.getURIProperty(MESSAGE_STYLE_URI);
        interfaceOperationType.setStyle(style);
        MessageInfo recMessageInfo = this.getMessageIn(recMessageProcessInfo);
        if (recMessageInfo != null)
        {
            MessageRefType messageRefType = wsdlFactory.createMessageRefType();
            JAXBElement<MessageRefType> interfaceOperationTypeInput = wsdlFactory.createInterfaceOperationTypeInput(messageRefType);
            interfaceOperationType.getInputOrOutputOrInfault().add(interfaceOperationTypeInput);
            name = this.fixName(recMessageInfo.getField(MessageInfo.DESCRIPTION).toString());
            String code = recMessageInfo.getField(MessageInfo.CODE).toString();
            if (code == null)
                code = name;
            String element = ((PropertiesField)recMessageInfo.getField(MessageInfo.MESSAGE_PROPERTIES)).getProperty(MessageInfo.ELEMENT);
            if (element == null)
                if (code != null)
                    element = code;
            String messageLabel = "In";
            messageRefType.setElement(element);
            messageRefType.setMessageLabel(messageLabel);
            messageRefType = wsdlFactory.createMessageRefType();
        }
        recMessageInfo = this.getMessageOut(recMessageProcessInfo);
        if (recMessageInfo != null)
        {
            MessageRefType messageRefType = wsdlFactory.createMessageRefType();
            JAXBElement<MessageRefType> interfaceOperationTypeOutput = wsdlFactory.createInterfaceOperationTypeOutput(messageRefType);
            interfaceOperationType.getInputOrOutputOrInfault().add(interfaceOperationTypeOutput);
            name = this.fixName(recMessageInfo.getField(MessageInfo.DESCRIPTION).toString());
            String code = recMessageInfo.getField(MessageInfo.CODE).toString();
            if (code == null)
                code = name;
            String element = ((PropertiesField)recMessageInfo.getField(MessageInfo.MESSAGE_PROPERTIES)).getProperty(MessageInfo.ELEMENT);
            if (element == null)
                if (code != null)
                    element = code;
            String messageLabel = "Out";
            messageRefType.setElement(element);
            messageRefType.setMessageLabel(messageLabel);
        }
    }
442110
public static <T extends TypeDescription> ElementMatcher.Junction<T> isInterface() {
        return new ModifierMatcher<T>(ModifierMatcher.Mode.INTERFACE);
    }
337156
private function addInterfaceProvider($interface, Reference $reference)
    {
        if (empty($this->interfaceProviders[$interface])) {
            $this->interfaceProviders[$interface]= [];
        }

        $this->interfaceProviders[$interface][] = $reference;
    }
322138
def create_interface(self):
        """"""
        return Interface(
            self.networkapi_url,
            self.user,
            self.password,
            self.user_ldap)
60953
public static int setInterface(int modifier, boolean b) {
        if (b) {
            return (modifier | (INTERFACE | ABSTRACT)) & 
                (~FINAL & ~SYNCHRONIZED & ~VOLATILE & ~TRANSIENT & ~NATIVE);
        }
        else {
            return modifier & ~INTERFACE;
        }
    }
86856
private static void getAllInterfaces(Class<?> cls, Collection<Class<?>> interfacesFound) {
        while (cls != null) {
            Class<?>[] interfaces = cls.getInterfaces();

            for (int i = 0; i < interfaces.length; i++) {
                interfacesFound.add(interfaces[i]);
                getAllInterfaces(interfaces[i], interfacesFound);
            }

            cls = cls.getSuperclass();
         }
     }
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);
		}
	}
1068810
boolean addImplementedInterface(JSTypeExpression interfaceName) {
    lazyInitInfo();
    if (info.implementedInterfaces == null) {
      info.implementedInterfaces = new ArrayList<>(2);
    }
    if (info.implementedInterfaces.contains(interfaceName)) {
      return false;
    }
    info.implementedInterfaces.add(interfaceName);
    return true;
  }
297846
public function addType(WidgetTypeInterface $widget)
    {
        if (!$this->hasType($widget)) {
            $this->types[$widget->getName()] = $widget;
        } else {
            throw new \InvalidArgumentException(sprintf('Widget type "%s" is already registered.', $widget->getName()));
        }
    }
346115
public function onAddedToType(TypeInterface &$type)
    {
        parent::onAddedToType($type);

        if ($this->getAddIndex()) {
            $type->addIndex(new Index($this->name));
        }

        $type->addTrait(CreatedAtInterface::class, CreatedAtInterfaceImplementation::class)->serialize($this->name);
    }
1317223
function addInteraction() {
  const value = typeSelect.value;
  if (value !== 'None') {
    draw = new Draw({
      source: source,
      type: typeSelect.value,
      freehand: true
    });
    map.addInteraction(draw);
  }
}
946303
public Datatype.Builder setInterfaceType(boolean interfaceType) {
    this.interfaceType = interfaceType;
    _unsetProperties.remove(Property.INTERFACE_TYPE);
    return (Datatype.Builder) this;
  }
1113707
public InterfaceMethodRefConstant addInterfaceRef(String className,
                                                    String name,
                                                    String type)
  {
    InterfaceMethodRefConstant entry = getInterfaceRef(className, name, type);

    if (entry != null)
      return entry;

    ClassConstant classEntry = addClass(className);
    NameAndTypeConstant typeEntry = addNameAndType(name, type);

    entry = new InterfaceMethodRefConstant(this, _entries.size(),
                                           classEntry.getIndex(),
                                           typeEntry.getIndex());

    addConstant(entry);

    return entry;
  }
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));
        }
    }
434891
private void addDirectSubTypes(XClass type, ArrayList subTypes)
    {
        if (type.isInterface())
        {
            if (type.getExtendingInterfaces() != null)
            {
                subTypes.addAll(type.getExtendingInterfaces());
            }
            // we have to traverse the implementing classes as these array contains all classes that
            // implement the interface, not only those who have an "implement" declaration
            // note that for whatever reason the declared interfaces are not exported via the XClass interface
            // so we have to get them via the underlying class which is hopefully a subclass of AbstractClass
            if (type.getImplementingClasses() != null)
            {
                Collection declaredInterfaces = null;
                XClass     subType;

                for (Iterator it = type.getImplementingClasses().iterator(); it.hasNext(); )
                {
                    subType = (XClass)it.next();
                    if (subType instanceof AbstractClass)
                    {
                        declaredInterfaces = ((AbstractClass)subType).getDeclaredInterfaces();
                        if ((declaredInterfaces != null) && declaredInterfaces.contains(type))
                        {
                            subTypes.add(subType);
                        }
                    }
                    else
                    {
                        // Otherwise we have to live with the bug
                        subTypes.add(subType);
                    }
                }
            }
        }
        else
        {
            subTypes.addAll(type.getDirectSubclasses());
        }
    }
1172748
function showInterface(interfaceName) {
    var intf = Interfaces[interfaceName]

    e_interfaceName.innerHTML = interfaceName

    var html = []

    showInterfaceIdl(intf, html)
    showInterfaceJavaScript(intf, html)
    showInterfaceJava(intf, html)

    e_interfaceBody.innerHTML = html.join("\n")

    reapplyDisplayStyles()
}