add a {@link Historizable} instance to the list identified by historizable.getName()

@param historizable the historizable to add
333798
public void addHistorizable(Historizable historizable) {
    getCorePlugin().addHistorizable(keyHandler.handle(historizable.getName()), historizable);
  }
639250
public void add(ServiceReference<S> declarationBinderRef) throws InvalidFilterException {
        BinderDescriptor binderDescriptor = new BinderDescriptor(declarationBinderRef);
        declarationBinders.put(declarationBinderRef, binderDescriptor);
    }
688645
private void initializeHistoryEventHandlers(final List<HistoryEventHandler> historyEventHandlers) {
    EnsureUtil.ensureNotNull("History event handler", historyEventHandlers);
    for (HistoryEventHandler historyEventHandler : historyEventHandlers) {
      EnsureUtil.ensureNotNull("History event handler", historyEventHandler);
      this.historyEventHandlers.add(historyEventHandler);
    }
  }
175879
@Override
    public T addClass(String fullyQualifiedClassName) throws IllegalArgumentException {
        Validate.notNullOrEmpty(fullyQualifiedClassName, "Fully-qualified class name must be specified");

        // Get this archive's CLs
        Iterable<ClassLoader> cls = getArchiveClassLoaders();
        assert cls != null : "CLs of this archive is not specified:" + this.getArchive();

        // Find the class in the configured CLs
        final Class<?> classToAdd;
        try {
            classToAdd = ClassLoaderSearchUtilDelegator.findClassFromClassLoaders(fullyQualifiedClassName, cls);
        } catch (final ClassNotFoundException cnfe) {
            throw new IllegalArgumentException("Could not find the requested Class " + fullyQualifiedClassName
                + " in any of the configured ClassLoaders for this archive", cnfe);
        }

        // Add
        return addClass(classToAdd);
    }
1373212
public void registerStatus(MtasSolrStatus item) throws IOException {
    history.add(item);
    running.add(item);
  }
925206
@Override
	public List<RecordTag> getTagsForHistoryID (long historyId) throws DatabaseException {
    	SqlPreparedStatementWrapper psGetTagsForHistoryId = null;
        try {
        	psGetTagsForHistoryId = DbSQL.getSingleton().getPreparedStatement("tag.ps.gettagsforhid");
			List<RecordTag> result = new ArrayList<>();
			psGetTagsForHistoryId.getPs().setLong(1, historyId);
			try (ResultSet rs = psGetTagsForHistoryId.getPs().executeQuery()) {
				while (rs.next()) {
					result.add(new RecordTag(rs.getLong(TAGID), rs.getLong(TAGID), rs.getString(TAG)));
				}
			}
			
			return result;
		} catch (SQLException e) {
			throw new DatabaseException(e);
		} finally {
			DbSQL.getSingleton().releasePreparedStatement(psGetTagsForHistoryId);
		}
    }
101175
void addFieldInfo(String className, List<FieldInfo> fieldInfoList) {
        if (ivFieldInfoMap == null) {
            ivFieldInfoMap = new HashMap<String, List<FieldInfo>>();
        }
        ivFieldInfoMap.put(className, fieldInfoList);
    }
420986
public final void addInjectionBinding(InjectionBinding<A> injectionBinding)
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isDebugEnabled())
            Tr.debug(tc, "addInjectionBinding: " + injectionBinding);

        // jndi name not found in collection, simple add
        ivAllAnnotationsCollection.put(injectionBinding.getJndiName(), injectionBinding);
    }
764442
protected void addSerializableClass(Class<?> serializable) {
        safeMapper.addMixIn(serializable, UseToStringAsValueMixIn.class);
        fullMapper.addMixIn(serializable, UseToStringAsValueMixIn.class);
    }
1027613
public void setAttribute(String id, Object obj, boolean save) {
        if (save) {
            String historyAttribute = id + "history";
            Queue<Object> history = (Queue<Object>) getAttribute(historyAttribute);
            if (history == null) {
                history = new LinkedList<>();
                setAttribute(historyAttribute, history);
            }
            if (this.getAttribute(id) != null) {
                history.add(getAttribute(id));
            }
        }
        setAttribute(id, obj);
    }
419646
public void add(String name, Iterable<?> value) {
		if (value != null) {
			this.content.put(name, value);
		}
	}
811869
protected List<Entry> getList (Name username)
    {
        if (username instanceof KeepNoHistory) {
            return null;
        }
        List<Entry> history = _histories.get(username);
        if (history == null) {
            _histories.put(username, history = Lists.newArrayList());
        }
        return history;
    }
154277
@Override
    public T addAsLibraries(Archive<?>... archives) throws IllegalArgumentException {
        Validate.notNull(archives, "Archives must be specified");
        for (final Archive<?> archive : archives) {
            addAsLibrary(archive);
        }
        return covarientReturn();
    }
551670
@Override
  public void updateModifiableFieldsFromEntity(CaseDefinitionEntity updatingCaseDefinition) {
    if (this.key.equals(updatingCaseDefinition.key) && this.deploymentId.equals(updatingCaseDefinition.deploymentId)) {
      this.revision = updatingCaseDefinition.revision;
      this.historyTimeToLive = updatingCaseDefinition.historyTimeToLive;
    }
    else {
      LOG.logUpdateUnrelatedCaseDefinitionEntity(this.key, updatingCaseDefinition.key, this.deploymentId, updatingCaseDefinition.deploymentId);
    }
  }
806772
public History[] refreshHistory(int limit, int offset) throws Exception {
        BasicNameValuePair[] params = {
            new BasicNameValuePair("limit", String.valueOf(limit)),
            new BasicNameValuePair("offset", String.valueOf(offset))
        };
        return constructHistory(params);
    }
1021395
public void addPTable(PTable physicalTable)
    {
        Object strKey = physicalTable.getLookupKey();
        m_htTableList.put(strKey, physicalTable);
        this.getPDatabaseParent().addTableToCache(physicalTable);   // If cache is on
    }
477480
public void setNote(String note) {
       try {
           staticTableHistory.updateNote(historyId, note);
           httpMessageCachedData.setNote(note != null && note.length() > 0);
           notifyEvent(HistoryReferenceEventPublisher.EVENT_NOTE_SET);
       } catch (DatabaseException e) {
           log.error(e.getMessage(), e);
       }
       
   }