Java Cache.Entry方法代码示例

import javax.cache.Cache; //导入方法依赖的package包/类
/**
 * Constructs input for {@link ColumnDecisionTreeTrainer}.
 *
 * @param c Cache.
 * @param valuesMapper Function for mapping cache entry to stream used by {@link ColumnDecisionTreeTrainer}.
 * @param labelsMapper Function used for mapping cache value to labels array.
 * @param keyMapper Function used for mapping feature index to the cache key.
 * @param catFeaturesInfo Information about which features are categorical in form of feature index -> number of
 * categories.
 * @param featuresCnt Count of features.
 * @param samplesCnt Count of samples.
 */
// TODO: IGNITE-5724 think about boxing/unboxing
public CacheColumnDecisionTreeTrainerInput(IgniteCache<K, V> c,
    IgniteSupplier<Stream<K>> labelsKeys,
    IgniteFunction<Cache.Entry<K, V>, Stream<IgniteBiTuple<Integer, Double>>> valuesMapper,
    IgniteFunction<V, DoubleStream> labelsMapper,
    IgniteFunction<Integer, Stream<K>> keyMapper,
    Map<Integer, Integer> catFeaturesInfo,
    int featuresCnt, int samplesCnt) {

    cacheName = c.getName();
    this.labelsKeys = labelsKeys;
    this.valuesMapper = valuesMapper;
    this.labelsMapper = labelsMapper;
    this.keyMapper = keyMapper;
    this.catFeaturesInfo = catFeaturesInfo;
    this.samplesCnt = samplesCnt;
    this.featuresCnt = featuresCnt;
}
 

import javax.cache.Cache; //导入方法依赖的package包/类
/**
 * Gets buffer which holds changes for specific cache made during transaction.
 *
 * @return buffer.
 */
private Collection<Cache.Entry<?, ?>> getBuffer() {
    Map<Object, Object> properties = session.properties();
    Set<String> caches = (Set<String>) properties.get(CACHES_PROPERTY_NAME);
    if (caches == null) {
        properties.put(CACHES_PROPERTY_NAME, caches = new HashSet<>());
        properties.put(BUFFER_PROPERTY_NAME, new HashMap<String, Map>());
    }
    Map<String, Collection<Cache.Entry<?, ?>>> buffer = (Map<String, Collection<Cache.Entry<?, ?>>>) properties.get(BUFFER_PROPERTY_NAME);
    if (caches.add(cacheName)) {
        Collection<Cache.Entry<?, ?>> cacheBuffer = new ArrayList<>();
        buffer.put(cacheName, cacheBuffer);
        return cacheBuffer;
    } else {
        return buffer.get(cacheName);
    }
}
 

import javax.cache.Cache; //导入方法依赖的package包/类
/** {@inheritDoc} */
@Override public Object execute() throws IgniteException {
    Injection.inject(this, ignite);
    final Map<Object, Cache.Entry<?, ?>> mergedData = new HashMap<>();
    for (Metadata metadata : metadatas) {
        keyValueProvider.fetchAllKeyValues(cacheName, metadata, new IgniteInClosure<Cache.Entry<Object, Object>>() {
            @Override public void apply(Cache.Entry<Object, Object> entry) {
                Object key = entry.getKey();
                if (!mergedData.containsKey(key)) {
                    mergedData.put(key, new CacheEntryImpl<>(key, entry.getValue()));
                }
            }
        });
    }
    keyValueProvider.write(idSequencer.getNextId(), Collections.singletonMap(cacheName, mergedData.values()), destination);
    return null;
}
 

import javax.cache.Cache; //导入方法依赖的package包/类
@Override public void process(Map<?, ?> entries) {
    if (!running) {
        return;
    }
    long txId = idSequencer.getNextId();
    Collection<Cache.Entry<?, ?>> updates = txDataToCacheUpdates(entries);

    producer.writeTransaction(txId, Collections.singletonMap(config.getCacheName(), updates));
    stats.recordOperationStartTime(txId, System.currentTimeMillis());
}
 

import javax.cache.Cache; //导入方法依赖的package包/类
@Override
public TransactionScope apply(Long transactionId, Map<String, Collection<Cache.Entry<?, ?>>> updates) {
    List<Map.Entry<String, List>> scope = new ArrayList<>(updates.size());

    for (Map.Entry<String, Collection<Cache.Entry<?, ?>>> cacheUpdate : updates.entrySet()) {
        List keys = cacheUpdate
            .getValue()
            .stream()
            .map(Cache.Entry::getKey)
            .collect(Collectors.toList());
        scope.add(new AbstractMap.SimpleImmutableEntry<String, List>(cacheUpdate.getKey(), keys));
    }
    return new TransactionScope(transactionId, scope);
}
 

import javax.cache.Cache; //导入方法依赖的package包/类
private static Collection<Cache.Entry<?, ?>> txDataToCacheUpdates(Map<?, ?> txDataEntries) {
    Collection<Cache.Entry<?, ?>> updates = new ArrayList<>();

    for (Object value : txDataEntries.values()) {
        TransactionData txData = (TransactionData)value;
        AccountTransactionKey txKey = new AccountTransactionKey(txData.getTransactionId(),
            txData.getPartition());
        AccountTransaction accountTx = new AccountTransaction(
            txKey,
            txData.getFromAccountId(),
            txData.getToAccountId(),
            txData.getMoneyAmount()
        );
        AccountKey toAccountKey = new AccountKey(txData.getToAccountId(), txData.getPartition());
        AccountKey fromAccountKey = new AccountKey(txData.getFromAccountId(), txData.getPartition());
        Account toAccount = new Account(toAccountKey);
        Account fromAccount = new Account(fromAccountKey);
        long timestamp = System.currentTimeMillis();

        fromAccount.addTransaction(timestamp, txKey);
        toAccount.addTransaction(timestamp, txKey);

        updates.add(new CacheEntryImpl<>(txKey, accountTx));
        updates.add(new CacheEntryImpl<>(toAccountKey, toAccount));
        updates.add(new CacheEntryImpl<>(fromAccountKey, fromAccount));
    }
    return updates;
}
 

import javax.cache.Cache; //导入方法依赖的package包/类
public Future<RecordMetadata> writeTransaction(long transactionId, Map<String,
        Collection<Cache.Entry<?, ?>>> updates) throws CacheWriterException {
    try {
        return send(localTopic, partitions, transactionId, updates);
    }
    catch (Exception e) {
        throw new CacheWriterException(e);
    }
}
 

import javax.cache.Cache; //导入方法依赖的package包/类
private Message convertToMessage(long transactionId, Map<String, Collection<Cache.Entry<?, ?>>> updates) {
    Message result = new Message(transactionId);
    for (Map.Entry<String, Collection<Cache.Entry<?, ?>>> cacheToUpdates : updates.entrySet()) {
        String cacheName = cacheToUpdates.getKey();
        for (Cache.Entry<?, ?> cacheUpdates : cacheToUpdates.getValue()) {
            result.metadata.addRow(cacheName, cacheUpdates.getKey());
            result.values.add(cacheUpdates.getValue());
        }
    }
    return result;
}
 

import javax.cache.Cache; //导入方法依赖的package包/类
/** {@inheritDoc} */
@Override public void writeAll(
    Collection<Cache.Entry<? extends K, ? extends V>> entries) throws CacheWriterException {
    putAll((Collection)entries);
}
 

import javax.cache.Cache; //导入方法依赖的package包/类
public Iterator<Cache.Entry<Integer,SpatialPartition>>
        getEntriesIterator() {
    return spatialPartitionsData.iterator();
}
 

import javax.cache.Cache; //导入方法依赖的package包/类
/**
 * Writes key-value to persistent store.
 */
protected void writeKV(Object key, Object value, String cacheName, Metadata metadata) {
    Collection<Cache.Entry<?, ?>> entries = Collections.<Cache.Entry<?, ?>>singletonList(new CacheEntryImpl<>(key, value));
    resource.getKVProvider().write(resource.nextTransactionId(), Collections.singletonMap(cacheName, entries), metadata);
}
 

import javax.cache.Cache; //导入方法依赖的package包/类
private void notifyListeners(long transactionId, Map<String, Collection<Cache.Entry<?, ?>>> updates) {
    for (ModificationListener listener : allListeners) {
        listener.handle(transactionId, updates);
    }
}
 

import javax.cache.Cache; //导入方法依赖的package包/类
/** {@inheritDoc} */
@Override public void write(Cache.Entry<? extends K, ? extends V> entry) throws CacheWriterException {
    put(entry.getKey(), entry.getValue());
}
 

import javax.cache.Cache; //导入方法依赖的package包/类
@Override
public void fetchAllKeyValues(String cacheName, Metadata metadata, IgniteInClosure<Cache.Entry<Object, Object>> action) {
    //do nothing;
}
 

import javax.cache.Cache; //导入方法依赖的package包/类
@Override public void writeTransaction(long transactionId,
    Map<String, Collection<Cache.Entry<?, ?>>> updates) throws CacheWriterException {
    producer.writeTransaction(transactionId, updates);
}