Add an interface provider to the list
@param string $interface
@param Reference $reference
337156
private function addInterfaceProvider($interface, Reference $reference)
    {
        if (empty($this->interfaceProviders[$interface])) {
            $this->interfaceProviders[$interface]= [];
        }

        $this->interfaceProviders[$interface][] = $reference;
    }
328086
public function removeInterface($interface) {
		if ($interface instanceof PhpInterface) {
			$name = $interface->getName();
			$qname = $interface->getQualifiedName();

			$this->removeUseStatement($qname);
		} else {
			$name = $interface;
		}

		$this->interfaces->remove($name);

		return $this;
	}
1060618
public function cancel($reference = null, $subscriptionId = null)
    {
        if ($reference) {
          $this->setParameter('REFERENCE', $reference);
        }

        if ($subscriptionId) {
          $this->setParameter('ABONNEMENT', $subscriptionId);
        }

        $this->transport->setEndpoint($this->getUrl());

        return $this->transport->call($this);
    }
655372
public function &addTrait($interface = null, $implementation = null)
    {
        if (is_array($interface)) {
            foreach ($interface as $k => $v) {
                $this->addTrait($k, $v);
            }
        } else {
            if ($interface || $implementation) {
                if (empty($interface)) {
                    $interface = '--just-paste-trait--';
                }

                if (empty($this->traits[$interface])) {
                    $this->traits[$interface] = [];
                }

                if ($implementation && array_search($implementation, $this->traits[$interface]) === false) {
                    $this->traits[$interface][] = $implementation;
                }
            } else {
                throw new InvalidArgumentException('Interface or implementation are required');
            }
        }

        return $this;
    }
1317024
public function addInterface(string $interfaceName, string $alias = null)
    {
        $this->interfaces[] = $this->addUse($interfaceName, $alias);
    }
896916
def virtual_interface_list(provider, names, **kwargs):
    '''
    

    '''
    client = _get_client()
    return client.extra_action(provider=provider, names=names, action='virtual_interface_list', **kwargs)
712171
public void addInterface(Class<?> ifc) {

        LettuceAssert.notNull(ifc, "Interface type must not be null");
        LettuceAssert.isTrue(ifc.isInterface(), "Type must be an interface");

        this.interfaces.add(ifc);
    }
789718
public function addProvider(ProviderInterface $provider)
    {
        if (array_key_exists($name = $provider->getName(), $this->providers)) {
            throw new \InvalidArgumentException("Wide search provider '{$name}' is already registered.");
        }

        $this->providers[$name] = $provider;
    }
60964
public function addInterface(string $interface) : bool
    {
        $retval = false;

        if (!array_search($interface, $this->interface_list)) {
            $this->interface_list[] = $interface;
            $retval = true;
        }

        return $retval;
    }
1237959
public function add(ProviderInterface $provider)
    {
        $container = $this->container;

        $this->container = $provider->register($container);

        $this->providers[] = (string) get_class($provider);

        return $this;
    }
287046
private function changeReference(Reference $reference, $serviceId)
    {
        if (method_exists($reference, 'isStrict')) {
            // Stay compatible with Symfony 2
            return new Reference($serviceId, $reference->getInvalidBehavior(), $reference->isStrict(false));
        }

        return new Reference($serviceId, $reference->getInvalidBehavior());
    }
669311
public function addProvider($provider) {
        $this->validateProvider($provider);

        if (is_object($provider)) {
            $class = get_class($provider);
            $instance = $provider;
        } else {
            $class = $provider;
            $instance = null;
        }

        if ( ! array_has($this->providers, $class)) {
            $this->providers[$class] = [
                'instance' => $instance,
                'tags' => [],
            ];
        }
    }
1062494
public function addProvider(ProviderInterface $provider, $alias, $priority)
    {
        $this->providers[$alias] = array(
            'provider' => $provider,
            'priority' => $priority,
            'alias' => $alias,
        );

        uasort(
            $this->providers,
            function ($a, $b) {
                if ($a['priority'] == $b['priority']) {
                    return 0;
                }

                return $a['priority'] < $b['priority'] ? 1 : -1;
            }
        );
    }
674036
public void addInterface(Class<?> newInterface) {
        if (!newInterface.isInterface()) {
            throw new IllegalArgumentException(newInterface + " is not an interface");
        }
        additionalInterfaces.add(newInterface);
    }
747864
public function addIO($io): void
    {
        if (!$io instanceof AbstractInput && !$io instanceof AbstractOutput) {
            throw new \InvalidArgumentException('io must be an instance of '.AbstractInput::class.' or '.AbstractOutput::class.' but '.\get_class($io).' instead !');
        }

        $this->aggregate->add($io);
    }
860733
protected function hasTargetedBinding(string $interface, string $target = null) : bool
    {
        return isset($this->bindings[$target][$interface]);
    }
1064715
function add(interface){
    var i = arr.collection,
        found = false;
    while (i--) {
        if(interface.name === collection[i].name){
            found = true;
        }
    }
    if(!found){ collection.push( interface ) };
}