interface function
556918
function(...a_args) {

		// ref args length and 0th arg
		let n_args = a_args.length;
		let z_arg0 = a_args[0];

		// no arguments OR single argument is a boolean (fetch)
		if(n_args === 0 || (n_args === 1 && 'boolean' === typeof z_arg0)) {

			// no soft/hard options
			if('function' === typeof h_handler.fetch) {
				return h_handler.fetch();
			}
			// fetch soft
			else if(!n_args || false === z_arg0) {
				return h_handler.fetch.soft();
			}
			// fetch hard
			else {
				return h_handler.fetch.hard();
			}
		}
		// add
		else {
			h_handler.add(...a_args);
		}

		// update self reference to this
		self = this;

		// chain
		return this;
	}
48004
function T(iid, val, type, hasGetterSetter, internalIid) {
        var aret;
        associateSidWithFunction(val, internalIid);
        if (hasGetterSetter) {
            for (var offset in val) {
                if (hasGetOwnPropertyDescriptor && val.hasOwnProperty(offset)) {
                    var desc = Object.getOwnPropertyDescriptor(val, offset);
                    if (desc !== undefined) {
                        if (typeof desc.get === 'function') {
                            T(iid, desc.get, 12, false, internalIid);
                        }
                        if (typeof desc.set === 'function') {
                            T(iid, desc.set, 12, false, internalIid);
                        }
                    }
                }
            }
        }
        if (sandbox.analysis && sandbox.analysis.literal) {
            aret = sandbox.analysis.literal(iid, val, hasGetterSetter);
            if (aret) {
                val = aret.result;
            }
        }
        return (lastComputedValue = val);
    }
627123
def _interp_function(self, y_ip1, y_i, t_ip1, t_i, imt_per):
        
        return y_i + (y_ip1 - y_i) / (t_ip1 - t_i) * (imt_per - t_i)
714699
private void _function() throws
      IOException
  {
    // Assumes that builder already contains an IDENT
    if (debug)
    {
      checkArgument('(' == reader.peek());
    }
    builder.type = Type.FUNCTION;
    builder.append(reader.next());
  }
454574
function _gpfInterfacesPromisify(interfaceSpecifier) {
        return function (object) {
            var iInterfaceImpl = _gpfInterfaceQuery(interfaceSpecifier, object);
            if (!iInterfaceImpl) {
                gpf.Error.interfaceExpected({ name: _gpfGetFunctionName(interfaceSpecifier) });
            }
            return _gpfInterfacesWrap(iInterfaceImpl, interfaceSpecifier, Promise.resolve());
        };
    }
420010
def get_interface_by_instance_name(self, name):
        ''''''
        with self._mutex:
            for intf in self.interfaces:
                if intf.instance_name == name:
                    return intf
            return None
1136098
function showInterfaceJava(intf, html) {
    html.push("<div class='show-Java'><h3>Java</h3><pre>")

    intf.methods.forEach(function(method){
        showInterfaceJavaMethod(intf, method, html)
    })

    html.push("</pre></div>")
}
346184
function instanceOf(instance, target) {
        if (!isFunction(target)) {
            return false;
        }

        if (instance instanceof target) {
            return true;
        }

        if (instance && instance.$static && instance.$static[$class] && target && target[$interface]) {
            return instanceOfInterface(instance, target);
        }

        return false;
    }
478541
public static boolean implementsInterface(Class<?> c, Class<?> i) {
		if (c == i)
			return true;

		for (Class<?> x : c.getInterfaces())
			if (implementsInterface(x, i))
				return true;

		return false;
	}
1054213
function _inputInterfaces (interfaces, msg, type, options, i = 0) {

			return i >= interfaces.length ? Promise.resolve() : Promise.resolve().then(() => {

				let result = null;

					switch (type) {

						case "log":
							result = interfaces[i].log(msg, options);
						break;
						case "success":
							result = interfaces[i].success(msg, options);
						break;
						case "information":
							result = interfaces[i].information(msg, options);
						break;
						case "warning":
							result = interfaces[i].warning(msg, options);
						break;
						case "error":
							result = interfaces[i].error(msg, options);
						break;

						default:
							// nothing to do here
						break;

					}

				return null === result ? Promise.resolve() : Promise.resolve().then(() => {

					if ("boolean" === typeof result) {

						return result ? Promise.resolve() : Promise.reject(
							new Error("Impossible to log \"" + msg + "\" message with \"" + type + "\" type on all the interfaces")
						);

					}
					else {
						return "object" === typeof result && result instanceof Promise ? result : Promise.resolve();
					}

				}).then(() => {
					return _inputInterfaces(interfaces, msg, type, options, i + 1);
				});

			});

		}
835211
def interfaces(self):
        """"""

        ifaces = []

        if self._wlan_open_handle(CLIENT_VERSION,
                                  byref(self._nego_version),
                                  byref(self._handle)) \
           is not ERROR_SUCCESS:
            self._logger.error("Open handle failed!")

        if self._wlan_enum_interfaces(self._handle, byref(self._ifaces)) \
           is not ERROR_SUCCESS:
            self._logger.error("Enum interface failed!")

        interfaces = cast(self._ifaces.contents.InterfaceInfo,
                     POINTER(WLAN_INTERFACE_INFO))
        for i in range(0, self._ifaces.contents.dwNumberOfItems):
            iface = {}
            iface['guid'] = interfaces[i].InterfaceGuid
            iface['name'] = interfaces[i].strInterfaceDescription
            ifaces.append(iface)

        return ifaces
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 ) };
}
876417
private void checkInterface(Node n, FunctionType functionType) {
    // Interface must extend only interfaces
    for (ObjectType extInterface : functionType.getExtendedInterfaces()) {
      if (extInterface.getConstructor() != null && !extInterface.getConstructor().isInterface()) {
        compiler.report(
            JSError.make(n, CONFLICTING_EXTENDED_TYPE, "interface", getBestFunctionName(n)));
      }
    }

    // Check whether the extended interfaces have any conflicts
    if (functionType.getExtendedInterfacesCount() > 1) {
      // Only check when extending more than one interfaces
      HashMap<String, ObjectType> properties = new HashMap<>();
      LinkedHashMap<String, ObjectType> currentProperties = new LinkedHashMap<>();
      for (ObjectType interfaceType : functionType.getExtendedInterfaces()) {
        currentProperties.clear();
        checkInterfaceConflictProperties(
            n, getBestFunctionName(n), properties, currentProperties, interfaceType);
        properties.putAll(currentProperties);
      }
    }

    List<FunctionType> loopPath = functionType.checkExtendsLoop();
    if (loopPath != null) {
      String strPath = "";
      for (int i = 0; i < loopPath.size() - 1; i++) {
        strPath += loopPath.get(i).getDisplayName() + " -> ";
      }
      strPath += Iterables.getLast(loopPath).getDisplayName();
      compiler.report(
          JSError.make(n, INTERFACE_EXTENDS_LOOP, loopPath.get(0).getDisplayName(), strPath));
    }
  }
1301001
def interface(self):
        
        
        # Possible control arguments
        controls = {
            'start': self.do_start,
            'stop': self.do_stop,
            'status': self.do_status,
            'restart': self.do_restart,
            'reload': self.do_restart    
        }
        
        # Process the control argument
        try:
            controls[self.command]()
        except KeyError:
            self.write_stdout('Usage: {} {{start|stop|status|restart|reload}}'.format(self.name), 3)
        exit(0)
204741
def _function(self, type, name, args=""):
        
        return FunctionManager(self, type=type, name=name, args=args)
639543
function Function (retType, argTypes, abi) {
  if (!(this instanceof Function)) {
    return new Function(retType, argTypes, abi);
  }

  debug('creating new FunctionType');

  // check args
  assert(!!retType, 'expected a return "type" object as the first argument');
  assert(Array.isArray(argTypes), 'expected Array of arg "type" objects as the second argument');

  // normalize the "types" (they could be strings, so turn into real type
  // instances)
  this.retType = ref.coerceType(retType);
  this.argTypes = argTypes.map(ref.coerceType);
  this.abi = null == abi ? bindings.FFI_DEFAULT_ABI : abi;
}
46941
function _wrapQueryInterface (orgQueryInterface) {
    return function (interfaceDefinition) {
        /*eslint-disable no-invalid-this*/
        _gpfIgnore(interfaceDefinition);
        var result = _queryInterface.apply(this, arguments);
        if (null === result) {
            result = orgQueryInterface.apply(this, arguments);
        }
        return result;
        /*eslint-enable no-invalid-this*/
    };
}