Register the provided class with the trace service and assign it to the
provided group name. Translated messages will attempt to use the input
message bundle source.

@param aClass
@param group
@param bundle
@return TraceComponent
558276
public static TraceComponent register(Class<?> aClass, String group, String bundle) {
        TraceComponent tc = new TraceComponent(aClass, group, bundle);
        com.ibm.websphere.ras.TrConfigurator.registerTraceComponent(tc);
        return tc;
    }
1078990
public <TMessage> void register(final Class<TMessage> msgMetaClass) {
    final String classId = getClassId(msgMetaClass);
    LOG.log(Level.INFO, "Registering message: {0}", classId);
    this.nameToSerializerMap.put(classId, SerializationFactory.createSerializer(msgMetaClass));
    this.nameToDeserializerMap.put(classId, SerializationFactory.createDeserializer(msgMetaClass));
  }
932276
public ComponentAdapter registerComponentInstance(Object componentKey, Object componentInstance) throws PicoRegistrationException {
		if (componentInstance instanceof MutablePicoContainer) {
			MutablePicoContainer pc = (MutablePicoContainer) componentInstance;
			Object contrivedKey = new Object();
			String contrivedComp = "";
			pc.registerComponentInstance(contrivedKey, contrivedComp);
			try {
				if (this.getComponentInstance(contrivedKey) != null) {
					throw new PicoRegistrationException("Cannot register a container to itself. The container is already implicitly registered.");
				}
			} finally {
				pc.unregisterComponent(contrivedKey);
			}

		}
		ComponentAdapter componentAdapter = new InstanceComponentAdapter(componentKey, componentInstance);
		registerComponent(componentAdapter);
		return componentAdapter;
	}
886819
protected void register(final Class<? extends Component<?>> interfaceClass, final Class<? extends Component<?>> implClass) {
        register(interfaceClass, implClass, PriorityLevel.Normal, 0);
    }
692678
public static <T> T getService(BundleContext bundleContext, Class<T> serviceClass) {
        T service = null;
        if (FrameworkState.isValid()) {
            ServiceReference<T> ref = bundleContext.getServiceReference(serviceClass);

            if (ref != null) {
                service = bundleContext.getService(ref);
            }
        }
        return service;
    }
368180
public static void xmlGlobalExistent(Class<?> aClass) {
		throw new XmlMappingGlobalExistException(MSG.INSTANCE.message(xmlMappingGlobalExistException, aClass.getSimpleName()));
	}
903667
public void start(BundleContext bc) throws Exception {
		bundleContext = bc;
		tracker = new ServiceTracker<>(bc,
				HttpService.class, this);
		tracker.open();
	}
1031964
public static <T> void bindArguments(T target, Bundle bundle) {
        @SuppressWarnings("unchecked")
        BundleBinding<T> binding = (BundleBinding<T>) getBundleBinding(target.getClass().getClassLoader(), target.getClass());
        if (binding != null) {
            binding.bindArguments(target, bundle);
        }
    }
767299
private void registerDefaultDelegationProvider(ComponentContext cc) {
        defaultDelegationProvider = new DefaultDelegationProvider();
        defaultDelegationProvider.setSecurityService(securityServiceRef.getService());
        defaultDelegationProvider.setIdentityStoreHandlerService(identityStoreHandlerServiceRef);
        BundleContext bc = cc.getBundleContext();
        Dictionary<String, Object> props = new Hashtable<String, Object>();
        props.put("type", "defaultProvider");
        defaultDelegationProviderReg = bc.registerService(DelegationProvider.class,
                                                          defaultDelegationProvider,
                                                          props);
    }
274405
public void register(BundleContext bndCtx) {
        final String methodName = "register()";
        final boolean trace = TraceComponent.isAnyTracingEnabled();
        if (trace && tc.isEntryEnabled())
            Tr.entry(tc, methodName, this);
        Hashtable<String, String> props = new Hashtable<String, String>();
        props.put("jmx.objectname", this.obn.toString());

        if (IS_DEBUGGING)
            // Extra Check: Does this MBean exist already?
            MBeanHelper.isMbeanExist(objectName.toString() + "*", className, methodName);

        // Register the MBean
        if (trace && tc.isDebugEnabled())
            Tr.debug(tc, "activateMBean started for " + this.obn.toString());
        this.reg = bndCtx.registerService(JCAConnectionFactoryMBeanImpl.class.getName(), this, props);
        if (trace && tc.isEntryEnabled())
            Tr.exit(tc, methodName, this);
    }
369795
public static synchronized void register(Class<?> clazz)
	{
		if (clazz.isAnnotationPresent(javax.ws.rs.ext.Provider.class))
		{
			classes.add(clazz);
			revision++;
		}
		else
		{
			throw new RuntimeException("Class " + clazz.getName() + " is not annotated with javax.ws.rs.ext.Provider");
		}
	}
943694
static void register(Class<? extends URLStreamHandler> handlerClass) {
    checkArgument("Handler".equals(handlerClass.getSimpleName()));

    String pkg = handlerClass.getPackage().getName();
    int lastDot = pkg.lastIndexOf('.');
    checkArgument(lastDot > 0, "package for Handler (%s) must have a parent package", pkg);

    String parentPackage = pkg.substring(0, lastDot);

    String packages = System.getProperty(JAVA_PROTOCOL_HANDLER_PACKAGES);
    if (packages == null) {
      packages = parentPackage;
    } else {
      packages += "|" + parentPackage;
    }
    System.setProperty(JAVA_PROTOCOL_HANDLER_PACKAGES, packages);
  }
1359557
@Override
    public final void addTransformer(ClassTransformer transformerClass) {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.entry(tc, "addTransformer: PUID = " + ivArchivePuId + ", transformer = " + transformerClass); //d454146
        }

        if (transformerClass != null) {
            JPAComponent jpaComp = getJPAComponent();
            if (jpaComp != null && jpaComp.getCaptureEnhancedEntityClassBytecode()) {
                transformerClass = new CapturingClassTransformer(transformerClass, ivApplInfo.getApplName(), jpaComp.getServerLogDirectory());
            }
        }

        ivTransformers.add(transformerClass);

        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.exit(tc, "addTransformer : # registered transfromer = " + ivTransformers.size());
        }
    }
1212585
public static AbstractWarningsParser getParser(@CheckForNull final String group) {
        if (StringUtils.isEmpty(group)) {
            return new NullWarnigsParser("NULL");
        }

        List<AbstractWarningsParser> parsers = ParserRegistry.getParsers(group);
        if (parsers.isEmpty()) {
            return new NullWarnigsParser(group);
        }
        else {
            return parsers.get(0);
        }
    }
213065
@Override
  public CommunicationGroupDriver newCommunicationGroup(final Class<? extends Name<String>> groupName,
                                                        final Class<? extends Topology> topologyClass,
                                                        final int numberOfTasks, final int customFanOut) {
    LOG.entering("GroupCommDriverImpl", "newCommunicationGroup",
        new Object[]{Utils.simpleName(groupName), numberOfTasks});

    final CommunicationGroupDriver commGroupDriver;
    try {
      commGroupDriver
          = commGroupDriverFactory.getNewInstance(groupName, topologyClass, numberOfTasks, customFanOut);
    } catch (final InjectionException e) {
      LOG.log(Level.WARNING, "Cannot inject new CommunicationGroupDriver");
      throw new RuntimeException(e);
    }

    commGroupDrivers.put(groupName, commGroupDriver);
    LOG.exiting("GroupCommDriverImpl", "newCommunicationGroup",
        "Created communication group: " + Utils.simpleName(groupName));
    return commGroupDriver;
  }
959169
@Override
    public IComponentGroupService newGroupService(ComponentGroupServiceDescriptor svcDescriptor)
            throws GroupsException {
        try {
            return new ReferenceIndividualGroupService(svcDescriptor);
        } catch (GroupsException ge) {
            log.error(ge.getMessage(), ge);
            throw new GroupsException(ge);
        }
    }
1167566
public void startBundle(Bundle bundle)
    {
        if (bundle != null)
            if ((bundle.getState() != Bundle.ACTIVE) && (bundle.getState() != Bundle.STARTING))
        {
            try {
                bundle.start();
            } catch (BundleException e) {
                e.printStackTrace();
            }
        }
    }