Factory method to create a new storage backed by a hashmap.
@param name
@param <K>
@param <V>
@return
979769
public static <K,V> Storage<K,V> createHashMapStorage(String name){
		return new Storage<K,V>(name, new MapStorageWrapper<K, V>(new HashMap<K, V>()));
	}
1007372
@NotNull
    public static Key<Integer> integerKey(@NotNull String name) {
        return create(name, Integer.class);
    }
396077
@SuppressWarnings("unchecked")
  public <T extends AbstractCache<KEY, VALUE>> T named(String name) {
    this.name = name;
    return (T) this;
  }
777463
public ByteBuffer mapFile(String name) throws IOException
  {
    final Metadata metadata = internalFiles.get(name);
    if (metadata == null) {
      return null;
    }

    final int fileNum = metadata.getFileNum();
    while (buffersList.size() <= fileNum) {
      buffersList.add(null);
    }

    MappedByteBuffer mappedBuffer = buffersList.get(fileNum);
    if (mappedBuffer == null) {
      mappedBuffer = Files.map(outFiles.get(fileNum));
      buffersList.set(fileNum, mappedBuffer);
    }

    ByteBuffer retVal = mappedBuffer.duplicate();
    retVal.position(metadata.getStartOffset()).limit(metadata.getEndOffset());
    return retVal.slice();
  }
1021720
public static Application create(final String name) throws Exception{
    	final Map<String, Object> params = new HashMap<String, Object>();
    	params.put("name", name);
    	
    	return create(params);
    }
184940
public App named(String name) {
        App newApp = copy();
        newApp.name = name;
        return newApp;
    }
380443
public static <K, V> HashMap<K, V> createHashMap(int initialCapacity) {
        return new HashMap<K, V>(initialCapacity);
    }
628840
private Map<String, Object> loadData(String name) {
        Map<String, Object> data = new HashMap<>();

        Map<String, Object> files = context.getDatafiles(name);
        if (files != null) {
            data = EdenUtils.merge(data, files);
        }

        Map<String, Object> file = context.getDatafile(name);
        if(file != null) {
            data = EdenUtils.merge(data, file);
        }

        Map<String, Object> envFile = context.getDatafile(name + "-" + context.getEnvironment());
        if(envFile != null) {
            data = EdenUtils.merge(data, envFile);
        }

        return data;
    }
559991
@Override
    public java.util.concurrent.Future<CreateTopicResult> createTopicAsync(String name) {

        return createTopicAsync(new CreateTopicRequest().withName(name));
    }
17361
public static <K, V> LinkedHashMultimap<K, V> create() {
    return new LinkedHashMultimap<K, V>(DEFAULT_KEY_CAPACITY, DEFAULT_VALUE_SET_CAPACITY);
  }
155657
public static Specification newInstance(String name)
    {
        Specification specification = new Specification();
        specification.setName(name);
        return specification;
    }
305535
public T addFile(final String name, final List<String> path, final byte[] newHash, final boolean isDirectory) {
        return addFile(name, path, newHash, isDirectory, null);
    }
119639
private final Object getObject(String name)
   {
      Object result = m_map.get(name);
      return (result);
   }
531958
public KieSessionModel newKieSessionModel(String name) {
        KieSessionModel kieSessionModel = new KieSessionModelImpl( this, name );
        Map<String, KieSessionModel> newMap = new HashMap<String, KieSessionModel>();
        newMap.putAll( this.kSessions );
        newMap.put( kieSessionModel.getName(), kieSessionModel );
        setKSessions( newMap );

        return kieSessionModel;
    }
562549
public static void putHashTable(final String name, final Hashtable hash) {
		final Enumeration<String> keys = hash.keys();
		final StringBuffer buf = new StringBuffer("");
		while (keys.hasMoreElements()) {
			if (!buf.toString().equals("")) {
				// end the previous record
				buf.append(";");
			}
			final String key = keys.nextElement();
			final String value = hash.get(key).toString();
			buf.append(key + ":" + value);
		}
		put(fixKey(name), buf.toString());
	}
1143764
public static <K, V> HashMap<K, V> newHashMap(int size, boolean isOrder) {
		return MapUtil.newHashMap(size, isOrder);
	}
14410
public static DataResource fromName(String name)
    {
        String[] parts = StringUtils.split(name, '/');

        if (!parts[0].equals(ROOT_NAME) || parts.length > 3)
            throw new IllegalArgumentException(String.format("%s is not a valid data resource name", name));

        if (parts.length == 1)
            return root();

        if (parts.length == 2)
            return keyspace(parts[1]);

        return columnFamily(parts[1], parts[2]);
    }