/*
(non-Javadoc)
@see javax.slee.resource.ResourceAdaptor#raActive()
497944
public void raActive() {
		
		try {
			final Properties properties = prepareRaProperties();
			this.sipFactory = SipFactory.getInstance();
			this.sipFactory.setPathName("org.mobicents.ext");
			this.sipStack = (SipStackImpl) this.sipFactory.createSipStack(properties);
			this.sipStack.start();
			this.activityManagement = new LocalSipActivityManagement();

			if (tracer.isFineEnabled()) {
				tracer
						.fine("---> START "
								+ Arrays.toString(transports.toArray()));
			}
			boolean created = false;
			for (String trans : transports) {
				ListeningPoint lp = this.sipStack.createListeningPoint(
						this.stackAddress, this.port, trans);
				if (!created) {
					this.provider = this.sipStack.createSipProvider(lp);
					this.provider.addSipListener(this);
					created = true;
				} else
					this.provider.addListeningPoint(lp);
			}

			// LETS CREATE FP
			// SipFactory sipFactory = SipFactory.getInstance();
			AddressFactory addressFactory = sipFactory.createAddressFactory();
			HeaderFactory headerFactory = sipFactory.createHeaderFactory();
			MessageFactory messageFactory = sipFactory.createMessageFactory();

			this.providerWrapper.raActive(addressFactory, headerFactory, messageFactory, sipStack, provider);

		} catch (Throwable ex) {
			String msg = "error in initializing resource adaptor";
			tracer.severe(msg, ex);
			throw new RuntimeException(msg,ex);
		}

		if (tracer.isFineEnabled()) {
			tracer.fine("Sip Resource Adaptor entity active.");
		}
	}
406323
function action() {
    var self = Thng.resourceConstructor.call(this, this.id);
    return self.action.apply(self, arguments);
  }
427637
private function updateActive()
    {
        $this->each(function ($item) {
            if (isset($item->links)) {
                $this->makeActive($item);
            }
        });
    }
575421
public void raActive() {
        activities = new ConcurrentHashMap<HttpClientNIORequestActivityHandle, HttpClientNIORequestActivity>();
        try {
            if (httpClientFactory != null) {
                httpAsyncClient = httpClientFactory.newHttpAsyncClient();
            } else {
                httpAsyncClient = buildHttpAsyncClient();
            }

            // Can't be sure whether factory produced closeable client or some specialization of AbstractHttpAsyncClient
            if (httpAsyncClient instanceof CloseableHttpAsyncClient) {
                ((CloseableHttpAsyncClient) httpAsyncClient).start();
            }

            isActive = true;
            if (tracer.isInfoEnabled()) {
                tracer.info(String.format("HttpClientNIOResourceAdaptor=%s entity activated.",
                        this.resourceAdaptorContext.getEntityName()));
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
923652
@Override
    public void setActive(boolean active) {
        TreeModelEvent event = null;
        BugTreeModel.TreeModification whatToDo;

        if (active != this.active) {
            if (active == false) {
                this.active = active;
            }

            StackedFilterMatcher theSame = this;
            FilterMatcher[] filtersInStack = theSame.getFilters();
            ArrayList<Sortables> order = MainFrame.getInstance().getSorter().getOrder();
            int sizeToCheck = filtersInStack.length;
            if (order.contains(Sortables.DIVIDER)) {
                if (order.indexOf(Sortables.DIVIDER) < filtersInStack.length) {
                    sizeToCheck++;
                }
            }
            List<Sortables> sortablesToCheck = order.subList(0, Math.min(sizeToCheck, order.size()));
            Debug.println("Size to check" + sizeToCheck + " checking list" + sortablesToCheck);
            Debug.println("checking filters");
            ArrayList<String> almostPath = new ArrayList<>();
            ArrayList<Sortables> almostPathSortables = new ArrayList<>();
            for (int x = 0; x < sortablesToCheck.size(); x++) {
                Sortables s = sortablesToCheck.get(x);
                for (FilterMatcher fm : filtersInStack) {
                    if (s.equals(fm.getFilterBy())) {
                        almostPath.add(fm.getValue());
                        almostPathSortables.add(fm.getFilterBy());
                    }
                }
            }
            ArrayList<String> finalPath = new ArrayList<>();
            for (int x = 0; x < almostPath.size(); x++) {
                Sortables s = almostPathSortables.get(x);
                if (MainFrame.getInstance().getSorter().getOrderBeforeDivider().contains(s)) {
                    finalPath.add(almostPath.get(x));
                }
            }
            try {
                if (finalPath.size() == filtersInStack.length) {
                    if (active == true) {
                        event = (MainFrame.getInstance().getBugTreeModel()).removeBranch(finalPath);
                        whatToDo = BugTreeModel.TreeModification.REMOVE;
                    } else {
                        event = (MainFrame.getInstance().getBugTreeModel()).insertBranch(finalPath);
                        whatToDo = BugTreeModel.TreeModification.INSERT;
                    }
                } else {
                    event = (MainFrame.getInstance().getBugTreeModel()).restructureBranch(finalPath, active);// if
                    // active
                    // is
                    // true,
                    // this
                    // removes,
                    // if
                    // active
                    // if
                    // false,
                    // it
                    // inserts
                    if (active) {
                        whatToDo = BugTreeModel.TreeModification.REMOVERESTRUCTURE;
                    } else {
                        whatToDo = BugTreeModel.TreeModification.INSERTRESTRUCTURE;
                    }
                }

                if (active == true) {
                    this.active = active;
                }
                (MainFrame.getInstance().getBugTreeModel()).sendEvent(event, whatToDo);
            } catch (BranchOperationException e) {
                // Another filter already filters out the branch this filter
                // would filter out, set active, but don't send any tree model
                // events.
                this.active = active;
            }
        }

    }
468942
@Override
  public void channelActive(final ChannelHandlerContext ctx) throws Exception {
    controlSettings = dcpControl.getControls(getServerVersion(ctx.channel())).entrySet().iterator();
    negotiate(ctx);
  }
1130471
public ResourceActivity getBlockingActivity(ResourceActivity activity) {
        ResourceList res = activity.getResourceList();
        for (ResourceActivity a : inProgress)
            if(res.isCollidingWith(a.getResourceList()))
                return a;
        return null;
    }
951593
public function containersActive() {
    $ps = $this->taskDockerComposePs()
      ->file($this->dockerComposeFile)
      ->projectName($this->config->get('name'))
      ->setVerbosityThreshold(VerbosityThresholdInterface::VERBOSITY_DEBUG)
      ->printOutput(FALSE)
      ->run()
      ->getMessage();
    $this->say("$ps");
  }
559658
public void
setActive(int len) {
	if (len > array.length - pos) {
		throw new IllegalArgumentException("cannot set active " +
						   "region past end of input");
	}
	end = pos + len;
}
256660
public synchronized void activate() {

        synchronized (this.conditions) {
            IWatchedCondition cond = null;
            for (Iterator iterator = this.conditions.iterator(); iterator.hasNext(); ) {
                IObjectReference objRef = (IObjectReference) iterator.next();
                if (objRef.get() != null) {
                    cond = (IWatchedCondition) objRef.get();
                    cond.setActive(true);
                }
            }
        }
    }
374603
@Override
  public void onActive(Result<? super Boolean> result)
  {
    _stubClass.onActive(this, result);
    
    if (_container != null) {
      _container.onActive();
      
      _stubClass.onActive(_container);
    }
  }
38981
public static void setActive(boolean active) {
    if (active) System.setProperty(ACTIVATE_PROPERTY, "true");
    else System.clearProperty(ACTIVATE_PROPERTY);
    TimerTrace.active = active;
  }
163189
@CallSuper
    @Override
    protected void onInactive() {
        for (Map.Entry<LiveData<?>, Source<?>> source : mSources) {
            source.getValue().unplug();
        }
    }
1189156
public void setActive(boolean active) {
		if (active == this.active)
			return;

		this.active = active;
		if (rayHandler == null)
			return;
		
		if (active) {
			rayHandler.lightList.add(this);
			rayHandler.disabledLights.removeValue(this, true);
		} else {
			rayHandler.disabledLights.add(this);
			rayHandler.lightList.removeValue(this, true);
		}
	}
1226804
public void setActive(HostPort hp)
        throws UnknownHostException,
               ClientException,
               IOException {
        if (logger.isDebugEnabled()) {
            logger.debug("hostport: " + hp.getHost() + " " + hp.getPort());
        }
        session.serverMode = Session.SERVER_ACTIVE;
        this.remoteServerAddress = hp;
    }
927967
function set_network_active( $is_network_active = true, $is_delegated_connection = false ) {
            $this->_is_network_active       = $is_network_active;
            $this->_is_delegated_connection = $is_delegated_connection;
        }
211895
public boolean isActive() {

        if (!m_enabled) {
            return false;
        }
        long currentTime = System.currentTimeMillis();
        return ((currentTime > m_timeStart) && (currentTime < m_timeEnd));
    }