Return a union of property names associated with channels

@param channels - list of channels
@return a set of all unique property names associated with atleast one or
more channel in channels
424181
public static Collection<String> getPropertyNames(
			Collection<Channel> channels) {
		Collection<String> propertyNames = new HashSet<String>();
		for (Channel channel : channels) {
			propertyNames.addAll(getPropertyNames(channel));
		}
		return propertyNames;
	}
601378
public Map<String, Class<?>> getPayloadPropertyNames(Map<String,Class<?>> mapPropertyNames)
    {
        mapPropertyNames= super.getPayloadPropertyNames(mapPropertyNames);
        if (m_messageDataDescChildren != null)
        {
            for (String strKey : m_messageDataDescChildren.keySet())
            {
                MessageDataDesc messageDataDesc = m_messageDataDescChildren.get(strKey);
                mapPropertyNames = messageDataDesc.getPayloadPropertyNames(mapPropertyNames);
            }
        }
        return mapPropertyNames;
    }
444411
public static Properties combineProperties(Properties... properties) {
    Properties combinedProperties = new Properties();
    for (Properties props : properties) {
      combinedProperties.putAll(props);
    }
    return combinedProperties;
  }
175419
private static List<String> loadChannels(Map<String, String[]> channels) {
        final boolean bTrace = TraceComponent.isAnyTracingEnabled();
        final ChannelFramework cf = ChannelFrameworkFactory.getChannelFramework();
        List<String> createdChannels = new ArrayList<String>(channels.size());
        boolean fireMissingEvent = false;

        final EndPointMgr epm = EndPointMgrImpl.getRef();
        String key, value;
        for (Entry<String, String[]> entry : channels.entrySet()) {
            String channel = entry.getKey();
            Map<Object, Object> props = new HashMap<Object, Object>();
            int weight = -1;
            Class<?> factoryType = null;
            for (String prop : entry.getValue()) {
                key = extractKey(prop);
                value = extractValue(prop);
                if ("type".equalsIgnoreCase(key)) {
                    if (null != factoryType) {
                        // already set
                        continue;
                    }
                    factoryType = cf.lookupFactory(value);
                } else if ("endpoint".equalsIgnoreCase(key)) {
                    if (props.containsKey("hostname")) {
                        // already set
                        continue;
                    }
                    // convert to host/port
                    if (null != epm) {
                        EndPointInfo ep = epm.getEndPoint(value);
                        if (null != ep) {
                            if (bTrace && tc.isDebugEnabled()) {
                                Tr.debug(tc, "Using endpoint: " + ep);
                            }
                            props.put("endPointName", value);
                            props.put("hostname", ep.getHost());
                            props.put("port", String.valueOf(ep.getPort()));
                        } else {
                            if (bTrace && tc.isEventEnabled()) {
                                Tr.event(tc, "Unknown endpoint: " + value);
                            }
                        }
                    } else {
                        if (bTrace && tc.isEventEnabled()) {
                            Tr.event(tc, "Unable to convert endpoint: " + value);
                        }
                    }
                } else if ("weight".equalsIgnoreCase(key)) {
                    if (0 > weight) {
                        // already set
                        continue;
                    }
                    try {
                        weight = Integer.parseInt(value);
                    } catch (NumberFormatException nfe) {
                        FFDCFilter.processException(nfe, "ChannelUtils.loadChannels",
                                                    "weight", new Object[] { entry, cf });
                        if (bTrace && tc.isEventEnabled()) {
                            Tr.event(tc, "Invalid discrimination weight: " + value);
                        }
                    }
                } else {
                    props.put(key, value);
                }
            } // end-props
            if (null == factoryType) {
                if (bTrace && tc.isEventEnabled()) {
                    Tr.event(tc, "Delay; channel missing factory; " + channel);
                }
                delayedConfig.put(CHANNEL_PREFIX + channel, entry.getValue());
                createdChannels.add(channel);
                fireMissingEvent = true;
                continue;
            }
            // change invalid weights to the default number
            if (0 > weight) {
                weight = 10;
            }
            try {
                ChannelData cd = cf.getChannel(channel);
                if (null == cd) {
                    cd = cf.addChannel(channel, factoryType, props, weight);
                } else {
                    cf.updateAllChannelProperties(channel, props);
                }
                createdChannels.add(channel);
            } catch (Exception e) {
                FFDCFilter.processException(e, "ChannelUtils.loadChannels",
                                            "update", new Object[] { entry, cf });
                if (bTrace && tc.isEventEnabled()) {
                    Tr.event(tc, "Unable to add channel: " + channel + "; " + e);
                }
            }
        } // end-channels

        if (fireMissingEvent) {
            fireMissingEvent();
        }

        return createdChannels;
    }
543995
public static synchronized List getPropertyNames(String entityTypeName) {
        if (propertyNames != null) {
            return propertyNames;
        } else {
            {
                List names = new ArrayList();
                names.add(PROP_PRINCIPAL_NAME);
                names.add(PROP_PASSWORD);
                names.add(PROP_REALM);
                names.add(PROP_CERTIFICATE);
                names.addAll(Party.getPropertyNames("Party"));
                propertyNames = Collections.unmodifiableList(names);
                return propertyNames;
            }
        }
    }
1015199
private final Set<String> getNonSmokeAndMirrorsPropertyNameSet() {

        /* Get the names of all the properties in the JMS Property Maps */
        /* We need a copy so that we can add extra items, and so can the caller */
        Set<String> names = new HashSet<String>();

        // Add the names for the two flavours of properties, without creating lists
        // and maps unnecessarily.
        if (mayHaveJmsUserProperties()) {
            names.addAll(getJmsUserPropertyMap().keySet());
        }
        if (mayHaveMappedJmsSystemProperties()) {
            names.addAll(getJmsSystemPropertyMap().keySet());
        }

        // The MQMD properties may be in the JmsSystemPropertyMap AND the MQMSetPropertiesMap
        // however, the Set will cater for this as it doesn't allow duplicates.
        if (hasMQMDPropertiesSet()) {
            names.addAll(getMQMDSetPropertiesMap().keySet());
        }
        return names;
    }
785191
public java.util.List<String> getDeliveryChannelNames() {
        if (deliveryChannelNames == null) {
            deliveryChannelNames = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return deliveryChannelNames;
    }
1346694
@Override
  public final Set<String> getOwnPropertyNames() {
    if (prototypeSlot == null) {
      return super.getOwnPropertyNames();
    } else {
      ImmutableSet.Builder<String> names = ImmutableSet.builder();
      names.add("prototype");
      names.addAll(super.getOwnPropertyNames());
      return names.build();
    }
  }
70042
@SuppressWarnings({ "rawtypes", "unchecked" })
	@Override
	public PrefixedPropertiesEnumeration<?> propertyNames() {
		lock.readLock().lock();
		try {
			final Set result = new HashSet();
			for (final Object key : getKeyMap(false).keySet()) {
				result.add(getUnprefixedKey(key));
			}
			return new PrefixedPropertiesEnumerationImpl(result.iterator(), true);
		} finally {
			lock.readLock().unlock();
		}
	}
752317
Collection<AsteriskChannel> getChannels()
    {
        Collection<AsteriskChannel> copy;

        synchronized (channels)
        {
            copy = new ArrayList<>(channels.size() + 2);
            for (AsteriskChannel channel : channels.values())
            {
                if (channel.getState() != ChannelState.HUNGUP)
                {
                    copy.add(channel);
                }
            }
        }
        return copy;
    }
1144303
public String[] findGetterPropertyNames() {
        final Method[] getters = findGetterMethods();
        final List<String> result = new ArrayList<String>();
        for (int i = 0; i < getters.length; i++) {
            final Method m = getters[i];
            String name = m.getName();
            String propertyName = null;
            if (name.startsWith("get") && name.length() > 3) {
                propertyName = name.substring(3);
            } else if (name.startsWith("is") && name.length() > 2) {
                propertyName = name.substring(2);
            } else if (name.startsWith("are") && name.length() > 3) {
                propertyName = name.substring(3);
            }
            if (propertyName != null) {
                propertyName = INFLECTOR.camelCase(INFLECTOR.underscore(propertyName), false);
                result.add(propertyName);
            }
        }
        return result.toArray(new String[result.size()]);
    }
1162615
def from_names(cls, *names):
        
        new = cls()
        for namestr in names:
            for name in cls._split_names(namestr):
                new.append(Channel(name))
        return new
1121045
public static channel[] get(nitro_service service) throws Exception{
		channel obj = new channel();
		channel[] response = (channel[])obj.get_resources(service);
		return response;
	}
1359846
public static Collection<String> getAllTagNames(Collection<Channel> channels) {
		Collection<String> tagNames = new HashSet<String>();
		for (Channel channel : channels) {
			tagNames.addAll(getTagNames(channel));
		}
		return tagNames;
	}
1139780
public List<AsteriskChannel> getDialedChannels()
    {
        final List<AsteriskChannel> copy;

        synchronized (dialedChannels)
        {
            copy = new ArrayList<>(dialedChannels);
        }

        return copy;
    }
1032929
def parse_channels(self):
        """"""
        channels = []
        for channel in self._project_dict["channels"]:
            channels.append(Channel(channel, self._is_sixteen_bit, self._ignore_list))
        return channels
1252471
public List<String> getChannels() {
        if (filterParams == null || filterParams.isEmpty()) {
            return new ArrayList<String>();
        }
        String params = (String) filterParams.get(CHANNELS_QUERY_PARAM);
        if (!isPull() || getFilter() == null || !BY_CHANNEL_FILTER_NAME.equals(getFilter()) || params == null || params.isEmpty()) {
            return new ArrayList<String>();
        }
        String[] paramsArray = params.split(",");
        return new ArrayList<String>(Arrays.asList(paramsArray));
    }