This method forms a {@link Map} of parameters for the device shaking.

@return a key-value pair. The key is the command name. The value is a {@link Map} command arguments.
761267
public static Map.Entry<String, Map<String, ?>>  shakeCommand() {
        return new AbstractMap.SimpleEntry<>(SHAKE, ImmutableMap.of());
    }
581261
public Map<String, Object> toMap() {
        HashMap<String, Object> map = new HashMap<>();

        map.put("id", id);
        map.put("pipelineName", pipelineName);
        map.put("stageName", stageName);
        map.put("myCheckin", myCheckin);
        map.put("event", event.toString());

        return map;
    }
961687
@Override
    public Map<String, List<String>> toParameters() {
        final Map<String, List<String>> outParams = new LinkedHashMap<>();
        outParams.put("resource", Collections.singletonList(resource));
        outParams.put("grant_type", Collections.singletonList(GRANT_TYPE) );
        outParams.put("code", Collections.singletonList(deviceCode.getDeviceCode()));

        return outParams;
    }
716862
public Map<String, Object> getHiddenParams()
    {
        Map<String, Object> mapParams = new Hashtable<String, Object>();
        return mapParams;
    }
220521
public static Map mapKeys(Mapper mapper, Map map) {
        return mapKeys(mapper, map, false);
    }
1351691
public Map<String, String[]> getParams() {

        // get the params
        Map<String, String[]> params = CmsCollectionsGenericWrapper.map(m_request.getParameterMap());
        if (params.size() == 0) {
            return null;
        }
        return params;
    }
778503
static List<String> flaggedKeyValues(final String flagName, @Nullable Map<?, ?> keyValueMapping) {
    List<String> result = Lists.newArrayList();
    if (keyValueMapping != null && keyValueMapping.size() > 0) {
      for (Map.Entry<?, ?> entry : keyValueMapping.entrySet()) {
        result.addAll(string(flagName, entry.getKey() + "=" + entry.getValue()));
      }

      return result;
    }

    return Collections.emptyList();
  }
687538
private String getParameterValue(CmsObject cms, Map<String, String[]> parameterMap, String key) {

        String result = null;
        String[] params = parameterMap.get(key);
        if ((params != null) && (params.length > 0)) {
            result = params[0];
        }
        if (result == null) {
            return "";
        }
        return result;
    }
580163
public Map<String, Object> executeCdpCommand(String commandName, Map<String, Object> parameters) {
    Objects.requireNonNull(commandName, "Command name must be set.");
    Objects.requireNonNull(parameters, "Parameters for command must be set.");

    @SuppressWarnings("unchecked")
    Map<String, Object> toReturn = (Map<String, Object>) getExecuteMethod().execute(
        ChromeDriverCommand.EXECUTE_CDP_COMMAND,
        ImmutableMap.of("cmd", commandName, "params", parameters));

    return ImmutableMap.copyOf(toReturn);
  }
89976
protected Map<String, String> getInfoMap() {

        Map<String, String> infos = new LinkedHashMap<String, String>();
        List<CmsSessionInfo> sessions = OpenCms.getSessionManager().getSessionInfos();
        List<CmsUUID> user = new ArrayList<CmsUUID>();
        for (CmsSessionInfo info : sessions) {
            CmsUUID id = info.getUserId();
            if (!user.contains(id)) {
                user.add(id);
            }
        }
        infos.put(
            CmsVaadinUtils.getMessageText(Messages.GUI_MESSAGES_SESSION_COUNT_0),
            String.valueOf(sessions.size()));
        infos.put(CmsVaadinUtils.getMessageText(Messages.GUI_MESSAGES_USER_COUNT_0), String.valueOf(user.size()));
        return infos;
    }
348119
public Map/*< String, List< String > >*/ getParameters()
    {
        if(_parameters == null || !_parameters.hasParameters())
            return Collections.EMPTY_MAP;
        else return _parameters.getParameters();
    }
172573
function() {
			var parameters = [];
			this.forEach(function(parm) {
				var newParm = new CommandParameter(parm.name, parm.type, parm.label, parm.value, parm.lines, parm.eventListeners, parm.validator);
				parameters.push(newParm);
			});
			var copy = new ParametersDescription(parameters, this._options, this.getParameters);
			// this value may have changed since the options
			copy.clientCollect = this.clientCollect;
			copy.message = this.message;
			return copy;
			
		 }
487042
private Map<String, Item> getKeyItemMap() {

        Map<String, Item> ret = new HashMap<String, Item>();
        for (Object itemId : m_container.getItemIds()) {
            ret.put(
                m_container.getItem(itemId).getItemProperty(TableProperty.KEY).getValue().toString(),
                m_container.getItem(itemId));
        }
        return ret;

    }
15474
public static Map.Entry<String, Map<String, ?>> unlockDeviceCommand() {
        return new AbstractMap.SimpleEntry<>(UNLOCK, ImmutableMap.of());
    }
586917
public Map<String, String> newKeys() {
		Map<String, String> keys = getEntity(invokePost("_newkeys", null), Map.class);
		if (keys != null && keys.containsKey("secretKey")) {
			this.secretKey = keys.get("secretKey");
		}
		return keys;
	}
417273
private Map<String, List<String>> shakeHands() throws WebSocketException
    {
        // The raw socket created by WebSocketFactory.
        Socket socket = mSocketConnector.getSocket();

        // Get the input stream of the socket.
        WebSocketInputStream input = openInputStream(socket);

        // Get the output stream of the socket.
        WebSocketOutputStream output = openOutputStream(socket);

        // Generate a value for Sec-WebSocket-Key.
        String key = generateWebSocketKey();

        // Send an opening handshake to the server.
        writeHandshake(output, key);

        // Read the response from the server.
        Map<String, List<String>> headers = readHandshake(input, key);

        // Keep the input stream and the output stream to pass them
        // to the reading thread and the writing thread later.
        mInput  = input;
        mOutput = output;

        // The handshake succeeded.
        return headers;
    }
849045
public HashMap<String,Object> getValueMap()
  {
    try {
      if (_values == null) {
        _values = new HashMap<String,Object>();

        Method []methods = _ann.annotationType().getMethods();

        for (int i = 0; i < methods.length; i++) {
          Method method = methods[i];

          if (method.getDeclaringClass().equals(Class.class))
            continue;
          if (method.getDeclaringClass().equals(Object.class))
            continue;
          if (method.getParameterTypes().length != 0)
            continue;

          _values.put(method.getName(), method.invoke(_ann));
        }
      }

      return _values;
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }