Java Code Examples for org.eclipse.collections.impl.map.mutable.UnifiedMap#newMap()

private Map<String, MithraObjectConfigurationType> getAllDefinedClasses(FileInputStream runtimeConfigFile)
{
    final Map<String, MithraObjectConfigurationType> allDefinedClasses = UnifiedMap.newMap();

    MithraRuntimeType mithraRuntimeType = new MithraConfigurationManager().parseConfiguration(runtimeConfigFile);

    for (ConnectionManagerType connectionManagerType : mithraRuntimeType.getConnectionManagers())
    {
        for (SchemaType schemaType : connectionManagerType.getSchemas())
        {
            this.addToAllDefinedClasses(allDefinedClasses, schemaType.getMithraObjectConfigurations());
        }
        this.addToAllDefinedClasses(allDefinedClasses, connectionManagerType.getMithraObjectConfigurations());
    }
    return allDefinedClasses;
}
 

private void setUpPortals()
{
    Map<String, MithraObjectPortal> allPortals = UnifiedMap.newMap();
    for (MithraRuntimeConfig config : this.mithraRuntimeList)
    {
        for (MithraObjectPortal portal : config.getObjectPortals())
        {
            String key = portal.getFinder().getFinderClassName();
            MithraObjectPortal existingPortal = allPortals.get(key);
            if (this.validateConnectionManagers && (existingPortal != null && !portalsHaveSameConnectionManager(portal, existingPortal)))
            {
                throw new IllegalStateException(key + " must use same connection managers in all configurations");
            }
            allPortals.put(key, portal);
        }
    }
    this.portals = FastList.newList(allPortals.values());
}
 

private void writeToFiles(ExecutorService executor, Map<Pair<RelatedFinder, Object>, List<MithraDataObject>> extract)
{
    UnifiedMap<File, UnifiedMap<RelatedFinder, List<MithraDataObject>>> dataByFile = UnifiedMap.newMap();
    for (Pair<RelatedFinder, Object> key : extract.keySet())
    {
        File outputFile = this.outputStrategy.getOutputFile(key.getOne(), key.getTwo());
        if (outputFile != null)
        {
            dataByFile.getIfAbsentPut(outputFile, UnifiedMap.<RelatedFinder, List<MithraDataObject>>newMap()).put(key.getOne(), extract.get(key));
        }
    }
    for (File file : dataByFile.keySet())
    {
        executor.submit(new FileWriterTask(file, dataByFile.get(file)));
    }
}
 

private Map<RelatedFinder, NonUniqueIndex> getExistingData()
{
    if (!this.overwrite)
    {
        if (this.saveMergedDataInMemory)
        {
            LOGGER.info("Loading merged data from memory. Size size of the list is " + this.mergedData.size());
            return this.loadData(this.mergedData);
        }
        else if (new File(this.fileName).exists())
        {
            LOGGER.info("Loading existing data from " + this.fileName);
            return this.loadDataFromFile(this.fileName);
        }
    }
    return UnifiedMap.newMap();
}
 

public Map<Pair<RelatedFinder, Object>, List<MithraDataObject>> getDataObjectsByFinderAndSource()
{
    UnifiedMap<Pair<RelatedFinder, Object>, List<MithraDataObject>> result = UnifiedMap.newMap(this.dataObjectsByFinder.size());
    for (MithraObject key : this.dataObjectsByFinder.keySet())
    {
        FullUniqueIndex mithraObjects = this.dataObjectsByFinder.get(key);
        RelatedFinder finder = finder(key);
        Object source = source(key);
        List<MithraDataObject> mithraDataObjects = FastList.newList(mithraObjects.size());
        for (Object mithraObject : mithraObjects.getAll())
        {
            mithraDataObjects.add(((MithraObject) mithraObject).zGetCurrentData());
        }
        result.put(Pair.of(finder, source), mithraDataObjects);
    }
    return result;
}
 

private Map<Thread, StackTraceElement[]> getStackTracesForRelevantThreads()
{
    UnifiedMap<Thread, StackTraceElement[]> result = UnifiedMap.newMap();
    for (int i = 0; i < toFree.size(); i++)
    {
        OffHeapThreadSnapShot snapShot = toFree.get(i);
        for (Iterator<Thread> it = snapShot.activeThreads.keySet().iterator(); it.hasNext(); )
        {
            Thread thread = it.next();
            if (!thread.getState().equals(State.RUNNABLE))
            {
                it.remove();
            }
            else if (!result.containsKey(thread))
            {
                result.put(thread, thread.getStackTrace());
            }
        }
    }
    return result;
}
 

public void queue(long base)
{
    Map<Thread, StackTraceElement[]> allStackTraces = UnifiedMap.newMap(Thread.getAllStackTraces());
    allStackTraces.remove(Thread.currentThread());
    for (Iterator<Thread> it = allStackTraces.keySet().iterator(); it.hasNext(); )
    {
        Thread thread = it.next();
        if (!isBusy(thread, allStackTraces.get(thread)))
        {
            it.remove();
        }
    }
    logger.debug("Queuing "+base+" to free later");
    synchronized (newToFree)
    {
        newToFree.add(new OffHeapThreadSnapShot(base, allStackTraces));
    }
}
 

@Test
public void testSendSetsProperties() throws NamingException, JMSException, RollbackException, RestartTopicException, XAException
{
    mithraTransaction = topicResourcesWithTransactionXid.startTransaction();

    UnifiedMap<String, Object> msgProperties = UnifiedMap.<String, Object>newMap();
    msgProperties.put("Hello", "World");
    Future<Void> voidFuture = outTopic.asyncSendMessages(FastList.newListWith("msg1".getBytes()), msgProperties);
    topicResourcesWithTransactionXid.commit(mithraTransaction, FastList.<Future>newListWith(voidFuture), FastList.<JmsTopic>newList());

    Message messageRecvd = incomingTopic.receive(100);
    assertEquals("msg1", JmsUtil.getMessageBodyAsString(messageRecvd));
    assertEquals("World", messageRecvd.getStringProperty("Hello"));
}
 

@Test
public void testSendSetsPropertiesAsync() throws NamingException, JMSException, RollbackException, RestartTopicException, XAException
{
    mithraTransaction = topicResourcesWithTransactionXid.startTransaction();

    UnifiedMap<String, Object> msgProperties = UnifiedMap.<String, Object>newMap();
    msgProperties.put("Hello", "World");
    Future<Void> voidFuture = asyncOutTopic.asyncSendMessages(FastList.newListWith("msg1".getBytes()), msgProperties);
    topicResourcesWithTransactionXid.commit(mithraTransaction, FastList.<Future>newListWith(voidFuture), FastList.<JmsTopic>newList());

    Message messageRecvd = incomingTopic.receive(100);
    assertEquals("msg1", JmsUtil.getMessageBodyAsString(messageRecvd));
    assertEquals("World", messageRecvd.getStringProperty("Hello"));
}
 

protected void storeRelated(RelatedFinder relatedFinder, Object related)
{
    if (this.partialRelationships == EMPTY_MAP)
    {
        this.partialRelationships = UnifiedMap.newMap();
    }
    this.partialRelationships.put(((AbstractRelatedFinder)relatedFinder).getRelationshipName(), related);
}
 

public void addDerivedColumnSubstitution(String fullyQualifiedColumn, String derivedColumnName, WhereClause whereClause)
{
    if (this.derivedColumnSubstitutionMap == null)
    {
        this.derivedColumnSubstitutionMap = UnifiedMap.newMap();
    }
    if (!this.derivedColumnSubstitutionMap.containsKey(fullyQualifiedColumn))
    {
        this.derivedColumnSubstitutionMap.put(fullyQualifiedColumn, derivedColumnName);
    }
    whereClause.addReachableColumn(fullyQualifiedColumn);
}
 

protected List populateQueryCache(List immediateParentList, List resultList, CachedQueryPair baseQuery)
{
    HashMap<Operation, List> opToListMap = new HashMap<Operation, List>();
    UnifiedMap<Operation, Object> opToParentMap = UnifiedMap.newMap();
    populateOpToListMapWithEmptyList(immediateParentList, opToListMap, opToParentMap);
    int doNotCacheCount = associateResultsWithOps(resultList, opToListMap, 1, opToParentMap);
    clearLeftOverObjectCache(opToParentMap);
    return cacheResults(opToListMap, doNotCacheCount, baseQuery);
}
 

public synchronized Map<String, List<MithraNotificationEvent>> getNotificationsToSend()
{
    Map<String, List<MithraNotificationEvent>> result = mithraNoTxNotificationEvents;
    if (result.isEmpty())
    {
        result = Collections.EMPTY_MAP;
    }
    else
    {
        mithraNoTxNotificationEvents = UnifiedMap.newMap();
    }
    return result;
}
 

@TearDown(Level.Iteration)
public void tearDown() {
    map = new HashMap<>(size);
    iterableMap = new HashedMap<>(size);
    mutableMap = UnifiedMap.newMap(size);
    for (int i = 0; i < size; i++) {
        map.put(i, i);
        mutableMap.put(i, i);
        iterableMap.put(i, i);
    }
}
 

public void addClassAndRelatedToFile(RelatedFinder finder, Operation op, List<DeepRelationshipAttribute> deepFetchAttributes) throws IOException
{
    Map<RelatedFinder, List<MithraDataObject>> map = UnifiedMap.newMap();
    this.addClassAndRelatedToMap(finder, op, deepFetchAttributes, map);
    this.addDataByFinder(map);
}
 

@Override
protected MutableMap<K, MutableList<V>> createMap() {
    return UnifiedMap.newMap();
}
 

public FeatureVectorsPartition() {
  vectors = UnifiedMap.newMap();
  recentIDs = UnifiedSet.newSet();
  lock = new AutoReadWriteLock();
}
 

public UnifiedMap<MapperStackImpl, MapperStackImpl> getMsiPool()
{
    if (msiPool == null) msiPool = UnifiedMap.newMap();
    return msiPool;
}
 

private UnifiedMap<ObjectWithMapperStack<? extends TemporalAttribute>, ObjectWithMapperStack<AsOfOperation>> getAsOfOperationMap()
{
    if (asOfOperationMap == null) asOfOperationMap = UnifiedMap.newMap(3);
    return asOfOperationMap;
}
 

private UnifiedMap<ObjectWithMapperStack<? extends TemporalAttribute>, InternalList> getEqualityAsOfOperationMap()
{
    if (equalityAsOfOperationMap == null) equalityAsOfOperationMap = UnifiedMap.newMap(3);
    return equalityAsOfOperationMap;
}