Make a wire from the group of bdas to a set of destination bdas

@param wireFromBdas the wiring from bda
@param wireToBdas the wiring destination bda
4766
private void wireBdas(Collection<WebSphereBeanDeploymentArchive> wireFromBdas, Collection<WebSphereBeanDeploymentArchive> wireToBdas) {
        for (WebSphereBeanDeploymentArchive wireFromBda : wireFromBdas) {
            Collection<BeanDeploymentArchive> accessibleBdas = wireFromBda.getBeanDeploymentArchives();
            for (WebSphereBeanDeploymentArchive wireToBda : wireToBdas) {
                if ((wireToBda != wireFromBda) && ((accessibleBdas == null) || !accessibleBdas.contains(wireToBda))) {
                    wireFromBda.addBeanDeploymentArchive(wireToBda);
                }
            }
        }
    }
999888
@Override
    protected int writeBytesWireFormat ( byte[] dst, int dstIndex ) {
        int start = dstIndex;
        SMBUtil.writeInt2(33, dst, dstIndex);
        dst[ dstIndex + 2 ] = this.infoType;
        dst[ dstIndex + 3 ] = this.fileInfoClass;
        dstIndex += 4;

        int bufferLengthOffset = dstIndex;
        dstIndex += 4;
        int bufferOffsetOffset = dstIndex;
        dstIndex += 4;

        SMBUtil.writeInt4(this.additionalInformation, dst, dstIndex);
        dstIndex += 4;

        System.arraycopy(this.fileId, 0, dst, dstIndex, 16);
        dstIndex += 16;

        SMBUtil.writeInt2(dstIndex - getHeaderStart(), dst, bufferOffsetOffset);
        int len = this.info.encode(dst, dstIndex);
        SMBUtil.writeInt4(len, dst, bufferLengthOffset);
        dstIndex += len;
        return dstIndex - start;
    }
551482
def make_wire_commands(*ids):
  """"""
  cmd_to_wire = {
      cmd: sum(ord(c) << (i * 8) for i, c in enumerate(cmd)) for cmd in ids
  }
  wire_to_cmd = {wire: cmd for cmd, wire in six.iteritems(cmd_to_wire)}
  return cmd_to_wire, wire_to_cmd
683730
@Autowired(required = false)
    public void setDataExporters(Collection<IDataExporter<? extends Object>> dataExporters) {
        this.dataExporters = dataExporters;
    }
1081253
void connectTo(final Node<T> o) {
    if (!this.graph.equals(o.graph))
      throw new IllegalArgumentException("Cannot connect to nodes of two different graphs.");
    if (this.equals(o)) {
      return;
    }
    neighbours.add(o);
  }
1114128
public void makeCrossBoundaryWiring() throws CDIException {
        Collection<WebSphereBeanDeploymentArchive> sharedLibs = bdasByType.get(ArchiveType.SHARED_LIB);
        Collection<WebSphereBeanDeploymentArchive> earLibs = bdasByType.get(ArchiveType.EAR_LIB);
        Collection<WebSphereBeanDeploymentArchive> rarModules = bdasByType.get(ArchiveType.RAR_MODULE);
        Collection<WebSphereBeanDeploymentArchive> ejbModules = bdasByType.get(ArchiveType.EJB_MODULE);
        Collection<WebSphereBeanDeploymentArchive> warModules = bdasByType.get(ArchiveType.WEB_MODULE);
        Collection<WebSphereBeanDeploymentArchive> clientModules = bdasByType.get(ArchiveType.CLIENT_MODULE);
        Collection<WebSphereBeanDeploymentArchive> allAccessibleBdas = new HashSet<WebSphereBeanDeploymentArchive>();
        allAccessibleBdas.addAll(sharedLibs);
        allAccessibleBdas.addAll(earLibs);
        allAccessibleBdas.addAll(ejbModules);
        allAccessibleBdas.addAll(rarModules);

        wireBdas(earLibs, allAccessibleBdas);
        wireBdas(rarModules, allAccessibleBdas);
        wireBdas(ejbModules, allAccessibleBdas);
        wireBdas(warModules, allAccessibleBdas);
        wireBdas(clientModules, allAccessibleBdas);
        wireBdasBasedOnClassLoader(earLibs, warModules);
    }
569003
public void setDBSubnetGroups(java.util.Collection<DBSubnetGroup> dBSubnetGroups) {
        if (dBSubnetGroups == null) {
            this.dBSubnetGroups = null;
            return;
        }

        this.dBSubnetGroups = new java.util.ArrayList<DBSubnetGroup>(dBSubnetGroups);
    }
642861
@Autowired(required = false)
    public void setDataImporters(Collection<IDataImporter<? extends Object>> dataImporters) {
        this.dataImporters = dataImporters;
    }
271422
def _remove_wire_nets(block):
    

    wire_src_dict = _ProducerList()
    wire_removal_set = set()  # set of all wirevectors to be removed

    # one pass to build the map of value producers and
    # all of the nets and wires to be removed
    for net in block.logic:
        if net.op == 'w':
            wire_src_dict[net.dests[0]] = net.args[0]
            if not isinstance(net.dests[0], Output):
                wire_removal_set.add(net.dests[0])

    # second full pass to create the new logic without the wire nets
    new_logic = set()
    for net in block.logic:
        if net.op != 'w' or isinstance(net.dests[0], Output):
            new_args = tuple(wire_src_dict.find_producer(x) for x in net.args)
            new_net = LogicNet(net.op, net.op_param, new_args, net.dests)
            new_logic.add(new_net)

    # now update the block with the new logic and remove wirevectors
    block.logic = new_logic
    for dead_wirevector in wire_removal_set:
        del block.wirevector_by_name[dead_wirevector.name]
        block.wirevector_set.remove(dead_wirevector)

    block.sanity_check()
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);
    }
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;
   }
1102518
@Override
    public void transferInstruction(InstructionHandle handle, BasicBlock basicBlock, TypeQualifierValueSet fact)
            throws DataflowAnalysisException {
        if (!fact.isValid()) {
            return;
        }
        Location location = new Location(handle, basicBlock);

        Instruction i = handle.getInstruction();
        if (i instanceof InvokeInstruction) {
            InvokeInstruction ii = (InvokeInstruction) i;
            if (i instanceof INVOKEDYNAMIC) {
                return;
            }
            XMethod m = XFactory.createXMethod(ii, cpg);
            if (TypeQualifierDataflowAnalysis.isIdentifyFunctionForTypeQualifiers(m)) {
                ValueNumberFrame vnaFrameAtLocation = vnaDataflow.getFactAtLocation(location);
                ValueNumberFrame vnaFrameAfterInstruction = vnaDataflow.getFactAfterLocation(location);
                ValueNumber in = vnaFrameAtLocation.getStackValue(0);
                ValueNumber out = vnaFrameAfterInstruction.getStackValue(0);
                fact.copyInfo(in, out);
                return;
            }
        }

        // This is a simple process.
        // Check to see if there are any sources/sinks at this location,
        // and if so, model them.

        Set<SourceSinkInfo> sourceSinkSet = sourceSinkMap.get(location);
        if (sourceSinkSet != null) {
            if (DEBUG_VERBOSE) {
                System.out.println("Modeling source/sink at " + location.toCompactString() + ": " + sourceSinkSet.toString());
            }
            for (SourceSinkInfo sourceSinkInfo : sourceSinkSet) {
                fact.modelSourceSink(sourceSinkInfo);
            }
        }
    }
1130831
public void setDBInstances(java.util.Collection<DBInstance> dBInstances) {
        if (dBInstances == null) {
            this.dBInstances = null;
            return;
        }

        this.dBInstances = new java.util.ArrayList<DBInstance>(dBInstances);
    }
480278
public void setConditionalForwarderIpAddrs(java.util.Collection<String> conditionalForwarderIpAddrs) {
        if (conditionalForwarderIpAddrs == null) {
            this.conditionalForwarderIpAddrs = null;
            return;
        }

        this.conditionalForwarderIpAddrs = new com.amazonaws.internal.SdkInternalList<String>(conditionalForwarderIpAddrs);
    }
264340
public void setJobFlowIds(java.util.Collection<String> jobFlowIds) {
        if (jobFlowIds == null) {
            this.jobFlowIds = null;
            return;
        }

        this.jobFlowIds = new com.amazonaws.internal.SdkInternalList<String>(jobFlowIds);
    }
601605
public void setDataProviderOutputTransformers(Collection<Transformer> dataProviderOutputTransformers) {
        if (dataProviderOutputTransformers == null) {
            this.dataProviderOutputTransformers = null;
        } else {
            this.dataProviderOutputTransformers = new ArrayList<Transformer>();
            this.dataProviderOutputTransformers.addAll(dataProviderOutputTransformers);
        }
    }
1325300
void closeTransactionalBranch(Xid xid) {

        if (this.transactionBinding.getTransactionBindingType() != TransactionBindingType.GlobalTransaction) {
            throw new IllegalStateException("XAConnection not associated to a global transaction");
        }

        GlobalTransactionProxy<C> globalTransactionProxy = this.transactionBinding.getEnlistedGlobalTransaction();
        globalTransactionProxy.close();

        delistTransaction();
    }