Java TIntObjectHashMap类代码示例

import gnu.trove.map.hash.TIntObjectHashMap; //导入依赖的package包/类
public void addPartition(EquivalenceManagedPartition partition) {
	if (!this.observedPartitions.contains(partition.getIndices()) && !this.containsSimilarPartition(partition)) {
		this.observedPartitions.add(partition.getIndices());
		long hashNumber = partition.getHashNumber();
		System.out.println(String.format("Partition[%s]\t%d\tSize: %d", partition.getIndices(), hashNumber, partition.size()));
		partitionHashes.putIfAbsent(hashNumber, new TIntObjectHashMap<THashSet<EquivalenceManagedPartition>>());
		partitionHashes.get(hashNumber).putIfAbsent(partition.size(), new THashSet<EquivalenceManagedPartition>());
		THashSet<EquivalenceManagedPartition> partitionGroup = partitionHashes.get(hashNumber).get(partition.size());

		if (partitionGroup.isEmpty()) {
			partitionGroup.add(partition);
		} else {
			// then there is at least one element in the partitionGroup
			checkPossibleEquivalences(partitionGroup, partition);
		}
	}
}
 

import gnu.trove.map.hash.TIntObjectHashMap; //导入依赖的package包/类
public CodeGenTypes(HIRModuleGenerator moduleBuilder, TargetData td)
{
    builder = moduleBuilder;
    typeCaches = new HashMap<>();
    recordBeingLaidOut = new HashSet<>();
    functionBeingProcessed = new HashSet<>();
    deferredRecords = new LinkedList<>();
    recordDeclTypes = new HashMap<>();
    cgRecordLayout = new HashMap<>();
    fieldInfo = new HashMap<>();
    bitfields = new HashMap<>();
    context = moduleBuilder.getASTContext();
    target = context.target;
    theModule = moduleBuilder.getModule();
    targetData = td;
    pointersToResolve = new LinkedList<>();
    tagDeclTypes = new HashMap<>();
    functionTypes = new HashMap<>();
    functionInfos = new TIntObjectHashMap<>();
}
 

import gnu.trove.map.hash.TIntObjectHashMap; //导入依赖的package包/类
public void register(Item item, int meta, ModelResourceLocation location)
{
    TIntObjectHashMap<ModelResourceLocation> locs = locations.get(item);
    TIntObjectHashMap<IBakedModel>           mods = models.get(item);
    if (locs == null)
    {
        locs = new TIntObjectHashMap<ModelResourceLocation>();
        locations.put(item, locs);
    }
    if (mods == null)
    {
        mods = new TIntObjectHashMap<IBakedModel>();
        models.put(item, mods);
    }
    locs.put(meta, location);
    mods.put(meta, getModelManager().getModel(location));
}
 

import gnu.trove.map.hash.TIntObjectHashMap; //导入依赖的package包/类
public void createMesh(List<Mesher> meshers, JmeResourceManager resourceManager) {
	Realm realm = chunk.getRealm();
	
	TIntObjectMap<Mesh> meshes = new TIntObjectHashMap<>();
	
	for (Mesher mesher : meshers) {
		meshes.putAll(mesher.buildMeshes(chunk));
	}
	
	geometries.clear();
	
	for (int key : meshes.keys()) {
		Block block = realm.getCosmos().getBlocks().get(key);
		
		Geometry geometry = new Geometry(chunk.toString() + ":" + block.getName(), meshes.get(key));
		geometry.setMaterial(resourceManager.getMaterial(block));
		geometry.setQueueBucket(Bucket.Transparent);
		
		geometries.add(geometry);
	}
}
 

import gnu.trove.map.hash.TIntObjectHashMap; //导入依赖的package包/类
public void testGet() {
    int element_count = 20;
    int[] keys = new int[element_count];
    String[] vals = new String[element_count];

    TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
    for (int i = 0; i < element_count; i++) {
        keys[i] = i + 1;
        vals[i] = Integer.toString(i + 1);
        raw_map.put(keys[i], vals[i]);
    }
    Map<Integer, String> map = TDecorators.wrap(raw_map);

    assertEquals(vals[10], map.get(Integer.valueOf(keys[10])));
    assertNull(map.get(Integer.valueOf(1138)));

    Integer key = Integer.valueOf(1138);
    map.put(key, null);
    assertTrue(map.containsKey(key));
    assertNull(map.get(key));

    Long long_key = Long.valueOf(1138);
    //noinspection SuspiciousMethodCalls
    assertNull(map.get(long_key));
}
 

import gnu.trove.map.hash.TIntObjectHashMap; //导入依赖的package包/类
public void testContainsKey() {
    int element_count = 20;
    int[] keys = new int[element_count];
    String[] vals = new String[element_count];

    TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
    for (int i = 0; i < element_count; i++) {
        keys[i] = i + 1;
        vals[i] = Integer.toString(i + 1);
        raw_map.put(keys[i], vals[i]);
    }
    Map<Integer, String> map = TDecorators.wrap(raw_map);

    for (int i = 0; i < element_count; i++) {
        assertTrue("Key should be present: " + keys[i] + ", map: " + map,
                map.containsKey(keys[i]));
    }

    int key = 1138;
    assertFalse("Key should not be present: " + key + ", map: " + map,
            map.containsKey(key));
}
 

import gnu.trove.map.hash.TIntObjectHashMap; //导入依赖的package包/类
public void testContainsValue() {
    int element_count = 20;
    int[] keys = new int[element_count];
    String[] vals = new String[element_count];

    TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
    for (int i = 0; i < element_count; i++) {
        keys[i] = i + 1;
        vals[i] = Integer.toString(i + 1);
        raw_map.put(keys[i], vals[i]);
    }
    Map<Integer, String> map = TDecorators.wrap(raw_map);

    for (int i = 0; i < element_count; i++) {
        assertTrue("Value should be present: " + vals[i] + ", map: " + map,
                map.containsValue(vals[i]));
    }

    String val = "1138";
    assertFalse("Key should not be present: " + val + ", map: " + map,
            map.containsValue(val));

    //noinspection SuspiciousMethodCalls
    assertFalse("Random object should not be present in map: " + map,
            map.containsValue(new Object()));
}
 

import gnu.trove.map.hash.TIntObjectHashMap; //导入依赖的package包/类
public void testPutAllMap() {
    int element_count = 20;
    int[] keys = new int[element_count];
    String[] vals = new String[element_count];

    TIntObjectMap<String> raw_control = new TIntObjectHashMap<String>();
    for (int i = 0; i < element_count; i++) {
        keys[i] = i + 1;
        vals[i] = Integer.toString(i + 1);
        raw_control.put(keys[i], vals[i]);
    }
    Map<Integer, String> control = TDecorators.wrap(raw_control);

    TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
    Map<Integer, String> map = TDecorators.wrap(raw_map);

    Map<Integer, String> source = new HashMap<Integer, String>();
    for (int i = 0; i < element_count; i++) {
        source.put(keys[i], vals[i]);
    }

    map.putAll(source);
    assertEquals(control, map);
}
 

import gnu.trove.map.hash.TIntObjectHashMap; //导入依赖的package包/类
public void testPutAll() throws Exception {
    TIntObjectMap<String> raw_t = new TIntObjectHashMap<String>();
    Map<Integer, String> t = TDecorators.wrap(raw_t);
    TIntObjectMap<String> raw_m = new TIntObjectHashMap<String>();
    Map<Integer, String> m = TDecorators.wrap(raw_m);
    m.put(2, "one");
    m.put(4, "two");
    m.put(6, "three");

    t.put(5, "four");
    assertEquals(1, t.size());

    t.putAll(m);
    assertEquals(4, t.size());
    assertEquals("two", t.get(4));
}
 

import gnu.trove.map.hash.TIntObjectHashMap; //导入依赖的package包/类
public void testClear() {
    int element_count = 20;
    int[] keys = new int[element_count];
    String[] vals = new String[element_count];

    TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
    for (int i = 0; i < element_count; i++) {
        keys[i] = i + 1;
        vals[i] = Integer.toString(i + 1);
        raw_map.put(keys[i], vals[i]);
    }
    Map<Integer, String> map = TDecorators.wrap(raw_map);
    assertEquals(element_count, map.size());

    map.clear();
    assertTrue(map.isEmpty());
    assertEquals(0, map.size());

    assertNull(map.get(keys[5]));
}
 

import gnu.trove.map.hash.TIntObjectHashMap; //导入依赖的package包/类
@SuppressWarnings({"unchecked"})
public void testSerialize() throws Exception {
    int element_count = 20;
    int[] keys = new int[element_count];
    String[] vals = new String[element_count];

    TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
    for (int i = 0; i < element_count; i++) {
        keys[i] = i + 1;
        vals[i] = Integer.toString(i + 1);
        raw_map.put(keys[i], vals[i]);
    }
    Map<Integer, String> map = TDecorators.wrap(raw_map);

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(baos);
    oos.writeObject(map);

    ByteArrayInputStream bias = new ByteArrayInputStream(baos.toByteArray());
    ObjectInputStream ois = new ObjectInputStream(bias);

    Map<Integer, String> deserialized = (Map<Integer, String>) ois.readObject();

    assertEquals(map, deserialized);
}
 

import gnu.trove.map.hash.TIntObjectHashMap; //导入依赖的package包/类
public void init(){
    handlerMap = new HashMap<>();
    TIntObjectHashMap<Class<?>> netEventHandlerClassMap = ServiceHelper.getNetEventListenerHandlerClassMap();
    netEventHandlerClassMap.forEachEntry(new TIntObjectProcedure<Class<?>>() {
        @Override
        public boolean execute(int i, Class<?> aClass) {
            handlerMap.put(i, (NetEventListenerHandler) BeanHelper.getServiceBean(aClass));
            return true;
        }
    });

    selfAdd = Util.getHostAddress()+":"+Server.getEngineConfigure().getNetEventPort();


    monitorService = BeanHelper.getServiceBean(MonitorService.class);
    eventService = BeanHelper.getServiceBean(EventService.class);
    monitorService.addStartCondition(SysConstantDefine.NetEventServiceStart,
            "wait for netEvent start and connect mainServer");
}
 

import gnu.trove.map.hash.TIntObjectHashMap; //导入依赖的package包/类
public DynamicGrid(T defaultElement, T[][] data){
  this(defaultElement);
  for(int x = 0; x < data.length; ++x){
    T[] arr = data[x];
    TIntObjectHashMap<T> map = new TIntObjectHashMap<>();
    for(int y = 0; y < arr.length; ++y){
      T element = arr[y];
      if(element != null){
        map.put(y, element);
      }
    }
    map.compact();
    grid.put(x, map);
  }
  grid.compact();
}
 

import gnu.trove.map.hash.TIntObjectHashMap; //导入依赖的package包/类
public static byte[] transform(WatchedEntity entity, byte[] data) throws IOException {
    if (entity == null) {
        return data;
    }
    TIntObjectMap<DataWatcherObject> objects = DataWatcherSerializer.decodeData(data);
    TIntObjectMap<DataWatcherObject> newobjects = new TIntObjectHashMap<DataWatcherObject>();
    //copy entity
    moveDWData(objects, newobjects, 0, 0); //flags
    moveDWData(objects, newobjects, 1, 1); //air
    moveDWData(objects, newobjects, 2, 2); //nametag
    moveDWData(objects, newobjects, 3, 3); //nametagvisible
    //copy specific types
    for (RemappingEntry entry : entity.getType().getRemaps()) {
        moveDWData(objects, newobjects, entry.getFrom(), entry.getTo());
    }
    return DataWatcherSerializer.encodeData(newobjects);
}
 

import gnu.trove.map.hash.TIntObjectHashMap; //导入依赖的package包/类
public void setFeatureExtractor(TrendDetectorFeatureExtractor fe) {
	this.extractor = fe;
	final MersenneTwister rng = new MersenneTwister();

	final DoubleGaussianFactory gauss = new DoubleGaussianFactory(fe.nDimensions(), rng, w);
	final HashFunctionFactory<double[]> factory = new HashFunctionFactory<double[]>() {
		@Override
		public HashFunction<double[]> create() {
			return new LSBModifier<double[]>(gauss.create());
		}
	};

	sketcher = new IntLSHSketcher<double[]>(factory, nbits);
	database = new ArrayList<TIntObjectHashMap<Set<WriteableImageOutput>>>(
			sketcher.arrayLength());

	for (int i = 0; i < sketcher.arrayLength(); i++)
		database.add(new TIntObjectHashMap<Set<WriteableImageOutput>>());

}