Return a map of properties with name as key and value as entry

@param result
Array {propName, propSize, values...,propNameN, propSizeN,
valuesN}
@param startingPoint
@return
180969
private Map<String, String[]> extractArgout(final String[] result, final int startingPoint) {
        final Map<String, String[]> map = new CaseInsensitiveMap<String[]>();
        if (result.length > 4) {
            // System.out.println(result[0]);// device name
            // System.out.println(Integer.valueOf(result[1]));// prop size
            // System.out.println(result[2]);// prop name
            int i = startingPoint;
            int nextSize = Integer.valueOf(result[i + 1]);

            while (i < result.length) {
                // System.out.println("i " + i);
                if (nextSize > 0) {
                    final String name = result[i].toLowerCase(Locale.ENGLISH);
                    final String[] propValues = Arrays.copyOfRange(result, i + 2, nextSize + i + 2);
                    map.put(name, propValues);
//                    System.out.println("name " + name);
//                    System.out.println("prop1 " + Arrays.toString(propValues));
                }
                final int idxNextPropSize;
                if (nextSize == 0) {
                    // System.out.println("zero");
                    idxNextPropSize = i + 4;
                    i = i + 3;
                } else {
                    idxNextPropSize = nextSize + i + 3;
                    i = nextSize + i + 2;
                }
                // System.out.println("idxNextPropSize " + idxNextPropSize);

                if (idxNextPropSize >= result.length) {
                    break;
                }

                // System.out.println("idxNextPropSize value " +
                // result[idxNextPropSize]);
                nextSize = Integer.valueOf(result[idxNextPropSize]);
                // System.out.println("nextSize " + nextSize);
            }
        }
        return map;
    }
945214
public void startOnInit(Result<I> result)
  {
    
    DeployFactory2<I> builder = builder();
    
    if (builder == null) {
      result.ok(null);
      return;
    }
    
    if (! _lifecycle.toInit()) {
      result.ok(get());
      return;
    }
    
    _strategy.startOnInit(this, result);
  }
117174
private List<ResultMap> getResultMap(String namespace, Class<?> clazz, Configuration conf) {
    String dynamicResultMapId = namespace + "." + GENERATE_RESULT_MAP_NAME;
    ResultMap dynamicResultMap = buildResultMap(dynamicResultMapId, clazz, conf);
    List<ResultMap> resultMaps = Lists.newArrayList();
    resultMaps.add(dynamicResultMap);
    return Collections.unmodifiableList(resultMaps);
  }
1157958
@Override
	public Map<String, String> toProperties() {
		DescriptorProperties properties = new DescriptorProperties();
		List<Map<String, String>> subKeyValues = new ArrayList<>();
		for (Map.Entry<String, LinkedHashMap<String, String>> entry : tableSchema.entrySet()) {
			String name = entry.getKey();
			LinkedHashMap<String, String> props = entry.getValue();
			Map<String, String> map = new HashMap<>();
			map.put(SCHEMA_NAME, name);
			map.putAll(props);
			subKeyValues.add(map);
		}
		properties.putIndexedVariableProperties(
			SCHEMA,
			subKeyValues);
		return properties.asMap();
	}
265905
public GeoServiceGeocodingResult toGeoServiceGeocodingResult(
            final GeocodingResult result) {
        if (result == null) {
            return null;
        }
        return new GeoServiceGeocodingResult(
                result.addressComponents,
                result.formattedAddress,
                result.postcodeLocalities,
                toGeoServiceGeometry(result.geometry),
                result.types,
                result.partialMatch,
                result.placeId);
    }
1187283
public Map<String, Object> getAllProperties() {
        Map<String, Object> map = new HashMap<>();

        Arrays
            .stream(catalog)
            .filter(Objects::nonNull)
            .map(Map::entrySet)
            .flatMap(Collection::stream)
            .forEach((Map.Entry<String, Object> entry) -> {
                String k = entry.getKey();
                Object value = resolvePlaceHoldersIfNecessary(entry.getValue());
                Map finalMap = map;
                int index = k.indexOf('.');
                if (index != -1) {
                    String[] keys = k.split("\\.");
                    for (int i = 0; i < keys.length - 1; i++) {
                        if (!finalMap.containsKey(keys[i])) {
                            finalMap.put(keys[i], new HashMap<>());
                        }
                        Object next = finalMap.get(keys[i]);
                        if (next instanceof Map) {
                            finalMap = ((Map) next);
                        }
                    }
                    finalMap.put(keys[keys.length - 1], value);
                } else {
                    finalMap.put(k, value);
                }
            });

        return map;
    }
986495
@Override
    public Object get(Symbol key, Scriptable start)
    {
        Slot slot = slotMap.query(key, 0);
        if (slot == null) {
            return Scriptable.NOT_FOUND;
        }
        return slot.getValue(start);
    }
1074924
private Map processEvent(MatchResult result) {
    Map map = new HashMap();
    //group zero is the entire match - process all other groups
    for (int i = 1; i < result.groupCount() + 1; i++) {
      Object key = matchingKeywords.get(i - 1);
      Object value = result.group(i);
      map.put(key, value);

    }
    return map;
  }
743452
public static Map<String, CmsProperty> toObjectMap(Iterable<CmsProperty> properties) {

        Map<String, CmsProperty> result = new LinkedHashMap<String, CmsProperty>();
        for (CmsProperty property : properties) {
            result.put(property.getName(), property);
        }
        return result;
    }
270029
private Map<String, String> simpleColumnToPropertyMappings(Map<String, ColumnMetaData> cm){
		Map<String, String> result = new HashMap<String, String>(cm.size());
		for (Entry<String, ColumnMetaData> entry: cm.entrySet()){
			result.put(entry.getKey(), entry.getValue().getPropertyName());
		}
		return result;
	}
674764
function getEntryURLs(properties, preference = ENTRY_URL_TYPE_ANY) {
    const urlRef = Object.keys(properties)
        .filter(key => URL_PROP.test(key))
        .reduce(
            (output, nextKey) =>
                Object.assign(output, {
                    [nextKey]: properties[nextKey]
                }),
            {}
        );
    if (preference === ENTRY_URL_TYPE_GENERAL || preference === ENTRY_URL_TYPE_LOGIN) {
        return Object.keys(urlRef)
            .sort((a, b) => {
                if (preference === ENTRY_URL_TYPE_GENERAL) {
                    const general = /^ur[li]$/i;
                    const aVal = general.test(a) ? 1 : 0;
                    const bVal = general.test(b) ? 1 : 0;
                    return bVal - aVal;
                } else if (preference === ENTRY_URL_TYPE_LOGIN) {
                    const login = /login/i;
                    const aVal = login.test(a) ? 1 : 0;
                    const bVal = login.test(b) ? 1 : 0;
                    return bVal - aVal;
                }
                return 0;
            })
            .map(key => urlRef[key]);
    } else if (preference === ENTRY_URL_TYPE_ICON) {
        const iconProp = Object.keys(urlRef).find(key => URL_PROP_ICON.test(key));
        return iconProp ? [urlRef[iconProp]] : [];
    }
    // Default is "any" URLs
    return objectValues(urlRef);
}
304433
public static Result createResultForStage1(Result result) {
    VariableMap emptyVariableMap = new VariableMap(ImmutableMap.of());
    return new Result(
        result.errors,
        result.warnings,
        emptyVariableMap,
        emptyVariableMap,
        emptyVariableMap,
        null,
        null,
        "",
        null,
        null,
        null);
  }
31024
static public Map<String,Object> propertiesToMap(Dictionary<?, ?> properties)
    {
        Map<String,Object> map = null;
        if (properties != null)
        {
	        map = new Hashtable<String,Object>();
	        Enumeration<?> keys = properties.keys();
	        while (keys.hasMoreElements())
	        {
	        	Object key = keys.nextElement();
                map.put((String)key, properties.get(key));	            
	        }
        }
        return map;
    }
1098284
private Map<String, TypeName> convertPropertiesToTypes(Map<String, ExecutableElement> properties) {
    Map<String, TypeName> types = new LinkedHashMap<>();
    for (Map.Entry<String, ExecutableElement> entry : properties.entrySet()) {
      ExecutableElement el = entry.getValue();
      types.put(entry.getKey(), TypeName.get(el.getReturnType()));
    }
    return types;
  }
807617
public static MapPropertySource of(String name, Map<String, Object> map) {
        return new MapPropertySource(name, map);
    }
651649
public Map<String, ByteString> rangeQueryRawState(String startKey, String endKey) {
        Map<String, ByteString> map = new HashMap<>();
        for (Chaincode.RangeQueryStateKeyValue mapping : handler.handleRangeQueryState(
                startKey, endKey, uuid).getKeysAndValuesList()) {
            map.put(mapping.getKey(), mapping.getValue());
        }
        return map;
    }
1258192
static String[] getProp(final Map<String, String[]> prop, final String propertyName) {
        String[] result = null;
        if (prop != null) {
            for (final Entry<String, String[]> entry : prop.entrySet()) {
                if (entry.getKey().equalsIgnoreCase(propertyName)) {
                    result = entry.getValue();
                }
            }
        }
        return result;
    }