Gets a Set of the extension(s) marked NON-CRITICAL in the
certificate. In the returned set, each extension is
represented by its OID string.

@return a set of the extension oid strings in the
certificate that are NOT marked critical.
491799
public Set<String> getNonCriticalExtensionOIDs() {
        if (info == null) {
            return null;
        }
        try {
            CertificateExtensions exts = (CertificateExtensions)info.get(
                                         CertificateExtensions.NAME);
            if (exts == null) {
                return null;
            }
            Set<String> extSet = new TreeSet<>();
            for (Extension ex : exts.getAllExtensions()) {
                if (!ex.isCritical()) {
                    extSet.add(ex.getExtensionId().toString());
                }
            }
            extSet.addAll(exts.getUnparseableExtensions().keySet());
            return extSet;
        } catch (Exception e) {
            return null;
        }
    }
444565
public boolean hasUnsupportedCriticalExtension() {
        if (info == null)
            return false;
        try {
            CertificateExtensions exts = (CertificateExtensions)info.get(
                                         CertificateExtensions.NAME);
            if (exts == null)
                return false;
            return exts.hasUnsupportedCriticalExtension();
        } catch (Exception e) {
            return false;
        }
    }
169085
public List<ExtensionElement> getExtendedInfoAsList() {
        List<ExtensionElement> res = null;
        if (extendedInfo != null) {
            res = new ArrayList<>(1);
            res.add(extendedInfo);
        }
        return res;
    }
723775
public Set<Body> getBodies() {
        List<ExtensionElement> bodiesList = getExtensions(Body.ELEMENT, Body.NAMESPACE);
        Set<Body> resultSet = new HashSet<>(bodiesList.size());
        for (ExtensionElement extensionElement : bodiesList) {
            Body body = (Body) extensionElement;
            resultSet.add(body);
        }
        return resultSet;
    }
1200484
public Set<String> getGeneratedIds() {
		synchronized(lock) {
			if(generatedIds == null) return Collections.emptySet();
			if(frozen) return generatedIds;
			return AoCollections.unmodifiableCopySet(generatedIds);
		}
	}
1171895
public Set<List<String>> getPluginOpts() {
        String plugins = options.get(Option.PLUGIN);
        if (plugins == null)
            return Collections.emptySet();

        Set<List<String>> pluginOpts = new LinkedHashSet<>();
        for (String plugin: plugins.split("\\x00")) {
            pluginOpts.add(List.from(plugin.split("\\s+")));
        }
        return Collections.unmodifiableSet(pluginOpts);
    }
191873
public java.util.List<String> getEgressOnlyInternetGatewayIds() {
        if (egressOnlyInternetGatewayIds == null) {
            egressOnlyInternetGatewayIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return egressOnlyInternetGatewayIds;
    }
812791
public List<Certificate> getCertificates() throws CertificateException, IOException {
        final String methodName = "getCertificates";
        logger.entry(this, methodName);
        
        final String fileData = getPemFileData();

        final List<ByteBuf> certDataList = new ArrayList<ByteBuf>();
        final Matcher m = CERTIFICATE_PATTERN.matcher(fileData);
        int start = 0;
        while (m.find(start)) {            
            final ByteBuf base64CertData = Unpooled.copiedBuffer(m.group(1), Charset.forName("US-ASCII"));
            final ByteBuf certData = Base64.decode(base64CertData);
            base64CertData.release();
            certDataList.add(certData);
            start = m.end();
        }
        
        if (certDataList.isEmpty()) {
            final CertificateException exception = new CertificateException("No certificates found in PEM file: " + pemFile);
            logger.throwing(this,  methodName, exception);
            throw exception;
        }
        
        final CertificateFactory cf = CertificateFactory.getInstance("X.509");
        final List<Certificate> certificates = new ArrayList<Certificate>();

        try {
            for (ByteBuf certData: certDataList) {
                certificates.add(cf.generateCertificate(new ByteBufInputStream(certData)));
            }
        } finally {
            for (ByteBuf certData: certDataList) certData.release();
        }
        
        logger.exit(this, methodName, certificates);
        
        return certificates;
    }
386697
public final Map<String, Set<String>> getExtensionMimeMap() throws OSException {
        initializeMimeExtensionArrays();
        return Collections.unmodifiableMap(extensionMime);
    }
439052
public java.util.List<String> getObjectIds() {
        if (objectIds == null) {
            objectIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return objectIds;
    }
1288884
public java.util.List<String> getInstanceIdSet() {
        if (instanceIdSet == null) {
            instanceIdSet = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return instanceIdSet;
    }
303545
public Certificate[] getCertificates() {
        // getCodeSigners() does the sec check
        final CodeSigner[] codeSigners = getCodeSigners();
        if (codeSigners == null) {
            return null;
        }
        final List<Certificate> certList = new ArrayList<Certificate>(codeSigners.length * 3);
        for (CodeSigner signer : codeSigners) {
            certList.addAll(signer.getSignerCertPath().getCertificates());
        }
        return certList.toArray(new Certificate[certList.size()]);
    }
727833
public Set<String> getExpandedRows() {
		Set<String> keys = getComponentModel().expandedRows;
		if (keys == null) {
			return Collections.emptySet();
		} else {
			return Collections.unmodifiableSet(keys);
		}
	}
1020162
public Set<String> getPropertyBundleNameSet() {

		Set<String> bundleNameSet = new HashSet<>();

		for (Object key : props.keySet()) {
			Matcher matcher = bundleNamePattern.matcher((String) key);
			if (matcher.matches()) {

				String id = matcher.group(2);
				bundleNameSet.add(id);
			}
		}
		return bundleNameSet;
	}
710561
public Set<String> getPureKeywords() {
		Set<String> kws = this.pureSarlKeywords == null ? null : this.pureSarlKeywords.get();
		if (kws == null) {
			kws = new HashSet<>();
			kws.add(getAsKeyword());
			kws.add(getRequiresKeyword());
			kws.add(getWithKeyword());
			kws.add(getItKeyword());
			kws.add(getArtifactKeyword());
			kws.add(getAnnotationKeyword());
			kws.add(getSpaceKeyword());
			kws.add(getOnKeyword());
			kws.add(getCapacityKeyword());
			kws.add(getEventKeyword());
			kws.add(getVarKeyword());
			kws.add(getAgentKeyword());
			kws.add(getDispatchKeyword());
			kws.add(getUsesKeyword());
			kws.add(getSkillKeyword());
			kws.add(getDefKeyword());
			kws.add(getFiresKeyword());
			kws.add(getOverrideKeyword());
			kws.add(getIsStaticAssumeKeyword());
			kws.add(getBehaviorKeyword());
			kws.add(getExtensionExtensionKeyword());
			kws.add(getValKeyword());
			kws.add(getTypeofKeyword());
			kws.add(getOccurrenceKeyword());
			this.pureSarlKeywords = new SoftReference<>(kws);
		}
		return Collections.unmodifiableSet(kws);
	}
1278413
@Override
	public Set<String> getContainedIds() {
		Set<String> s = super.getContainedIds();
		s.addAll(constraint.getContainedIds());
		return s;
	}
386767
public List<String> getExtensionsWithDeps() {
		if (extensionsWithDeps.isEmpty()) {
			return Collections.emptyList();
		}

		List<String> extensionClassnames = new ArrayList<>(extensionsWithDeps.size());
		for (ExtensionWithDeps extension : extensionsWithDeps) {
			extensionClassnames.add(extension.getClassname());
		}
		return extensionClassnames;
	}