Java Functional类代码示例

import org.ethereum.util.Functional; //导入依赖的package包/类
/**
 * Returns limited list of nodes matching {@code predicate} criteria<br>
 * The nodes are sorted then by their totalDifficulties
 *
 * @param predicate only those nodes which are satisfied to its condition are included in results
 * @param limit max size of returning list
 *
 * @return list of nodes matching criteria
 */
public List<NodeHandler> getNodes(
        Functional.Predicate<NodeHandler> predicate,
        int limit    ) {
    ArrayList<NodeHandler> filtered = new ArrayList<>();
    synchronized (this) {
        for (NodeHandler handler : nodeHandlerMap.values()) {
            if (predicate.test(handler)) {
                filtered.add(handler);
            }
        }
    }
    Collections.sort(filtered, new Comparator<NodeHandler>() {
        @Override
        public int compare(NodeHandler o1, NodeHandler o2) {
            return o2.getNodeStatistics().getEthTotalDifficulty().compareTo(
                    o1.getNodeStatistics().getEthTotalDifficulty());
        }
    });
    return CollectionUtils.truncate(filtered, limit);
}
 

import org.ethereum.util.Functional; //导入依赖的package包/类
private static <T> byte[] encodeList(List<T> entries, Functional.Function<T, byte[]> encoder) {
    byte[][] result = new byte[entries.size()][];
    for (int i = 0; i < entries.size(); i++) {
        result[i] = encoder.apply(entries.get(i));
    }

    return RLP.encodeList(result);
}
 

import org.ethereum.util.Functional; //导入依赖的package包/类
private static <T> List<T> decodeList(RLPList list, Functional.Function<byte[], T> decoder) {
    List<T> result = new ArrayList<>();
    for (RLPElement item : list) {
        result.add(decoder.apply(item.getRLPData()));
    }
    return result;
}
 

import org.ethereum.util.Functional; //导入依赖的package包/类
private static <K, V> byte[] encodeMap(Map<K, V> map, Functional.Function<K, byte[]> keyEncoder, Functional.Function<V, byte[]> valueEncoder) {
    byte[][] result = new byte[map.size()][];
    int i = 0;
    for (Map.Entry<K, V> entry : map.entrySet()) {
        byte[] key = keyEncoder.apply(entry.getKey());
        byte[] value = valueEncoder.apply(entry.getValue());
        result[i++] = RLP.encodeList(key, value);
    }
    return RLP.encodeList(result);
}
 

import org.ethereum.util.Functional; //导入依赖的package包/类
private static <K, V> Map<K, V> decodeMap(RLPList list, Functional.Function<byte[], K> keyDecoder, Functional.Function<byte[], V> valueDecoder) {
    Map<K, V> result = new HashMap<>();
    for (RLPElement entry : list) {
        K key = keyDecoder.apply(((RLPList) entry).get(0).getRLPData());
        V value = valueDecoder.apply(((RLPList) entry).get(1).getRLPData());
        result.put(key, value);
    }
    return result;
}
 

import org.ethereum.util.Functional; //导入依赖的package包/类
private static byte[] encodeSummaries(final List<TransactionExecutionSummary> summaries) {
    return encodeList(summaries, new Functional.Function<TransactionExecutionSummary, byte[]>() {
        @Override
        public byte[] apply(TransactionExecutionSummary summary) {
            return summary.getEncoded();
        }
    });
}
 

import org.ethereum.util.Functional; //导入依赖的package包/类
private static List<TransactionExecutionSummary> decodeSummaries(RLPList summaries) {
    return decodeList(summaries, new Functional.Function<byte[], TransactionExecutionSummary>() {
        @Override
        public TransactionExecutionSummary apply(byte[] encoded) {
            return new TransactionExecutionSummary(encoded);
        }
    });
}
 

import org.ethereum.util.Functional; //导入依赖的package包/类
private static Map<String, TransactionReceipt> decodeReceipts(RLPList receipts) {
    return decodeMap(receipts, new Functional.Function<byte[], String>() {
        @Override
        public String apply(byte[] bytes) {
            return new String(bytes);
        }
    }, new Functional.Function<byte[], TransactionReceipt>() {
        @Override
        public TransactionReceipt apply(byte[] encoded) {
            return new TransactionReceipt(encoded);
        }
    });
}
 

import org.ethereum.util.Functional; //导入依赖的package包/类
private static byte[] encodeRewards(Map<byte[], BigInteger> rewards) {
    return encodeMap(rewards, new Functional.Function<byte[], byte[]>() {
        @Override
        public byte[] apply(byte[] bytes) {
            return RLP.encodeElement(bytes);
        }
    }, new Functional.Function<BigInteger, byte[]>() {
        @Override
        public byte[] apply(BigInteger reward) {
            return RLP.encodeBigInteger(reward);
        }
    });
}
 

import org.ethereum.util.Functional; //导入依赖的package包/类
private Map<DataWord, DataWord> keyValues(Functional.Function<Entry, Boolean> filter) {
    Map<DataWord, DataWord> result = new HashMap<>();
    for (Entry entry : getEntries()) {
        if (filter == null || filter.apply(entry)) {
            result.put(entry.getKey(), entry.getValue());
        }
    }
    return result;

}
 

import org.ethereum.util.Functional; //导入依赖的package包/类
public Map<DataWord, DataWord> getChanged() {
    return keyValues(new Functional.Function<Entry, Boolean>() {
        @Override
        public Boolean apply(Entry entry) {
            return entry.isChanged();
        }
    });
}
 

import org.ethereum.util.Functional; //导入依赖的package包/类
public Map<DataWord, DataWord> getReadOnly() {
    return keyValues(new Functional.Function<Entry, Boolean>() {
        @Override
        public Boolean apply(Entry entry) {
            return !entry.isChanged();
        }
    });
}
 

import org.ethereum.util.Functional; //导入依赖的package包/类
Functional.Consumer<BzzMessage> createIn1() {
    return new Functional.Consumer<BzzMessage>() {
        @Override
        public void accept(BzzMessage bzzMessage) {
            BzzMessage smsg = serialize(bzzMessage);
            if (TestPeer.MessageOut) {
                stdout.println("+ " + name1 + " => " + name2 + ": " + smsg);
            }
            out2.accept(smsg);
        }
    };
}
 

import org.ethereum.util.Functional; //导入依赖的package包/类
Functional.Consumer<BzzMessage> createIn2() {
    return new Functional.Consumer<BzzMessage>() {
        @Override
        public void accept(BzzMessage bzzMessage) {
            BzzMessage smsg = serialize(bzzMessage);
            if (TestPeer.MessageOut) {
                stdout.println("+ " + name2 + " => " + name1 + ": " + smsg);
            }
            out1.accept(smsg);
        }
    };
}
 

import org.ethereum.util.Functional; //导入依赖的package包/类
public void setMessageSender(Functional.Consumer<DiscoveryEvent> messageSender) {
    this.messageSender = messageSender;
}