Adds a new crash to the container.
        If the crash appears to be already known, it's ignored.

        @see: L{Crash.key}

        @type  crash: L{Crash}
        @param crash: Crash object to add.
514110
def add(self, crash):
        
        if crash not in self:
            key  = crash.key()
            skey = self.marshall_key(key)
            data = self.marshall_value(crash, storeMemoryMap = True)
            self.__db[skey] = data
983810
def add(cache, strategy)
      c = cache.to_sym
      s = strategy.to_sym

      fail Exceptions::UnknownCachingStrategy, "Unknown caching strategy \":#{strategy}\" given. Did you register it in advance?"  unless caching_strategies.key?(strategy)

      caches[c] = caching_strategies[s].new
      caches[c]
    end
908320
def addFailure(self, test, err, capt=None, tbinfo=None):
        
        self.__insert_test_result(constants.State.FAILURE, test, err)
289051
synchronized void add(Write write) {
        Exceptions.checkNotClosed(this.closed, this);
        this.writes.addLast(write);
        this.totalLength += write.data.getLength();
        write.setQueueAddedTimestamp(this.timeSupplier.get());
    }
638646
public void add(String message, IOException cause) {
        causes.add(new IOException(message, cause));
    }
792983
def handle_crash(exception)
      # TODO: add meta info
      Internals::Logger.crash("Actor crashed!", exception)
      shutdown ExitEvent.new(behavior_proxy, exception)
    rescue => ex
      Internals::Logger.crash("Actor#handle_crash CRASHED!", ex)
    end
1262387
def crashlog_status(**kwargs):
    
    ctx = Context(**kwargs)
    ctx.execute_action('crashlog:status', **{
        'storage': ctx.repo.create_secure_service('storage'),
    })
1311713
def addExpectedFailure(self, test: unittest.case.TestCase, err: tuple) -> None:
        
        # noinspection PyTypeChecker
        self.add_result(TestState.expected_failure, test, err)
987989
public void add(E e) {
    // resize when needed
    if(size + 1 > queue.length) {
      resize(size + 1);
    }
    // final int pos = size;
    this.size += 1;
    heapifyUp(size - 1, e);
    heapModified();
  }
1238725
public void add(Counter<? extends Pair<T>> counter) {
        for (Map.Entry<? extends Pair<T>,Integer> e : counter) {
            count(e.getKey(), e.getValue());
        }
    }
675494
public void add(ObjectType type, boolean explicit) {
        int index = factory.getIndexOfType(type);
        if (!exceptionSet.get(index)) {
            ++size;
        }
        exceptionSet.set(index);
        if (explicit) {
            explicitSet.set(index);
        }

        commonSupertype = null;
    }
1244862
@Override
    public boolean add(BugInstance bugInstance) {
        return add(bugInstance,
                bugInstance.getFirstVersion() == 0L && bugInstance.getLastVersion() == 0L);
    }
766055
void add( K key, V value ) {
        List<V> rules = map.get( key );
        if( rules == null ) {
            rules = new ArrayList<>();
            map.put( key, rules );
        }
        rules.add( value );
    }
763146
public void add(T method)
    {
        // check for overridden method
        if (isOverrideMethod(method)) {
            return;
        }

        // Add to the list of managed methods
        _methods.put(method.getName() + method.getArgTypes(), method);

        // Ensure that all added methods have a unique index
        Object nameValue = _nameMap.get(method.getName());
        if (nameValue == null)
        {
            // first method with this name, considered unique (for now)
            _nameMap.put(method.getName(), method);
        }
        else
        {
            int nextIndex;
            if (nameValue instanceof AptMethod)
            {
                // 2nd method with this name, add index to original and start indexing
                ((AptMethod)nameValue).setIndex(0);
                nextIndex = 1;
            }
            else
            {
                // 3rd (or later) method with this name, continue indexing
                nextIndex = ((Integer)nameValue).intValue();
            }

            method.setIndex(nextIndex++);
            _nameMap.put(method.getName(), nextIndex);
        }
    }
124723
public void addError(Message message, boolean fatal) throws CompilationFailedException {
        if (fatal) {
            addFatalError(message);
        }
        else {
            addError(message);
        }
    }
244078
public boolean add(final K key, final S subcontainer, final V value) {
		final S curSubcontainer = this.subcontainerByKey.get(key);
		if (curSubcontainer == null) { // key does not exist
			if (this.mode == Mode.UPDATE)
				return false;

		} else { // key exists
			if (this.mode == Mode.CREATE)
				return false;

			if (subcontainer != curSubcontainer) {
				if (this.closed)
					throw new IllegalStateException(
							"MultiContainer put(" + key + ", " + value + ") in " + subcontainer);
				this.valueByKeyBySubcontainer.get(curSubcontainer).remove(key);
			}
		}


		if (subcontainer != curSubcontainer)
			this.subcontainerByKey.put(key, subcontainer);

		final Map<K, V> valueByKey = this.valueByKeyBySubcontainer.get(subcontainer);
		if (this.closed && !valueByKey.containsKey(key))
			throw new IllegalStateException(
					"MultiContainer put(" + key + ", " + value + ") in " + subcontainer);
		else if (this.debug && !valueByKey.containsKey(key))
			Logger.getLogger("debug").severe(
					"MultiContainer put(" + key + ", " + value + ") in " + subcontainer);

		valueByKey.put(key, value);
		return true;
	}
962905
public void addInstance(Object instance)
            throws Exception
    {
        if (isDestroyed()) {
            throw new IllegalStateException("System already stopped");
        }
        else {
            startInstance(instance);
            if (methodsMap.get(instance.getClass()).hasFor(PreDestroy.class)) {
                managedInstances.add(instance);
            }
        }
    }