Gets the integer map.

@param response
the response
@param args
the args
@return the integer map
18451
private final Map<String, Integer> getIntegerMap(NamedList<Object> response, String... args) {
    Object objectItem = response.findRecursive(args);
    Map<String, Integer> result = null;
    if (objectItem != null && objectItem instanceof Map) {
      result = (Map) objectItem;
    }
    return result;
  }
762134
public MessageMap getMap(BigInteger index) {
    if (array != null)
      return array[index.intValue()];
    else
      return (MessageMap)hashtable.get(index);
  }
364447
@Override
    public Object map(Object input) {
        Number n = (Number) input;
        if (inputSchema.getMetaData(columnNumber).isValid(new IntWritable(n.intValue()))) {
            return input;
        } else {
            return value;
        }
    }
749282
@GetMapping(path = {"/swivel/turingImage"})
    public void generate(final HttpServletResponse response, final HttpServletRequest request) throws Exception {
        response.setContentType("image/png");
        val principal = request.getParameter("principal");
        if (StringUtils.isBlank(principal)) {
            throw new IllegalArgumentException("No principal is specified in the turing image request");
        }
        generateImage(response.getOutputStream(), principal);
    }
896875
private int getMapping(final String mapping, final int revisionCounter)
    {

        String tempA, tempB;

        int length = 0;
        int revC = -1, mapC = -1;
        int index, max = mapping.length();

        while (length < max && revC < revisionCounter) {

            // Read revisionCounter
            index = mapping.indexOf(' ', length);
            tempA = mapping.substring(length, index);
            length = index + 1;

            // Read mappedCounter
            index = mapping.indexOf(' ', length);
            if (index == -1) {
                index = mapping.length();
            }
            tempB = mapping.substring(length, index);
            length = index + 1;

            // Parse values
            revC = Integer.parseInt(tempA);
            mapC = Integer.parseInt(tempB);

            // System.out.println(revC + " -> " + mapC);
        }

        if (revC == revisionCounter) {
            // System.out.println(revC + " >> " + mapC);
            return mapC;
        }

        return revisionCounter;
    }
1140889
public static Map<Object,Object> parse(List<String>   args)
	{
		final short START =1, VAL=2;
		short state = START;
		Map<Object,Object> map = new HashMap<>(args.size());
		
		String key=null,value=null;
		for (String arg : args)
		{
			arg = arg.trim();
			
			switch(state)
			{
				case START: 
					
					if(arg.startsWith("-"))
						arg = Text.replaceForRegExprWith(arg, "^-*", "");
					
					if(arg.contains("="))
					{
						String[] tokens = Text.splitRE(arg, "=");
						if(tokens.length == 2)
						{
							key = tokens[0];
							value = tokens[1];
							
							map.put(key, formatValue(value));
							
							state = START;
						}
					}
					else
					{
						key = arg;
						state = VAL;
					}
					
					System.out.println("key:"+key);
					
					
				break;
				case VAL: 
					
					map.put(key, formatValue(arg));
					state = START;
				break;
			 	default: throw new RuntimeException("Unknown message:");
			}
		}
		
		
		return map;
	}
1336295
@Override
    public Object map(Object input) {
        String value = input.toString();
        //Do conversion
        Integer classIdx = statesMap.get(value);
        if (classIdx == null) {
            throw new IllegalStateException("Cannot convert categorical value to integer value: input value (\"" + value
                    + "\") is not in the list of known categories (state names/categories: " + stateNames + ")");
        }
        return classIdx;
    }
1250737
public static void main(String[] args) {
    Map<Integer,Integer> originalMap = new HashMap<Integer,Integer>();
    Random r = new Random();
    for (int i = 0; i < 1000; i++) {
      originalMap.put(Integer.valueOf(i), Integer.valueOf(r.nextInt(1000)));
    }
    Map<Integer,Integer> originalCopyMap = new HashMap<Integer,Integer>(originalMap);
    Map<Integer,Integer> deltaCopyMap = new HashMap<Integer,Integer>(originalMap);
    Map<Integer,Integer> deltaMap = new DeltaMap<Integer,Integer>(originalMap);
    // now make a lot of changes to deltaMap;
    // add and change some stuff
    for (int i = 900; i < 1100; i++) {
      Integer rInt = Integer.valueOf(r.nextInt(1000));
      deltaMap.put(Integer.valueOf(i), rInt);
      deltaCopyMap.put(Integer.valueOf(i), rInt);
    }
    // remove some stuff
    for (int i = 0; i < 100; i++) {
      Integer rInt = Integer.valueOf(r.nextInt(1100));
      deltaMap.remove(rInt);
      deltaCopyMap.remove(rInt);
    }
    // set some stuff to null
    for (int i = 0; i < 100; i++) {
      Integer rInt = Integer.valueOf(r.nextInt(1100));
      deltaMap.put(rInt, null);
      deltaCopyMap.put(rInt, null);
    }

    System.out.println("Original preserved? " + originalCopyMap.equals(originalMap));
    System.out.println("Delta accurate? " + deltaMap.equals(deltaCopyMap));
  }
614174
public static Integer getInt(Map<?, ?> map, Object key) {
		return get(map, key, Integer.class);
	}
385414
@UsedByGeneratedCode
    public static Map mapOf(Object... values) {
        int len = values.length;
        if (len % 2 != 0) {
            throw new IllegalArgumentException("Number of arguments should be an even number representing the keys and values");
        }

        Map answer = new LinkedHashMap(len / 2);
        int i = 0;
        while (i < values.length - 1) {
            answer.put(values[i++], values[i++]);
        }
        return answer;
    }
1255888
public static List<Map<String, Object>> getListMap(String sql, Object... arg) {
        Connection connection = JDBCUtils.getConnection();
        PreparedStatement ps = null;
        ResultSet result = null;
        List<Map<String, Object>> listMap = new ArrayList<Map<String, Object>>();
        try {
            ps = connection.prepareStatement(sql);
            for (int i = 0; i < arg.length; i++) {
                ps.setObject(i + 1, arg[i]);
            }

            result = ps.executeQuery();
            listMap = DBUtils.handleResultSetToMapList(result, listMap);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.release(result, ps, connection);
        }
        return listMap;
    }
1027641
public int getInt(Integer type)
   {
      int result = 0;

      byte[] item = m_map.get(type);
      if (item != null)
      {
         result = MPPUtility.getInt(item, 0);
      }

      return (result);
   }
956543
@Override
    public Map<String, String[]> getParameterMap() {
        ServletRESTRequestImpl ret = castRequest();
        if (ret != null)
            return ret.getParameterMap();
        return null;
    }
594372
private static String convertArgs(String[] args)
    {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < args.length; i++)
        {
            result.append(args[i]);
            if (i < args.length - 1)
            {
                result.append(' ');
            }
        }
        return result.toString().toUpperCase();
    }
575743
@Override
    public Integer getIntegerOrDie(String key) {
        Integer value = getInteger(key);
        if (value == null) {
            throw new IllegalArgumentException(String.format(ERROR_KEYNOTFOUND, key));
        } else {
            return value;
        }
    }
286220
public static StringBuilder computeMessageBuffer(HttpResponse response) {
    StringBuilder builder = new StringBuilder();
    int statusCode = response.getStatusCode();
    if (statusCode != 0) {
      builder.append(statusCode);
    }
    String statusMessage = response.getStatusMessage();
    if (statusMessage != null) {
      if (statusCode != 0) {
        builder.append(' ');
      }
      builder.append(statusMessage);
    }
    return builder;
  }
1236685
public Map<String, String> getStringMap(final Map<String, String> map) {
		final int len = getVInt();
		for (int i = 0; i < len; i++) {
			map.put(getString(), getString());
		}
		return map;
	}