<p>
If the option requires access to a port, then this DB security group allows access to the port.
</p>

@return If the option requires access to a port, then this DB security group allows access to the port.
553593
public java.util.List<DBSecurityGroupMembership> getDBSecurityGroupMemberships() {
        if (dBSecurityGroupMemberships == null) {
            dBSecurityGroupMemberships = new com.amazonaws.internal.SdkInternalList<DBSecurityGroupMembership>();
        }
        return dBSecurityGroupMemberships;
    }
776769
public static boolean isPortAvailable(int port) {
        StringBuilder builder = new StringBuilder();
        builder.append("Testing port ").append(port).append("\n");
        try (Socket s = new Socket("localhost", port)) {
            // If the code makes it this far without an exception it means
            // something is using the port and has responded.
            builder.append("Port ").append(port).append(" is not available").append("\n");
            return false;
        } catch (IOException e) {
            builder.append("Port ").append(port).append(" is available").append("\n");
            return true;
        } finally {
            log.fine(builder.toString());
        }
    }
901564
public static boolean isPortAvailable(int port) {
		try {
			ServerSocket serverSocket = ServerSocketFactory.getDefault().createServerSocket(port, 1,
					InetAddress.getByName("localhost"));
			serverSocket.close();
			return true;
		} catch (Exception ex) { // NOSONAR
			return false;
		}
	}
1145778
@Override
    public boolean isSecure() {
        boolean secure = (null != this.connection.getSSLContext());
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "isSecure: " + secure);
        }
        return secure;
    }
417988
public String getAccessKey() {
		String accessKey = getAsNullableString("access_key");
		accessKey = accessKey != null ? accessKey : getAsNullableString("client_key");
		return accessKey;
	}
50564
public byte[] getPort() {
        byte[] port = new byte[2];
        int p = (getEndpointAddress() == null ? this.port
                : getEndpointAddress().getPort());
        port[1] = (byte) p;
        port[0] = (byte) (p >> 8);
        return port;
    }
609150
public static Boolean canAccess(String url) {
		return ContextUtils.getAuthorizationEngine(ContextUtils.getRequest())
				.check(url) == null;
	}
283219
public boolean isOnline()
    {
        Boolean online = getOptionValue(OnlineModeOption.NAME);
        return online == null ? DEFAULT_ONLINE : online;
    }
850020
@Override
    public boolean checkDiscriminatorAccess(
                                            SecurityContext secContext,
                                            OperationType operation) throws SIDiscriminatorSyntaxException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(
                        tc,
                        "checkDiscriminatorAccess",
                        new Object[] { secContext, operation });

        boolean allow = true;

        if (isTopicAccessCheckRequired())
        {
            if (!accessChecker.checkDiscriminatorAccess(secContext,
                                                        this,
                                                        secContext.getDiscriminator(),
                                                        operation))
            {
                allow = false;
            }
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "checkDiscriminatorAccess", Boolean.valueOf(allow));

        return allow;
    }
443161
public boolean allowAccess(String user) {

        try {
            return m_cms.getPermissions(m_root, user).requiresViewPermission();
        } catch (CmsException e) {
            LOG.error(e.getLocalizedMessage(), e);
            return true;
        }
    }
351083
public boolean checkAccess(AccessFlags flags){

        boolean isPublic = flags.is(AccessFlags.ACC_PUBLIC);
        boolean isProtected = flags.is(AccessFlags.ACC_PROTECTED);
        boolean isPrivate = flags.is(AccessFlags.ACC_PRIVATE);
        boolean isPackage = !(isPublic || isProtected || isPrivate);

        if ((showAccess == AccessFlags.ACC_PUBLIC) && (isProtected || isPrivate || isPackage))
            return false;
        else if ((showAccess == AccessFlags.ACC_PROTECTED) && (isPrivate || isPackage))
            return false;
        else if ((showAccess == 0) && (isPrivate))
            return false;
        else
            return true;
    }
70055
@Override
	public boolean checkPermission(Set<SecurityGroup> groups, Permission permission)
	{
		if (groups == null || groups.isEmpty())
			return false;

		for (SecurityGroup group : groups)
		{
			if (checkPermission(group, permission))
				return true;
		}

		return false;
	}
1057655
public static boolean available(int port) {
        if (port < MIN_PORT_NUMBER || port > MAX_PORT_NUMBER) {
            throw new IllegalArgumentException("Invalid start port: " + port);
        }

        ServerSocket ss = null;
        DatagramSocket ds = null;
        try {
            ss = new ServerSocket(port);
            ss.setReuseAddress(true);
            ds = new DatagramSocket(port);
            ds.setReuseAddress(true);
            return true;
        } catch (IOException e) {
            // Do nothing
        } finally {
            if (ds != null) {
                ds.close();
            }

            if (ss != null) {
                try {
                    ss.close();
                } catch (IOException e) {
                    /* should not be thrown */
                }
            }
        }

        return false;
    }
800514
public int getPort() {
    final Connector[] connectors = this.server.getConnectors();
    checkState(connectors.length >= 1, "Server must have at least 1 connector");

    // The first connector is created upon initializing the server. That's the one that has the port.
    return connectors[0].getLocalPort();
  }
1117364
public boolean isNull() {
        if (ip == null) {
            return true;
        } else if (ip.length() == 0) {
            return true;
        } else if (port < 0) {
            return true;
        } else {
            return false;
        }
    }
255171
@Override
    public int isSupportedOption(String option) {
        proc.debug(DBG_FMGR, "isSupportedOption: %s\n", option);
        return stdFileManager.isSupportedOption(option);
    }
1261745
public function isUserAllowedAccess()
    {
        $requestedRoles = $this->getRequestedRoles();

        // we allow access if there are no requested roles that the user must have
        if (count($requestedRoles) < 1) {
            return true;
        }

        return $this->getAccessDecision($requestedRoles);
    }