Override the base implementation to pass along the share ID our
        constructor was passed.
343394
def cloneURL(self, scheme, netloc, pathsegs, querysegs, fragment):
        
        return self.__class__(
            self._shareID, scheme, netloc, pathsegs, querysegs, fragment)
922031
private <T extends Property> Map<String, String> getOverriddenImplementationConfiguration(
            Collection<T> overridableProperties) {

        Map<String, String> ret = new HashMap<>();

        overridableProperties.forEach(p -> {
            String val = getProperty(p, null);
            if (val != null) {
                ret.put(p.getPropertyName(), val);
            }
        });

        implementationConfiguration.forEach(ret::putIfAbsent);

        return ret;
    }
1371370
protected void addConstructedGuardToMethodBody(final ClassMethod classMethod, String className) {
        if (!useConstructedFlag()) {
            return;
        }
        // now create the conditional
        final CodeAttribute cond = classMethod.getCodeAttribute();
        cond.aload(0);
        cond.getfield(classMethod.getClassFile().getName(), CONSTRUCTED_FLAG_NAME, BytecodeUtils.BOOLEAN_CLASS_DESCRIPTOR);

        // jump if the proxy constructor has finished
        BranchEnd jumpMarker = cond.ifne();
        // generate the invokespecial call to the super class method
        // this is run when the proxy is being constructed
        cond.aload(0);
        cond.loadMethodParameters();
        cond.invokespecial(className, classMethod.getName(), classMethod.getDescriptor());
        cond.returnInstruction();
        cond.branchEnd(jumpMarker);
    }
1053124
def _take_ownership(self):
        

        if self:
            ptr = cast(self.value, GIBaseInfo)
            _UnrefFinalizer.track(self, ptr)
            self.__owns = True
859309
def inherit(self):
        
        # Preserve original data and merge parent
        # (original data needed for custom inheritance extensions)
        self.original_data = self.data
        self.merge()
        log.debug("Data for '{0}' inherited.".format(self))
        log.data(pretty(self.data))
        #  to all children
        for child in self.children.values():
            child.inherit()
899008
private void addConstructorByKeyRef() {
    context.constructorByKeyRef = MethodSpec.constructorBuilder().addParameter(keyRefSpec);
    addCommonParameters(context.constructorByKeyRef);
    if (isBaseClass()) {
      assignKeyRefAndValue();
    } else {
      callParentByKeyRef();
    }
  }
1146219
function createOverride(sXHRMethod) {

		mRegistry[sXHRMethod] = Object.create(null);

		//  backup the original function
		mXHRFunctions[sXHRMethod] = window.XMLHttpRequest.prototype[sXHRMethod];

		window.XMLHttpRequest.prototype[sXHRMethod] = function() {
			var oArgs = arguments;

			// call the original function first
			mXHRFunctions[sXHRMethod].apply(this, oArgs);

			// call the registered callbacks in order of their registration
			for (var sName in mRegistry[sXHRMethod]) {
				mRegistry[sXHRMethod][sName].apply(this, oArgs);
			}

		};

	}
251336
function extendPreventingOverrides (a, b) {
          Object.keys(b).forEach(addContentFromBtoA)
          return a

          function addContentFromBtoA (key) {
            if (a.hasOwnProperty(key)) {
              mergeIntoAnArray(a, b, key)
            } else {
              a[key] = b[key]
            }
          }
        }
92443
function (item/*, index*/) {
		var old = item;
		var Constructor;
		if (!(item instanceof ok.Base)) {
			Constructor = this.getConstructor(item);
			item = new Constructor(item);
		}
		var identified = this.identify(item);
		if (identified) {
			identified.set(old);
		}
		else {
			var index = this.findInsertIndex(item);
			this.items.insert(index + 1, item);
		}
	}
382103
protected function shareInstancesInContainer() {
        $this->container->set([Router::class, IRouter::class], $this->router);
        $this->container->set(
            [RequestHandler::class, IRequestHandler::class], $this->requestHandler
        );
    }
1018973
public boolean recordOverride() {
    if (!currentInfo.isOverride()) {
      currentInfo.setOverride(true);
      populated = true;
      return true;
    } else {
      return false;
    }
  }
43496
@Override
    public ContainerDef overrideProperty(String name, String value) {
        container.getOrCreate("configuration").removeChild("property@name=" + name);
        container.getOrCreate("configuration").getOrCreate("property@name=" + name).text(value);
        return this;
    }
848069
private void visitOverride(AnnotatedNode node, AnnotationNode visited) {
        ClassNode annotationClassNode = visited.getClassNode();
        if (annotationClassNode.isResolved() && annotationClassNode.getName().equals("java.lang.Override")) {
            if (node instanceof MethodNode) {
                MethodNode origMethod = (MethodNode) node;
                ClassNode cNode = node.getDeclaringClass();
                ClassNode next = cNode;
                outer:
                while (next != null) {
                    Map genericsSpec = createGenericsSpec(next);
                    MethodNode mn = correctToGenericsSpec(genericsSpec, origMethod);
                    if (next != cNode) {
                        ClassNode correctedNext = correctToGenericsSpecRecurse(genericsSpec, next);
                        MethodNode found = getDeclaredMethodCorrected(genericsSpec, mn, correctedNext);
                        if (found != null) break;
                    }
                    List<ClassNode> ifaces = new ArrayList<ClassNode>();
                    ifaces.addAll(Arrays.asList(next.getInterfaces()));
                    Map updatedGenericsSpec = new HashMap(genericsSpec);
                    while (!ifaces.isEmpty()) {
                        ClassNode origInterface = ifaces.remove(0);
                        if (!origInterface.equals(ClassHelper.OBJECT_TYPE)) {
                            updatedGenericsSpec = createGenericsSpec(origInterface, updatedGenericsSpec);
                            ClassNode iNode = correctToGenericsSpecRecurse(updatedGenericsSpec, origInterface);
                            MethodNode found2 = getDeclaredMethodCorrected(updatedGenericsSpec, mn, iNode);
                            if (found2 != null) break outer;
                            ifaces.addAll(Arrays.asList(iNode.getInterfaces()));
                        }
                    }
                    ClassNode superClass = next.getUnresolvedSuperClass();
                    if (superClass!=null) {
                        next =  correctToGenericsSpecRecurse(updatedGenericsSpec, superClass);
                    } else {
                        next = null;
                    }
                }
                if (next == null) {
                    addError("Method '" + origMethod.getName() + "' from class '" + cNode.getName() + "' does not override " +
                            "method from its superclass or interfaces but is annotated with @Override.", visited);
                }
            }
        }
    }
564479
public com.groupon.odo.proxylib.models.Method getMethodForOverrideId(int overrideId) {
        com.groupon.odo.proxylib.models.Method method = null;

        // special case for IDs < 0
        if (overrideId < 0) {
            method = new com.groupon.odo.proxylib.models.Method();
            method.setId(overrideId);

            if (method.getId() == Constants.PLUGIN_RESPONSE_OVERRIDE_CUSTOM ||
                method.getId() == Constants.PLUGIN_RESPONSE_HEADER_OVERRIDE_ADD ||
                method.getId() == Constants.PLUGIN_RESPONSE_HEADER_OVERRIDE_REMOVE) {
                method.setMethodType(Constants.PLUGIN_TYPE_RESPONSE_OVERRIDE);
            } else {
                method.setMethodType(Constants.PLUGIN_TYPE_REQUEST_OVERRIDE);
            }
        } else {
            // get method information from the database
            PreparedStatement queryStatement = null;
            ResultSet results = null;
            try (Connection sqlConnection = sqlService.getConnection()) {
                queryStatement = sqlConnection.prepareStatement(
                    "SELECT * FROM " + Constants.DB_TABLE_OVERRIDE +
                        " WHERE " + Constants.GENERIC_ID + " = ?"
                );
                queryStatement.setInt(1, overrideId);
                results = queryStatement.executeQuery();

                if (results.next()) {
                    method = new com.groupon.odo.proxylib.models.Method();
                    method.setClassName(results.getString(Constants.OVERRIDE_CLASS_NAME));
                    method.setMethodName(results.getString(Constants.OVERRIDE_METHOD_NAME));
                }
            } catch (SQLException e) {
                e.printStackTrace();
                return null;
            } finally {
                try {
                    if (results != null) {
                        results.close();
                    }
                } catch (Exception e) {
                }
                try {
                    if (queryStatement != null) {
                        queryStatement.close();
                    }
                } catch (Exception e) {
                }
            }

            // if method is still null then just return
            if (method == null) {
                return method;
            }

            // now get the rest of the data from the plugin manager
            // this gets all of the actual method data
            try {
                method = PluginManager.getInstance().getMethod(method.getClassName(), method.getMethodName());
                method.setId(overrideId);
            } catch (Exception e) {
                // there was some problem.. return null
                return null;
            }
        }

        return method;
    }
491462
def set_override_chan(self, channel, value):
        ''''''
        self.override[channel] = value
        self.override_counter = 10
        self.send_rc_override()
366589
def augment_init_method(cls):
    

    orig_init = cls.__init__

    def new_init(self, *args, **kwargs):
        super(CustomGenerator, self).__init__()  # TODO: does this behave correctly with longer inheritance chains?

        orig_init(self, *args, **kwargs)

        self.orig_args = args
        self.orig_kwargs = kwargs

        self.ns_gen_templates = TohuNamespace()
        self.ns_gen_templates.update_from_dict(self.__class__.__dict__)
        self.ns_gen_templates.update_from_dict(self.__dict__)
        self.ns_gen_templates.set_owner(self.__class__)
        self._mark_field_generator_templates()

        self.ns_gens = self.ns_gen_templates.spawn()
        self.ns_gens.set_owner(self)

        self._update_namespace_with_field_generators()
        self._set_field_names()
        self._set_tohu_items_name()
        self._set_tohu_items_cls()

    cls.__init__ = new_init
494912
private void overrideUseArtifactoryGradlePlugin(T overrider, Class overriderClass) {
        if (overriderClass.getSimpleName().equals(ArtifactoryGradleConfigurator.class.getSimpleName())) {
            try {
                Field useArtifactoryGradlePluginField = overriderClass.getDeclaredField("useArtifactoryGradlePlugin");
                useArtifactoryGradlePluginField.setAccessible(true);
                Object useArtifactoryGradlePlugin = useArtifactoryGradlePluginField.get(overrider);

                if (useArtifactoryGradlePlugin == null) {
                    Field skipInjectInitScriptField = overriderClass.getDeclaredField("skipInjectInitScript");
                    skipInjectInitScriptField.setAccessible(true);
                    Object skipInjectInitScript = skipInjectInitScriptField.get(overrider);
                    if (skipInjectInitScript instanceof Boolean && skipInjectInitScript != null) {
                        useArtifactoryGradlePluginField.set(overrider, skipInjectInitScript);
                    }
                }
            } catch (NoSuchFieldException | IllegalAccessException e) {
                converterErrors.add(getConversionErrorMessage(overrider, e));
            }
        }
    }