/* (non-Javadoc)
@see com.ibm.ws.sib.processor.impl.interfaces.DestinationHandler#isPubSub()
519030
public boolean isPubSub()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "isPubSub");
      
    boolean isPubSub = (getDestinationType() == DestinationType.TOPICSPACE);
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "isPubSub", new Boolean(isPubSub));

    return isPubSub;
  }
66097
public SIMPPubSubOutboundTransmitControllable getPubSubOutboundTransmitControllable()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getPubSubOutboundTransmitControllable");
    
    SIMPPubSubOutboundTransmitControllable outbound = null;
    //there will only be a stream set if the PSOH is not null
    if(_outputHandler!=null)
    {
      //at the moment there should be just one stream set in the
      //iterator
      SIMPIterator iterator = getPubSubOutboundTransmitIterator();
      if(iterator.hasNext())
      {
        outbound = (SIMPPubSubOutboundTransmitControllable)iterator.next();
      }
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "getPubSubOutboundTransmitControllable", outbound);
    return outbound;
  }
1184592
@Override
    public PubSubOutputHandler getPubSubOutputHandler(SIBUuid8 neighbourUUID)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "getPubSubOutputHandler", neighbourUUID);

        PubSubOutputHandler handler =
                        _pubSubRealization.getPubSubOutputHandler(neighbourUUID);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "getPubSubOutputHandler", handler);

        return handler;
    }
992051
public Boolean isSubscribed(String channel) {
		Boolean result = null;

		/*
		 * Sanity checks
		 */
		if (!isConnected) {
			raiseOrtcEvent(EventEnum.OnException, this,
					new OrtcNotConnectedException());
		} else if (Strings.isNullOrEmpty(channel)) {
			raiseOrtcEvent(EventEnum.OnException, this,
					new OrtcEmptyFieldException("Channel"));
		} else if (!Strings.ortcIsValidInput(channel)) {
			raiseOrtcEvent(EventEnum.OnException, this,
					new OrtcInvalidCharactersException("Channel"));
		} else {
			ChannelSubscription subscribedChannel = subscribedChannels
					.get(channel);
			result = subscribedChannel != null
					&& subscribedChannel.isSubscribed();
		}

		return result;
	}
1311397
public synchronized PubSubOutputHandler createPubSubOutputHandler(Neighbour neighbour)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "createPubSubOutputHandler", new Object[] { neighbour });

        // Check that this handler wasn't already created.
        PubSubOutputHandler handler = getPubSubOutputHandler(neighbour.getUUID());

        if (handler == null)
            handler =
                            new PubSubOutputHandler(
                                            _messageProcessor,
                                            neighbour,
                                            _baseDestinationHandler);

        _pubsubOutputHandlerLockManager.lockExclusive();
        // Put this outputhandler into the list of handlers.
        _pubsubOutputHandlers.put(neighbour.getUUID(), handler);
        _pubsubOutputHandlerLockManager.unlockExclusive();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "createPubSubOutputHandler", handler);

        return handler;
    }
118178
private static boolean isSubtype(
      ObjectType typeA,
      RecordType typeB,
      ImplCache implicitImplCache,
      SubtypingMode subtypingMode) {

    MatchStatus cached = implicitImplCache.checkCache(typeA, typeB);
    if (cached != null) {
      return cached.subtypeValue();
    }

    boolean result =
        isStructuralSubtypeHelper(
            typeA, typeB, implicitImplCache, subtypingMode, ALL_PROPS_ARE_REQUIRED);
    return implicitImplCache.updateCache(typeA, typeB, MatchStatus.valueOf(result));
  }
1340886
public boolean hasSubOUs() throws CmsException {

        List<CmsOrganizationalUnit> orgUnits = OpenCms.getOrgUnitManager().getOrganizationalUnits(
            getCms(),
            m_paramOufqn,
            true);
        if (orgUnits == null) {
            return false;
        }
        if (orgUnits.size() < 1) {
            return false;
        }
        return true;
    }
974992
public boolean acceptsSubstitution(Method m) {
        Class<?>[] paramTypes = m.getParameterTypes();
        if (paramTypes.length > 0) {
            // Check if last param is a Substitution
            Class<?> lastParam = paramTypes[paramTypes.length - 1];
            return Substitution.class.isAssignableFrom(lastParam);
        }
        return false;
    }
433825
public boolean destinationExists(JsDestinationAddress addr) throws SIMPNullParameterException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "destinationExists", new Object[] { addr });

        // Now look for the destination in the hash table
        boolean exists = destinationExists(addr.getDestinationName(), addr.getBusName());

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "destinationExists", new Boolean(exists));

        return exists;
    }
857117
public static boolean isSub(File parent, File sub) {
		Assert.notNull(parent);
		Assert.notNull(sub);
		return sub.toPath().startsWith(parent.toPath());
	}
193907
public void setPubSubInputHandler(PubSubInputHandler pubSubInputHandler)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "setPubSubInputHandler", pubSubInputHandler);
    this.pubSubInputHandler = pubSubInputHandler;
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "setPubSubInputHandler");
  }
799297
@Override
    public void serverStopping() {
        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled())
            SibTr.entry(tc, "serverStopping");

        synchronized (_mpStartStopLock) {
            _isWASOpenForEBusiness = false;
        }

        // If the destination manager is null, then don't even attempt this.
        // There is a possibility that the destination manager instance is
        // corrupt.
        if (_destinationManager != null)
            _destinationManager.announceWASClosedForEBusiness();

        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled())
            SibTr.exit(tc, "serverStopping");
    }
845259
public boolean subscriberLaunched() {
        boolean launched = true;
        for (int i = 0; i < numWorkers; i++) {
            launched = launched && subscriber[i].subscriberLaunched();
        }

        return launched;
    }
927981
@Pure
	public boolean insideBusHub() {
		final BusStop busStop = getBusStop();
		if (busStop != null) {
			return busStop.insideBusHub();
		}
		return false;
	}
87188
@Override
  public void getSubchannel(
      GetSubchannelRequest request, StreamObserver<GetSubchannelResponse> responseObserver) {
    InternalInstrumented<ChannelStats> s = channelz.getSubchannel(request.getSubchannelId());
    if (s == null) {
      responseObserver.onError(
          Status.NOT_FOUND.withDescription("Can't find subchannel " + request.getSubchannelId())
              .asRuntimeException());
      return;
    }

    GetSubchannelResponse resp;
    try {
      resp = GetSubchannelResponse
          .newBuilder()
          .setSubchannel(ChannelzProtoUtil.toSubchannel(s))
          .build();
    } catch (StatusRuntimeException e) {
      responseObserver.onError(e);
      return;
    }

    responseObserver.onNext(resp);
    responseObserver.onCompleted();
  }
531946
public boolean accepts(Method method) {
        return isPublic(method) && isVoid(method) && takesOneParameter(method) && isAnnotatedAsSubscription(method);
    }
484068
public boolean isSIBServerSubject()
   {
     if (tc.isEntryEnabled()) 
       SibTr.entry(tc, "isSIBServerSubject"); 
       
     boolean ispriv = false;
      
     // If the context is userid or alternate user based then it cannot be the
     // privileged SIBServerSubject, so we only need to check the Subject and
     // msg based contexts.     
     if(isSubjectBased())
     {     
       if(authorisationUtils != null)
       {
         ispriv = authorisationUtils.isSIBServerSubject(subject);
       }        
     }
     else if(isMsgBased())
     {     
       if(authorisationUtils != null)
       {
         ispriv = authorisationUtils.sentBySIBServer(msg);
       }             
     }

     if (tc.isEntryEnabled())
       SibTr.exit(tc, "isSIBServerSubject", new Boolean(ispriv));

     return ispriv; 
   }