Gets options and values for everything passed in to the command line including unamed options.

@return An <code>Map.Entry</code> of options and values for everything passed in to the command line including
unamed options.
7588
public Set<Map.Entry<String, String>> getSetEntries() {
      Set<Map.Entry<String, String>> entries = optionSet.stream()
                                                        .filter(this::isSet)
                                                        .map(no -> Tuple2.of(no.getName(),
                                                                             Convert.convert(no.getValue(),
                                                                                             String.class)))
                                                        .collect(Collectors.toSet());
      entries.addAll(unamedOptions.entrySet());
      return entries;
   }
1372053
@Override
	public Iterator<Map.Entry<K, V>> iterator() {
		return Collections.unmodifiableSet(state.entrySet()).iterator();
	}
53231
public Set<String> getOptionsValues() {
        Set<String> result = new HashSet<>();
        for (OptionGroup group : optionGroups.values()) {
            result.addAll(group.getOptionValues());
        }

        return result;
    }
633977
public Set<String> getEnabledOptionValues() {
        Set<String> result = new HashSet<>();
        for (OptionGroup group : optionGroups.values()) {
            result.addAll(group.getEnabledOptionValues());
        }

        return result;
    }
46345
public Map<String, ? extends Object> getOptionValues()
    {
        Map<String, Object> opts = new HashMap<String, Object>();
        for (Option opt : options)
        {
            if (opt.wasGiven()) opts.put( opt.getName(), opt.getValue() );
        }

        return opts;
    }
753748
public Map<String, Object> getProperties() {
        // Shallow copy entries to a newly instantiated HashMap.
        Map<String, Object> clone = new HashMap<String, Object>();
        Set<Entry<String, Object>> set = _properties.entrySet();
        
        for (Entry<String, Object> entry : set) {
            // There wouldn't be any entry with a null value.
            clone.put(entry.getKey(), entry.getValue());
        }
        
        return clone;
    }
409057
public CommandLine getCommandLine(Options commandLineOptions) throws Exception {
		final List<String> args = new ArrayList<>();

		properties.asMap().forEach((k, v) -> {
			// only add supported options
			if (commandLineOptions.hasOption(k)) {
				final Option o = commandLineOptions.getOption(k);
				final String argument = "--" + o.getLongOpt();
				// options without args
				if (!o.hasArg()) {
					final Boolean flag = Boolean.parseBoolean(v);
					// add key only
					if (flag) {
						args.add(argument);
					}
				}
				// add key and value
				else if (!o.hasArgs()) {
					args.add(argument);
					args.add(v);
				}
				// options with multiple args are not supported yet
				else {
					throw new IllegalArgumentException("Option '" + o + "' is not supported yet.");
				}
			}
		});

		return CliFrontendParser.parse(commandLineOptions, args.toArray(new String[args.size()]), true);
	}
760930
public final Set<Map.Entry<K,V>> entrySet() {

	return new AbstractSet<Map.Entry<K,V>>() {
	    public Iterator<Map.Entry<K,V>> iterator() {
		return entryIterator();
	    }
	    public int size() {
		return size;
	    }
	};
    }
1345958
protected static List<String> createOptions() {

        List<String> options = new ArrayList<String>();
        options.add(optionMapping.get(CmsAliasMode.permanentRedirect));
        options.add(optionMapping.get(CmsAliasMode.redirect));
        options.add(optionMapping.get(CmsAliasMode.passthrough));
        return options;
    }
107517
public List<String> getHelp() {

		List<String> out = new ArrayList<>();

		if (helpAppVersion != null) {
			out.add(helpAppVersion);
		}

		if (helpAppExample != null) {
			out.add(helpAppExample);
		}

		if (helpAppVersion != null || helpAppExample != null) {
	 		out.add(""); // new line
 		}

		// find longest option to format all other options by this one
		int max = 0;
		for (CommandOption option: options) {
			String command = option.toCommandString();
			max = Math.max(max, command.length());
		}

		for (CommandOption option: options) {
			String info = option.toCommandString();
			int spaces = max - info.length() + 1;

			String delimiter = new String(new char[spaces]).replace("\0", " "); // returns 'spaces' long empty string

			info = info + delimiter + option.getDescription();
			out.add(info);
		}

		return out;

	}
872829
public List<Entry> getEntries() {
		if(_sortedEntries == null) {
			this._sortedEntries = Lists.newArrayListWithCapacity(entries.size());
			for(Map.Entry<Term, Entry> e:entries.entrySet())
				this._sortedEntries.add(e.getValue());
			Collections.sort(this._sortedEntries);
		}
		return _sortedEntries;
	}
1120805
public String getOptionsHelpMessage() {
        String ls = System.getProperty("line.separator");
        usageMessage = "Available options:";
        StringBuilder sb = new StringBuilder(usageMessage);
        sb.append(ls);
        for (Option option : declaredOptions.values()) {
            String name = option.getName();
            int extraPadding = longestOptionNameLength - name.length();
            sb.append(" -").append(name);
            for (int i = 0; i < extraPadding; i++) {
                sb.append(' ');
            }
            sb.append(DEFAULT_PADDING).append(option.getDescription()).append(ls);
        }

        return sb.toString();
    }
630930
@Override
    public Set<java.util.Map.Entry<K, V>> entrySet() {
        final Set<Entry<K, V>> localSet = this.localMap.entrySet();

        if (isReadyOnly())
            return Collections.unmodifiableSet(localSet);

        return localSet;
    }
703608
public static Map.Entry<String, Map<String, ?>> getNetworkConnectionCommand() {
        return new AbstractMap.SimpleEntry<>(GET_NETWORK_CONNECTION, ImmutableMap.of());
    }
182699
public String getUrlParams()
   {
      StringBuffer osParams = new StringBuffer();

      for (Iterator i = this.entrySet().iterator(); i.hasNext();)
      {
         Map.Entry entry = (Map.Entry)i.next();
         if (entry.getValue() != null)
            osParams.append("&" + encodeConfig(entry.getKey().toString()) + "="
               + encodeConfig(entry.getValue().toString()));
      }
      return osParams.toString();
   }
209478
public static Map.Entry<String, Map<String, ?>> currentPackageCommand() {
        return new AbstractMap.SimpleEntry<>(GET_CURRENT_PACKAGE, ImmutableMap.of());
    }
589626
@Override
    public Set<Map.Entry<K, V>> entrySet() {
        return new AbstractSet<Map.Entry<K, V>>() {
            @Override
            public Iterator<Map.Entry<K, V>> iterator() {
                return new ObjIterator<Map.Entry<K, V>>() {
                    private final Iterator<Map.Entry<K, V>> keyValueEntryIter = keyMap.entrySet().iterator();

                    @Override
                    public boolean hasNext() {
                        return keyValueEntryIter.hasNext();
                    }

                    @Override
                    public Map.Entry<K, V> next() {
                        final Map.Entry<K, V> entry = keyValueEntryIter.next();

                        return new Map.Entry<K, V>() {
                            @Override
                            public K getKey() {
                                return entry.getKey();
                            }

                            @Override
                            public V getValue() {
                                return entry.getValue();
                            }

                            @Override
                            public V setValue(V value) {
                                //    if (N.equals(entry.getValue(), value)) {
                                //        return entry.getValue();
                                //    }
                                //
                                //    //    if (valueMap.containsKey(value)) {
                                //    //        throw new IllegalStateException("Value: " + N.toString(value) + " already existed.");
                                //    //    }
                                //
                                //    valueMap.remove(entry.getValue());
                                //    valueMap.put(value, entry.getKey());
                                //    return entry.setValue(value);

                                throw new UnsupportedOperationException();
                            }
                        };
                    }
                };
            }

            @Override
            public int size() {
                return keyMap.size();
            }
        };
    }