Returns the set of synchronized namespaces.

@return the set of synchronized namespaces.
170102
public Set<MongoNamespace> getSynchronizedNamespaces() {
    instanceLock.readLock().lock();
    try {
      return new HashSet<>(namespaces.keySet());
    } finally {
      instanceLock.readLock().unlock();
    }
  }
901665
public Set<String> getMBeanNames() {
        Set<String> nameSet = new TreeSet<String>();
        for (ObjectInstance instance : mBeanServer.queryMBeans(null, null)) {
            nameSet.add(sanitizer.escapeValue(instance.getObjectName().getCanonicalName()));
        }
        return nameSet;
    }
1311088
def get_namespaces(self):
        """"""
        cursor = self.cursor
        cursor.execute('SELECT DISTINCT namespace FROM gauged_statistics')
        return [namespace for namespace, in cursor]
758460
public static List<String> getAllNameSpaces() throws ApiException {
    V1NamespaceList listNamespace =
        COREV1_API.listNamespace(
            null, "true", null, null, null, 0, null, Integer.MAX_VALUE, Boolean.FALSE);
    List<String> list =
        listNamespace
            .getItems()
            .stream()
            .map(v1Namespace -> v1Namespace.getMetadata().getName())
            .collect(Collectors.toList());
    return list;
  }
712515
public Set<String> getKeySet() {
    final HashSet<String> keySet = new HashSet<>();

    keySet.addAll(localKeySet());

    if (this._parent != null) {
      keySet.addAll(this._parent.getKeySet());
    }

    return keySet;
  }
846116
public Collection<String> getNames() {
		Collection<String> names = new HashSet<String>();
		for (InitParam initParam : initParams) {
			names.add(initParam.getName());
		}
		return names;
	}
1045226
public Set<String> getKeySet() {
        HashSet<String> result = new HashSet<>();

        for (PollingDynamicConfig config : children) {
            Iterator<String> iter = config.getKeys();
            while (iter.hasNext()) {
                String key = iter.next();
                result.add(key);
            }
        }

        return result;
    }
1044839
public java.util.List<CidrBlock> getCidrBlockSet() {
        if (cidrBlockSet == null) {
            cidrBlockSet = new com.amazonaws.internal.SdkInternalList<CidrBlock>();
        }
        return cidrBlockSet;
    }
216054
public Set<Component> getRegisteredComponents() {
      Set<Component> set = new HashSet<>();
      for (ComponentRef<?> c : basicComponentRegistry.getRegisteredComponents()) {
         ComponentMetadata metadata = c.wired() != null ?
                                      componentMetadataRepo.getComponentMetadata(c.wired().getClass()) : null;
         Component component = new Component(c, metadata);
         set.add(component);
      }
      return set;
   }
456751
private Iterator<ConcurrentServiceReferenceElement<T>> elements() {
        Collection<ConcurrentServiceReferenceElement<T>> set;
        synchronized (elementMap) {
            if (elementSetUnsorted) {
                elementSet = new ConcurrentSkipListSet<ConcurrentServiceReferenceElement<T>>(elementMap.values());
                elementSetUnsorted = false;
            }
            set = elementSet;
        }

        return set.iterator();
    }
246603
public synchronized Collection<T> getAllChannels()
    {
        Collection<T> allChannels = new ArrayList<T>();
        allChannels.addAll(this.channels);
        allChannels.addAll(this.channelsWithId.values());
        return allChannels;
    }
86341
public static NamespaceContext createNamespaceContext() {
    return new NamespaceContext() {
      private HashMap<String, String> namespaces = new HashMap<String, String>(1);

      {
        namespaces.put(DEFAULT_NAMESPACE_PREFIX, DEFAULT_NAMESPACE_URI);
      }

      public String getNamespaceURI(String prefix) {
        if (namespaces.isEmpty() || StringUtil.isNullOrEmpty(prefix) || !namespaces.containsKey(prefix))
          return StringUtil.empty;
        return namespaces.get(prefix);
      }

      public Iterator getPrefixes(String namespaceURI) {
        return namespaces.values().iterator();
      }

      public String getPrefix(String namespaceURI) {
        if (StringUtil.isNullOrEmpty(namespaceURI))
          return StringUtil.empty;

        for(Entry<String, String> entry : namespaces.entrySet())
          if (namespaceURI.equals(entry.getValue()))
            return entry.getKey();

        return StringUtil.empty;
      }
    };
  }
220277
public String[] getFeatNames() {
        String[] namesArray = new String[nameIndexMap.size()];

        for (Map.Entry<String, Integer> entry : nameIndexMap.entrySet()) {
            namesArray[entry.getValue()] = entry.getKey();
        }

        return namesArray;
    }
15324
public Set<String> getPropertyNames() {
    return Sets.newHashSet(
        Iterables.concat(this.commonProperties.stringPropertyNames(), this.specProperties.stringPropertyNames()));
  }
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);
	}
210466
public static function getNamespaces()
    {
        $called = get_called_class();

        if (!isset(static::$namespaces[$called])) {
            static::$namespaces[$called] = new PriorityQueue();
        }

        return static::$namespaces[$called];
    }
673256
def getNamespaces(self):
        
        s = set()
        for n in self.branch + self.node.ancestors():
            if self.permit(n.expns):
                s.add(n.expns)
            s = s.union(self.pset(n))
        return s