Make a wiring from the wireFromBda to the wireToBda if the wireFromBda's classloader is the descendant of the wireToBda's classloader

@param wireFromBda
@param wireToBda
@param wireToBdaCL
@param wireFromBdaCL
166753
private void makeWiring(WebSphereBeanDeploymentArchive wireFromBda, WebSphereBeanDeploymentArchive wireToBda, ClassLoader wireToBdaCL, ClassLoader wireFromBdaCL) {
        while (wireFromBdaCL != null) {
            if (wireFromBdaCL == wireToBdaCL) {
                wireFromBda.addBeanDeploymentArchive(wireToBda);
                break;
            } else {
                wireFromBdaCL = wireFromBdaCL.getParent();
            }
        }
        //if we are here, it means the wireToBdaCL is root classloader, loading java.xx classes. All other bdas should be accessible to this new bda.
        if (wireFromBdaCL == wireToBdaCL) {
            wireFromBda.addBeanDeploymentArchive(wireToBda);
        }
    }
488854
@Override
    protected int readBytesWireFormat ( byte[] buffer, int bufferIndex ) throws SMBProtocolDecodingException {
        int start = bufferIndex;

        int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if ( structureSize != 9 ) {
            throw new SMBProtocolDecodingException("Expected structureSize = 9");
        }

        int bufferOffset = SMBUtil.readInt2(buffer, bufferIndex + 2) + getHeaderStart();
        bufferIndex += 4;
        int len = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        int elemStart = bufferOffset;
        FileNotifyInformationImpl i = new FileNotifyInformationImpl();
        bufferIndex += i.decode(buffer, bufferOffset, len);
        this.notifyInformation.add(i);

        while ( i.getNextEntryOffset() > 0 && bufferIndex < bufferOffset + len ) {
            bufferIndex = elemStart + i.getNextEntryOffset();
            elemStart = bufferIndex;

            i = new FileNotifyInformationImpl();
            bufferIndex += i.decode(buffer, bufferIndex, len);
            this.notifyInformation.add(i);
        }

        return bufferIndex - start;
    }
529527
public static void wireInSpring(Object o, String myBeanName) {
        // Lambda does not do this for you - though serverless does have a library to do it
        if (ctx == null) {
            synchronized (lck) {
                if (ctx == null) {
                    LOG.info("LamdaSpringUtil CTX is null -  initialising spring");
                    ctx = new ClassPathXmlApplicationContext(globalRootContextPath);
                }
            }
        } else {
            LOG.debug("LamdaSpringUtil CTX is not null - not initialising spring");
        }
        AutowireCapableBeanFactory factory = ctx.getAutowireCapableBeanFactory();
        factory.autowireBean(o);
        factory.initializeBean(0, myBeanName);
    }
1125938
public void createControlAdapter()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "createControlAdapter");

    // The type of control adapter created depends on the type of destination
    // that we're working with
    if(!destinationHandler.isLink())
    {
      XmitPoint rqm =
        (XmitPoint) destinationHandler.getRemoteQueuePointControl(getLocalizingMEUuid(), true);
      controlAdapter = new XmitPointControl(rqm,
                                            this,                                        
                                            destinationHandler); 
    }
    else
    { 
      // Use the StreamSet's Control Adapter for the "link remote queue points"
      controlAdapter = 
        new LinkRemoteQueuePoint(destinationHandler, this);
    }                                          
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "createControlAdapter", controlAdapter);
  }
592050
public static GatewayConfigTranslatorFactory newInstance(ClassLoader cl) {
        ServiceLoader<GatewayConfigTranslatorFactorySpi> services = load(GatewayConfigTranslatorFactorySpi.class, cl);
        return newInstance(services);
    }
1030927
@Override
    protected int readBytesWireFormat ( byte[] buffer, int bufferIndex ) throws SMBProtocolDecodingException {
        int start = bufferIndex;
        int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if ( structureSize != 17 ) {
            throw new SMBProtocolDecodingException("Expected structureSize = 17");
        }
        bufferIndex += 4;

        this.count = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        this.remaining = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        bufferIndex += 4; // WriteChannelInfoOffset/WriteChannelInfoLength
        return bufferIndex - start;
    }
1139508
@Override
	public int drainTo(Collection<? super E> c) {
		int i = queue.drainTo(c);
		if (i > 0){
			signalSizeReduced();
		}
		return i;
	}
1159466
function(wireConfig) {
	
		var klass = WireIt.wireClassFromXtype(wireConfig.xtype);
   
      var src = wireConfig.src;
      var tgt = wireConfig.tgt;
   
      var terminal1 = this.containers[src.moduleId].getTerminal(src.terminal);
      var terminal2 = this.containers[tgt.moduleId].getTerminal(tgt.terminal);
      var wire = new klass( terminal1, terminal2, this.el, wireConfig);
      wire.redraw();
   
      return wire;
   }
350107
private static synchronized void addTransformer() {
        if (detailedTransformTrace && tc.isEntryEnabled())
            Tr.entry(tc, "addTransformer");

        if (registeredTransformer == null && instrumentation != null) {
            registeredTransformer = new LibertyJava8WorkaroundRuntimeTransformer();
            instrumentation.addTransformer(registeredTransformer, false);
        }

        if (detailedTransformTrace && tc.isEntryEnabled())
            Tr.exit(tc, "addTransformer");
    }
96524
public static function assertWireType($wire, $type)
    {
        $expected = WireFormat::getWireType($type, $wire);

        if ($wire !== $expected) {
            throw new RuntimeException(sprintf(
                "Expected wire type %s but got %s for type %s.",
                $expected,
                $wire,
                $type
            ));
        }
    }
40845
public void init(ChannelFactoryData data) throws ChannelFactoryException {
        // Note, this call will throw an exception if any properties are invalid.
        new TCPFactoryConfiguration(data.getProperties());

        boolean asyncIOEnabled = ChannelFrameworkImpl.getRef().getAsyncIOEnabled();
        // see if an alternate Comm channel class was specified, if so load it
        commClassName = TCPFactoryConfiguration.getCommClass(asyncIOEnabled);
        if (commClassName != null) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Using comm class name [" + commClassName + "]");
            }
            boolean loaded = false;
            final ClassLoader cl = TCPChannelFactory.class.getClassLoader();
            if (cl != null) {
                try {
                    final String name = commClassName;
                    commClass = AccessController.doPrivileged(new PrivilegedExceptionAction<Class<?>>()
                    {
                        public Class<?> run() throws Exception
                    {
                        return cl.loadClass(name);
                    }
                    });
                    loaded = true;
                } catch (Exception e) {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                        Tr.debug(tc, "loadClass failed; " + e);
                    }
                    FFDCFilter.processException(e, getClass().getName() + ".init", "132", this);
                }
            }

            // try using the default loader, although that will probably fail also
            if (!loaded) {
                try {
                    final String name = commClassName;
                    commClass = AccessController.doPrivileged(new PrivilegedExceptionAction<Class<?>>()
                    {
                        public Class<?> run() throws Exception
                    {
                        return Class.forName(name);
                    }
                    });
                    loaded = true;
                } catch (Exception e) {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                        Tr.debug(tc, "Class.forName failed; " + e);
                    }
                    FFDCFilter.processException(e, getClass().getName() + ".init", "144", this);
                }
            }
        }
    }
16558
static void switchDollarSignPropsToBrackets(Node def, final AbstractCompiler compiler) {
    checkState(def.isObjectLit() || def.isClassMembers());
    for (Node keyNode : def.children()) {
      Node value = keyNode.getFirstChild();
      if (value != null && value.isFunction()) {
        NodeUtil.visitPostOrder(
            value.getLastChild(),
            new NodeUtil.Visitor() {
              @Override
              public void visit(Node n) {
                if (n.isString()
                    && n.getString().equals("$")
                    && n.getParent().isGetProp()
                    && n.getGrandparent().isGetProp()) {
                  Node dollarChildProp = n.getGrandparent();
                  dollarChildProp.setToken(Token.GETELEM);
                  compiler.reportChangeToEnclosingScope(dollarChildProp);
                }
              }
            });
      }
    }
  }
281173
public void lookupswitch(LookupList list) throws IOException
    {
        String def = createBranch();
        lookupswitch(def, list);
        fixAddress(def);
        anew(SwitchException.class);
        dup();
        invokeConstructor(SwitchException.class);
        athrow();
    }
634795
@Override
    protected void initializeProvider(InterceptorProvider provider, Bus bus) {
        super.initializeProvider(provider, bus);

        FlowIdProducerIn<Message> flowIdProducerIn = new FlowIdProducerIn<Message>();
        provider.getInInterceptors().add(flowIdProducerIn);
        provider.getInFaultInterceptors().add(flowIdProducerIn);

        FlowIdProducerOut<Message> flowIdProducerOut = new FlowIdProducerOut<Message>();
        provider.getOutInterceptors().add(flowIdProducerOut);
        provider.getOutFaultInterceptors().add(flowIdProducerOut);

        WireTapIn wireTapIn = new WireTapIn(logMessageContent, logMessageContentOverride);
        provider.getInInterceptors().add(wireTapIn);
        provider.getInInterceptors().add(epi);
        provider.getInFaultInterceptors().add(epi);

        WireTapOut wireTapOut = new WireTapOut(epi, logMessageContent, logMessageContentOverride);
        provider.getOutInterceptors().add(wireTapOut);
        provider.getOutFaultInterceptors().add(wireTapOut);

    }
1119685
public void pushClassLoader(BeanMetaData bmd)
    {
        ClassLoader classLoader = bmd.ivContextClassLoader; // F85059
        Object origCL = svThreadContextAccessor.pushContextClassLoaderForUnprivileged(classLoader);
        ivClassLoaderStack.push(origCL);

        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "pushClassLoader: " +
                         (origCL == ThreadContextAccessor.UNCHANGED ?
                                         "already " + Util.identity(classLoader) :
                                         Util.identity(origCL) + " -> " + Util.identity(classLoader)));
    }
1097125
@Override
    protected void initializeImpl()
    {
        //setup connection factory
        String className=this.getConfigurationValue(FaxClientSpiConfigurationConstants.CONNECTION_FACTORY_CLASS_NAME_PROPERTY_KEY);
        if(className==null)
        {
            className=HylaFAXClientConnectionFactoryImpl.class.getName();
        }
        this.connectionFactory=this.createHylaFAXClientConnectionFactory(className);
        if(this.connectionFactory==null)
        {
            throw new FaxException("HylaFAX connection factory is not available.");
        }
    }
753494
@Override
    public void elemAdd(MVec addend) {
        if (addend instanceof Tensor) {
            elemAdd((Tensor)addend);
        } else {
            throw new IllegalArgumentException("Addend must be of type " + this.getClass());
        }
    }