Overrides superclass.
421871
def _start_event_client(self):
        """"""
        event_client = SnippetClient(package=self.package, ad=self._ad)
        event_client.host_port = self.host_port
        event_client.device_port = self.device_port
        event_client.connect(self.uid,
                             jsonrpc_client_base.JsonRpcCommand.CONTINUE)
        return event_client
1276348
def inherited(subclass)
      subclass._arguments = []
      subclass._description = ''
      subclass._abstract = false
      subclass._skip_options = false
      subclass._exe_name = @_exe_name
      subclass._default_priority = @_default_priority.to_f / 2
      subclass._priority = 0
      super
    end
733873
function(name, func, superPrototype) {
		return function PseudoClass_setStaticSuper() {
			// Store the old super
			var previousSuper = this._super;

			// Use the method from the superclass' prototype
			// This strategy allows monkey patching (modification of superclass prototypes)
			this._super = superPrototype[name];

			// Call the actual function
			var ret = func.apply(this, arguments);

			// Restore the previous value of super
			// This is required so that calls to methods that use _super within methods that use _super work
			this._super = previousSuper;

			return ret;
		};
	}
8963
function() {
        if (!this._eAllSuperTypes) {
            var compute = function(eClass) {
                var superTypes = eClass.get('eSuperTypes').array(),
                    eAllSuperTypes = _.flatten(_.map(superTypes, function(s) {
                        return s.get('eAllSuperTypes');
                    }));

                return _.union(eAllSuperTypes, superTypes);
            };

            this.on('add:eSuperTypes remove:eSuperTypes', function() {
                this._eAllSuperTypes = compute(this);
            }, this);

            this._eAllSuperTypes = compute(this);
        }

        return this._eAllSuperTypes;
    }
735944
def dispatch(self, *args, **kwargs):
        """"""
        return super(AnimalUpdate, self).dispatch(*args, **kwargs)
520355
private static void applyOverrides() {
        // Get the appropriate InputStream to read overrides from, if any.
        InputStream stream = getContentTypesPropertiesStream();
        if (stream == null) {
            return;
        }

        try {
            try {
                // Read the properties file...
                Properties overrides = new Properties();
                overrides.load(stream);
                // And translate its mapping to ours...
                for (Map.Entry<Object, Object> entry : overrides.entrySet()) {
                    String extension = (String) entry.getKey();
                    String mimeType = (String) entry.getValue();
                    add(mimeType, extension);
                }
            } finally {
                stream.close();
            }
        } catch (IOException ignored) {
        }
    }
1225551
def accept_override(self):
        """"""
        conflicts = self.check_conflicts()
        if conflicts:
            for shortcut in conflicts:
                shortcut.key = ''
        self.accept()
721034
@Nonnull
  @CodingStyleguideUnaware
  public JSDefinedClass _extends (@Nonnull final AbstractJSClass aSuperClass)
  {
    m_aSuperClass = ValueEnforcer.notNull (aSuperClass, "SuperClass");
    return this;
  }
155855
public void overrideCubeProperties(DockerCompositions overrideDockerCompositions) {
        final Set<String> containerIds = overrideDockerCompositions.getContainerIds();
        for (String containerId : containerIds) {

            // main definition of containers contains a container that must be overrode
            if (containers.containsKey(containerId)) {
                final CubeContainer cubeContainer = containers.get(containerId);
                final CubeContainer overrideCubeContainer = overrideDockerCompositions.get(containerId);

                cubeContainer.setRemoveVolumes(overrideCubeContainer.getRemoveVolumes());
                
                cubeContainer.setAlwaysPull(overrideCubeContainer.getAlwaysPull());

                if (overrideCubeContainer.hasAwait()) {
                    cubeContainer.setAwait(overrideCubeContainer.getAwait());
                }

                if (overrideCubeContainer.hasBeforeStop()) {
                    cubeContainer.setBeforeStop(overrideCubeContainer.getBeforeStop());
                }

                if (overrideCubeContainer.isManual()) {
                    cubeContainer.setManual(overrideCubeContainer.isManual());
                }

                if (overrideCubeContainer.isKillContainer()) {
                    cubeContainer.setKillContainer(overrideCubeContainer.isKillContainer());
                }
            } else {
                logger.warning(String.format("Overriding Container %s are not defined in main definition of containers.",
                    containerId));
            }
        }
    }
383632
function inherits(ctor, sctor) {
		ctor.prototype = Object.create(sctor.prototype);
		ctor._super = sctor;
	}
508315
private static void checkedSetSuperClassDesc(ObjectStreamClass desc,
            ObjectStreamClass superDesc) throws StreamCorruptedException {
        if (desc.equals(superDesc)) {
            throw new StreamCorruptedException();
        }
        desc.setSuperclass(superDesc);
    }
1057355
def override(klass):
    

    namespace = klass.__module__.rsplit(".", 1)[-1]
    mod_name = const.PREFIX[-1] + "." + namespace
    module = sys.modules[mod_name]

    if isinstance(klass, types.FunctionType):
        def wrap(wrapped):
            setattr(module, klass.__name__, wrapped)
            return wrapped
        return wrap

    old_klass = klass.__mro__[1]
    name = old_klass.__name__
    klass.__name__ = name
    klass.__module__ = old_klass.__module__

    setattr(module, name, klass)

    return klass
647508
private void addSuperClass(Object object, Class<?> type)
    {
        for (final Class<?> types : type.getInterfaces())
        {
            addType(types, object);
        }
        final Class<?> parent = type.getSuperclass();
        if (parent != null)
        {
            addSuperClass(object, parent);
        }
    }
1288471
def super_mro(self):
        """"""
        if not isinstance(self.mro_pointer, scoped_nodes.ClassDef):
            raise exceptions.SuperError(
                "The first argument to super must be a subtype of "
                "type, not {mro_pointer}.",
                super_=self,
            )

        if isinstance(self.type, scoped_nodes.ClassDef):
            # `super(type, type)`, most likely in a class method.
            self._class_based = True
            mro_type = self.type
        else:
            mro_type = getattr(self.type, "_proxied", None)
            if not isinstance(mro_type, (bases.Instance, scoped_nodes.ClassDef)):
                raise exceptions.SuperError(
                    "The second argument to super must be an "
                    "instance or subtype of type, not {type}.",
                    super_=self,
                )

        if not mro_type.newstyle:
            raise exceptions.SuperError(
                "Unable to call super on old-style classes.", super_=self
            )

        mro = mro_type.mro()
        if self.mro_pointer not in mro:
            raise exceptions.SuperError(
                "The second argument to super must be an "
                "instance or subtype of type, not {type}.",
                super_=self,
            )

        index = mro.index(self.mro_pointer)
        return mro[index + 1 :]
149907
function() {
    this._super();

    if (!this._options.implicit) {
      this.removeOverride('<plural>');
      this.removeOverride('<singular>Objects');
      this.removeOverride('add<Singular>');
      this.removeOverride('add<Plural>');
      this.removeOverride('remove<Singular>');
      this.removeOverride('remove<Plural>');
      this.removeOverride('clear<Plural>');

      this.overrideProperty('<singular>', 'item', 'set');
      this.addHelper('get<Singular>', 'item');
      this.addHelper('set<Singular>', 'set');
      this.addHelper('fetch<Singular>', 'fetch');
    }
  }
1086007
public void associateSuperDef(ZooClassDef superDef) {
		if (this.superDef != null) {
			throw new IllegalStateException();
		}

		if (superDef == null) {
			throw new IllegalArgumentException();
		}
		
		//class invariant
		if (superDef.getOid() != oidSuper) {
			throw new IllegalStateException("s-oid= " + oidSuper + " / " + superDef.getOid() + 
					"  class=" + className);
		}
		
		this.superDef = superDef;
	}
1324151
def _subclass(self, parser):
        '''
         
        '''
        _set(self, '_sub', parser._create(memoryview(getattr(self, '_extra', b'')), self._target))
        try:
            object.__delattr__(self, '_extra')
        except:
            pass