Add other extra methods
177202
private void addProxyExtras(TypeSpec.Builder classBuilder) {
        addRemoterProxyMethods(classBuilder);
        addProxyDeathMethod(classBuilder, "linkToDeath", "Register a {@link android.os.IBinder.DeathRecipient} to know of binder connection lose\n");
        addProxyDeathMethod(classBuilder, "unlinkToDeath", "UnRegisters a {@link android.os.IBinder.DeathRecipient}\n");
        addProxyRemoteAlive(classBuilder);
        addProxyCheckException(classBuilder);
        addGetId(classBuilder);
        addHashCode(classBuilder);
        addEquals(classBuilder);
        addProxyDestroyMethods(classBuilder);
    }
137889
def merge_extra_options(self, needs_info):
        """"""
        extra_keys = set(self.options.keys()).difference(set(needs_info.keys()))
        for key in extra_keys:
            needs_info[key] = self.options[key]

        # Finally add all not used extra options with empty value to need_info.
        # Needed for filters, which need to access these empty/not used options.
        for key in self.option_spec:
            if key not in needs_info.keys():
                needs_info[key] = ""

        return extra_keys
1237562
function addSourceMethods() {
        $methodBindingArray = $this->implementWeaveInfo->getMethodBindingArray();
        $methods = $this->sourceClassReflection->getMethods();
        foreach ($methods as $sourceMethod) {
            
            if ($sourceMethod->getName() === '__construct') {
                continue;
            }
            
            $methodBindingToApply = null;
            foreach ($methodBindingArray as $methodBinding) {
                if ($methodBinding->matchesMethod($sourceMethod->getName()) ) {
                    $methodBindingToApply = $methodBinding;
                    break;
                }
            }

            if ($methodBindingToApply != null) {
                $decoratorMethod = $methodBindingToApply->getMethod();
                $decoratorMethodReflection = $this->decoratorReflection->getMethod($decoratorMethod);
                $this->addDecoratedMethod($sourceMethod, $decoratorMethodReflection);
            }
            else {
                $this->addPlainMethod($sourceMethod);
            }
        }
    }
543916
function addDecoratorMethods() {
        $methods = $this->decoratorReflection->getMethods();

        foreach ($methods as $method) {
            $name = $method->getName();

            if ($name === '__construct' || $name === '__prototype' || $name == '__extend') {
                continue;
            }

            $methodGenerator = MethodGenerator::fromReflection($method);
            $this->generator->addMethodFromGenerator($methodGenerator);
        }
    }
233283
public MethodInfo addMethod(Method method) {
        Modifiers modifiers = Modifiers.getInstance(method.getModifiers()).toAbstract(false);
        MethodInfo mi = addMethod(modifiers, method.getName(), MethodDesc.forMethod(method));
        
        // exception stuff...
        Class[] exceptions = method.getExceptionTypes();
        for (int i=0; i<exceptions.length; i++) {
            mi.addException(TypeDesc.forClass(exceptions[i]));
        }

        return mi;
    }
826719
def add_method(obj, func, name=None):
    """"""
    if name is None:
        name = func.__name__
    if sys.version_info < (3,):
        method = types.MethodType(func, obj, obj.__class__)
    else:
        method = types.MethodType(func, obj)
    setattr(obj, name, method)
721624
def add_validation_method(cls, method):
        
        method_name = method.func_name

        # add method name to additional validation method list
        cls._additional_validation.append(method_name)

        # add method to this class
        setattr(cls, method_name, method)
1184677
public void addMethodInfo(final MethodInfo methodInfo) {
        ArgUtils.notNull(methodInfo, "methodInfo");
        
        removeMethodInfo(methodInfo.getMethodName());
        this.methodInfos.add(methodInfo);
    }
1293987
private static int addMethod(ConstPool cPool, CtMethod method) {
        // addMethodrefInfo is a safe add, if constant already present it return the existing value without adding.
        return cPool.addMethodrefInfo( cPool.getThisClassInfo(), method.getName(), method.getSignature() );
    }
599990
def inject_extra_args(callback, request, kwargs):
    ''''''
    # TODO: this is a temporary pach, should be managed via honouring the
    # mimetype in the request header....
    annots = dict(callback.__annotations__)
    del annots['return']
    for param_name, (param_type, _) in annots.items():
        if param_type == Ptypes.path:
            continue  # Already parsed by werkzeug
        elif param_type == Ptypes.body:
            value = getattr(request, PTYPE_TO_REQUEST_PROPERTY[param_type])
            # TODO: The JSON conversion should be dependant from request
            # header type, really...
            value = json.loads(value.decode('utf-8'))
        else:
            get = lambda attr: getattr(request, attr).get(param_name, None)
            value = get(PTYPE_TO_REQUEST_PROPERTY[param_type])
        if value is not None:
            kwargs[param_name] = value
1275020
function addHooks(method) {
            // Add Pre hooks
            callQueue[method].pres.forEach((fn) => {
                self.pre(method, fn);
            });

            // Add Post hooks
            callQueue[method].post.forEach((fn) => {
                self.post(method, fn);
            });
        }
973575
function addMethod (char, method) {
  var keyIsBound = hasKeybinding(char);
  var listener = keyupHandler.bind(null, char, method);

  bindings[char] = bindings[char] || {methods: [], listeners: []};

  if (keyIsBound) window.removeEventListener('keyup', bindings[char].listeners[0]);

  bindings[char].methods.unshift(method);
  bindings[char].listeners.unshift(listener);
  window.addEventListener('keyup', listener);
}
829017
def _add_hookimpl(self, hookimpl):
        
        if hookimpl.hookwrapper:
            methods = self._wrappers
        else:
            methods = self._nonwrappers

        if hookimpl.trylast:
            methods.insert(0, hookimpl)
        elif hookimpl.tryfirst:
            methods.append(hookimpl)
        else:
            # find last non-tryfirst method
            i = len(methods) - 1
            while i >= 0 and methods[i].tryfirst:
                i -= 1
            methods.insert(i + 1, hookimpl)

        if "__multicall__" in hookimpl.argnames:
            warnings.warn(
                "Support for __multicall__ is now deprecated and will be"
                "removed in an upcoming release.",
                DeprecationWarning,
            )
            self.multicall = _legacymulticall
47746
def add(self, auth, method, args, notimeout=False):
        """"""
        authstr = self._authstr(auth)
        self._requests.setdefault(authstr, []).append((method, args))
        self._notimeouts.setdefault(authstr, False)
        if notimeout:
            self._notimeouts[authstr] = notimeout
1088046
def create_extras(cls: Type[T],
                  extras: Dict[str, Any]) -> Dict[str, Any]:
    
    subextras: Dict[str, Any] = {}
    if hasattr(cls, "from_params"):
        from_params_method = cls.from_params  # type: ignore
    else:
        # In some rare cases, we get a registered subclass that does _not_ have a
        # from_params method (this happens with Activations, for instance, where we
        # register pytorch modules directly).  This is a bit of a hack to make those work,
        # instead of adding a `from_params` method for them somehow. Then the extras
        # in the class constructor are what we are looking for, to pass on.
        from_params_method = cls
    if takes_kwargs(from_params_method):
        # If annotation.params accepts **kwargs, we need to pass them all along.
        # For example, `BasicTextFieldEmbedder.from_params` requires a Vocabulary
        # object, but `TextFieldEmbedder.from_params` does not.
        subextras = extras
    else:
        # Otherwise, only supply the ones that are actual args; any additional ones
        # will cause a TypeError.
        subextras = {k: v for k, v in extras.items()
                     if takes_arg(from_params_method, k)}
    return subextras
977618
def add_method(info, target_cls, virtual=False, dont_replace=False):
    """"""

    # escape before prefixing, like pygobject
    name = escape_identifier(info.name)
    if virtual:
        name = "do_" + name
        attr = VirtualMethodAttribute(info, target_cls, name)
    else:
        attr = MethodAttribute(info, target_cls, name)

    if dont_replace and hasattr(target_cls, name):
        return

    setattr(target_cls, name, attr)
1137686
def add(self, *args, **kwargs):
        
        return self._apply(operator.add, *args, **kwargs)