This method iterates through the property map of a destination
and constructs a string representing the name and property details.

@param destProps The destination property map
@return String The destination details in a String format
963712
private String encodeMap(Map<String, Object> destProps) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "encodeMap", destProps);

        // string result to return
        StringBuffer result = new StringBuffer("");

        // new HashMap which will contain only non-default NVPs
        Map<String, Object> nonDefaultProps = new HashMap<String, Object>();

        // Deal with each remaining property in turn.
        Iterator<Map.Entry<String, Object>> props = destProps.entrySet().iterator();
        while (props.hasNext()) {

            // Get the name and value of the property.
            Map.Entry<String, Object> nextProp = props.next();
            String propName = nextProp.getKey();
            Object propValue = nextProp.getValue();

            // make sure the value part goes out the same as it came in....
            // ie. if it contains an un-escaped '&', place '\\' behind it.
            // we only do this if the property value is a String.
            if (propValue instanceof String) {
                propValue = URIDestinationCreator.escapeValueString((String) propValue);
            }

            // for the name, get the default value
            Object propDefaultValue = MsgDestEncodingUtilsImpl.getDefaultPropertyValue(propName);

            // check to see if the value we have is the same as the default
            if (((propDefaultValue == null) && (propValue == null))
                || ((propDefaultValue != null) && (propDefaultValue.equals(propValue)))) {
                // Do nothing - we don't want to waste space encoding default values.
            }
            else {
                // if Queue, we don't want to add DEST_NAME as it will be added later manually
                if (this instanceof JmsQueue && !propName.equals(DEST_NAME)) {
                    // place the non-default name and value in the new HashMap
                    nonDefaultProps.put(propName, propValue);
                }
                // we don't want to add DEST_DISCRIM if its a topic, or the topic space if its default,
                // or the DEST_NAME, because they get added manually later.
                else if (this instanceof JmsTopic
                         && !DEST_DISCRIM.equals(propName)
                         && !DEST_NAME.equals(propName)
                         && !JmsTopicImpl.DEFAULT_TOPIC_SPACE.equals(propValue)) {
                    if (propValue != null) {
                        // place the non-default name and value in the new HashMap
                        nonDefaultProps.put(propName, propValue);
                    }
                }
            }
        }

        // Now prepare to loop through the new HashMap which only contains non-default properties,
        // and print each name and value separated by an "&" (unless its the last NVP).
        Iterator<Map.Entry<String, Object>> iter = nonDefaultProps.entrySet().iterator();

        // Queue specific stuff
        if (this instanceof JmsQueue) {
            // add the prefix
            result.append("queue://");

            // get the dest name out of the map
            String destName = (String) destProps.get(DEST_NAME);

            // guard against null values being printed as "null"
            if (destName == null)
                destName = "";

            // Validate the dest name value to escape unescaped illegal chars.
            // These escape chars would have been removed when the dest was created.
            destName = URIDestinationCreator.escapeDestName(destName);

            // put the name of the queue name as the first part of the result
            result.append(destName);
            // if there are no more NVPs, we don't want a '?' on the end of the name
            if (iter.hasNext()) {
                result.append("?");
            }
        }

        // Topic specific stuff
        else if (this instanceof JmsTopic) {
            // add prefix
            result.append("topic://");

            // get out the props we know names of
            String destName = (String) destProps.get(DEST_DISCRIM);
            String topicSpace = (String) destProps.get(DEST_NAME);

            // guard against null values being printed as "null"
            if (destName == null)
                destName = "";
            if (topicSpace == null)
                topicSpace = "";

            // Validate the dest name and topic space values to escape unescaped illegal chars.
            // These escape chars would have been removed when the dest was created.
            destName = URIDestinationCreator.escapeDestName(destName);
            topicSpace = URIDestinationCreator.escapeValueString(topicSpace);

            // Add the name of the topic first.
            result.append(destName);

            // Make sure topic space is the first NVP after topic name.
            // We don't want to print the topic space if it is the default value.
            if (!JmsTopicImpl.DEFAULT_TOPIC_SPACE.equals(topicSpace)) {

                //NB. By putting the constant first we avoid doing null/empty checking.
                result.append("?topicSpace=");
                result.append(topicSpace);

                // Now prepare the string for further properties if they exist.
                if (iter.hasNext())
                    result.append("&");
            }
            else {
                // We have not added the topic space in, but need to prepare the string
                // for further properties if they exist.
                if (iter.hasNext())
                    result.append("?");
            }
        }

        // If this isn't a Queue or a Topic, not much we can do other than alert the user
        else {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                SibTr.debug(this, tc, "Destination in question is neither a JmsQueue of JmsTopic");
        }

        // loop through the non-default NVPs and append to dest name
        while (iter.hasNext()) {

            Map.Entry<String, Object> nextProp = iter.next();

            // Liberty change : 	
            // Setting the name of the bus to null so that it does not get printed in 
            // the Message
            if (nextProp.getKey().equals(BUS_NAME)) {
                continue;
            }

            result.append(nextProp.getKey());
            result.append("=");
            result.append(nextProp.getValue());

            // only append an ampersand if there are more props to come
            if (iter.hasNext())
                result.append("&");
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "encodeMap", result);
        return result.toString();
    }
876030
public Map<String, String> getPropertiesAsMap(Properties properties) {
		Map<String, String> result = new HashMap<String, String>();
		for (String key : properties.stringPropertyNames()) {
			result.put(key, properties.getProperty(key));
		}
		return result;
	}
149868
protected int getLastPropertySeparatorIndex(String propertyPath) {
		boolean inKey = false;
		for (int i = propertyPath.length() - 1; i >= 0; i--) {
			switch (propertyPath.charAt(i)) {
			case PropertyAccessor.PROPERTY_KEY_SUFFIX_CHAR:
				inKey = true;
				break;
			case PropertyAccessor.PROPERTY_KEY_PREFIX_CHAR:
				return i;
			case PropertyAccessor.NESTED_PROPERTY_SEPARATOR_CHAR:
				if (!inKey) {
					return i;
				}
				break;
			}
		}
		return -1;
	}
1048022
public String getStringProperty(final String name) {
        String prop = null;
        try {
            prop = System.getProperty(name);
        } catch (final SecurityException ignored) {
            // Ignore
        }
        return prop == null ? props.getProperty(name) : prop;
    }
955471
private void getPropsString(StringBuilder strProps, List<ConfigPropType> propsList, int indent)
   {
      for (ConfigPropType props : propsList)
      {
         for (int i = 0; i < indent; i++)
            strProps.append(" ");
         strProps.append("<config-property name=\"");
         strProps.append(props.getName());
         strProps.append("\">");
         strProps.append(props.getValue());
         strProps.append("</config-property>");
         strProps.append("\n");
      }
   }
800305
def _get_dest(*args, **kwargs):  # pragma: no cover
    
    prefix_chars = kwargs.get('prefix_chars', '-')
    # determine short and long option strings
    option_strings = []
    long_option_strings = []

    for option_string in args:
        # strings starting with two prefix characters are long options
        option_strings.append(option_string)
        if option_string[0] in prefix_chars:
            if len(option_string) > 1:
                if option_string[1] in prefix_chars:
                    long_option_strings.append(option_string)

    # infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'
    dest = kwargs.get('dest', None)
    if dest is None:
        if long_option_strings:
            dest_option_string = long_option_strings[0]
        else:
            dest_option_string = option_strings[0]
        dest = dest_option_string.lstrip(prefix_chars)
        if not dest:
            msg = _('dest= is required for options like %r')
            raise ValueError(msg % option_string)
        dest = dest.replace('-', '_')

    # return the updated dest name
    return dest
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;
    }
906782
public Map<String, INIProperty> getProperties(String pstrSection)
    {
        Map<String, INIProperty>        hmRet = null;
        INISection objSec = null;

        objSec = (INISection) this.mhmapSections.get(pstrSection);
        if (objSec != null)
        {
            hmRet = objSec.getProperties();
            objSec = null;
        }
        return hmRet;
    }
1185541
public String[] getPropertiesAsString(List<?> properties) {

        Iterator<?> i = properties.iterator();
        StringBuffer res1 = new StringBuffer(512);
        StringBuffer res2 = new StringBuffer(512);
        while (i.hasNext()) {
            CmsAttributeComparison compare = (CmsAttributeComparison)i.next();
            res1.append(compare.getName()).append(": ").append(compare.getVersion1()).append("\n");
            res2.append(compare.getName()).append(": ").append(compare.getVersion2()).append("\n");
        }
        return new String[] {res1.toString(), res2.toString()};
    }
49288
public String getProperties(String strCommand, Map<String,Object> properties)
    {
        int iIndex = strCommand.indexOf('=');
        if (iIndex != -1)
        {
            if (this.getParentScreen().getTask() != null)
            	Util.parseArgs(properties, strCommand);
            if (properties.get(DBParams.COMMAND) != null)
                strCommand = (String)properties.get(DBParams.COMMAND);
        }
        return strCommand;
    }
454307
public static String convertPropertyName(String prop) {
        if (Character.isDigit(prop.charAt(0))) {
            return prop;
        }
        return BeanUtils.decapitalize(prop);
    }
334029
function getProperties(props) {
    var re = [];

    $.each(props, function(key) {
      key = $.camelCase(key); // Convert "text-align" => "textAlign"
      key = $.transit.propertyMap[key] || $.cssProps[key] || key;
      key = uncamel(key); // Convert back to dasherized

      if ($.inArray(key, re) === -1) { re.push(key); }
    });

    return re;
  }
335164
private Map<String, String> subPropertyMap(String configPrefix, Map propertiesMap) {
        Map<String, String> config = new HashMap<String, String>();
        for (Object o : propertiesMap.keySet()) {
            String key = (String) o;
            if (key.startsWith(configPrefix)) {
                String conf = key.substring(configPrefix.length());
                config.put(conf, propertiesMap.get(key).toString());
            }
        }
        return config;
    }
910052
public static String getPropertyNameRepresentation(String name) {
        // Strip any package from the name.
        int pos = name.lastIndexOf('.');
        if (pos != -1) {
            name = name.substring(pos + 1);
        }

        if (name.isEmpty()) {
            return name;
        }

        // Check whether the name begins with two upper case letters.
        if (name.length() > 1 && Character.isUpperCase(name.charAt(0)) &&
            Character.isUpperCase(name.charAt(1))) {
            return name;
        }

        String propertyName = name.substring(0, 1).toLowerCase(Locale.ENGLISH) + name.substring(1);
        if (propertyName.indexOf(' ') > -1) {
            propertyName = propertyName.replaceAll("\\s", "");
        }
        return propertyName;
    }
73473
public String getStringProperty (final String name, final String def)
  {
    String val = m_aProps.getProperty (name, def);
    if (val == null)
      return def;
    val = val.trim ();
    return val.length () == 0 ? def : val;
  }
413930
public static Map<String,Object> stringToProperties(String strProperties)
    {
        Properties properties = new Properties();
        if ((strProperties != null) && (strProperties.length() > 0))
        {
            ByteArrayOutputStream baOut = new ByteArrayOutputStream();
            OutputStreamWriter osOut = new OutputStreamWriter(baOut);
            try   {
                osOut.write(strProperties);     // Char->Byte
                osOut.flush();
                baOut.flush();
                ByteArrayInputStream baIn = new ByteArrayInputStream(baOut.toByteArray());
                properties.load(baIn);
            } catch (IOException ex)    {
                ex.printStackTrace();
            }
        }
        Map<String,Object> map = Utility.propertiesToMap(properties);    // This is okay.
        return map;
    }
796463
public Map<String,Object> getTransportProperties()
    {
        Map<String,Object> propMessageTransport = null;
        Record recMessageTransport = Record.makeRecordFromClassName(MessageTransportModel.THICK_CLASS, this);
        recMessageTransport.setKeyArea(MessageTransportModel.CODE_KEY);
        String strMessageType = this.getMessageTransportType();
        recMessageTransport.getField(MessageTransportModel.CODE).setString(strMessageType);
        try {
            if (recMessageTransport.seek(null))
            {
                PropertiesField fldProperty = (PropertiesField)recMessageTransport.getField(MessageTransportModel.PROPERTIES);
                propMessageTransport = fldProperty.loadProperties();
            }
        } catch (DBException ex) {
            ex.printStackTrace();
        } finally {
            recMessageTransport.free();
            recMessageTransport = null;
        }
        return propMessageTransport;
    }