This is a Hook method for subclasses to override. Please keep it protected unless you know
what you are doing.
773076
protected void doPropagateAssertObject(InternalFactHandle factHandle,
                                           PropagationContext context,
                                           InternalWorkingMemory workingMemory,
                                           ObjectSink sink) {
        sink.assertObject( factHandle,
                           context,
                           workingMemory );
    }
944227
function hook(p, key) {
    var h = function h(e) {
      // update only when the argument is an Event object
      if (e && e instanceof Event) {
        // suppress updating on the inherit tag
        e.preventUpdate = true;
        // call original method
        p[key](e);
        // update automatically
        p.update();
      } else {
        p[key](e);
      }
    };
    h._inherited = true;
    return h;
  }
950913
public void overrideSetting(String name, float value) {
        overrides.put(name, Float.toString(value));
    }
66654
function () {
                if (this._overriddenClasses != null) {
                    for (var i in this._overriddenClasses) {
                        var clsInfos = this._overriddenClasses[i];

                        // restore the global classpath to point to the original
                        var ns = Aria.nspace(clsInfos.clsNs);
                        ns[clsInfos.clsName] = clsInfos.initialClass;

                        // also restore require cache
                        var initialClasspath = clsInfos.clsNs + "." + clsInfos.clsName;
                        var cacheKey = Aria.getLogicalPath(initialClasspath, ".js", true);
                        require.cache[cacheKey] = clsInfos.cachedModule;
                    }
                    this._overriddenClasses = null;
                }
            }
865339
def apply_overrides(request, omap):
        
        if omap:
            for k, v in omap.iteritems():
                o = request.GetElement('overrides').AppendElment()
                o.SetElement('fieldId', k)
                o.SetElement('value', v)
893092
def register(self, hook):
        
        assert callable(hook), \
            "Hook must be a callable"
        assert issubclass(hook, HookBase), \
            "The hook does not inherit from HookBase"

        self._registry.append(hook)
967948
def _override_cfg(container, yamlkeys, value):
    

    key = yamlkeys[0]
    rest = yamlkeys[1:]

    if len(rest) == 0:
        # no rest means we found the key to update.
        container[key] = value

    elif key in container:
        # still need to find the leaf in the tree, so recurse.
        _override_cfg(container[key], rest, value)

    else:
        # need to create a sub-tree down to the leaf to insert into.
        subtree = {}
        _override_cfg(subtree, rest, value)
        container[key] = subtree
278045
protected function loadOverrides()
    {
        if ($this->overrides === null) {
            $this->overrides = [];

            if ($this->overrideFile !== null) {
                $this->overrides = Craft::$app->getConfig()->getConfigFromFile($this->overrideFile);
            }
        }
    }
247423
public function setClasses($classes, $override = true)
    {
        foreach ($classes as $key => $class) {
            if ($override || !isset($this->_classes[$key])) {
                $this->_classes[$key] = $class;
            }
        }
    }
1225551
def accept_override(self):
        """"""
        conflicts = self.check_conflicts()
        if conflicts:
            for shortcut in conflicts:
                shortcut.key = ''
        self.accept()
119898
public void addOverrideMap(Map<String, String> overrideMap) {
    if (sealed) {
      throw new IllegalStateException("Instance is sealed.");
    }
    for (Map.Entry<String, String> entry : overrideMap.entrySet()) {
      try {
        ParameterOverrideInfo info = new ParameterOverrideInfo(entry.getKey());
        if (info.isOverrideSystemDefault()) {
          putMapIfNotExsits(overrideSystemDefaultMap, info.getParameterName(), entry.getValue());
        }
        else if (StringUtils.isNotEmpty(info.getConfigurationId()))  {
          Map<String, String> overrideForceScopeMapEntry = overrideForceScopeMap.get(info.getConfigurationId());
          if (overrideForceScopeMapEntry == null) {
            overrideForceScopeMapEntry = new HashMap<>();
            overrideForceScopeMap.put(info.getConfigurationId(), overrideForceScopeMapEntry);
          }
          putMapIfNotExsits(overrideForceScopeMapEntry, info.getParameterName(), entry.getValue());
          if (info.isLocked()) {
            Set<String> lockedParameterNamesScopeMapEntry = lockedParameterNamesScopeMap.get(info.getConfigurationId());
            if (lockedParameterNamesScopeMapEntry == null) {
              lockedParameterNamesScopeMapEntry = new HashSet<>();
              lockedParameterNamesScopeMap.put(info.getConfigurationId(), lockedParameterNamesScopeMapEntry);
            }
            putSetIfNotExsits(lockedParameterNamesScopeMapEntry, info.getParameterName());
          }
        }
        else {
          putMapIfNotExsits(overrideForceMap, info.getParameterName(), entry.getValue());
          if (info.isLocked()) {
            putSetIfNotExsits(lockedParameterNamesSet, info.getParameterName());
          }
        }
      }
      catch (IllegalArgumentException ex) {
        log.warn("Ignoring invalid parameter override definition:\n" + ex.getMessage());
      }
    }
  }
637508
private boolean overridesSuperclassMethod(JavaClass javaClass, Method method) {
        if (method.isStatic()) {
            return false;
        }

        try {
            JavaClass[] superclassList = javaClass.getSuperClasses();
            if (superclassList != null) {
                JavaClassAndMethod match = Hierarchy.findMethod(superclassList, method.getName(), method.getSignature(),
                        Hierarchy.INSTANCE_METHOD);
                if (match != null) {
                    return true;
                }
            }

            JavaClass[] interfaceList = javaClass.getAllInterfaces();
            if (interfaceList != null) {
                JavaClassAndMethod match = Hierarchy.findMethod(interfaceList, method.getName(), method.getSignature(),
                        Hierarchy.INSTANCE_METHOD);
                if (match != null) {
                    return true;
                }
            }

            return false;
        } catch (ClassNotFoundException e) {
            return true;
        }
    }
467850
private void visitOverride(AnnotatedNode node, AnnotationNode visited) {
        ClassNode annotationClassNode = visited.getClassNode();
        if (annotationClassNode.isResolved() && annotationClassNode.getName().equals("java.lang.Override")) {
            if (node instanceof MethodNode && !Boolean.TRUE.equals(node.getNodeMetaData(Verifier.DEFAULT_PARAMETER_GENERATED))) {
                boolean override = false;
                MethodNode origMethod = (MethodNode) node;
                ClassNode cNode = origMethod.getDeclaringClass();
                if (origMethod.hasDefaultValue()) {
                    List<MethodNode> variants = cNode.getDeclaredMethods(origMethod.getName());
                    for (MethodNode m : variants) {
                        if (m.getAnnotations().contains(visited) && isOverrideMethod(m)) {
                            override = true;
                            break;
                        }
                    }
                } else {
                    override = isOverrideMethod(origMethod);
                }

                if (!override) {
                    addError("Method '" + origMethod.getName() + "' from class '" + cNode.getName() + "' does not override " +
                            "method from its superclass or interfaces but is annotated with @Override.", visited);
                }
            }
        }
    }
246431
def apply_inheritance(self):
        
        super(Services, self).apply_inheritance()

        # add_item only ensure we can build a key for services later (after explode)
        for item in list(self.items.values()):
            self.add_item(item, False)
275620
private void overrideDeployerDetails(T overrider, Class overriderClass) {
        if (overrider instanceof DeployerOverrider) {
            try {
                Field deployerDetailsField = overriderClass.getDeclaredField("deployerDetails");
                deployerDetailsField.setAccessible(true);
                Object deployerDetails = deployerDetailsField.get(overrider);

                if (deployerDetails == null) {
                    Field oldDeployerDetailsField = overriderClass.getDeclaredField("details");
                    oldDeployerDetailsField.setAccessible(true);
                    Object oldDeployerDetails = oldDeployerDetailsField.get(overrider);
                    if (oldDeployerDetails != null) {
                        ServerDetails deployerServerDetails = createInitialDeployDetailsFromOldDeployDetails((ServerDetails) oldDeployerDetails);
                        deployerDetailsField.set(overrider, deployerServerDetails);
                    }
                }
            } catch (NoSuchFieldException | IllegalAccessException e) {
                converterErrors.add(getConversionErrorMessage(overrider, e));
            }
        }
    }
206384
private static <T> T overrideOf(Class<T> clazz, Class<?> targetType, Annotation annotation) {
        try {
            if (annotation != null) {
                try {
                    return clazz.getConstructor(Class.class, annotation.annotationType()).newInstance(targetType, annotation);
                } catch (final NoSuchMethodException no) {}
            }
            try {
                return clazz.getConstructor(Class.class).newInstance(targetType);
            } catch (final NoSuchMethodException no) {}
            return clazz.newInstance();
        } catch (final Exception e) {
            throw new DynamoDBMappingException("could not instantiate " + clazz, e);
        }
    }
279719
def set(self, **kwargs):
        '''
        
        '''
        for lower_key, value in kwargs.items():
            if lower_key.lower() != lower_key:
                raise ValueError('Requires lowercase: %s' % lower_key)
            key = lower_key.upper()
            try:
                getattr(self, key)
            except (AttributeError, ConfigurationError):
                raise AttributeError('Cannot override %s' % key)
            self.overridden_settings[key] = value