gnu.trove.map.TIntObjectMap Java Examples

@Override
public void execute() {
	try {
		Connection conn = DriverManager.getConnection(jdbcString);
		deleteThenCreate(conn);
		int s1 = (int) options1.getOrDefault(AqlOption.start_ids_at);
		int s2 = (int) options2.getOrDefault(AqlOption.start_ids_at);
		Pair<TObjectIntMap<X1>, TIntObjectMap<X1>> I = h.src().algebra().intifyX(s1);
		Pair<TObjectIntMap<X2>, TIntObjectMap<X2>> J = h.dst().algebra().intifyX(s2);
		for (En en : h.src().schema().ens) {
			for (X1 x : h.src().algebra().en(en)) {
				storeMyRecord(I, J, conn, x, prefix + enToString(en), en);
			}
		}
		conn.close();
	} catch (Exception e) {
		e.printStackTrace();
		throw new RuntimeException(e);
	}
}
 

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);
}
 

@Test
public void testTroveMapPreservesSynapseOrdering() {
    Synapse s = new Synapse();
    TIntObjectMap<Synapse> t = new TIntObjectHashMap<>();
    t.put(2, s);
    t.put(4, s);
    t.put(6, s);
    t.put(8, s);
    t.put(10, s);
    t.put(12, s);
    
    int[] expectedKeys = { 12, 10, 8, 6, 4, 2 };
    assertTrue(Arrays.equals(expectedKeys, t.keys()));
    
    // Insert a cell index in the middle, check that order is still
    // preserved following inserts
    t.put(3, s);
    expectedKeys = new int[] { 12, 10, 8, 6, 4, 3, 2 };
    assertTrue(Arrays.equals(expectedKeys, t.keys()));
    
    // Check reversing produces ascending ordered Synapses
    expectedKeys = new int[] { 2, 3, 4, 6, 8, 10, 12 };
    assertTrue(Arrays.equals(expectedKeys, ArrayUtils.reverse(t.keys())));
}
 

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);
}
 

private static mt_other encodeOther(TIntObjectMap<metric_value> t_other, int timestampsSize) {
    LOG.log(Level.FINEST, "encoding {0}", TDecorators.wrap(t_other));
    metric_value[] values = new metric_value[timestampsSize];
    int values_len = 0;
    for (int i = 0; i < values.length; ++i) {
        metric_value mv = t_other.get(i);
        if (mv != null)
            values[values_len++] = mv;
    }

    mt_other result = new mt_other();
    result.presence = createPresenceBitset(t_other.keySet(), timestampsSize);
    result.values = Arrays.copyOf(values, values_len);

    return result;
}
 

@Override
public StaticRouting fromJSON(Model mo, JSONObject o) throws JSONConverterException {
    Network v = Network.get(mo);
    TIntObjectMap<Link> idToLink = new TIntObjectHashMap<>();
    for (Link l : v.getLinks()) {
        idToLink.put(l.id(), l);
    }
    StaticRouting r = new StaticRouting();
    checkKeys(o, ROUTES_LABEL);
    JSONArray a = (JSONArray) o.get(ROUTES_LABEL);
    for (Object ao : a) {
        StaticRouting.NodesMap nm = nodesMapFromJSON(mo, (JSONObject) ((JSONObject) ao).get("nodes_map"));
        Map<Link, Boolean> links = new LinkedHashMap<>();
        JSONArray aoa = (JSONArray) ((JSONObject) ao).get("links");
        for (Object aoao : aoa) {
            links.put(idToLink.get(requiredInt((JSONObject)aoao, "link")),
                    Boolean.valueOf(requiredString((JSONObject) aoao, "direction")));
        }
        r.setStaticRoute(nm, links);
    }
    return r;
}
 

/**
 * Find matches for a given set
 */
private TIntFloatHashMap search(int[][] querySet, int[][][] collection, float simThreshold,
        TIntObjectMap<TIntList>[] idx) {

    /* SIGNATURE GENERATION */
    TIntSet[] unflattenedSignature = computeUnflattenedSignature(querySet, simThreshold, idx);

    /* CANDIDATE SELECTION AND CHECK FILTER */
    TIntObjectMap<TIntFloatMap> checkFilterCandidates = applyCheckFilter(querySet, collection,
            unflattenedSignature, idx, simThreshold);

    /* NEAREST NEIGHBOR FILTER */
    TIntSet nnFilterCandidates = applyNNFilter(querySet, collection, checkFilterCandidates, simThreshold);

    /* VERIFICATION */
    TIntFloatHashMap matches = verifyCandidates(querySet, collection, nnFilterCandidates, simThreshold);

    return matches;
}
 

/**
 * Computes the join between two already transformed and indexed collections
 *
 * @param collection1
 * @param collection2
 * @param simThreshold
 * @return
 */
HashMap<String, Float> join(int[][][] collection1, int[][][] collection2, float simThreshold) {
    final HashMap<String, Float> matchingPairs = new HashMap<>();

    /* CREATE INDEX */
    TIntObjectMap<TIntList>[] idx = buildSetInvertedIndex(collection2, tokenDict.size());

    /* EXECUTE THE JOIN ALGORITHM */
    for (int i = 0; i < collection1.length; i++) {
        TIntFloatHashMap matches = search(collection1[i], collection2, simThreshold, idx);
        for (int j : matches.keys()) {
            matchingPairs.put(i + "_" + j, matches.get(j));
        }
    }

    return matchingPairs;
}
 

private void storeMyRecord(Pair<TObjectIntMap<X1>, TIntObjectMap<X1>> i,
		Pair<TObjectIntMap<X2>, TIntObjectMap<X2>> j, Connection conn, X1 x, String table, En en) throws Exception {
	List<String> hdrQ = new LinkedList<>();
	List<String> hdr = new LinkedList<>();
	hdr.add("src" + idCol);
	hdr.add("dst" + idCol);
	hdrQ.add("?");
	hdrQ.add("?");

	String insertSQL = "INSERT INTO " + table + "(" + Util.sep(hdr, ",") + ") values (" + Util.sep(hdrQ, ",") + ")";
	PreparedStatement ps = conn.prepareStatement(insertSQL);

	ps.setObject(1, i.first.get(x), colTy0);
	ps.setObject(2, j.first.get(h.repr(en, x)), colTy0);

	ps.executeUpdate();
	ps.close();
}
 

/**
 * 
 * @param chr
 * @param pos
 * @return null if not found
 */
public E get(String chr, int pos){
	TIntObjectMap<E> chrElements = data.get(chr);
	if(chrElements == null){
		return null;
	} else {
		return chrElements.get(pos);
	}
}
 

@SuppressWarnings("RedundantStringConstructorCall")
public void put(String chr, int pos, E element){
	TIntObjectMap<E> chrElements = data.get(chr);
	if(chrElements == null){
		chrElements = new TIntObjectHashMap<E>();
		data.put(new String(chr), chrElements);
	}
	chrElements.put(pos, element);
}
 

/**
 * 
 * @param chr
 * @param pos
 * @return the removed element or null
 */
public E remove(String chr, int pos){
	
	TIntObjectMap<E> chrElements = data.get(chr);
	if(chrElements == null){
		return null;
	} else {
		return chrElements.remove(pos);
	}
	
}
 

public Iterator<E> chrIterator(String chr) {
	
	TIntObjectMap<E> chrElements = data.get(chr);
	if(chrElements == null){
		return null;
	} else {
		return chrElements.valueCollection().iterator();
	}
	
}
 

@Override
public Iterator<E> iterator() {
	
	Iterator[] chrIterators = new Iterator[data.size()];
	
	int i = 0;
	for(TIntObjectMap<E> chrData : data.values()){
		chrIterators[i] = chrData.valueCollection().iterator();
		++i;
	}
	return Iterators.concat(chrIterators);
	
}
 

public int size(){
	int count = 0;

	for(TIntObjectMap<E> chrResults : data.values()){
		count += chrResults.size();
	}
	return count;
}
 

@Override
public int test() {
    final TIntObjectMap<Integer> m_map = new TIntObjectHashMap<>( m_keys.length / 2 + 1, m_fillFactor );
    final Integer value = 1;
    int add = 0, remove = 0;
    while ( add < m_keys.length )
    {
        m_map.put( m_keys[ add ], value );
        ++add;
        m_map.put( m_keys[ add ], value );
        ++add;
        m_map.remove( m_keys[ remove++ ] );
    }
    return m_map.size();
}
 

@Override
public int test() {
    final TIntObjectMap<Integer> m_map = new TIntObjectHashMap<>( m_keys.length, m_fillFactor );
    for ( int i = 0; i < m_keys.length; ++i )
        m_map.put( m_keys[ i ], null );
    for ( int i = 0; i < m_keys.length; ++i )
        m_map.put( m_keys[ i ], null );
    return m_map.size();
}
 

private static mt_hist encodeHist(TIntObjectMap<histogram> t_hist, int timestampsSize) {
    LOG.log(Level.FINEST, "encoding {0}", TDecorators.wrap(t_hist));
    histogram values[] = new histogram[timestampsSize];
    int values_len = 0;
    for (int i = 0; i < values.length; ++i) {
        if (t_hist.containsKey(i))
            values[values_len++] = t_hist.get(i);
    }

    mt_hist result = new mt_hist();
    result.presence = createPresenceBitset(t_hist.keySet(), timestampsSize);
    result.values = Arrays.copyOf(values, values_len);

    return result;
}
 

private static TIntObjectMap<TextureHolder> initializeIcons(Map<TextureSprite, TextureArea> sprite2TextureMap) {
    TIntObjectMap<TextureHolder> resultMap = new TIntObjectHashMap<>();
    for (int i = 0; i < 4; i++) {
        resultMap.put(pack(i, i + 1), new TextureHolder(sprite2TextureMap.get(TextureSprite.EDGE), i));
        resultMap.put(pack(i, i + 1, i + 2), new TextureHolder(sprite2TextureMap.get(TextureSprite.T_JOINT), i));
    }
    for (int i = 0; i < 2; i++) {
        resultMap.put(pack(i, i + 2), new TextureHolder(sprite2TextureMap.get(TextureSprite.STRAIGHT), i));
        resultMap.put(pack(i), new TextureHolder(sprite2TextureMap.get(TextureSprite.STRAIGHT), i));
        resultMap.put(pack(i + 2), new TextureHolder(sprite2TextureMap.get(TextureSprite.STRAIGHT), i));
    }
    resultMap.put(pack(0, 1, 2, 3), new TextureHolder(sprite2TextureMap.get(TextureSprite.CROSS), 0));
    return resultMap;
}
 

public BlockPattern(Predicate<BlockWorldState>[][][] predicatesIn,
                    List<Pair<Predicate<BlockWorldState>, IntRange>> countMatches,
                    TIntObjectMap<Predicate<PatternMatchContext>> layerMatchers,
                    List<Predicate<PatternMatchContext>> validators,
                    RelativeDirection[] structureDir,
                    int[][] aisleRepetitions) {
    this.blockMatches = predicatesIn;
    this.countMatches = countMatches.toArray(new Pair[0]);
    this.layerMatchers.putAll(layerMatchers);
    this.validators = validators.toArray(new Predicate[0]);
    this.fingerLength = predicatesIn.length;

    if (this.fingerLength > 0) {
        this.thumbLength = predicatesIn[0].length;

        if (this.thumbLength > 0) {
            this.palmLength = predicatesIn[0][0].length;
        } else {
            this.palmLength = 0;
        }
    } else {
        this.thumbLength = 0;
        this.palmLength = 0;
    }
    this.structureDir = structureDir;
    this.aisleRepetitions = aisleRepetitions;

    initializeCenterOffsets();
}
 

/**
 * DO NOT close this connection
 */
// client should not remove
public synchronized Connection addIndices(Pair<TObjectIntMap<X>, TIntObjectMap<X>> j, Map<En, List<String>> indices,
		int vlen) {
	if (conn == null) {
		conn = createAndLoad(indices, j, vlen);
		this.indicesLoaded = new LinkedList<>();
		for (List<String> l : indices.values()) {
			this.indicesLoaded.addAll(l);
		}
		return conn;
	}
	try (Statement stmt = conn.createStatement()) {
		for (List<String> ss : indices.values()) {
			for (String s : ss) {
				if (!indicesLoaded.contains(s)) {
					stmt.execute(s);
					indicesLoaded.add(s);
				}
			}
		}
		stmt.close();
		return conn;
	} catch (Exception ex) {
		ex.printStackTrace();
		throw new RuntimeException(ex);
	}
}
 

@Override
public void execute() {
	try {
		StringBuffer sb = new StringBuffer();
		CSVPrinter printer = new CSVPrinter(sb, ToCsvPragmaInstance.getFormat(options1));
		int srcId = (int) options1.getOrDefault(AqlOption.start_ids_at);
		int dstId = (int) options2.getOrDefault(AqlOption.start_ids_at);

		Pair<TObjectIntMap<X1>, TIntObjectMap<X1>> a = h.src().algebra().intifyX(srcId);
		Pair<TObjectIntMap<X2>, TIntObjectMap<X2>> b = h.dst().algebra().intifyX(dstId);

		for (En en : h.src().schema().ens) {
			for (X1 x1 : h.src().algebra().en(en)) {
				List<String> row = new LinkedList<>();
				row.add(Integer.toString(a.first.get(x1)));
				X2 x2 = h.repr(en, x1);
				row.add(Integer.toString(b.first.get(x2)));
				printer.printRecord(row);
			}
		}

		printer.close();
		delete();
		if (!file.createNewFile()) {
			throw new RuntimeException("Could not create new file: " + file);
		}
		FileWriter out = new FileWriter(file);
		out.write(sb.toString());
		out.close();
	} catch (IOException e) {
		throw new RuntimeException(e);
	}
}
 

@Test
public void testPutAllTIntObjectMap() {
  TIntObjectMap<String> map = new gnu.trove.map.hash.TIntObjectHashMap<>();
  tIntObjectHashMap.putAll(map);
  verify(delegate).putAll(map);
}
 

/** See {@link gnu.trove.map.hash.TIntObjectHashMap#putAll(TIntObjectMap)} */
public void putAll(TIntObjectMap<? extends V> map) {
  delegate.putAll(map);
}
 

public TIntObjectMap<JDA> getMap()
{
    if (!lock.writeLock().isHeldByCurrentThread())
        throw new IllegalStateException("Cannot access map without holding write lock!");
    return elements;
}
 

public static byte[] encodeData(TIntObjectMap<DataWatcherObject> objects) {
	PacketDataSerializer serializer = new PacketDataSerializer(Unpooled.buffer());
	TIntObjectIterator<DataWatcherObject> iterator = objects.iterator();
	while (iterator.hasNext()) {
		iterator.advance();
		DataWatcherObject object = iterator.value();
		final int tk = ((object.type.getId() << 5) | (iterator.key() & 0x1F)) & 0xFF;
		serializer.writeByte(tk);
		switch (object.type) {
			case BYTE: {
				serializer.writeByte((byte) object.value);
				break;
			}
			case SHORT: {
				serializer.writeShort((short) object.value);
				break;
			}
			case INT: {
				serializer.writeInt((int) object.value);
				break;
			}
			case FLOAT: {
				serializer.writeFloat((float) object.value);
				break;
			}
			case STRING: {
			    PacketDataSerializerHelper.writeString(serializer, (String) object.value);
				break;
			}
			case ITEMSTACK: {
			    PacketDataSerializerHelper.writeItemStack(serializer, (ItemStack) object.value);
				break;
			}
			case VECTOR3I: {
				BlockPosition blockPos = (BlockPosition) object.value;
				serializer.writeInt(blockPos.getX());
				serializer.writeInt(blockPos.getY());
				serializer.writeInt(blockPos.getZ());
				break;
			}
			case VECTOR3F: {
				Vector3f vector = (Vector3f) object.value;
				serializer.writeFloat(vector.getX());
				serializer.writeFloat(vector.getY());
				serializer.writeFloat(vector.getZ());
				break;
			}
		}
	}
	serializer.writeByte(127);
	return Utils.toArray(serializer);
}
 

private static void moveDWData(TIntObjectMap<DataWatcherObject> from, TIntObjectMap<DataWatcherObject> to, int oldId, int newId) {
    DataWatcherObject dwobject = from.remove(oldId);
    if (dwobject != null) {
        to.put(newId, dwobject);
    }
}
 

public static byte[] encodeData(TIntObjectMap<DataWatcherObject> objects) {
	PacketDataSerializer serializer = new PacketDataSerializer(Unpooled.buffer());
	TIntObjectIterator<DataWatcherObject> iterator = objects.iterator();
	while (iterator.hasNext()) {
		iterator.advance();
		DataWatcherObject object = iterator.value();
		final int tk = ((object.type.getId() << 5) | (iterator.key() & 0x1F)) & 0xFF;
		serializer.writeByte(tk);
		switch (object.type) {
			case BYTE: {
				serializer.writeByte((byte) object.value);
				break;
			}
			case SHORT: {
				serializer.writeShort((short) object.value);
				break;
			}
			case INT: {
				serializer.writeInt((int) object.value);
				break;
			}
			case FLOAT: {
				serializer.writeFloat((float) object.value);
				break;
			}
			case STRING: {
			    PacketDataSerializerHelper.writeString(serializer, (String) object.value);
				break;
			}
			case ITEMSTACK: {
			    PacketDataSerializerHelper.writeItemStack(serializer, (ItemStack) object.value);
				break;
			}
			case VECTOR3I: {
				BlockPosition blockPos = (BlockPosition) object.value;
				serializer.writeInt(blockPos.getX());
				serializer.writeInt(blockPos.getY());
				serializer.writeInt(blockPos.getZ());
				break;
			}
			case VECTOR3F: {
				Vector3f vector = (Vector3f) object.value;
				serializer.writeFloat(vector.getX());
				serializer.writeFloat(vector.getY());
				serializer.writeFloat(vector.getZ());
				break;
			}
		}
	}
	serializer.writeByte(127);
	return Utils.toArray(serializer);
}
 

private static void moveDWData(TIntObjectMap<DataWatcherObject> from, TIntObjectMap<DataWatcherObject> to, int oldId, int newId) {
    DataWatcherObject dwobject = from.remove(oldId);
    if (dwobject != null) {
        to.put(newId, dwobject);
    }
}
 

public ChrPosMap() {
	data = new HashMap<String, TIntObjectMap<E>>();
}