/*
(non-Javadoc)

@see
edu.umd.cs.findbugs.classfile.IAnalysisEngineRegistrar#registerWith(edu
.umd.cs.findbugs.classfile.IAnalysisCache)
169485
@Override
    public void registerAnalysisEngines(IAnalysisCache analysisCache) {
        for (IClassAnalysisEngine<?> engine : classAnalysisEngineList) {
            engine.registerWith(analysisCache);
        }
        for (IMethodAnalysisEngine<?> engine : methodAnalysisEngineList) {
            engine.registerWith(analysisCache);
        }
    }
1361511
static void register(final Object value) {
        synchronized (HashCodeBuilder.class) {
            if (getRegistry() == null) {
                REGISTRY.set(new HashSet<IDKey>());
            }
        }
        getRegistry().add(new IDKey(value));
    }
235195
public static ExtensionRegistry addToRegistry(final FileDescriptor file,
      final ExtensionRegistry registry) {
    for (final FieldDescriptor extension : file.getExtensions()) {
      addToRegistry(extension, registry);
    }

    for (final Descriptor descriptor : file.getMessageTypes()) {
      addToRegistry(descriptor, registry);
    }

    return registry;
  }
670055
public SerializerRegistry register(Class<?> type) {
    if (type == null)
      throw new NullPointerException("type cannot be null");
    return register(type, calculateTypeId(type));
  }
767605
public static void register(int id, Class<? extends Tag> tag) throws TagRegisterException {
        if(idToTag.containsKey(id)) {
            throw new TagRegisterException("Tag ID \"" + id + "\" is already in use.");
        }

        if(tagToId.containsKey(tag)) {
            throw new TagRegisterException("Tag \"" + tag.getSimpleName() + "\" is already registered.");
        }

        idToTag.put(id, tag);
        tagToId.put(tag, id);
    }
626550
public void registerClass(String name, byte[] bytes) {
	    
		if (registeredClasses.containsKey(name)) {
			throw new IllegalStateException("Attempted to register a class that has been registered already: " + name);
		}
		registeredClasses.put(name, bytes);
	}
1099150
public static void registerImplementation(Class<? extends ActionBarSherlock> implementationClass) {
        if (!implementationClass.isAnnotationPresent(Implementation.class)) {
            throw new IllegalArgumentException("Class " + implementationClass.getSimpleName() + " is not annotated with @Implementation");
        } else if (IMPLEMENTATIONS.containsValue(implementationClass)) {
            if (DEBUG) Log.w(TAG, "Class " + implementationClass.getSimpleName() + " already registered");
            return;
        }

        Implementation impl = implementationClass.getAnnotation(Implementation.class);
        if (DEBUG) Log.i(TAG, "Registering " + implementationClass.getSimpleName() + " with qualifier " + impl);
        IMPLEMENTATIONS.put(impl, implementationClass);
    }
263215
public synchronized void registerKey(DispatchableKey key)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "registerKey", key);
    keyRegistry.add(key);
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "registerKey");
  }
879381
private void register(PathMapping pathMapping) throws IOException {

		GeneratorRegistry generatorRegistry = bundlesHandler.getConfig().getGeneratorRegistry();
		List<PathMapping> mappings = new ArrayList<>();
		if (generatorRegistry.isPathGenerated(pathMapping.getPath())) {
			List<PathMapping> genPathMappings = generatorRegistry.getGeneratedPathMappings(pathMapping.getBundle(),
					pathMapping.getPath(), rsReader);
			if (genPathMappings != null) {
				mappings.addAll(genPathMappings);
			} else {
				mappings.add(pathMapping);
			}
		} else {
			mappings.add(pathMapping);
		}

		for (PathMapping pMapping : mappings) {
			String filePath = rsReader.getFilePath(pMapping.getPath());
			registerPathMapping(pMapping, filePath);
		}
	}
795075
private void registerWithMaster() throws IOException {
    BlockStoreMeta storeMeta = mBlockWorker.getStoreMetaFull();
    StorageTierAssoc storageTierAssoc = new WorkerStorageTierAssoc();
    List<ConfigProperty> configList =
        ConfigurationUtils.getConfiguration(ServerConfiguration.global(), Scope.WORKER);
    mMasterClient.register(mWorkerId.get(),
        storageTierAssoc.getOrderedStorageAliases(), storeMeta.getCapacityBytesOnTiers(),
        storeMeta.getUsedBytesOnTiers(), storeMeta.getBlockList(),
        storeMeta.getLostStorage(), configList);
  }
248985
public static void register(final ProteinModification modification) {
		if (modification==null) throw new IllegalArgumentException("modification == null!");

		lazyInit();

		String id = modification.getId();
		if (byId.containsKey(id)) {
			throw new IllegalArgumentException(id+" has already been registered.");
		}

		registry.add(modification);
		byId.put(id, modification);

		ModificationCategory cat = modification.getCategory();
		byCategory.get(cat).add(modification);

		ModificationOccurrenceType occType = modification.getOccurrenceType();
		byOccurrenceType.get(occType).add(modification);


		ModificationCondition condition = modification.getCondition();
		List<Component> comps = condition.getComponents();
		for (Component comp:comps) {
			Set<ProteinModification> mods = byComponent.get(comp);
			if (mods==null) {
				mods = new HashSet<ProteinModification>();
				byComponent.put(comp, mods);
			}
			mods.add(modification);
		}

		String pdbccId = modification.getPdbccId();
		if (pdbccId!=null) {
			Set<ProteinModification> mods = byPdbccId.get(pdbccId);
			if (mods==null) {
				mods = new HashSet<ProteinModification>();
				byPdbccId.put(pdbccId, mods);
			}
			mods.add(modification);
		}

		String residId = modification.getResidId();
		if (residId!=null) {
			Set<ProteinModification> mods = byResidId.get(residId);
			if (mods==null) {
				mods = new HashSet<ProteinModification>();
				byResidId.put(residId, mods);
			}
			mods.add(modification);
		}

		String psimodId = modification.getPsimodId();
		if (psimodId!=null) {
			Set<ProteinModification> mods = byPsimodId.get(psimodId);
			if (mods==null) {
				mods = new HashSet<ProteinModification>();
				byPsimodId.put(psimodId, mods);
			}
			mods.add(modification);
		}

		for (String keyword : modification.getKeywords()) {
			Set<ProteinModification> mods = byKeyword.get(keyword);
			if (mods==null) {
				mods = new HashSet<ProteinModification>();
				byKeyword.put(keyword, mods);
			}
			mods.add(modification);
		}
	}
1130416
public static void register(CollectorRegistry registry) {
    new StandardExports().register(registry);
    new MemoryPoolsExports().register(registry);
    new MemoryAllocationExports().register(registry);
    new BufferPoolsExports().register(registry);
    new GarbageCollectorExports().register(registry);
    new ThreadExports().register(registry);
    new ClassLoadingExports().register(registry);
    new VersionInfoExports().register(registry);
  }
93151
protected void registerKnownJdkImmutableClasses() {
        registerImmutable(String.class);
        registerImmutable(Integer.class);
        registerImmutable(Long.class);
        registerImmutable(Boolean.class);
        registerImmutable(Class.class);
        registerImmutable(Float.class);
        registerImmutable(Double.class);
        registerImmutable(Character.class);
        registerImmutable(Byte.class);
        registerImmutable(Short.class);
        registerImmutable(Void.class);

        registerImmutable(BigDecimal.class);
        registerImmutable(BigInteger.class);
        registerImmutable(URI.class);
        registerImmutable(URL.class);
        registerImmutable(UUID.class);
        registerImmutable(Pattern.class);
    }
931794
public void register(String table, String column, Class<?> javaType) {
        register(table, column, javaTypeMapping.getType(javaType));
    }
436213
public static <T,R> void register(Class<T> from, Class<R> to, Function<T,R> transform) {
        REGISTRY.register(from, to, transform);
    }
1143199
public final void register() {
        synchronized (this) {
            if (filterFactoryServiceRegistration != null) {
                throw new IllegalStateException(String.format("%s [%s] has been registered.", getClass()
                    .getSimpleName(), this));
            }
            filterFactoryServiceRegistration = bundleContext.registerService(SERVICE_CLASSES, this, properties);
            LOGGER.info("Registered filterFactory for application {} with priority {}", getApplicationName(),
                getPriority());
        }
    }
192518
public static void setRegisterWithVM(final boolean registerWithVM) {
    if (Converters.registerWithVM != registerWithVM) {
      Converters.registerWithVM = registerWithVM;

      // register all converters with the VM
      if (registerWithVM) {
        for (Entry<Class, Converter> entry : REGISTRY.entrySet()) {
          Class type = entry.getKey();
          Converter converter = entry.getValue();
          PropertyEditorManager.registerEditor(type, converter.getClass());
        }
      }
    }
  }