############################ Standard delegating implementations ############################
970093
public Class<?> getType(final ELContext ctx, final Object base, final Object property)
    {
        return resolver.getType(ctx, base, property);
    }
1330338
public void delegateTo(final ClassLoader classLoader, final boolean isParent) {
        if (classLoader == null) {
            return;
        }
        // Check if this is a parent before checking if the classloader is already in the delegatedTo set,
        // so that if the classloader is a context classloader but also a parent, it still gets marked as
        // a parent classloader.
        if (isParent) {
            allParentClassLoaders.add(classLoader);
        }
        if (delegatedTo.add(classLoader)) {
            // Find ClassLoaderHandlerRegistryEntry for this classloader
            final ClassLoaderHandlerRegistryEntry entry = getRegistryEntry(classLoader);
            // Delegate to this classloader, by recursing to that classloader to get its classloader order
            entry.findClassLoaderOrder(classLoader, this);
        }
    }
800496
private void processAddDependency(Node n, Node parent) {
    CodingConvention convention = compiler.getCodingConvention();
    List<String> typeDecls =
        convention.identifyTypeDeclarationCall(n);

    // TODO(nnaze): Use of addDependency() should someday cause a warning
    // as we migrate users to explicit goog.forwardDeclare() calls.
    if (typeDecls != null) {
      for (String typeDecl : typeDecls) {
        compiler.forwardDeclareType(typeDecl);
      }
    }

    // We can't modify parent, so just create a node that will
    // get compiled out.
    Node emptyNode = IR.number(0);
    parent.replaceChild(n, emptyNode);
    compiler.reportChangeToEnclosingScope(emptyNode);
  }
1111197
private void writeToDelegate(byte[] data) {

        if (m_delegateStream != null) {
            try {
                m_delegateStream.write(data);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
191140
function delegate(req, res) {
  var cmd = req.info.command
    , method;

  if(!cmd.sub) {
    throw new Error('attempt to delegate with no subcommand info');
  }

  method = req.exec[cmd.sub.cmd];

  // subcommand is declared but the command exec handler
  // has not declared the method and is attempting to delegate
  // we treat this as unknown subcommand which allows partial
  // subcommand exec handlers that may call delegate but only
  // implement a subset of the declared subcommands
  if(typeof method !== 'function') {
    return res.send(StoreError.UnknownSubcommand);
  }

  // rewrite the cmd/args
  req.cmd = cmd.sub.cmd;
  req.args = cmd.sub.args;
  method.call(this, req, res);
}
839773
public OvhReverseDelegation ip_delegation_POST(String ip, String target) throws IOException {
		String qPath = "/ip/{ip}/delegation";
		StringBuilder sb = path(qPath, ip);
		HashMap<String, Object>o = new HashMap<String, Object>();
		addBody(o, "target", target);
		String resp = exec(qPath, "POST", sb.toString(), o);
		return convertTo(resp, OvhReverseDelegation.class);
	}
480512
private static String adjustData(String data, ClassNode type, DelegationMetadata dmd) {
        StringBuilder path = new StringBuilder();
        int i = 0;
        String[] propertyPath = data.split("\\.");
        while (dmd != null) {
            int strategy = dmd.getStrategy();
            ClassNode delegate = dmd.getType();
            dmd = dmd.getParent();
            switch (strategy) {
                case Closure.DELEGATE_FIRST:
                    if (!delegate.isDerivedFrom(CLOSURE_TYPE) && !delegate.isDerivedFrom(type)) {
                        path.append("owner"); // must be non-delegate case
                    } else {
                        path.append("delegate");
                    }
                    break;
                default:
                    if (i >= propertyPath.length) return data;
                    path.append(propertyPath[i]);
            }
            if (type.equals(delegate)) break;
            i++;
            if (dmd != null) path.append('.');
        }
        String result = path.toString();
        if (!result.isEmpty()) {
            return result;
        }
        return data;
    }
775350
def delegate(method, &convproc)
      convproc ||= lambda{|v,t| v.send(method) }
      upon(lambda{|v,t| v.respond_to?(method) }, convproc)
    end
567305
protected void addDelegate (PlaceControllerDelegate delegate)
    {
        if (_delegates == null) {
            _delegates = Lists.newArrayList();
        }
        _delegates.add(delegate);
    }
893795
function delegate(callback, el) {
        var currentElement = el;

        do {
            if (!isClickTarget(currentElement)) continue;
            callback(currentElement);
            return;
        } while(currentElement.nodeName.toUpperCase() !== 'BODY' && (currentElement = currentElement.parentNode));
    }
179565
private ArrayListImpl<ChildLink<T>> modifiableDelegate() {
    if (delegate.getCount() != 0) {
      delegate = new ArrayListImpl<>(delegate);
    }
    return delegate;
  }
119520
function (handler) {
            this.cleanCache();

            // initialization of delegation manager
            if (!this.__delegateMapping) {
                ariaUtilsAriaWindow.attachWindow();

                var body = Aria.$window.document.body;
                this.rootListener = ariaCoreBrowser.isOldIE ? body : Aria.$window;
                this.__delegateMapping = {};
                var utilEvent = ariaUtilsEvent, index, l;
                for (index = 0, l = this.delegatedOnBody.length; index < l; index++) {
                    utilEvent.addListener(body, this.delegatedOnBody[index], {
                        fn : this.delegate,
                        scope : this
                    });
                }
                for (index = 0, l = this.delegatedOnWindow.length; index < l; index++) {
                    utilEvent.addListener(this.rootListener, this.delegatedOnWindow[index], {
                        fn : this.delegate,
                        scope : this
                    });
                }
            }
            var id = this.__idMgr.getId();
            while (this._changed && this._changed[id]) {
                this._changed[id] = false;
                id = this.__idMgr.getId();
            }
            this.__delegateMapping[id] = new ariaUtilsCallback(handler);
            return id;
        }
1272451
@Override
  public PostingsFormat postingsFormat() {
    initDelegate();
    if (delegate.postingsFormat() instanceof PerFieldPostingsFormat) {
      Codec defaultCodec = Codec.getDefault();
      PostingsFormat defaultPostingsFormat = defaultCodec.postingsFormat();
      if (defaultPostingsFormat instanceof PerFieldPostingsFormat) {
        defaultPostingsFormat = ((PerFieldPostingsFormat) defaultPostingsFormat)
            .getPostingsFormatForField(null);
        if ((defaultPostingsFormat == null)
            || (defaultPostingsFormat instanceof PerFieldPostingsFormat)) {
          // fallback option
          return new MtasCodecPostingsFormat(
              PostingsFormat.forName("Lucene70"));
        } else {
          return new MtasCodecPostingsFormat(defaultPostingsFormat);
        }
      } else {
        return new MtasCodecPostingsFormat(defaultPostingsFormat);
      }
    } else {
      return new MtasCodecPostingsFormat(delegate.postingsFormat());
    }
  }
447143
protected function delegateAdminObservers()
    {
        $this->app['events']->listen('eloquent.saving:*',
            'Bkwld\Decoy\Observers\Localize');
        $this->app['events']->listen('eloquent.saving:*',
            'Bkwld\Decoy\Observers\Encoding@onSaving');
        $this->app['events']->listen('eloquent.saved:*',
            'Bkwld\Decoy\Observers\ManyToManyChecklist');
        $this->app['events']->listen('eloquent.deleted:*',
            'Bkwld\Decoy\Observers\Encoding@onDeleted');
        $this->app['events']->listen('decoy::model.validating:*',
            'Bkwld\Decoy\Observers\ValidateExistingFiles@onValidating');
    }
65691
@Override
    public void processMessage() {
        VectorAggregation aggregation = new VectorAggregation(rowIndex, (short) voidConfiguration.getNumberOfShards(),
                        getShardIndex(), storage.getArray(key).getRow(rowIndex).dup());
        aggregation.setOriginatorId(this.getOriginatorId());

        clipboard.pin(aggregation);

        DistributedVectorMessage dvm = new DistributedVectorMessage(key, rowIndex);
        dvm.setOriginatorId(this.originatorId);

        if (voidConfiguration.getNumberOfShards() > 1)
            transport.sendMessageToAllShards(dvm);
        else {
            aggregation.extractContext(this);
            aggregation.processMessage();
        }
    }
1087197
private Node delegate(Tag tag, Object value) {
        Objects.requireNonNull(tag);
        Node node = delegate(value);
        node.setTag(tag);
        return node;
    }
1098631
def _delegate(from_owner, to_owner, method):
  
  dgate = lambda self, *args, **kwargs: getattr(getattr(self, to_owner), method)(*args, **kwargs)
  dgate.__name__ = method
  dgate.__doc__ = "Delegates to {0}.{1}: {2}".format(to_owner, method, method.__doc__)
  setattr(from_owner, method, dgate)