Initialize this object.

@param tsc
@param link
@param vc
@param hcc
429205
public void init(TCPConnectionContext tsc, ConnectionLink link, VirtualConnection vc, HttpChannelConfig hcc) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Initializing ISC: " + this);
        }
        super.init(tsc, hcc);
        setBodyRC(HttpISCBodyReadCallback.getRef());
        this.myLink = (HttpInboundLink) link;
        if (link instanceof H2HttpInboundLinkWrap) {
            super.setH2Connection(true);
            super.setPushPromise(((H2HttpInboundLinkWrap) link).isPushPromise());
        }
        setVC(vc);
        vc.getStateMap().put(CallbackIDs.CALLBACK_HTTPISC, this);
        // during discrimination, this is skipped so do it now
        getRequestImpl().initScheme();
    }
660688
@Override
    public void init()
    {
        this.log.debug("Initializing the linking uberspector.");
        // Create the array
        String[] arrayClassnames = this.runtime.getConfiguration().getStringArray(UBERSPECT_ARRAY_CLASSNAMES);
        this.uberspectors = new ArrayList<Uberspect>(arrayClassnames.length);
        for (String classname : arrayClassnames) {
            initializeUberspector(classname);
        }
        // If the chain is empty, use a SecureUberspector
        if (this.uberspectors.isEmpty()) {
            this.log.error("No uberspectors defined! "
                + "This uberspector is just a placeholder that relies on at least one real uberspector "
                + "to actually allow method calls. Using SecureUberspector instead as a fallback.");
            initializeUberspector(SecureUberspector.class.getCanonicalName());
        }
    }
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;
  }
294431
private void init(String svcUrl) {
		try {
			serviceUrl = new URL(svcUrl);
		} catch (MalformedURLException e) {
			throw new RuntimeException("It looks like the URL for remote NCBI BLAST service ("
									   + svcUrl + ") is wrong. Cause: " + e.getMessage(), e);
		}
	}
705668
public void init(BaseApplet baseApplet, RemoteSession remoteSession, String strDescription, String objID, String strRecordName)
    {
        m_baseApplet = baseApplet;
        m_remoteSession = remoteSession;
        m_strDescription = strDescription;
        m_objID = objID;
        m_strRecordName = strRecordName;
    }
453359
public void setLinked(boolean linked) {
        if (linked != this.linked) {
            this.linked = linked;
            
            if (!initializing) {
                internalDeserialize(true);
                getRoot().activate(true);
            }
        }
    }
670177
public void init(BaseMessageHeader messageHeader, Object data)
    {
        m_messageDataDesc = null;
        m_externalMessage = null;
        
        m_messageHeader = messageHeader;
        this.setData(data);
        m_bIsConsumed = false;
    }
595093
public void init (String nodeName, String sharedSecret, String hostName,
        String publicHostName, int port)
    {
        init(nodeName, sharedSecret, hostName, publicHostName, port, "");
    }
367221
public void addBcc(String bcc) {
        if (this.bcc.length() > 0) {
            this.bcc.append(",");
        }
        this.bcc.append(bcc);
    }
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));}
179342
@Override
  public final void initialize(FlowletContext ctx) throws Exception {
    super.initialize(ctx);
    portsAnnouncementList = Lists.newArrayList();
    DefaultInputFlowletConfigurer configurer = new DefaultInputFlowletConfigurer(this);
    create(configurer);
    InputFlowletSpecification spec = configurer.createInputFlowletSpec();

    dataIngestionPortsMap = Maps.newHashMap();
    int httpPort = 0;
    if (ctx.getRuntimeArguments().get(Constants.HTTP_PORT) != null) {
      httpPort = Integer.parseInt(ctx.getRuntimeArguments().get(Constants.HTTP_PORT));
    }
    dataIngestionPortsMap.put(Constants.HTTP_PORT, httpPort);
    for (String inputName : spec.getInputSchemas().keySet()) {
      int tcpPort = 0;
      if (ctx.getRuntimeArguments().get(Constants.TCP_INGESTION_PORT_PREFIX + inputName) != null) {
        tcpPort = Integer.parseInt(ctx.getRuntimeArguments().get(Constants.TCP_INGESTION_PORT_PREFIX + inputName));
      }
      dataIngestionPortsMap.put(Constants.TCP_INGESTION_PORT_PREFIX + inputName, tcpPort);
    }

    // Setup temporary directory structure
    tmpFolder = Files.createTempDir();
    File baseDir = new File(tmpFolder, "baseDir");
    baseDir.mkdirs();

    InputFlowletConfiguration inputFlowletConfiguration = new LocalInputFlowletConfiguration(baseDir, spec);
    File binDir = inputFlowletConfiguration.createStreamEngineProcesses();

    healthInspector = new HealthInspector(this);
    metricsRecorder = new MetricsRecorder(metrics);

    //Initiating AbstractInputFlowlet Components
    recordQueue = new GDATRecordQueue();

    //Initiating Netty TCP I/O ports
    inputFlowletService = new InputFlowletService(binDir, spec, healthInspector, metricsRecorder, recordQueue,
                                                  dataIngestionPortsMap, this);
    inputFlowletService.startAndWait();

    //Starting health monitor service
    healthInspector.startAndWait();

    //Initializing methodsDriver
    Map<String, StreamSchema> schemaMap = MetaInformationParser.getSchemaMap(new File(binDir.toURI()));
    methodsDriver = new MethodsDriver(this, schemaMap);

    //Initialize stopwatch and retry counter
    stopwatch = new Stopwatch();
    retryCounter = 0;
  }
606541
public void ready(VirtualConnection inVC) {
        // This should not be called because the TCPConnLink is always
        // ready since it is the first in the chain.
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(tc, "Invalid call to ready: " + inVC);
        }
    }
838894
@Override
    public void init(Vertx vertx, Context context) {
        super.init(vertx, context);

        try {
            // Create the real verticle and init
            realVerticle = createRealVerticle();
            realVerticle.init(vertx, context);

        } catch (Throwable t) {
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            }
            throw new RuntimeException(t);
        }
    }
1082747
public void init(String strQueueName, String strQueueType, Object source, Map<String,Object> properties)
    {
        m_messageReceiver = null;
        m_vListenerList = null;
        m_bCreateRemoteFilter = true;
        m_bUpdateRemoteFilter = true;
        m_bThinTarget = false;
        super.init(strQueueName, strQueueType, source, properties);
    }
844010
@Override
    public synchronized void initChain(String chainName) throws ChannelException, ChainException {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "initChain: " + chainName);
        }
        if (null == chainName) {
            throw new InvalidChainNameException("Null chain name");
        }

        // Find the chain in the framework configuration.
        ChainData chainData = chainDataMap.get(chainName);
        if (null == chainData) {
            InvalidChainNameException e = new InvalidChainNameException("Unable to init unknown chain, " + chainName);
            FFDCFilter.processException(e, getClass().getName() + ".initChain", "2142", this, new Object[] { chainName });
            throw e;

        }

        // Ensure we have an inbound chain.
        if (FlowType.OUTBOUND.equals(chainData.getType())) {
            throw new InvalidChainNameException("Outbound chain cannot use this interface.");
        }

        // Verify the chain isn't already in the runtime.
        Chain chain = getRunningChain(chainName);
        if (null != chain) {
            InvalidRuntimeStateException e = new InvalidRuntimeStateException("Chain cannot be initialized, its already in the runtime.");
            FFDCFilter.processException(e, getClass().getName() + ".initChain", "2158", this, new Object[] { chain });
            throw e;
        }

        initChainInternal(chainData);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "initChain");
        }
    }
510516
public void init(VirtualConnection inVC, HttpOutboundChannel channel) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Init on link: " + this + " " + inVC);
        }
        super.init(inVC);
        this.myChannel = channel;
        this.bIsActive = true;
        setEnableReconnect(this.myChannel.getHttpConfig().allowsRetries());
        setAllowReconnect(true);
    }
250250
def vcs_init(self):
        """"""
        VCS(os.path.join(self.outdir, self.name), self.pkg_data)