Gets all interfaces that were implemented by this class.

@return InterfaceType[]
966596
public function getImplementedInterfaces()
    {
        $result = array();
        foreach ($this->getReflectionClass()->getInterfaces() as $interface)
        {
            $result[] = Type::byReflectionClass($interface);
        }
        return $result;
    }
1258789
public function getIndices()
    {
        $indices = $this->indices();

        if (empty($indices)) {
            $className = (new \ReflectionClass($this))->getShortName();

            return [$className];
        }

        return $indices;
    }
359159
public function getInspectionData()
    {
        return [
            static::PARAM_CLASSES    => $this->declaredClasses,
            static::PARAM_INTERFACES => $this->declaredInterfaces,
            static::PARAM_TRAITS     => $this->declaredTraits,
            static::PARAM_FUNCTIONS  => $this->declaredFunctions,
            static::PARAM_CONSTANTS  => $this->declaredConstants,
        ];
    }
761780
static List<NetworkInterface> getInterfaces() throws SocketException {
        List<NetworkInterface> all = new ArrayList<NetworkInterface>();
        addAllInterfaces(all, Collections.list(NetworkInterface.getNetworkInterfaces()));
        return all;
    }
875540
public function getInterfaceActiveLanguages(): Collection
    {
        return cache()->remember($this->interfaceCacheKey, now()->addWeek(), function () {
            return $this->getRepository()->getInterfaceLanguages();
        });
    }
768878
@SuppressWarnings("unchecked")
	 Class<?>[] getAllInterfacesAndClasses ( Class<?>[] classes ) 
    {
        if(0 == classes.length ) 
        {
            return classes;
        }
        else 
        {
            List<Class<?>> extendedClasses = new ArrayList<Class<?>>();
            // all interfaces hierarchy
            for (Class<?> clazz: classes) {
            	if (clazz != null) 
            	{
            		Class<?>[] interfaces = clazz.getInterfaces();
	                if (interfaces != null)
	                {
	                	extendedClasses.addAll(Arrays.asList(interfaces));
	                }
	                Class<?> superclass = clazz.getSuperclass();
	                if (superclass != null && superclass != Object.class)
	                {
	                	extendedClasses.addAll(Arrays.asList(superclass));
	                }
            	}
            }
            
            //Class::getInterfaces() gets only interfaces/classes implemented/extended directly by a given class.
            //We need to walk the whole way up the tree.
            return (Class[]) ArrayUtils.addAll( classes, getAllInterfacesAndClasses( extendedClasses.toArray(new Class[extendedClasses.size()])));
        }
    }
754691
protected function getIntroducedMethodsFromInterfaceIntroductions(array $interfaceIntroductions): array
    {
        $methods = [];
        $methodsAndIntroductions = [];
        foreach ($interfaceIntroductions as $introduction) {
            $interfaceName = $introduction->getInterfaceName();
            $methodNames = get_class_methods($interfaceName);
            if (is_array($methodNames)) {
                foreach ($methodNames as $newMethodName) {
                    if (isset($methodsAndIntroductions[$newMethodName])) {
                        throw new Aop\Exception('Method name conflict! Method "' . $newMethodName . '" introduced by "' . $introduction->getInterfaceName() . '" declared in aspect "' . $introduction->getDeclaringAspectClassName() . '" has already been introduced by "' . $methodsAndIntroductions[$newMethodName]->getInterfaceName() . '" declared in aspect "' . $methodsAndIntroductions[$newMethodName]->getDeclaringAspectClassName() . '".', 1173020942);
                    }
                    $methods[] = [$interfaceName, $newMethodName];
                    $methodsAndIntroductions[$newMethodName] = $introduction;
                }
            }
        }
        return $methods;
    }
505379
public com.sun.javadoc.Type[] interfaceTypes() {
        //### Cache result here?
        return TypeMaker.getTypes(env, env.types.interfaces(type));
    }
1353721
protected function getElementTypes()
    {
        $classes = ClassInfo::subclassesFor(BaseElement::class);
        $output = [];

        foreach ($classes as $className) {
            if ($className === BaseElement::class) {
                continue;
            }

            $output[] = $className;
        }

        return $output;
    }
969222
public static function getAvailableTypes()
    {
        return [
            self::TYPE_STRING,
            self::TYPE_INTEGER,
            self::TYPE_FLOAT,
            self::TYPE_BOOLEAN,
            self::TYPE_DATETIME,
        ];
    }
544046
public function getAll() : array
    {
        $fieldOptions = call_user_func($this->fieldOptionsLoader);
        TypeMismatchException::verifyAllInstanceOf(__METHOD__, '<return>', $fieldOptions, IFieldOption::class);
        return $fieldOptions;
    }
156873
static public function getImplementations()
    {
        $list = array();
        foreach ( self::$implementations as $name => $className )
        {
            $list[] = $name;
        }
        return $list;
    }
302483
public function getInterfaces() {
    /* das hier ist etwas mehr tricky, als bei property und method weil interfaces auch in reflection
       eine reflectionClass sind und deshalb keine getDeclaringClass() Methode haben
       deshalb gucken wir ob parent das Interface implementiert. Wenn ja tun wir so als wäre dies nicht unser eigenes implements
       
       dies hilft beim Klasse-Schreiben jedoch nicht. Dort würde das Interface dann immer wieder verschwinden,
       auch wenn es explizit hinzugefügt worden wäre
       
       das ist nicht so trivial:
       InterfaceC extends InterfaceA, InterfaceB
       dann dürfen InterfacA und InterfaceB nicht implementiert werden (nur C)
    */
    if (!isset($this->parentClass)) return $this->interfaces;
    
    $interfaces = array();
    foreach ($this->interfaces as $interface) {
      if (!$this->parentClass->hasInterface($interface)) {
        $interfaces[$interface->getFQN()] = $interface;
      }
    }
    return $interfaces;
  }
1220382
public ResolvableType[] getInterfaces() {
        Class<?> resolved = resolve();
        Object[] array = resolved.getGenericInterfaces();
        if (resolved == null || (array == null || array.length == 0)) {
            return EMPTY_TYPES_ARRAY;
        }
        if (this.interfaces == null) {
            this.interfaces = forTypes(TypeWrapper.forGenericInterfaces(resolved), asVariableResolver());
        }
        return this.interfaces;
    }
112273
public function getTypes()
    {
        return array_reduce(
            $this->_models,
            function ($result, $item) {
                $result[$item['type']] = $item['type'];
                return $result;
            },
            []
        );
    }
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);
    }
645952
public List<JSTypeExpression> getImplementedInterfaces() {
    if (info == null || info.implementedInterfaces == null) {
      return ImmutableList.of();
    }
    return Collections.unmodifiableList(info.implementedInterfaces);
  }