Entfernt das Interface aus der Klasse

@chainable
431130
public function removeInterface(GClass $class) {
    if (array_key_exists($n = $class->getFQN(), $this->interfaces)) {
      unset($this->interfaces[$n]);
    }
    return $this;
  }
675499
List<JCTree> classOrInterfaceBody(Name className, boolean isInterface) {
        accept(LBRACE);
        if (token.pos <= endPosTable.errorEndPos) {
            // error recovery
            skip(false, true, false, false);
            if (token.kind == LBRACE)
                nextToken();
        }
        ListBuffer<JCTree> defs = new ListBuffer<JCTree>();
        while (token.kind != RBRACE && token.kind != EOF) {
            defs.appendList(classOrInterfaceBodyDeclaration(className, isInterface));
            if (token.pos <= endPosTable.errorEndPos) {
               // error recovery
               skip(false, true, true, false);
           }
        }
        accept(RBRACE);
        return defs.toList();
    }
865830
function(implClass, modClass) {

	var impls = {
		DelayableQueue : [

			/**
			 * Returns a queueable interface to the original object
			 * This allows us to insert delays between chainable method calls using the .wait() method
			 * Currently this is only implemented for the node class, but it should be possible to use this with any object.
			 */
			'wait', function () {

				/**
				 * Queueable object which implements methods from another interface
				 * @param object Context for the callback
				 */
				function QueueableObject(context) {
					this.queue = [];
					this.context = context;
					this.inWork = false;
				}
				
				QueueableObject.prototype = {
					_add: function(func, args) {

						var self = this;

						self.queue.push({type: 'chain', func: func, args: args});
						if (!self.inWork) {
							return self._process();
						}
					},

					/**
					 * Process the queue
					 * Shifts an item off the queue and waits for it to finish
					 */
					_process: function() {

						var self = this, item;

						self.inWork = true;
						
						if (!self.queue.length) {
							return;
						}
						
						item = self.queue.shift();

						if (item.type == 'wait') {
							setTimeout(function(){
								self._process();
							}, item.duration*1000);
						} else {
							self.context = item.func.apply(self.context, item.args);
							self._process();
						}
						return self;
					},

					/**
					 * Updates the current delay timer
					 */
					wait: function(duration) {
						this.queue.push({type: 'wait', duration: duration});
						return this;
					}
				};
				
				return function (duration) {

					var self = this,
						mockObj = new QueueableObject(self);

					/**
					 * Returns an executable function
					 * uses setTimeout and the total queueTimer
					 */
					getQueuedFunction = function(func) {
						return function() {
							mockObj._add(func, arguments);
							return mockObj;
						}
					};

					/**
					 * Wrap all class functions
					 * We can unwrap at the end if the current wait is 0
					 */
					for( var i in self ) {
						if (typeof self[i] != 'function' || i == 'wait' ) { continue; }
						mockObj[i] = getQueuedFunction(self[i]);
					}

					mockObj.wait(duration);
					
					return mockObj;
				}
			}
		]
	};

	modClass[impls[implClass][0]] = impls[implClass][1]();
}
938912
function getConstructorInterface(namespace, module) {

    var methods = [];


    // Add the main chainable type.

    var chainableGenerics = getChainableBaseGenerics(namespace.name)
    var chainableType = 'ChainableBase' + chainableGenerics;

    if (namespace.name !== 'Object') {
      chainableType += ' & Object.ChainableBase' + getChainableBaseGenerics('Object');
    }
    module.types.push({
      name: 'Chainable' + chainableGenerics,
      type: chainableType
    });


    // Set up constructor methods.

    var rawType = getRawType(namespace.name);

    var constructorMethod = {
      name: 'new',
      type: 'constructor',
      module: namespace.name,
      generics: getNamespaceBaseGenerics(namespace.name),
      returns: 'Chainable' + getChainableInstanceGenerics(namespace.name),
      params: [{
        name: 'raw',
        type: rawType
      }]
    };

    var createMethod = namespace.methods.find(function(method) {
      return method.name === 'create';
    });

    if (createMethod) {
      // If the namespace has a "create" method, then it will be mapped
      // to the chainable constructor, so accomodate for that here.
      constructorMethod.params = createMethod.params;
      constructorMethod.params[0].required = false;
    }

    var factoryMethod = clone(constructorMethod);
    factoryMethod.name = '';

    methods.push(constructorMethod);
    methods.push(factoryMethod);


    // Set up all remaining methods.

    namespace.methods.forEach(function(method) {
      var instanceParam = {
        name: 'instance',
        required: true,
        type: getInstanceParamType(method, rawType)
      };
      var method = clone(method);
      if (method.type === 'instance') {
        method.params.unshift(instanceParam);
        if (method.signatures) {
          method.signatures.forEach(function(signature) {
            signature.unshift(instanceParam);
          });
        }
        if (namespace.name === 'Array') {
          method.generics = ['T'];
        }
      }
      methods.push(method);
    });

    methods = buildMethods(methods, namespace, 'static');
    return getInterfaceSource('Constructor', methods.join('\n'), null, 'SugarNamespace');
  }
271859
function &interfaces()
    {
        $interfaces = NULL;
        foreach ($this->_classes as $name => $interface) {
            if ($interface->isInterface()) {
                $interfaces[$name] =& $this->_classes[$name];
            }
        }

        return $interfaces;
    }
110940
function chain(promise,
               onResolve = idResolveHandler,
               onReject = idRejectHandler) {
  var deferred = getDeferred(promise.constructor);
  switch (promise.status_) {
    case undefined:
      throw TypeError;
    case 0:
      promise.onResolve_.push(onResolve, deferred);
      promise.onReject_.push(onReject, deferred);
      break;
    case +1:
      promiseEnqueue(promise.value_, [onResolve, deferred]);
      break;
    case -1:
      promiseEnqueue(promise.value_, [onReject, deferred]);
      break;
  }
  return deferred.promise;
}
188502
def map_with_monad(lam = nil, &blk)
      bind { |v| self.class.unit((lam || blk).call(v)) }
    end
1106903
def when(*args)
      return self.next{[]} if args.empty?
      args = args.flatten
      args.each_with_index{|d, index|
        unless d.is_a?(Deferredable::Chainable) || d.is_a?(Deferredable::Awaitable)
          raise TypeError, "Argument #{index} of Deferred.when must be #{Deferredable::Chainable}, but given #{d.class}"
        end
        if d.respond_to?(:has_child?) && d.has_child?
          raise "Already assigned child for argument #{index}"
        end
      }
      defer, *follow = *args
      defer.next{|res|
        [res, *follow.map{|d| +d }]
      }
    end
371335
protected function DefineInterface()
    {
        parent::DefineInterface();
        $externalFunctions = array('generateVariants', 'getPossibleVariantCombinations');
        $this->methodCallAllowed = array_merge($this->methodCallAllowed, $externalFunctions);
    }
662995
function Chain() {
    this.props = {}
    this.state = {}

    this.props._context = this
    this.props._data = {}
    this.props._nodes = new LinkNodes()
    this.props._finals =[]
}
623924
function(required, cb) {
      var chain = new Chain(config);
      chain.on(required, cb);
      return chain;
    }
777246
@Override
   protected void implementInterface(InterfaceCapableSource<?> source, Iterable<String> value, JavaSourceFacet facet)
   {
      for (String type : value)
      {
         source.addInterface(type);
      }
   }
1223604
private static List<DAType> computeExtendedInterfaces(List<DAInterface> interfaces) {
    Optional<DAType> functionInterface = from(interfaces)
        .filter(DAInterfacePredicates.isGuavaFunction())
        .transform(toDAType())
        .filter(notNull())
        .first();
    if (functionInterface.isPresent()) {
      return Collections.singletonList(functionInterface.get());
    }
    return  Collections.emptyList();
  }
899691
public static <E, I extends Iterator<E>> Iterator<E> chain(Iterable<I> iterators) {
        dbc.precondition(iterators != null, "cannot chain a null iterable");
        return new ChainIterator<>(iterators.iterator());
    }
1293356
function onInstance(Meanio,meanioinstance,defer){
  Meanio.prototype.serve = genericServe.bind(meanioinstance,Meanio);
  var middleware = {
    before: [],
    after: []
  };
  //so tangled up, much spaghetti...
  Meanio.prototype.chainware = {

    add: function(event, weight, func) {
      middleware[event].splice(weight, 0, {
        weight: weight,
        func: func
      });
      middleware[event].join();
      middleware[event].sort(function(a, b) {
        if (a.weight < b.weight) {
          a.next = b.func;
        } else {
          b.next = a.func;
        }
        return (a.weight - b.weight);
      });
    },

    before: function(req, res, next) {
      if (!middleware.before.length) return next();
      this.chain('before', 0, req, res, next);
    },

    after: function(req, res, next) {
      if (!middleware.after.length) return next();
      this.chain('after', 0, req, res, next);
    },

    chain: function(operator, index, req, res, next) {
      var args = [req, res,
        function() {
          if (middleware[operator][index + 1]) {
            this.chain('before', index + 1, req, res, next);
          } else {
            next();
          }
        }
      ];

      middleware[operator][index].func.apply(this, args);
    }
  };

  defer.resolve();
}
22414
function multi(cb) {
  // not chainable with a callback
  if(typeof cb === 'function') {
    return this.execute(Constants.MAP.multi.name, [], cb);
  }

  // chainable instance
  return new Multi(this);
}
1051640
function chain(fn, m) {
  if(!isFunction(fn)) {
    throw new TypeError('chain: Chain returning function required for first argument')
  }

  if(!(isChain(m) || isArray(m))) {
    throw new TypeError('chain: Chain of the same type required for second argument')
  }

  if(isArray(m)) {
    return _chain(fn, m)
  }

  return (m[fl.chain] || m.chain).call(m, fn)
}