Initialize this object.

@param tsc
@param link
@param vc
@param hcc
487040
public void init(TCPConnectionContext tsc, HttpOutboundLink link, VirtualConnection vc, HttpChannelConfig hcc) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Initializing OSC: " + this);
        }
        init(tsc, hcc);
        setBodyRC(HttpOSCBodyReadCallback.getRef());
        setLink(link);
        setVC(vc);
        getVC().getStateMap().put(CallbackIDs.CALLBACK_HTTPOSC, this);
    }
367221
public void addBcc(String bcc) {
        if (this.bcc.length() > 0) {
            this.bcc.append(",");
        }
        this.bcc.append(bcc);
    }
873068
@Override
    public void init(TCPWriteRequestContext x, H2MuxTCPWriteCallback c) {
        writeReqContext = x;
        muxCallback = c;

        // callback will need to know how to get back to this write queue.
        // This means one and only one H2WriteTree per H2InboundLink which has just one true TCP Channel facing write callback
        muxCallback.setH2WorkQ(this);

        tree = new Tree();

    }
14990
protected void init(MuxServer server, int channel)
        throws IOException
    {
        this.server = server;
        this.channel = channel;

        this.url = null;

        chunkLength = 0;
    }
882901
public static void setVCConnectionType(VirtualConnection vc, ConnectionType connType) {
        if (vc == null || connType == null) {
            return;
        }

        Map<Object, Object> map = vc.getStateMap();

        // Internal connections are both inbound and outbound (they're connections
        // to ourselves)
        // so while we prevent setting Outbound ConnTypes for inbound connections
        // and vice versa,
        // we don't prevent internal types from being set as either.
        if (vc instanceof InboundVirtualConnection && ConnectionType.isOutbound(connType.type)) {
            throw new IllegalStateException("Cannot set outbound ConnectionType on inbound VirtualConnection");
        } else if (vc instanceof OutboundVirtualConnection && ConnectionType.isInbound(connType.type)) {
            throw new IllegalStateException("Cannot set inbound ConnectionType on outbound VirtualConnection");
        }

        map.put(CONNECTION_TYPE_VC_KEY, connType);
    }
254721
public void init(String txn, TransactionConfig btc) {
        if (log.isLoggable(Level.FINE)) {
            log.fine("ProcessManager: initialise btxn '" + txn + "' config=" + btc
                    + " processors=" + btc.getProcessors().size());
        }

        if (btc.getProcessors() != null && !btc.getProcessors().isEmpty()) {
            List<ProcessorWrapper> procs = new ArrayList<ProcessorWrapper>();

            for (int i = 0; i < btc.getProcessors().size(); i++) {
                procs.add(new ProcessorWrapper(btc.getProcessors().get(i)));
            }

            synchronized (processors) {
                processors.put(txn, procs);
            }
        } else {
            synchronized (processors) {
                processors.remove(txn);
            }
        }
    }
967368
public void registerLink() throws SIResourceException
  { 
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "registerLink");
    // Tell TRM that the link exists 
    try
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
        SibTr.debug(tc, "Register MQLink: " + getUuid() + ", with mqLinkManager");       
      _mqLinkManager.define(getUuid());
    }
    catch (LinkException e)
    {
      //Error during create of the link.  Trace an FFST and exit
      FFDCFilter.processException(
        e,
        "com.ibm.ws.sib.processor.impl.MQLinkHandler.registerLink",
        "1:804:1.71",
        this);
  
      SibTr.exception(tc, e);
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
        SibTr.exit(tc, "registerLink", e);
      throw new SIResourceException(e);
    }

    //Register the link with TRM
    registerDestination();
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "registerLink");
  }
192291
public static void initialiseLinks(TraceCompletionInformation ci, long fragmentBaseTime, Node n,
            StringBuilder nodeId) {
        // Add Communication to represent a potential 'CausedBy' link from one or more fragments back to
        // this node
        TraceCompletionInformation.Communication c = new TraceCompletionInformation.Communication();

        c.getIds().add(nodeId.toString());

        // Define a a multi-consumer as potentially multiple CausedBy correlations may be created
        // back to this node
        c.setMultipleConsumers(true);

        // Calculate the base duration for the communication
        c.setBaseDuration(n.getTimestamp() - fragmentBaseTime);

        c.setExpire(System.currentTimeMillis()+
                TraceCompletionInformation.Communication.DEFAULT_EXPIRY_WINDOW_MILLIS);

        if (log.isLoggable(Level.FINEST)) {
            log.finest("Adding communication to completion information: ci=" + ci + " comms=" + c);
        }

        ci.getCommunications().add(c);

        if (n.getClass() == Producer.class) {
            // Get correlation ids
            List<CorrelationIdentifier> cids = n.findCorrelationIds(Scope.Interaction, Scope.ControlFlow);

            if (!cids.isEmpty()) {
                c = new TraceCompletionInformation.Communication();

                for (int i = 0; i < cids.size(); i++) {
                    c.getIds().add(cids.get(i).getValue());
                }

                c.setMultipleConsumers(((Producer) n).multipleConsumers());

                // Calculate the base duration for the communication
                c.setBaseDuration(n.getTimestamp() - fragmentBaseTime);

                c.setExpire(System.currentTimeMillis() +
                        TraceCompletionInformation.Communication.DEFAULT_EXPIRY_WINDOW_MILLIS);

                if (log.isLoggable(Level.FINEST)) {
                    log.finest("Adding communication to completion information: ci=" + ci + " comms=" + c);
                }

                ci.getCommunications().add(c);
            }
        } else if (n.containerNode()) {
            ContainerNode cn = (ContainerNode) n;
            for (int i = 0; i < cn.getNodes().size(); i++) {
                int len = nodeId.length();
                nodeId.append(':');
                nodeId.append(i);
                initialiseLinks(ci, fragmentBaseTime, cn.getNodes().get(i), nodeId);

                // Remove this child's specific path, so that next iteration will add a different path number
                nodeId.delete(len, nodeId.length());
            }
        }
    }
999924
private void initHeadTail(Node<E> h, Node<E> t) {
        if (h == t) {
            if (h == null)
                h = t = new Node<>(null);
            else {
                // Avoid edge case of a single Node with non-null item.
                Node<E> newNode = new Node<>(null);
                t.lazySetNext(newNode);
                newNode.lazySetPrev(t);
                t = newNode;
            }
        }
        head = h;
        tail = t;
    }
867799
public void init(String txn, TransactionConfig btc) {
        FilterProcessor fp = null;

        if (btc.getFilter() != null) {
            fp = new FilterProcessor(txn, btc);
        }

        synchronized (filterMap) {
            // Check if old filter processor needs to be removed
            FilterProcessor oldfp = filterMap.get(txn);
            if (oldfp != null) {
                globalExclusionFilters.remove(oldfp);
                btxnFilters.remove(oldfp);
            }

            if (fp != null) {
                // Add new filter processor
                filterMap.put(txn, fp);
                if (fp.isIncludeAll()) {
                    globalExclusionFilters.add(fp);
                } else {
                    btxnFilters.add(fp);
                }
            } else {
                filterMap.remove(txn);
            }
        }
    }
9934
public void error(VirtualConnection vc, Throwable t) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "error() called: " + vc);
        }
        // can't do anything with a null VC
        if (null == vc) {
            return;
        }
        Object o = vc.getStateMap().get(CallbackIDs.CALLBACK_HTTPICL);
        if (null == o) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "ERROR: null ICL in error()");
            }
            return;
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Error occurring while purging body: " + t);
        }
        // close the connection
        ((HttpInboundLink) o).close(vc, (Exception) t);
    }
991677
public static void init(String dirName, StoredProcedureFactory factory) {

		if (inited) {
			if (logger.isLoggable(Level.WARNING))
				logger.warning("discarding duplicated init request");
			return;
		}
		
		// Set the stored procedure factory
		spFactory = factory;

		/*
		 * Note: We read properties file here before, but we moved it to a
		 * utility class, PropertiesFetcher, for safety reason.
		 */

		// read classes
		queryPlannerCls = CoreProperties.getLoader().getPropertyAsClass(
				VanillaDb.class.getName() + ".QUERYPLANNER",
				HeuristicQueryPlanner.class, QueryPlanner.class);
		updatePlannerCls = CoreProperties.getLoader().getPropertyAsClass(
				VanillaDb.class.getName() + ".UPDATEPLANNER",
				IndexUpdatePlanner.class, UpdatePlanner.class);
		
		// initialize storage engine
		initFileAndLogMgr(dirName);
		initTaskMgr();
		initTxMgr();

		// the first transaction for initializing the system
		Transaction initTx = txMgr.newTransaction(
				Connection.TRANSACTION_SERIALIZABLE, false);

		/*
		 * initialize the catalog manager to ensure the recovery process can get
		 * the index info (required for index logical recovery)
		 */
		boolean isDbNew = fileMgr.isNew();
		initCatalogMgr(isDbNew, initTx);
		if (isDbNew) {
			if (logger.isLoggable(Level.INFO))
				logger.info("creating new database...");
		} else {
			if (logger.isLoggable(Level.INFO))
				logger.info("recovering existing database");
			// add a checkpoint record to limit rollback
			RecoveryMgr.initializeSystem(initTx);
		}

		// initialize the statistics manager to build the histogram
		initStatMgr(initTx);
		
		// create a checkpoint
		txMgr.createCheckpoint(initTx);

		// commit the initializing transaction
		initTx.commit();

		// initializing checkpointing task
		boolean doCheckpointing = CoreProperties.getLoader().getPropertyAsBoolean(
				VanillaDb.class.getName() + ".DO_CHECKPOINT", true);
		if (doCheckpointing)
			initCheckpointingTask();

		// finish initialization
		inited = true;
	}
77071
private void init(int initCapacity) {
        assert (initCapacity & -initCapacity) == initCapacity; // power of 2
        assert initCapacity >= MINIMUM_CAPACITY;
        assert initCapacity <= MAXIMUM_CAPACITY;

        threshold = (initCapacity * 3)/ 4;
        table = new long[2 * initCapacity];
    }
1150840
public void createMQLink(
    VirtualLinkDefinition vld, 
    MQLinkDefinition mqld,
    LocalizationDefinition ld) 
    throws SIIncorrectCallException, SIMPDestinationAlreadyExistsException, SIResourceException, SIException 
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "createMQLink", new Object[] {vld, mqld, ld});

    checkStarted();
    
    Set localizingMEs = vld.getLinkLocalitySet();
    destinationManager.createMQLinkLocalization(mqld, ld, vld, localizingMEs);
 
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "createMQLink");

    return;
  }
1027154
public void setIncomingLinks(int i, Title v) { 
    if (Descriptor_Type.featOkTst && ((Descriptor_Type)jcasType).casFeat_incomingLinks == null)
      jcasType.jcas.throwFeatMissing("incomingLinks", "de.julielab.jules.types.wikipedia.Descriptor");
    jcasType.jcas.checkArrayBounds(jcasType.ll_cas.ll_getRefValue(addr, ((Descriptor_Type)jcasType).casFeatCode_incomingLinks), i);
    jcasType.ll_cas.ll_setRefArrayValue(jcasType.ll_cas.ll_getRefValue(addr, ((Descriptor_Type)jcasType).casFeatCode_incomingLinks), i, jcasType.ll_cas.ll_getFSRef(v));}
10744
public void init(Record record, String strName, int iDataLength, String strDesc, Object strDefault)
    {
        m_recVendor = null;
        m_recProfile = null;
        VENDOR_CONTACT_TYPE_ID = "";
        PROFILE_CONTACT_TYPE_ID = "";
        super.init(record, strName, iDataLength, strDesc, strDefault);
    }
845396
def initCTR(self, iv=0):
        """"""
        assert struct.calcsize("Q") == self.blocksize()
        self.ctr_iv = iv
        self._calcCTRBUF()