target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void deserializeElection_unevenOuterList() throws Exception { AddressBasedAuthorizer mockedAuthorizer = mock(AddressBasedAuthorizer.class); byte[] rlpFirstElement = RLP.encodeElement(Hex.decode("010203")); byte[] data = RLP.encodeList(rlpFirstElement); try { BridgeSerializationUtils.deserializeElection(data, mockedAuthorizer); } catch (RuntimeException e) { Assert.assertTrue(e.getMessage().contains("expected an even number of entries, but odd given")); return; } Assert.fail(); }
|
public static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer) { if (data == null || data.length == 0) { return new ABICallElection(authorizer); } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeElection: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; Map<ABICallSpec, List<RskAddress>> votes = new HashMap<>(); for (int k = 0; k < numEntries; k++) { ABICallSpec spec = deserializeABICallSpec(rlpList.get(k * 2).getRLPData()); List<RskAddress> specVotes = deserializeVoters(rlpList.get(k * 2 + 1).getRLPData()); votes.put(spec, specVotes); } return new ABICallElection(authorizer, votes); }
|
BridgeSerializationUtils { public static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer) { if (data == null || data.length == 0) { return new ABICallElection(authorizer); } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeElection: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; Map<ABICallSpec, List<RskAddress>> votes = new HashMap<>(); for (int k = 0; k < numEntries; k++) { ABICallSpec spec = deserializeABICallSpec(rlpList.get(k * 2).getRLPData()); List<RskAddress> specVotes = deserializeVoters(rlpList.get(k * 2 + 1).getRLPData()); votes.put(spec, specVotes); } return new ABICallElection(authorizer, votes); } }
|
BridgeSerializationUtils { public static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer) { if (data == null || data.length == 0) { return new ABICallElection(authorizer); } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeElection: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; Map<ABICallSpec, List<RskAddress>> votes = new HashMap<>(); for (int k = 0; k < numEntries; k++) { ABICallSpec spec = deserializeABICallSpec(rlpList.get(k * 2).getRLPData()); List<RskAddress> specVotes = deserializeVoters(rlpList.get(k * 2 + 1).getRLPData()); votes.put(spec, specVotes); } return new ABICallElection(authorizer, votes); } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer) { if (data == null || data.length == 0) { return new ABICallElection(authorizer); } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeElection: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; Map<ABICallSpec, List<RskAddress>> votes = new HashMap<>(); for (int k = 0; k < numEntries; k++) { ABICallSpec spec = deserializeABICallSpec(rlpList.get(k * 2).getRLPData()); List<RskAddress> specVotes = deserializeVoters(rlpList.get(k * 2 + 1).getRLPData()); votes.put(spec, specVotes); } return new ABICallElection(authorizer, votes); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer) { if (data == null || data.length == 0) { return new ABICallElection(authorizer); } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeElection: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; Map<ABICallSpec, List<RskAddress>> votes = new HashMap<>(); for (int k = 0; k < numEntries; k++) { ABICallSpec spec = deserializeABICallSpec(rlpList.get(k * 2).getRLPData()); List<RskAddress> specVotes = deserializeVoters(rlpList.get(k * 2 + 1).getRLPData()); votes.put(spec, specVotes); } return new ABICallElection(authorizer, votes); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
@Test public void deserializeElection_invalidCallSpec() throws Exception { AddressBasedAuthorizer authorizer = getTestingAddressBasedAuthorizer(); byte[] rlpFirstSpec = RLP.encodeList(RLP.encode(Hex.decode("010203"))); byte[] rlpFirstVoters = RLP.encodeList(RLP.encodeElement(Hex.decode("03"))); byte[] data = RLP.encodeList(rlpFirstSpec, rlpFirstVoters); try { BridgeSerializationUtils.deserializeElection(data, authorizer); } catch (RuntimeException e) { Assert.assertTrue(e.getMessage().contains("Invalid serialized ABICallSpec")); return; } Assert.fail(); }
|
public static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer) { if (data == null || data.length == 0) { return new ABICallElection(authorizer); } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeElection: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; Map<ABICallSpec, List<RskAddress>> votes = new HashMap<>(); for (int k = 0; k < numEntries; k++) { ABICallSpec spec = deserializeABICallSpec(rlpList.get(k * 2).getRLPData()); List<RskAddress> specVotes = deserializeVoters(rlpList.get(k * 2 + 1).getRLPData()); votes.put(spec, specVotes); } return new ABICallElection(authorizer, votes); }
|
BridgeSerializationUtils { public static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer) { if (data == null || data.length == 0) { return new ABICallElection(authorizer); } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeElection: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; Map<ABICallSpec, List<RskAddress>> votes = new HashMap<>(); for (int k = 0; k < numEntries; k++) { ABICallSpec spec = deserializeABICallSpec(rlpList.get(k * 2).getRLPData()); List<RskAddress> specVotes = deserializeVoters(rlpList.get(k * 2 + 1).getRLPData()); votes.put(spec, specVotes); } return new ABICallElection(authorizer, votes); } }
|
BridgeSerializationUtils { public static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer) { if (data == null || data.length == 0) { return new ABICallElection(authorizer); } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeElection: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; Map<ABICallSpec, List<RskAddress>> votes = new HashMap<>(); for (int k = 0; k < numEntries; k++) { ABICallSpec spec = deserializeABICallSpec(rlpList.get(k * 2).getRLPData()); List<RskAddress> specVotes = deserializeVoters(rlpList.get(k * 2 + 1).getRLPData()); votes.put(spec, specVotes); } return new ABICallElection(authorizer, votes); } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer) { if (data == null || data.length == 0) { return new ABICallElection(authorizer); } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeElection: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; Map<ABICallSpec, List<RskAddress>> votes = new HashMap<>(); for (int k = 0; k < numEntries; k++) { ABICallSpec spec = deserializeABICallSpec(rlpList.get(k * 2).getRLPData()); List<RskAddress> specVotes = deserializeVoters(rlpList.get(k * 2 + 1).getRLPData()); votes.put(spec, specVotes); } return new ABICallElection(authorizer, votes); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer) { if (data == null || data.length == 0) { return new ABICallElection(authorizer); } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeElection: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; Map<ABICallSpec, List<RskAddress>> votes = new HashMap<>(); for (int k = 0; k < numEntries; k++) { ABICallSpec spec = deserializeABICallSpec(rlpList.get(k * 2).getRLPData()); List<RskAddress> specVotes = deserializeVoters(rlpList.get(k * 2 + 1).getRLPData()); votes.put(spec, specVotes); } return new ABICallElection(authorizer, votes); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
@Test public void isEmpty_Bytes() { Value val = new Value(new byte[0]); assertTrue(val.isEmpty()); }
|
public boolean isEmpty() { if (isNull()) { return true; } if (isBytes() && asBytes().length == 0) { return true; } if (isList() && asList().isEmpty()) { return true; } if (isString() && asString().equals("")) { return true; } return false; }
|
Value { public boolean isEmpty() { if (isNull()) { return true; } if (isBytes() && asBytes().length == 0) { return true; } if (isList() && asList().isEmpty()) { return true; } if (isString() && asString().equals("")) { return true; } return false; } }
|
Value { public boolean isEmpty() { if (isNull()) { return true; } if (isBytes() && asBytes().length == 0) { return true; } if (isList() && asList().isEmpty()) { return true; } if (isString() && asString().equals("")) { return true; } return false; } Value(); Value(Object obj); }
|
Value { public boolean isEmpty() { if (isNull()) { return true; } if (isBytes() && asBytes().length == 0) { return true; } if (isList() && asList().isEmpty()) { return true; } if (isString() && asString().equals("")) { return true; } return false; } Value(); Value(Object obj); static Value fromRlpEncoded(byte[] data); void init(byte[] rlp); Object asObj(); List<Object> asList(); int asInt(); long asLong(); BigInteger asBigInt(); String asString(); byte[] asBytes(); String getHex(); byte[] getData(); int[] asSlice(); Value get(int index); byte[] encode(); byte[] hash(); boolean isList(); boolean isString(); boolean isInt(); boolean isLong(); boolean isBigInt(); boolean isBytes(); boolean isReadableString(); boolean isHexString(); boolean isHashCode(); boolean isNull(); boolean isEmpty(); int length(); String toString(); }
|
Value { public boolean isEmpty() { if (isNull()) { return true; } if (isBytes() && asBytes().length == 0) { return true; } if (isList() && asList().isEmpty()) { return true; } if (isString() && asString().equals("")) { return true; } return false; } Value(); Value(Object obj); static Value fromRlpEncoded(byte[] data); void init(byte[] rlp); Object asObj(); List<Object> asList(); int asInt(); long asLong(); BigInteger asBigInt(); String asString(); byte[] asBytes(); String getHex(); byte[] getData(); int[] asSlice(); Value get(int index); byte[] encode(); byte[] hash(); boolean isList(); boolean isString(); boolean isInt(); boolean isLong(); boolean isBigInt(); boolean isBytes(); boolean isReadableString(); boolean isHexString(); boolean isHashCode(); boolean isNull(); boolean isEmpty(); int length(); String toString(); }
|
@Test public void web3_clientVersion() throws Exception { Web3 web3 = createWeb3(); String clientVersion = web3.web3_clientVersion(); assertTrue("client version is not including rsk!", clientVersion.toLowerCase().contains("rsk")); }
|
@Override public String web3_clientVersion() { String clientVersion = baseClientVersion + "/" + config.projectVersion() + "/" + System.getProperty("os.name") + "/Java1.8/" + config.projectVersionModifier() + "-" + buildInfo.getBuildHash(); if (logger.isDebugEnabled()) { logger.debug("web3_clientVersion(): {}", clientVersion); } return clientVersion; }
|
Web3Impl implements Web3 { @Override public String web3_clientVersion() { String clientVersion = baseClientVersion + "/" + config.projectVersion() + "/" + System.getProperty("os.name") + "/Java1.8/" + config.projectVersionModifier() + "-" + buildInfo.getBuildHash(); if (logger.isDebugEnabled()) { logger.debug("web3_clientVersion(): {}", clientVersion); } return clientVersion; } }
|
Web3Impl implements Web3 { @Override public String web3_clientVersion() { String clientVersion = baseClientVersion + "/" + config.projectVersion() + "/" + System.getProperty("os.name") + "/Java1.8/" + config.projectVersionModifier() + "-" + buildInfo.getBuildHash(); if (logger.isDebugEnabled()) { logger.debug("web3_clientVersion(): {}", clientVersion); } return clientVersion; } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); }
|
Web3Impl implements Web3 { @Override public String web3_clientVersion() { String clientVersion = baseClientVersion + "/" + config.projectVersion() + "/" + System.getProperty("os.name") + "/Java1.8/" + config.projectVersionModifier() + "-" + buildInfo.getBuildHash(); if (logger.isDebugEnabled()) { logger.debug("web3_clientVersion(): {}", clientVersion); } return clientVersion; } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); }
|
Web3Impl implements Web3 { @Override public String web3_clientVersion() { String clientVersion = baseClientVersion + "/" + config.projectVersion() + "/" + System.getProperty("os.name") + "/Java1.8/" + config.projectVersionModifier() + "-" + buildInfo.getBuildHash(); if (logger.isDebugEnabled()) { logger.debug("web3_clientVersion(): {}", clientVersion); } return clientVersion; } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); public Ethereum eth; }
|
@Test public void test1() throws InterruptedException { final ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor(); try { final TransportAsync transport = new TransportAsync(executor); final Instant start = Instant.now(); executor.schedule(() -> { transport.handleConnected(); }, 100, TimeUnit.MILLISECONDS); Transport.waitForConnection(transport); Duration duration = Duration.between(start, Instant.now()); System.out.println(duration); Assert.assertTrue(duration.compareTo(Duration.ofMillis(100)) > 0); } finally { executor.shutdown(); } }
|
public synchronized void handleConnected() { if (!this.state) { this.state = true; fireEvent(true, this.listener); } }
|
TransportAsync implements Transport { public synchronized void handleConnected() { if (!this.state) { this.state = true; fireEvent(true, this.listener); } } }
|
TransportAsync implements Transport { public synchronized void handleConnected() { if (!this.state) { this.state = true; fireEvent(true, this.listener); } } TransportAsync(final Executor executor); }
|
TransportAsync implements Transport { public synchronized void handleConnected() { if (!this.state) { this.state = true; fireEvent(true, this.listener); } } TransportAsync(final Executor executor); synchronized void handleConnected(); synchronized void handleDisconnected(); @Override void state(final Consumer<Boolean> listener); }
|
TransportAsync implements Transport { public synchronized void handleConnected() { if (!this.state) { this.state = true; fireEvent(true, this.listener); } } TransportAsync(final Executor executor); synchronized void handleConnected(); synchronized void handleDisconnected(); @Override void state(final Consumer<Boolean> listener); }
|
@Test public void testEmpty2() { final Topic topic = Topic.of(Collections.emptyList()); Assert.assertNull(topic); }
|
public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test public void testEmpty3() { final Topic topic = Topic.of((String) null); Assert.assertNull(topic); }
|
public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test(expected = IllegalArgumentException.class) public void testEmpty4() { Topic.of("foo", "bar", null); }
|
public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test(expected = IllegalArgumentException.class) public void testSpecial1() { Topic.of("foo", "#"); }
|
public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test(expected = IllegalArgumentException.class) public void testSpecial2() { Topic.of("foo", "+"); }
|
public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test(expected = IllegalArgumentException.class) public void testSpecial3() { Topic.of("foo", ""); }
|
public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test(expected = IllegalArgumentException.class) public void testSpecial4() { Topic.of("foo", "foo/bar"); }
|
public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test(expected = IllegalArgumentException.class) public void testSpecial4a() { Topic.of("foo", "/bar"); }
|
public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test(expected = IllegalArgumentException.class) public void testSpecial4b() { Topic.of("foo", "foo/"); }
|
public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test public void testSplit5() { final Topic topic = Topic.split(" Assert.assertNull(topic); }
|
public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } private Topic(final List<String> segments); }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test public void testSplitNull() { final Topic topic = Topic.split(null); Assert.assertNull(topic); }
|
public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } private Topic(final List<String> segments); }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test public void testSplitEmpty() { final Topic topic = Topic.split(""); Assert.assertNull(topic); }
|
public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } private Topic(final List<String> segments); }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test public void testEquals1() { final Topic t1 = Topic.split("foo/bar/baz"); final Topic t2 = Topic.split("foo/bar/baz"); assertEquals(t1, t2); }
|
public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } private Topic(final List<String> segments); }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test public void testNotEquals1() { final Topic t1 = Topic.split("foo/bar"); final Topic t2 = Topic.split("foo/baz"); assertNotEquals(t1, t2); }
|
public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } private Topic(final List<String> segments); }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { public static Topic split(String path) { if (path == null) { return null; } path = path.replaceAll("(^/+|/$)+", ""); if (path.isEmpty()) { return null; } return new Topic(Arrays.asList(path.split("\\/+"))); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test public void testStream() { final String result = Topic.split("foo/bar").stream().collect(Collectors.joining()); assertEquals("foobar", result); }
|
public Stream<String> stream() { return segments.stream(); }
|
Topic { public Stream<String> stream() { return segments.stream(); } }
|
Topic { public Stream<String> stream() { return segments.stream(); } private Topic(final List<String> segments); }
|
Topic { public Stream<String> stream() { return segments.stream(); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { public Stream<String> stream() { return segments.stream(); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test public void testToString() { assertEquals("foo/bar", Topic.of("foo", "bar").toString()); }
|
@Override public String toString() { return String.join("/", segments); }
|
Topic { @Override public String toString() { return String.join("/", segments); } }
|
Topic { @Override public String toString() { return String.join("/", segments); } private Topic(final List<String> segments); }
|
Topic { @Override public String toString() { return String.join("/", segments); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { @Override public String toString() { return String.join("/", segments); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test public void testHashCode() { final Map<Topic, Object> map = new HashMap<>(); map.put(Topic.of("foo", "bar"), 1); map.put(Topic.of("foo", "baz"), 2); assertEquals(1, map.get(Topic.split("foo/bar"))); assertEquals(2, map.get(Topic.split("foo/baz"))); }
|
@Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + (segments == null ? 0 : segments.hashCode()); return result; }
|
Topic { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + (segments == null ? 0 : segments.hashCode()); return result; } }
|
Topic { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + (segments == null ? 0 : segments.hashCode()); return result; } private Topic(final List<String> segments); }
|
Topic { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + (segments == null ? 0 : segments.hashCode()); return result; } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + (segments == null ? 0 : segments.hashCode()); return result; } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test(expected = NullPointerException.class) public void testNull1() { Payload.of((String) null, null); }
|
public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); }
|
Payload { public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); } }
|
Payload { public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); } private Payload(final Instant timestamp, final Map<String, ?> values, final boolean cloneValues); }
|
Payload { public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); } private Payload(final Instant timestamp, final Map<String, ?> values, final boolean cloneValues); Instant getTimestamp(); Map<String, ?> getValues(); @Override String toString(); static Payload of(final String key, final Object value); static Payload of(final Map<String, ?> values); static Payload of(final Instant timestamp, final String key, final Object value); static Payload of(final Instant timestamp, final Map<String, ?> values); }
|
Payload { public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); } private Payload(final Instant timestamp, final Map<String, ?> values, final boolean cloneValues); Instant getTimestamp(); Map<String, ?> getValues(); @Override String toString(); static Payload of(final String key, final Object value); static Payload of(final Map<String, ?> values); static Payload of(final Instant timestamp, final String key, final Object value); static Payload of(final Instant timestamp, final Map<String, ?> values); }
|
@Test(expected = NullPointerException.class) public void testNull2() { Payload.of(null); }
|
public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); }
|
Payload { public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); } }
|
Payload { public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); } private Payload(final Instant timestamp, final Map<String, ?> values, final boolean cloneValues); }
|
Payload { public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); } private Payload(final Instant timestamp, final Map<String, ?> values, final boolean cloneValues); Instant getTimestamp(); Map<String, ?> getValues(); @Override String toString(); static Payload of(final String key, final Object value); static Payload of(final Map<String, ?> values); static Payload of(final Instant timestamp, final String key, final Object value); static Payload of(final Instant timestamp, final Map<String, ?> values); }
|
Payload { public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); } private Payload(final Instant timestamp, final Map<String, ?> values, final boolean cloneValues); Instant getTimestamp(); Map<String, ?> getValues(); @Override String toString(); static Payload of(final String key, final Object value); static Payload of(final Map<String, ?> values); static Payload of(final Instant timestamp, final String key, final Object value); static Payload of(final Instant timestamp, final Map<String, ?> values); }
|
@Test(expected = NullPointerException.class) public void testNull3() { Payload.of(null, null, null); }
|
public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); }
|
Payload { public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); } }
|
Payload { public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); } private Payload(final Instant timestamp, final Map<String, ?> values, final boolean cloneValues); }
|
Payload { public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); } private Payload(final Instant timestamp, final Map<String, ?> values, final boolean cloneValues); Instant getTimestamp(); Map<String, ?> getValues(); @Override String toString(); static Payload of(final String key, final Object value); static Payload of(final Map<String, ?> values); static Payload of(final Instant timestamp, final String key, final Object value); static Payload of(final Instant timestamp, final Map<String, ?> values); }
|
Payload { public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); } private Payload(final Instant timestamp, final Map<String, ?> values, final boolean cloneValues); Instant getTimestamp(); Map<String, ?> getValues(); @Override String toString(); static Payload of(final String key, final Object value); static Payload of(final Map<String, ?> values); static Payload of(final Instant timestamp, final String key, final Object value); static Payload of(final Instant timestamp, final Map<String, ?> values); }
|
@Test(expected = NullPointerException.class) public void testNull4() { Payload.of((Instant) null, null); }
|
public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); }
|
Payload { public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); } }
|
Payload { public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); } private Payload(final Instant timestamp, final Map<String, ?> values, final boolean cloneValues); }
|
Payload { public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); } private Payload(final Instant timestamp, final Map<String, ?> values, final boolean cloneValues); Instant getTimestamp(); Map<String, ?> getValues(); @Override String toString(); static Payload of(final String key, final Object value); static Payload of(final Map<String, ?> values); static Payload of(final Instant timestamp, final String key, final Object value); static Payload of(final Instant timestamp, final Map<String, ?> values); }
|
Payload { public static Payload of(final String key, final Object value) { Objects.requireNonNull(key); return new Payload(now(), singletonMap(key, value), false); } private Payload(final Instant timestamp, final Map<String, ?> values, final boolean cloneValues); Instant getTimestamp(); Map<String, ?> getValues(); @Override String toString(); static Payload of(final String key, final Object value); static Payload of(final Map<String, ?> values); static Payload of(final Instant timestamp, final String key, final Object value); static Payload of(final Instant timestamp, final Map<String, ?> values); }
|
@Test public void testNull1() { final UserAndPassword c = Credentials.userAndPassword(null, (char[]) null); Assert.assertNull(c.getUsername()); Assert.assertNull(c.getPassword()); Assert.assertNull(c.getPasswordAsString()); }
|
public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); }
|
Credentials { public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); } }
|
Credentials { public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); } private Credentials(); }
|
Credentials { public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); } private Credentials(); static UserAndPassword userAndPassword(final String username, final String password); static UserAndPassword userAndPassword(final String username, final char[] password); }
|
Credentials { public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); } private Credentials(); static UserAndPassword userAndPassword(final String username, final String password); static UserAndPassword userAndPassword(final String username, final char[] password); }
|
@Test public void testNull2() { final UserAndPassword c = Credentials.userAndPassword(null, (String) null); Assert.assertNull(c.getUsername()); Assert.assertNull(c.getPassword()); Assert.assertNull(c.getPasswordAsString()); }
|
public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); }
|
Credentials { public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); } }
|
Credentials { public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); } private Credentials(); }
|
Credentials { public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); } private Credentials(); static UserAndPassword userAndPassword(final String username, final String password); static UserAndPassword userAndPassword(final String username, final char[] password); }
|
Credentials { public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); } private Credentials(); static UserAndPassword userAndPassword(final String username, final String password); static UserAndPassword userAndPassword(final String username, final char[] password); }
|
@Test public void testNonNull1() { final UserAndPassword c = Credentials.userAndPassword("user", "password".toCharArray()); Assert.assertNotNull(c.getUsername()); Assert.assertNotNull(c.getPassword()); Assert.assertNotNull(c.getPasswordAsString()); }
|
public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); }
|
Credentials { public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); } }
|
Credentials { public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); } private Credentials(); }
|
Credentials { public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); } private Credentials(); static UserAndPassword userAndPassword(final String username, final String password); static UserAndPassword userAndPassword(final String username, final char[] password); }
|
Credentials { public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); } private Credentials(); static UserAndPassword userAndPassword(final String username, final String password); static UserAndPassword userAndPassword(final String username, final char[] password); }
|
@Test public void testNonNull2() { final UserAndPassword c = Credentials.userAndPassword("user", "password"); Assert.assertNotNull(c.getUsername()); Assert.assertNotNull(c.getPassword()); Assert.assertNotNull(c.getPasswordAsString()); }
|
public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); }
|
Credentials { public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); } }
|
Credentials { public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); } private Credentials(); }
|
Credentials { public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); } private Credentials(); static UserAndPassword userAndPassword(final String username, final String password); static UserAndPassword userAndPassword(final String username, final char[] password); }
|
Credentials { public static UserAndPassword userAndPassword(final String username, final String password) { return new UserAndPassword(username, password != null ? password.toCharArray() : null); } private Credentials(); static UserAndPassword userAndPassword(final String username, final String password); static UserAndPassword userAndPassword(final String username, final char[] password); }
|
@Test public void test1() { Errors.ignore().handleError(new Exception(), Optional.empty()); }
|
public static ErrorHandler<RuntimeException> ignore() { return IGNORE; }
|
Errors { public static ErrorHandler<RuntimeException> ignore() { return IGNORE; } }
|
Errors { public static ErrorHandler<RuntimeException> ignore() { return IGNORE; } private Errors(); }
|
Errors { public static ErrorHandler<RuntimeException> ignore() { return IGNORE; } private Errors(); static ErrorHandler<RuntimeException> ignore(); static ErrorHandler<RuntimeException> handle(final BiConsumer<Throwable, Optional<Payload>> handler); static void ignore(final Throwable e, final Optional<Payload> payload); }
|
Errors { public static ErrorHandler<RuntimeException> ignore() { return IGNORE; } private Errors(); static ErrorHandler<RuntimeException> ignore(); static ErrorHandler<RuntimeException> handle(final BiConsumer<Throwable, Optional<Payload>> handler); static void ignore(final Throwable e, final Optional<Payload> payload); }
|
@Test public void test2() { Errors.handle((error, payload) -> { }).handleError(new Exception(), Optional.empty()); }
|
public static ErrorHandler<RuntimeException> handle(final BiConsumer<Throwable, Optional<Payload>> handler) { return new ErrorHandler<RuntimeException>() { @Override public void handleError(final Throwable e, final Optional<Payload> payload) throws RuntimeException { handler.accept(e, payload); } }; }
|
Errors { public static ErrorHandler<RuntimeException> handle(final BiConsumer<Throwable, Optional<Payload>> handler) { return new ErrorHandler<RuntimeException>() { @Override public void handleError(final Throwable e, final Optional<Payload> payload) throws RuntimeException { handler.accept(e, payload); } }; } }
|
Errors { public static ErrorHandler<RuntimeException> handle(final BiConsumer<Throwable, Optional<Payload>> handler) { return new ErrorHandler<RuntimeException>() { @Override public void handleError(final Throwable e, final Optional<Payload> payload) throws RuntimeException { handler.accept(e, payload); } }; } private Errors(); }
|
Errors { public static ErrorHandler<RuntimeException> handle(final BiConsumer<Throwable, Optional<Payload>> handler) { return new ErrorHandler<RuntimeException>() { @Override public void handleError(final Throwable e, final Optional<Payload> payload) throws RuntimeException { handler.accept(e, payload); } }; } private Errors(); static ErrorHandler<RuntimeException> ignore(); static ErrorHandler<RuntimeException> handle(final BiConsumer<Throwable, Optional<Payload>> handler); static void ignore(final Throwable e, final Optional<Payload> payload); }
|
Errors { public static ErrorHandler<RuntimeException> handle(final BiConsumer<Throwable, Optional<Payload>> handler) { return new ErrorHandler<RuntimeException>() { @Override public void handleError(final Throwable e, final Optional<Payload> payload) throws RuntimeException { handler.accept(e, payload); } }; } private Errors(); static ErrorHandler<RuntimeException> ignore(); static ErrorHandler<RuntimeException> handle(final BiConsumer<Throwable, Optional<Payload>> handler); static void ignore(final Throwable e, final Optional<Payload> payload); }
|
@Test public void test3() { Errors.handle(Errors::ignore).handleError(new Exception(), Optional.empty()); }
|
public static ErrorHandler<RuntimeException> handle(final BiConsumer<Throwable, Optional<Payload>> handler) { return new ErrorHandler<RuntimeException>() { @Override public void handleError(final Throwable e, final Optional<Payload> payload) throws RuntimeException { handler.accept(e, payload); } }; }
|
Errors { public static ErrorHandler<RuntimeException> handle(final BiConsumer<Throwable, Optional<Payload>> handler) { return new ErrorHandler<RuntimeException>() { @Override public void handleError(final Throwable e, final Optional<Payload> payload) throws RuntimeException { handler.accept(e, payload); } }; } }
|
Errors { public static ErrorHandler<RuntimeException> handle(final BiConsumer<Throwable, Optional<Payload>> handler) { return new ErrorHandler<RuntimeException>() { @Override public void handleError(final Throwable e, final Optional<Payload> payload) throws RuntimeException { handler.accept(e, payload); } }; } private Errors(); }
|
Errors { public static ErrorHandler<RuntimeException> handle(final BiConsumer<Throwable, Optional<Payload>> handler) { return new ErrorHandler<RuntimeException>() { @Override public void handleError(final Throwable e, final Optional<Payload> payload) throws RuntimeException { handler.accept(e, payload); } }; } private Errors(); static ErrorHandler<RuntimeException> ignore(); static ErrorHandler<RuntimeException> handle(final BiConsumer<Throwable, Optional<Payload>> handler); static void ignore(final Throwable e, final Optional<Payload> payload); }
|
Errors { public static ErrorHandler<RuntimeException> handle(final BiConsumer<Throwable, Optional<Payload>> handler) { return new ErrorHandler<RuntimeException>() { @Override public void handleError(final Throwable e, final Optional<Payload> payload) throws RuntimeException { handler.accept(e, payload); } }; } private Errors(); static ErrorHandler<RuntimeException> ignore(); static ErrorHandler<RuntimeException> handle(final BiConsumer<Throwable, Optional<Payload>> handler); static void ignore(final Throwable e, final Optional<Payload> payload); }
|
@Test public void testEmpty1() { final Topic topic = Topic.of((List<String>) null); Assert.assertNull(topic); }
|
public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
Topic { public static Topic of(final List<String> segments) { if (segments == null || segments.isEmpty()) { return null; } segments.forEach(Topic::ensureNotSpecial); return new Topic(new ArrayList<>(segments)); } private Topic(final List<String> segments); List<String> getSegments(); Stream<String> stream(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static Topic split(String path); static Topic of(final List<String> segments); static Topic of(final String first, final String... strings); static String ensureNotSpecial(final String segment); }
|
@Test public void givenSslEnabledInConfiguration_whenHttpsPortIsMissingInConfiguration_thenShouldUseDefaultHttpsPort() throws Exception { configuration.put(SSL_CONFIGURATION_KEY, TRUE); configuration.remove(HTTPS_PORT); configureServer(); assertThat(options.getPort()).isEqualTo(DEFAULT_HTTPS_PORT); }
|
private int getPort(ServerConfiguration configuration) { return configuration.getInteger(ConfigKies.HTTPS_PORT, ConfigKies.DEFAULT_HTTPS_PORT); }
|
JksServerConfigurator implements HttpServerConfigurator { private int getPort(ServerConfiguration configuration) { return configuration.getInteger(ConfigKies.HTTPS_PORT, ConfigKies.DEFAULT_HTTPS_PORT); } }
|
JksServerConfigurator implements HttpServerConfigurator { private int getPort(ServerConfiguration configuration) { return configuration.getInteger(ConfigKies.HTTPS_PORT, ConfigKies.DEFAULT_HTTPS_PORT); } }
|
JksServerConfigurator implements HttpServerConfigurator { private int getPort(ServerConfiguration configuration) { return configuration.getInteger(ConfigKies.HTTPS_PORT, ConfigKies.DEFAULT_HTTPS_PORT); } @Override void configureHttpServer(VertxContext context, HttpServerOptions options); }
|
JksServerConfigurator implements HttpServerConfigurator { private int getPort(ServerConfiguration configuration) { return configuration.getInteger(ConfigKies.HTTPS_PORT, ConfigKies.DEFAULT_HTTPS_PORT); } @Override void configureHttpServer(VertxContext context, HttpServerOptions options); }
|
@Test public void givenServiceDiscovery_whenPublishHttpServiceAndAskingForItsWebClientByJsonWithConfiguration_thenShouldGetTheClient(TestContext context) throws Exception { publishHttpEndpoint(httpEndpointConfiguration.metadata(metadata)); getWebClient(jsonFilter, metadata, context.asyncAssertSuccess(Assert::assertNotNull)); }
|
public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); }
|
HttpServiceDiscovery { public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); } }
|
HttpServiceDiscovery { public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
HttpServiceDiscovery { public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(HttpEndpointConfiguration configuration, Handler<AsyncResult<Record>> handler); void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler); void getWebClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); }
|
HttpServiceDiscovery { public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(HttpEndpointConfiguration configuration, Handler<AsyncResult<Record>> handler); void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler); void getWebClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishingMessageSourceAndAskingForItsConsumer_thenShouldGetTheConsumer(TestContext context) throws Exception { publishMessageSourceService(messageSourceConfiguration); vertxServiceDiscovery.messageSource().getConsumer(record -> record.getName().equals(SERVICE_NAME), context.asyncAssertSuccess()); }
|
public <T> void getConsumer(Function<Record, Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> handler) { MessageSource.getConsumer(serviceDiscovery, filter, handler); }
|
MessageSourceServiceDiscovery { public <T> void getConsumer(Function<Record, Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> handler) { MessageSource.getConsumer(serviceDiscovery, filter, handler); } }
|
MessageSourceServiceDiscovery { public <T> void getConsumer(Function<Record, Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> handler) { MessageSource.getConsumer(serviceDiscovery, filter, handler); } MessageSourceServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
MessageSourceServiceDiscovery { public <T> void getConsumer(Function<Record, Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> handler) { MessageSource.getConsumer(serviceDiscovery, filter, handler); } MessageSourceServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(MessageSourceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getConsumer(Function<Record, Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> handler); void getConsumer(JsonObject jsonFilter, Handler<AsyncResult<MessageConsumer<T>>> handler); }
|
MessageSourceServiceDiscovery { public <T> void getConsumer(Function<Record, Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> handler) { MessageSource.getConsumer(serviceDiscovery, filter, handler); } MessageSourceServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(MessageSourceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getConsumer(Function<Record, Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> handler); void getConsumer(JsonObject jsonFilter, Handler<AsyncResult<MessageConsumer<T>>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishingMessageSourceAndAskingForItsConsumerByJson_thenShouldGetTheConsumer(TestContext context) throws Exception { publishMessageSourceService(messageSourceConfiguration); vertxServiceDiscovery.messageSource().getConsumer(new JsonObject().put("name", SERVICE_NAME), context.asyncAssertSuccess()); }
|
public <T> void getConsumer(Function<Record, Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> handler) { MessageSource.getConsumer(serviceDiscovery, filter, handler); }
|
MessageSourceServiceDiscovery { public <T> void getConsumer(Function<Record, Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> handler) { MessageSource.getConsumer(serviceDiscovery, filter, handler); } }
|
MessageSourceServiceDiscovery { public <T> void getConsumer(Function<Record, Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> handler) { MessageSource.getConsumer(serviceDiscovery, filter, handler); } MessageSourceServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
MessageSourceServiceDiscovery { public <T> void getConsumer(Function<Record, Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> handler) { MessageSource.getConsumer(serviceDiscovery, filter, handler); } MessageSourceServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(MessageSourceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getConsumer(Function<Record, Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> handler); void getConsumer(JsonObject jsonFilter, Handler<AsyncResult<MessageConsumer<T>>> handler); }
|
MessageSourceServiceDiscovery { public <T> void getConsumer(Function<Record, Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> handler) { MessageSource.getConsumer(serviceDiscovery, filter, handler); } MessageSourceServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(MessageSourceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getConsumer(Function<Record, Boolean> filter, Handler<AsyncResult<MessageConsumer<T>>> handler); void getConsumer(JsonObject jsonFilter, Handler<AsyncResult<MessageConsumer<T>>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishingRedisDataSourceAndAskingForItsClient_thenShouldGetTheClient(TestContext context) throws Exception { publishRedisDataSourceService(dataSourceConfiguration); vertxServiceDiscovery.redis().getClient(filter(), context.asyncAssertSuccess()); }
|
public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); }
|
RedisServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); } }
|
RedisServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); } RedisServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
RedisServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); } RedisServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler); void getClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<RedisClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<RedisClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<RedisClient>> handler); }
|
RedisServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); } RedisServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler); void getClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<RedisClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<RedisClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<RedisClient>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishingRedisDataAndAskingForItsClientWithConfiguration_thenShouldGetTheClient(TestContext context) throws Exception { publishRedisDataSourceService(dataSourceConfiguration.metadata(metadata)); vertxServiceDiscovery.redis().getClient(filter(), metadata, context.asyncAssertSuccess()); }
|
public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); }
|
RedisServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); } }
|
RedisServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); } RedisServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
RedisServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); } RedisServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler); void getClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<RedisClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<RedisClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<RedisClient>> handler); }
|
RedisServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); } RedisServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler); void getClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<RedisClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<RedisClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<RedisClient>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishingRedisDataAndAskingForItsClientByJson_thenShouldGetTheClient(TestContext context) throws Exception { publishRedisDataSourceService(dataSourceConfiguration); vertxServiceDiscovery.redis().getClient(jsonFilter, context.asyncAssertSuccess()); }
|
public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); }
|
RedisServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); } }
|
RedisServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); } RedisServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
RedisServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); } RedisServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler); void getClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<RedisClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<RedisClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<RedisClient>> handler); }
|
RedisServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); } RedisServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler); void getClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<RedisClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<RedisClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<RedisClient>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishingRedisDataAndAskingForItsClientByJsonWithConfiguration_thenShouldGetTheClient(TestContext context) throws Exception { publishRedisDataSourceService(dataSourceConfiguration.metadata(metadata)); vertxServiceDiscovery.redis().getClient(jsonFilter, metadata, context.asyncAssertSuccess()); }
|
public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); }
|
RedisServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); } }
|
RedisServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); } RedisServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
RedisServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); } RedisServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler); void getClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<RedisClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<RedisClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<RedisClient>> handler); }
|
RedisServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler) { RedisDataSource.getRedisClient(serviceDiscovery, filter, handler); } RedisServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<RedisClient>> handler); void getClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<RedisClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<RedisClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<RedisClient>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishEventBusServiceAndAskingForItsProxy_thenShouldGetTheService(TestContext context) throws Exception { publishEventBusService(eventBusConfiguration); vertxServiceDiscovery.eventBus().getProxy(TestService.class, context.asyncAssertSuccess(Assert::assertNotNull)); }
|
public <T> void getProxy(Class<T> serviceClass, Handler<AsyncResult<T>> handler) { EventBusService.getProxy(serviceDiscovery, serviceClass, handler); }
|
EventBusServiceDiscovery { public <T> void getProxy(Class<T> serviceClass, Handler<AsyncResult<T>> handler) { EventBusService.getProxy(serviceDiscovery, serviceClass, handler); } }
|
EventBusServiceDiscovery { public <T> void getProxy(Class<T> serviceClass, Handler<AsyncResult<T>> handler) { EventBusService.getProxy(serviceDiscovery, serviceClass, handler); } EventBusServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
EventBusServiceDiscovery { public <T> void getProxy(Class<T> serviceClass, Handler<AsyncResult<T>> handler) { EventBusService.getProxy(serviceDiscovery, serviceClass, handler); } EventBusServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(EventBusServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getProxy(Class<T> serviceClass, Handler<AsyncResult<T>> handler); void getServiceProxy(Function<Record, Boolean> filter, Class<T> serviceClass, Handler<AsyncResult<T>> handler); void getServiceProxy(JsonObject jsonFilter, Class<T> serviceClass, Handler<AsyncResult<T>> handler); }
|
EventBusServiceDiscovery { public <T> void getProxy(Class<T> serviceClass, Handler<AsyncResult<T>> handler) { EventBusService.getProxy(serviceDiscovery, serviceClass, handler); } EventBusServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(EventBusServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getProxy(Class<T> serviceClass, Handler<AsyncResult<T>> handler); void getServiceProxy(Function<Record, Boolean> filter, Class<T> serviceClass, Handler<AsyncResult<T>> handler); void getServiceProxy(JsonObject jsonFilter, Class<T> serviceClass, Handler<AsyncResult<T>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishEventBusServiceAndAskingForItsServiceProxy_thenShouldGetTheService(TestContext context) throws Exception { publishEventBusService(eventBusConfiguration); vertxServiceDiscovery.eventBus().getServiceProxy(record -> record.getName().equals(SERVICE_NAME), TestService.class, context.asyncAssertSuccess(Assert::assertNotNull)); }
|
public <T> void getServiceProxy(Function<Record, Boolean> filter, Class<T> serviceClass, Handler<AsyncResult<T>> handler) { EventBusService.getServiceProxy(serviceDiscovery, filter, serviceClass, handler); }
|
EventBusServiceDiscovery { public <T> void getServiceProxy(Function<Record, Boolean> filter, Class<T> serviceClass, Handler<AsyncResult<T>> handler) { EventBusService.getServiceProxy(serviceDiscovery, filter, serviceClass, handler); } }
|
EventBusServiceDiscovery { public <T> void getServiceProxy(Function<Record, Boolean> filter, Class<T> serviceClass, Handler<AsyncResult<T>> handler) { EventBusService.getServiceProxy(serviceDiscovery, filter, serviceClass, handler); } EventBusServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
EventBusServiceDiscovery { public <T> void getServiceProxy(Function<Record, Boolean> filter, Class<T> serviceClass, Handler<AsyncResult<T>> handler) { EventBusService.getServiceProxy(serviceDiscovery, filter, serviceClass, handler); } EventBusServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(EventBusServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getProxy(Class<T> serviceClass, Handler<AsyncResult<T>> handler); void getServiceProxy(Function<Record, Boolean> filter, Class<T> serviceClass, Handler<AsyncResult<T>> handler); void getServiceProxy(JsonObject jsonFilter, Class<T> serviceClass, Handler<AsyncResult<T>> handler); }
|
EventBusServiceDiscovery { public <T> void getServiceProxy(Function<Record, Boolean> filter, Class<T> serviceClass, Handler<AsyncResult<T>> handler) { EventBusService.getServiceProxy(serviceDiscovery, filter, serviceClass, handler); } EventBusServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(EventBusServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getProxy(Class<T> serviceClass, Handler<AsyncResult<T>> handler); void getServiceProxy(Function<Record, Boolean> filter, Class<T> serviceClass, Handler<AsyncResult<T>> handler); void getServiceProxy(JsonObject jsonFilter, Class<T> serviceClass, Handler<AsyncResult<T>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishEventBusServiceAndAskingForItsServiceProxyByJson_thenShouldGetTheService(TestContext context) throws Exception { publishEventBusService(eventBusConfiguration); vertxServiceDiscovery.eventBus().getServiceProxy(jsonFilter, TestService.class, context.asyncAssertSuccess(Assert::assertNotNull)); }
|
public <T> void getServiceProxy(Function<Record, Boolean> filter, Class<T> serviceClass, Handler<AsyncResult<T>> handler) { EventBusService.getServiceProxy(serviceDiscovery, filter, serviceClass, handler); }
|
EventBusServiceDiscovery { public <T> void getServiceProxy(Function<Record, Boolean> filter, Class<T> serviceClass, Handler<AsyncResult<T>> handler) { EventBusService.getServiceProxy(serviceDiscovery, filter, serviceClass, handler); } }
|
EventBusServiceDiscovery { public <T> void getServiceProxy(Function<Record, Boolean> filter, Class<T> serviceClass, Handler<AsyncResult<T>> handler) { EventBusService.getServiceProxy(serviceDiscovery, filter, serviceClass, handler); } EventBusServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
EventBusServiceDiscovery { public <T> void getServiceProxy(Function<Record, Boolean> filter, Class<T> serviceClass, Handler<AsyncResult<T>> handler) { EventBusService.getServiceProxy(serviceDiscovery, filter, serviceClass, handler); } EventBusServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(EventBusServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getProxy(Class<T> serviceClass, Handler<AsyncResult<T>> handler); void getServiceProxy(Function<Record, Boolean> filter, Class<T> serviceClass, Handler<AsyncResult<T>> handler); void getServiceProxy(JsonObject jsonFilter, Class<T> serviceClass, Handler<AsyncResult<T>> handler); }
|
EventBusServiceDiscovery { public <T> void getServiceProxy(Function<Record, Boolean> filter, Class<T> serviceClass, Handler<AsyncResult<T>> handler) { EventBusService.getServiceProxy(serviceDiscovery, filter, serviceClass, handler); } EventBusServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(EventBusServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getProxy(Class<T> serviceClass, Handler<AsyncResult<T>> handler); void getServiceProxy(Function<Record, Boolean> filter, Class<T> serviceClass, Handler<AsyncResult<T>> handler); void getServiceProxy(JsonObject jsonFilter, Class<T> serviceClass, Handler<AsyncResult<T>> handler); }
|
@Test public void givenSslEnabledInConfiguration_whenHttpsPortIsSetInConfiguration_thenShouldUsePortFromConfiguration() throws Exception { configuration.put(SSL_CONFIGURATION_KEY, TRUE); configuration.put(HTTPS_PORT, DEFAULT_TEST_SSL_PORT); configureServer(); assertThat(options.getPort()).isEqualTo(DEFAULT_TEST_SSL_PORT); }
|
private int getPort(ServerConfiguration configuration) { return configuration.getInteger(ConfigKies.HTTPS_PORT, ConfigKies.DEFAULT_HTTPS_PORT); }
|
JksServerConfigurator implements HttpServerConfigurator { private int getPort(ServerConfiguration configuration) { return configuration.getInteger(ConfigKies.HTTPS_PORT, ConfigKies.DEFAULT_HTTPS_PORT); } }
|
JksServerConfigurator implements HttpServerConfigurator { private int getPort(ServerConfiguration configuration) { return configuration.getInteger(ConfigKies.HTTPS_PORT, ConfigKies.DEFAULT_HTTPS_PORT); } }
|
JksServerConfigurator implements HttpServerConfigurator { private int getPort(ServerConfiguration configuration) { return configuration.getInteger(ConfigKies.HTTPS_PORT, ConfigKies.DEFAULT_HTTPS_PORT); } @Override void configureHttpServer(VertxContext context, HttpServerOptions options); }
|
JksServerConfigurator implements HttpServerConfigurator { private int getPort(ServerConfiguration configuration) { return configuration.getInteger(ConfigKies.HTTPS_PORT, ConfigKies.DEFAULT_HTTPS_PORT); } @Override void configureHttpServer(VertxContext context, HttpServerOptions options); }
|
@Test public void givenServiceDiscovery_whenPublishingMessageSourceAndAskingForItsClient_thenShouldGetTheClient(TestContext context) throws Exception { publishJDBCDataSourceService(dataSourceConfiguration); vertxServiceDiscovery.jdbc().getClient(filter(), context.asyncAssertSuccess()); }
|
public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); }
|
JDBCServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); } }
|
JDBCServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); } JDBCServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
JDBCServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); } JDBCServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler); void getClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<JDBCClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<JDBCClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<JDBCClient>> handler); }
|
JDBCServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); } JDBCServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler); void getClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<JDBCClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<JDBCClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<JDBCClient>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishingMessageSourceAndAskingForItsClientWithConfiguration_thenShouldGetTheClient(TestContext context) throws Exception { publishJDBCDataSourceService(dataSourceConfiguration.metadata(metadata)); vertxServiceDiscovery.jdbc().getClient(filter(), metadata, context.asyncAssertSuccess()); }
|
public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); }
|
JDBCServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); } }
|
JDBCServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); } JDBCServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
JDBCServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); } JDBCServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler); void getClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<JDBCClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<JDBCClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<JDBCClient>> handler); }
|
JDBCServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); } JDBCServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler); void getClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<JDBCClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<JDBCClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<JDBCClient>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishingMessageSourceAndAskingForItsClientByJson_thenShouldGetTheClient(TestContext context) throws Exception { publishJDBCDataSourceService(dataSourceConfiguration); vertxServiceDiscovery.jdbc().getClient(jsonFilter, context.asyncAssertSuccess()); }
|
public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); }
|
JDBCServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); } }
|
JDBCServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); } JDBCServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
JDBCServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); } JDBCServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler); void getClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<JDBCClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<JDBCClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<JDBCClient>> handler); }
|
JDBCServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); } JDBCServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler); void getClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<JDBCClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<JDBCClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<JDBCClient>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishingMessageSourceAndAskingForItsClientByJsonWithConfiguration_thenShouldGetTheClient(TestContext context) throws Exception { publishJDBCDataSourceService(dataSourceConfiguration.metadata(metadata)); vertxServiceDiscovery.jdbc().getClient(jsonFilter, metadata, context.asyncAssertSuccess()); }
|
public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); }
|
JDBCServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); } }
|
JDBCServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); } JDBCServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
JDBCServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); } JDBCServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler); void getClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<JDBCClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<JDBCClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<JDBCClient>> handler); }
|
JDBCServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler) { JDBCDataSource.getJDBCClient(serviceDiscovery, filter, handler); } JDBCServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<JDBCClient>> handler); void getClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<JDBCClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<JDBCClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<JDBCClient>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishingRedisDataSourceAndAskingForItsClient_thenShouldGetTheClient(TestContext context) throws Exception { publishMongoDataSourceService(dataSourceConfiguration); vertxServiceDiscovery.mongo().getClient(filter(), context.asyncAssertSuccess()); }
|
public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler) { MongoDataSource.getMongoClient(serviceDiscovery, filter, handler); }
|
MongoServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler) { MongoDataSource.getMongoClient(serviceDiscovery, filter, handler); } }
|
MongoServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler) { MongoDataSource.getMongoClient(serviceDiscovery, filter, handler); } MongoServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
MongoServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler) { MongoDataSource.getMongoClient(serviceDiscovery, filter, handler); } MongoServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<MongoClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<MongoClient>> handler); }
|
MongoServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler) { MongoDataSource.getMongoClient(serviceDiscovery, filter, handler); } MongoServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<MongoClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<MongoClient>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishingRedisDataAndAskingForItsClientByJson_thenShouldGetTheClient(TestContext context) throws Exception { publishMongoDataSourceService(dataSourceConfiguration); vertxServiceDiscovery.mongo().getClient(jsonFilter, context.asyncAssertSuccess()); }
|
public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler) { MongoDataSource.getMongoClient(serviceDiscovery, filter, handler); }
|
MongoServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler) { MongoDataSource.getMongoClient(serviceDiscovery, filter, handler); } }
|
MongoServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler) { MongoDataSource.getMongoClient(serviceDiscovery, filter, handler); } MongoServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
MongoServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler) { MongoDataSource.getMongoClient(serviceDiscovery, filter, handler); } MongoServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<MongoClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<MongoClient>> handler); }
|
MongoServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler) { MongoDataSource.getMongoClient(serviceDiscovery, filter, handler); } MongoServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<MongoClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<MongoClient>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishingRedisDataAndAskingForItsClientByJsonWithConfiguration_thenShouldGetTheClient(TestContext context) throws Exception { publishMongoDataSourceService(dataSourceConfiguration.metadata(metadata)); vertxServiceDiscovery.mongo().getClient(jsonFilter, metadata, context.asyncAssertSuccess()); }
|
public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler) { MongoDataSource.getMongoClient(serviceDiscovery, filter, handler); }
|
MongoServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler) { MongoDataSource.getMongoClient(serviceDiscovery, filter, handler); } }
|
MongoServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler) { MongoDataSource.getMongoClient(serviceDiscovery, filter, handler); } MongoServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
MongoServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler) { MongoDataSource.getMongoClient(serviceDiscovery, filter, handler); } MongoServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<MongoClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<MongoClient>> handler); }
|
MongoServiceDiscovery { public void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler) { MongoDataSource.getMongoClient(serviceDiscovery, filter, handler); } MongoServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(DataSourceServiceConfiguration configuration, Handler<AsyncResult<Record>> handler); void getClient(Function<Record, Boolean> filter, Handler<AsyncResult<MongoClient>> handler); void getClient(JsonObject jsonFilter, Handler<AsyncResult<MongoClient>> handler); void getClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<MongoClient>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishingRecord_thenTheRecordShouldBePublished(TestContext context) throws Exception { vertxServiceDiscovery.publishRecord(record, context.asyncAssertSuccess()); }
|
public void publishRecord(Record record, Handler<AsyncResult<Record>> handler) { serviceDiscovery.publish(record, handler); }
|
VertxServiceDiscovery { public void publishRecord(Record record, Handler<AsyncResult<Record>> handler) { serviceDiscovery.publish(record, handler); } }
|
VertxServiceDiscovery { public void publishRecord(Record record, Handler<AsyncResult<Record>> handler) { serviceDiscovery.publish(record, handler); } VertxServiceDiscovery(Vertx vertx); }
|
VertxServiceDiscovery { public void publishRecord(Record record, Handler<AsyncResult<Record>> handler) { serviceDiscovery.publish(record, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
VertxServiceDiscovery { public void publishRecord(Record record, Handler<AsyncResult<Record>> handler) { serviceDiscovery.publish(record, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
@Test(expected = InvalidFilterException.class) public void givenServiceDiscovery_whenLookupForARecordWithNullFilter_thenShouldThrowException() throws Exception { lookup(null, ar -> { }); }
|
public void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, false, handler); }
|
VertxServiceDiscovery { public void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, false, handler); } }
|
VertxServiceDiscovery { public void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); }
|
VertxServiceDiscovery { public void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
VertxServiceDiscovery { public void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
@Test public void givenServiceDiscovery_whenLookupForARecordUnmatchingPredicate_thenShouldGetNullRecord(TestContext context) throws Exception { publishTestRecord(record); lookup(r -> r.getName().equals(NOT_EXISTED_NAME), context.asyncAssertSuccess(context::assertNull)); }
|
public void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, false, handler); }
|
VertxServiceDiscovery { public void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, false, handler); } }
|
VertxServiceDiscovery { public void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); }
|
VertxServiceDiscovery { public void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
VertxServiceDiscovery { public void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
@Test public void givenSslEnabledInConfigurationWithJksPathAndPassword_whenConfiguringServer_thenHttpOptionSslShouldBeEnabledAndConfiguredWithThePathAndPassword() throws Exception { configuration.put(SSL_CONFIGURATION_KEY, TRUE); configureServer(); assertThat(options.isSsl()).isTrue(); assertThat(options.getKeyStoreOptions() instanceof JksOptions).isTrue(); assertThat(options.getKeyStoreOptions().getPath()).isEqualTo(TEST_JKS_PATH); assertThat(options.getKeyStoreOptions().getPassword()).isEqualTo(TEST_JKS_SECRET); }
|
private String getPath(ServerConfiguration configuration) { return configuration.getString(ConfigKies.SSL_JKS_PATH); }
|
JksServerConfigurator implements HttpServerConfigurator { private String getPath(ServerConfiguration configuration) { return configuration.getString(ConfigKies.SSL_JKS_PATH); } }
|
JksServerConfigurator implements HttpServerConfigurator { private String getPath(ServerConfiguration configuration) { return configuration.getString(ConfigKies.SSL_JKS_PATH); } }
|
JksServerConfigurator implements HttpServerConfigurator { private String getPath(ServerConfiguration configuration) { return configuration.getString(ConfigKies.SSL_JKS_PATH); } @Override void configureHttpServer(VertxContext context, HttpServerOptions options); }
|
JksServerConfigurator implements HttpServerConfigurator { private String getPath(ServerConfiguration configuration) { return configuration.getString(ConfigKies.SSL_JKS_PATH); } @Override void configureHttpServer(VertxContext context, HttpServerOptions options); }
|
@Test public void givenServiceDiscovery_whenLookupForARecordMatchingPredicate_thenShouldGetTheRecord(TestContext context) throws Exception { publishTestRecord(record); lookup(r -> r.getName().equals(SERVICE_NAME), context.asyncAssertSuccess(record -> { context.assertEquals(SERVICE_NAME, record.getName()); })); }
|
public void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, false, handler); }
|
VertxServiceDiscovery { public void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, false, handler); } }
|
VertxServiceDiscovery { public void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); }
|
VertxServiceDiscovery { public void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
VertxServiceDiscovery { public void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
@Test(expected = InvalidFilterException.class) public void givenServiceDiscovery_whenLookupForARecordIncludingOutOfServicePassingNullFilter_thenShouldThrowException(TestContext context) throws Exception { lookupIncludeOutOfService(null, ar -> { }); }
|
public void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, true, handler); }
|
VertxServiceDiscovery { public void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, true, handler); } }
|
VertxServiceDiscovery { public void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, true, handler); } VertxServiceDiscovery(Vertx vertx); }
|
VertxServiceDiscovery { public void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, true, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
VertxServiceDiscovery { public void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, true, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
@Test public void givenServiceDiscovery_whenLookupForARecordIncludingOutOfService_thenShouldGetTheRecord(TestContext context) throws Exception { publishTestRecord(record.setStatus(Status.OUT_OF_SERVICE)); lookupIncludeOutOfService(r -> r.getName().equals(SERVICE_NAME), context.asyncAssertSuccess(record -> { context.assertEquals(Status.OUT_OF_SERVICE, record.getStatus()); })); }
|
public void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, true, handler); }
|
VertxServiceDiscovery { public void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, true, handler); } }
|
VertxServiceDiscovery { public void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, true, handler); } VertxServiceDiscovery(Vertx vertx); }
|
VertxServiceDiscovery { public void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, true, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
VertxServiceDiscovery { public void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler) { lookup(filter, true, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
@Test public void givenServiceDiscovery_whenLookupByJsonForARecordPassingNull_thenShouldGetTheRecord(TestContext context) throws Exception { publishTestRecord(record); lookupByJson(null, context.asyncAssertSuccess(record -> { context.assertEquals(SERVICE_NAME, record.getName()); })); }
|
public void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler) { serviceDiscovery.getRecord(jsonFilter, handler); }
|
VertxServiceDiscovery { public void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler) { serviceDiscovery.getRecord(jsonFilter, handler); } }
|
VertxServiceDiscovery { public void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler) { serviceDiscovery.getRecord(jsonFilter, handler); } VertxServiceDiscovery(Vertx vertx); }
|
VertxServiceDiscovery { public void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler) { serviceDiscovery.getRecord(jsonFilter, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
VertxServiceDiscovery { public void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler) { serviceDiscovery.getRecord(jsonFilter, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
@Test public void givenServiceDiscovery_whenLookupByJsonForARecordWithAName_thenShouldGetARecordWithThatName(TestContext context) throws Exception { publishTestRecord(record); lookupByJson(jsonFilter, context.asyncAssertSuccess(record -> { context.assertEquals(SERVICE_NAME, record.getName()); })); }
|
public void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler) { serviceDiscovery.getRecord(jsonFilter, handler); }
|
VertxServiceDiscovery { public void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler) { serviceDiscovery.getRecord(jsonFilter, handler); } }
|
VertxServiceDiscovery { public void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler) { serviceDiscovery.getRecord(jsonFilter, handler); } VertxServiceDiscovery(Vertx vertx); }
|
VertxServiceDiscovery { public void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler) { serviceDiscovery.getRecord(jsonFilter, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
VertxServiceDiscovery { public void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler) { serviceDiscovery.getRecord(jsonFilter, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
@Test(expected = InvalidFilterException.class) public void givenServiceDiscovery_whenLookupForAllRecordsPassingNullFilter_thenShouldThrowException() throws Exception { lookupAll(null, ar -> { }); }
|
public void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, false, handler); }
|
VertxServiceDiscovery { public void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, false, handler); } }
|
VertxServiceDiscovery { public void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); }
|
VertxServiceDiscovery { public void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
VertxServiceDiscovery { public void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
@Test public void givenServiceDiscovery_whenLookupForAllRecordsWithUnmatchingPredicate_thenShouldNotGetAnyRecord(TestContext context) throws Exception { publishTestRecord(record); publishTestRecord(otherRecord); lookupAll(record -> record.getName().equals(NOT_EXISTED_NAME), context.asyncAssertSuccess(records -> { context.assertTrue(records.isEmpty()); })); }
|
public void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, false, handler); }
|
VertxServiceDiscovery { public void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, false, handler); } }
|
VertxServiceDiscovery { public void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); }
|
VertxServiceDiscovery { public void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
VertxServiceDiscovery { public void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
@Test public void givenServiceDiscovery_whenLookupForAllRecordsWithMatchingPredicate_thenShouldGetAllRecordsMatching(TestContext context) throws Exception { publishTestRecord(record); publishTestRecord(otherRecord); lookupAll(record -> record.getName().contains(SERVICE_NAME), context.asyncAssertSuccess(records -> { context.assertEquals(2, records.size()); })); }
|
public void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, false, handler); }
|
VertxServiceDiscovery { public void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, false, handler); } }
|
VertxServiceDiscovery { public void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); }
|
VertxServiceDiscovery { public void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
VertxServiceDiscovery { public void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, false, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
@Test(expected = InvalidFilterException.class) public void givenServiceDiscovery_whenLookupForAllRecordsIncludingOutOfServicePassingNullFilter_thenShouldThrowException(TestContext context) throws Exception { lookupAllIncludeOutOfService(null, ar -> { }); }
|
public void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, true, handler); }
|
VertxServiceDiscovery { public void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, true, handler); } }
|
VertxServiceDiscovery { public void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, true, handler); } VertxServiceDiscovery(Vertx vertx); }
|
VertxServiceDiscovery { public void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, true, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
VertxServiceDiscovery { public void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, true, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
@Test public void givenServiceDiscovery_whenLookupForAllRecordsIncludingOutOfService_thenShouldGetAllRecordsIncludingOutOfService(TestContext context) throws Exception { publishTestRecord(record.setStatus(Status.OUT_OF_SERVICE)); publishTestRecord(otherRecord); lookupAllIncludeOutOfService(record -> record.getName().contains(SERVICE_NAME), context.asyncAssertSuccess(records -> { context.assertEquals(2, records.size()); })); }
|
public void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, true, handler); }
|
VertxServiceDiscovery { public void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, true, handler); } }
|
VertxServiceDiscovery { public void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, true, handler); } VertxServiceDiscovery(Vertx vertx); }
|
VertxServiceDiscovery { public void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, true, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
VertxServiceDiscovery { public void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler) { lookupAll(filter, true, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
@Test public void givenServiceDiscovery_whenPublishHttpServiceAndAskingForItsHttpClientByFilter_thenShouldGetTheClient(TestContext context) throws Exception { publishHttpEndpoint(httpEndpointConfiguration); getHttpClient(record -> record.getName().equals(SERVICE_NAME), context.asyncAssertSuccess(Assert::assertNotNull)); }
|
public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); }
|
HttpServiceDiscovery { public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); } }
|
HttpServiceDiscovery { public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
HttpServiceDiscovery { public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(HttpEndpointConfiguration configuration, Handler<AsyncResult<Record>> handler); void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler); void getWebClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); }
|
HttpServiceDiscovery { public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(HttpEndpointConfiguration configuration, Handler<AsyncResult<Record>> handler); void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler); void getWebClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); }
|
@Test public void givenServiceDiscovery_whenLookupForAllRecordsByJsonPassingNull_thenShouldGetAllRecords(TestContext context) throws Exception { publishTestRecord(record); publishTestRecord(otherRecord); lookupAllByJson(null, context.asyncAssertSuccess(records -> { context.assertEquals(2, records.size()); })); }
|
public void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler) { serviceDiscovery.getRecords(jsonFilter, handler); }
|
VertxServiceDiscovery { public void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler) { serviceDiscovery.getRecords(jsonFilter, handler); } }
|
VertxServiceDiscovery { public void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler) { serviceDiscovery.getRecords(jsonFilter, handler); } VertxServiceDiscovery(Vertx vertx); }
|
VertxServiceDiscovery { public void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler) { serviceDiscovery.getRecords(jsonFilter, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
VertxServiceDiscovery { public void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler) { serviceDiscovery.getRecords(jsonFilter, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
@Test public void givenServiceDiscovery_whenLookupForAllRecordsWithNameByJson_thenShouldGetAllRecordsMatching(TestContext context) throws Exception { publishTestRecord(record.setMetadata(metadata)); publishTestRecord(otherRecord.setMetadata(metadata)); lookupAllByJson(metadata, context.asyncAssertSuccess(records -> { context.assertEquals(2, records.size()); })); }
|
public void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler) { serviceDiscovery.getRecords(jsonFilter, handler); }
|
VertxServiceDiscovery { public void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler) { serviceDiscovery.getRecords(jsonFilter, handler); } }
|
VertxServiceDiscovery { public void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler) { serviceDiscovery.getRecords(jsonFilter, handler); } VertxServiceDiscovery(Vertx vertx); }
|
VertxServiceDiscovery { public void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler) { serviceDiscovery.getRecords(jsonFilter, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
VertxServiceDiscovery { public void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler) { serviceDiscovery.getRecords(jsonFilter, handler); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
@Test public void givenServiceDiscovery_whenPublishServiceAndLookupForItsServiceReference_thenShouldGetTheReference(TestContext context) throws Exception { publishTestRecord(record, context.asyncAssertSuccess(record -> { assertNotNull(vertxServiceDiscovery.lookupForAReference(record)); })); }
|
public ServiceReference lookupForAReference(Record record) { return serviceDiscovery.getReference(record); }
|
VertxServiceDiscovery { public ServiceReference lookupForAReference(Record record) { return serviceDiscovery.getReference(record); } }
|
VertxServiceDiscovery { public ServiceReference lookupForAReference(Record record) { return serviceDiscovery.getReference(record); } VertxServiceDiscovery(Vertx vertx); }
|
VertxServiceDiscovery { public ServiceReference lookupForAReference(Record record) { return serviceDiscovery.getReference(record); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
VertxServiceDiscovery { public ServiceReference lookupForAReference(Record record) { return serviceDiscovery.getReference(record); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
@Test public void givenServiceDiscovery_whenPublishServiceWithMetadataAndLookupForItsServiceReferencePassingConfiguration_thenShouldGetTheReferenceUponTheseConfigurations(TestContext context) throws Exception { publishTestRecord(record, context.asyncAssertSuccess(record -> { ServiceReference reference = vertxServiceDiscovery.lookupForAReferenceWithConfiguration(record, metadata); assertEquals(VALUE, reference.record().getMetadata().getString(KEY)); })); }
|
public ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration) { return serviceDiscovery.getReferenceWithConfiguration(record, configuration); }
|
VertxServiceDiscovery { public ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration) { return serviceDiscovery.getReferenceWithConfiguration(record, configuration); } }
|
VertxServiceDiscovery { public ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration) { return serviceDiscovery.getReferenceWithConfiguration(record, configuration); } VertxServiceDiscovery(Vertx vertx); }
|
VertxServiceDiscovery { public ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration) { return serviceDiscovery.getReferenceWithConfiguration(record, configuration); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
VertxServiceDiscovery { public ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration) { return serviceDiscovery.getReferenceWithConfiguration(record, configuration); } VertxServiceDiscovery(Vertx vertx); ServiceDiscovery serviceDiscovery(); HttpServiceDiscovery http(); EventBusServiceDiscovery eventBus(); MessageSourceServiceDiscovery messageSource(); JDBCServiceDiscovery jdbc(); RedisServiceDiscovery redis(); MongoServiceDiscovery mongo(); void unpublish(Record record, Handler<AsyncResult<Void>> handler); void publishRecord(Record record, Handler<AsyncResult<Record>> handler); void lookup(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<Record>> handler); void lookupByJson(JsonObject jsonFilter, Handler<AsyncResult<Record>> handler); void lookupAll(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllIncludeOutOfService(Function<Record, Boolean> filter, Handler<AsyncResult<List<Record>>> handler); void lookupAllByJson(JsonObject jsonFilter, Handler<AsyncResult<List<Record>>> handler); ServiceReference lookupForAReference(Record record); ServiceReference lookupForAReferenceWithConfiguration(Record record, JsonObject configuration); void releaseServiceObject(Object object); }
|
@Test public void givenServiceDiscovery_whenPublishHttpServiceAndAskingForItsHttpClientByFilterWithConfiguration_thenShouldGetTheClient(TestContext context) throws Exception { publishHttpEndpoint(httpEndpointConfiguration.metadata(metadata)); getHttpClient(record -> record.getName().equals(SERVICE_NAME), metadata, context.asyncAssertSuccess(Assert::assertNotNull)); }
|
public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); }
|
HttpServiceDiscovery { public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); } }
|
HttpServiceDiscovery { public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
HttpServiceDiscovery { public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(HttpEndpointConfiguration configuration, Handler<AsyncResult<Record>> handler); void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler); void getWebClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); }
|
HttpServiceDiscovery { public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(HttpEndpointConfiguration configuration, Handler<AsyncResult<Record>> handler); void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler); void getWebClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishHttpServiceAndAskingForItsHttpClientByJson_thenShouldGetTheClient(TestContext context) throws Exception { publishHttpEndpoint(httpEndpointConfiguration); getHttpClient(jsonFilter, context.asyncAssertSuccess(Assert::assertNotNull)); }
|
public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); }
|
HttpServiceDiscovery { public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); } }
|
HttpServiceDiscovery { public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
HttpServiceDiscovery { public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(HttpEndpointConfiguration configuration, Handler<AsyncResult<Record>> handler); void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler); void getWebClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); }
|
HttpServiceDiscovery { public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(HttpEndpointConfiguration configuration, Handler<AsyncResult<Record>> handler); void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler); void getWebClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishHttpServiceAndAskingForItsHttpClientByJsonWithConfiguration_thenShouldGetTheClient(TestContext context) throws Exception { publishHttpEndpoint(httpEndpointConfiguration.metadata(metadata)); getHttpClient(jsonFilter, metadata, context.asyncAssertSuccess(Assert::assertNotNull)); }
|
public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); }
|
HttpServiceDiscovery { public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); } }
|
HttpServiceDiscovery { public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
HttpServiceDiscovery { public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(HttpEndpointConfiguration configuration, Handler<AsyncResult<Record>> handler); void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler); void getWebClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); }
|
HttpServiceDiscovery { public void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler) { HttpEndpoint.getClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(HttpEndpointConfiguration configuration, Handler<AsyncResult<Record>> handler); void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler); void getWebClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishHttpServiceAndAskingForItsWebClientByFilter_thenShouldGetTheClient(TestContext context) throws Exception { publishHttpEndpoint(httpEndpointConfiguration); getWebClient(record -> record.getName().equals(SERVICE_NAME), context.asyncAssertSuccess(Assert::assertNotNull)); }
|
public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); }
|
HttpServiceDiscovery { public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); } }
|
HttpServiceDiscovery { public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
HttpServiceDiscovery { public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(HttpEndpointConfiguration configuration, Handler<AsyncResult<Record>> handler); void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler); void getWebClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); }
|
HttpServiceDiscovery { public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(HttpEndpointConfiguration configuration, Handler<AsyncResult<Record>> handler); void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler); void getWebClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishHttpServiceAndAskingForItsWebClientByFilterWithConfiguration_thenShouldGetTheClient(TestContext context) throws Exception { publishHttpEndpoint(httpEndpointConfiguration.metadata(metadata)); getWebClient(record -> record.getName().equals(SERVICE_NAME), metadata, context.asyncAssertSuccess(Assert::assertNotNull)); }
|
public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); }
|
HttpServiceDiscovery { public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); } }
|
HttpServiceDiscovery { public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
HttpServiceDiscovery { public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(HttpEndpointConfiguration configuration, Handler<AsyncResult<Record>> handler); void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler); void getWebClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); }
|
HttpServiceDiscovery { public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(HttpEndpointConfiguration configuration, Handler<AsyncResult<Record>> handler); void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler); void getWebClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); }
|
@Test public void givenServiceDiscovery_whenPublishHttpServiceAndAskingForItsWebClientByJson_thenShouldGetTheClient(TestContext context) throws Exception { publishHttpEndpoint(httpEndpointConfiguration); getWebClient(jsonFilter, context.asyncAssertSuccess(Assert::assertNotNull)); }
|
public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); }
|
HttpServiceDiscovery { public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); } }
|
HttpServiceDiscovery { public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); }
|
HttpServiceDiscovery { public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(HttpEndpointConfiguration configuration, Handler<AsyncResult<Record>> handler); void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler); void getWebClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); }
|
HttpServiceDiscovery { public void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler) { HttpEndpoint.getWebClient(serviceDiscovery, filter, handler); } HttpServiceDiscovery(ServiceDiscovery serviceDiscovery); void publish(HttpEndpointConfiguration configuration, Handler<AsyncResult<Record>> handler); void getHttpClient(Function<Record, Boolean> filter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, Handler<AsyncResult<HttpClient>> handler); void getHttpClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<HttpClient>> handler); void getWebClient(Function<Record, Boolean> filter, Handler<AsyncResult<WebClient>> handler); void getWebClient(Function<Record, Boolean> filter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, Handler<AsyncResult<WebClient>> handler); void getWebClient(JsonObject jsonFilter, JsonObject configuration, Handler<AsyncResult<WebClient>> handler); }
|
@Test public void testEventsOnPropertyChange() { ObservableList<ValueHolder> list = new ArrayListModel<ValueHolder>(); ValueHolder v1 = new ValueHolder("A"); list.add(v1); ValueHolder v2 = new ValueHolder("B"); list.add(v2); ListItemsUniqueModel<ValueHolder> unique = new ListItemsUniqueModel<ValueHolder>(list, ValueHolder.class, "value"); PropertyChangeListener listener = EasyMock.createStrictMock(PropertyChangeListener.class); listener.propertyChange(JUnitUtil.eqPropertyChangeEvent( new PropertyChangeEvent(unique, "value", true, false))); listener.propertyChange(JUnitUtil.eqPropertyChangeEvent( new PropertyChangeEvent(unique, "value", false, true))); EasyMock.replay(listener); unique.addPropertyChangeListener(listener); v1.setValue("B"); v1.setValue("Bar"); EasyMock.verify(listener); }
|
public void setValue(Object newValue) { throw new UnsupportedOperationException("ListItemsUniqueModel is read-only"); }
|
ListItemsUniqueModel extends AbstractValueModel { public void setValue(Object newValue) { throw new UnsupportedOperationException("ListItemsUniqueModel is read-only"); } }
|
ListItemsUniqueModel extends AbstractValueModel { public void setValue(Object newValue) { throw new UnsupportedOperationException("ListItemsUniqueModel is read-only"); } ListItemsUniqueModel(ObservableList<E> list, Class<E> beanClass, String propertyName); }
|
ListItemsUniqueModel extends AbstractValueModel { public void setValue(Object newValue) { throw new UnsupportedOperationException("ListItemsUniqueModel is read-only"); } ListItemsUniqueModel(ObservableList<E> list, Class<E> beanClass, String propertyName); Object getValue(); boolean calculate(); void setValue(Object newValue); }
|
ListItemsUniqueModel extends AbstractValueModel { public void setValue(Object newValue) { throw new UnsupportedOperationException("ListItemsUniqueModel is read-only"); } ListItemsUniqueModel(ObservableList<E> list, Class<E> beanClass, String propertyName); Object getValue(); boolean calculate(); void setValue(Object newValue); }
|
@Test public void testGetElementAtIndex() { assertEquals("A", CollectionUtil.getElementAtIndex(d_set, 0)); assertEquals("B", CollectionUtil.getElementAtIndex(d_set, 1)); }
|
public static <E> E getElementAtIndex(Collection<E> set, int idx) { if (idx >= set.size() || idx < 0) { throw new IndexOutOfBoundsException(); } Iterator<E> it = set.iterator(); for (int i = 0; i < idx; ++i) { it.next(); } return it.next(); }
|
CollectionUtil { public static <E> E getElementAtIndex(Collection<E> set, int idx) { if (idx >= set.size() || idx < 0) { throw new IndexOutOfBoundsException(); } Iterator<E> it = set.iterator(); for (int i = 0; i < idx; ++i) { it.next(); } return it.next(); } }
|
CollectionUtil { public static <E> E getElementAtIndex(Collection<E> set, int idx) { if (idx >= set.size() || idx < 0) { throw new IndexOutOfBoundsException(); } Iterator<E> it = set.iterator(); for (int i = 0; i < idx; ++i) { it.next(); } return it.next(); } }
|
CollectionUtil { public static <E> E getElementAtIndex(Collection<E> set, int idx) { if (idx >= set.size() || idx < 0) { throw new IndexOutOfBoundsException(); } Iterator<E> it = set.iterator(); for (int i = 0; i < idx; ++i) { it.next(); } return it.next(); } static E getElementAtIndex(Collection<E> set, int idx); static int getIndexOfElement(Collection<E> set, Object child); static boolean containsAllAndOnly(List<?> c1, List<?> c2); static boolean nextLexicographicElement(int x[], int c[]); }
|
CollectionUtil { public static <E> E getElementAtIndex(Collection<E> set, int idx) { if (idx >= set.size() || idx < 0) { throw new IndexOutOfBoundsException(); } Iterator<E> it = set.iterator(); for (int i = 0; i < idx; ++i) { it.next(); } return it.next(); } static E getElementAtIndex(Collection<E> set, int idx); static int getIndexOfElement(Collection<E> set, Object child); static boolean containsAllAndOnly(List<?> c1, List<?> c2); static boolean nextLexicographicElement(int x[], int c[]); }
|
@Test(expected=IndexOutOfBoundsException.class) public void testGetElementAtIndexTooHigh() { CollectionUtil.getElementAtIndex(d_set, 2); }
|
public static <E> E getElementAtIndex(Collection<E> set, int idx) { if (idx >= set.size() || idx < 0) { throw new IndexOutOfBoundsException(); } Iterator<E> it = set.iterator(); for (int i = 0; i < idx; ++i) { it.next(); } return it.next(); }
|
CollectionUtil { public static <E> E getElementAtIndex(Collection<E> set, int idx) { if (idx >= set.size() || idx < 0) { throw new IndexOutOfBoundsException(); } Iterator<E> it = set.iterator(); for (int i = 0; i < idx; ++i) { it.next(); } return it.next(); } }
|
CollectionUtil { public static <E> E getElementAtIndex(Collection<E> set, int idx) { if (idx >= set.size() || idx < 0) { throw new IndexOutOfBoundsException(); } Iterator<E> it = set.iterator(); for (int i = 0; i < idx; ++i) { it.next(); } return it.next(); } }
|
CollectionUtil { public static <E> E getElementAtIndex(Collection<E> set, int idx) { if (idx >= set.size() || idx < 0) { throw new IndexOutOfBoundsException(); } Iterator<E> it = set.iterator(); for (int i = 0; i < idx; ++i) { it.next(); } return it.next(); } static E getElementAtIndex(Collection<E> set, int idx); static int getIndexOfElement(Collection<E> set, Object child); static boolean containsAllAndOnly(List<?> c1, List<?> c2); static boolean nextLexicographicElement(int x[], int c[]); }
|
CollectionUtil { public static <E> E getElementAtIndex(Collection<E> set, int idx) { if (idx >= set.size() || idx < 0) { throw new IndexOutOfBoundsException(); } Iterator<E> it = set.iterator(); for (int i = 0; i < idx; ++i) { it.next(); } return it.next(); } static E getElementAtIndex(Collection<E> set, int idx); static int getIndexOfElement(Collection<E> set, Object child); static boolean containsAllAndOnly(List<?> c1, List<?> c2); static boolean nextLexicographicElement(int x[], int c[]); }
|
@Test(expected=IndexOutOfBoundsException.class) public void testGetElementAtIndexNegative() { CollectionUtil.getElementAtIndex(d_set, -1); }
|
public static <E> E getElementAtIndex(Collection<E> set, int idx) { if (idx >= set.size() || idx < 0) { throw new IndexOutOfBoundsException(); } Iterator<E> it = set.iterator(); for (int i = 0; i < idx; ++i) { it.next(); } return it.next(); }
|
CollectionUtil { public static <E> E getElementAtIndex(Collection<E> set, int idx) { if (idx >= set.size() || idx < 0) { throw new IndexOutOfBoundsException(); } Iterator<E> it = set.iterator(); for (int i = 0; i < idx; ++i) { it.next(); } return it.next(); } }
|
CollectionUtil { public static <E> E getElementAtIndex(Collection<E> set, int idx) { if (idx >= set.size() || idx < 0) { throw new IndexOutOfBoundsException(); } Iterator<E> it = set.iterator(); for (int i = 0; i < idx; ++i) { it.next(); } return it.next(); } }
|
CollectionUtil { public static <E> E getElementAtIndex(Collection<E> set, int idx) { if (idx >= set.size() || idx < 0) { throw new IndexOutOfBoundsException(); } Iterator<E> it = set.iterator(); for (int i = 0; i < idx; ++i) { it.next(); } return it.next(); } static E getElementAtIndex(Collection<E> set, int idx); static int getIndexOfElement(Collection<E> set, Object child); static boolean containsAllAndOnly(List<?> c1, List<?> c2); static boolean nextLexicographicElement(int x[], int c[]); }
|
CollectionUtil { public static <E> E getElementAtIndex(Collection<E> set, int idx) { if (idx >= set.size() || idx < 0) { throw new IndexOutOfBoundsException(); } Iterator<E> it = set.iterator(); for (int i = 0; i < idx; ++i) { it.next(); } return it.next(); } static E getElementAtIndex(Collection<E> set, int idx); static int getIndexOfElement(Collection<E> set, Object child); static boolean containsAllAndOnly(List<?> c1, List<?> c2); static boolean nextLexicographicElement(int x[], int c[]); }
|
@Test public void testGetIndexOfElement() { assertEquals(0, CollectionUtil.getIndexOfElement(d_set, "A")); assertEquals(1, CollectionUtil.getIndexOfElement(d_set, "B")); assertEquals(-1, CollectionUtil.getIndexOfElement(d_set, "C")); }
|
public static <E> int getIndexOfElement(Collection<E> set, Object child) { int i = 0; for (E e : set) { if (e.equals(child)) { return i; } ++i; } return -1; }
|
CollectionUtil { public static <E> int getIndexOfElement(Collection<E> set, Object child) { int i = 0; for (E e : set) { if (e.equals(child)) { return i; } ++i; } return -1; } }
|
CollectionUtil { public static <E> int getIndexOfElement(Collection<E> set, Object child) { int i = 0; for (E e : set) { if (e.equals(child)) { return i; } ++i; } return -1; } }
|
CollectionUtil { public static <E> int getIndexOfElement(Collection<E> set, Object child) { int i = 0; for (E e : set) { if (e.equals(child)) { return i; } ++i; } return -1; } static E getElementAtIndex(Collection<E> set, int idx); static int getIndexOfElement(Collection<E> set, Object child); static boolean containsAllAndOnly(List<?> c1, List<?> c2); static boolean nextLexicographicElement(int x[], int c[]); }
|
CollectionUtil { public static <E> int getIndexOfElement(Collection<E> set, Object child) { int i = 0; for (E e : set) { if (e.equals(child)) { return i; } ++i; } return -1; } static E getElementAtIndex(Collection<E> set, int idx); static int getIndexOfElement(Collection<E> set, Object child); static boolean containsAllAndOnly(List<?> c1, List<?> c2); static boolean nextLexicographicElement(int x[], int c[]); }
|
@Test public void testNextLexicographicElement() { int c[] = new int[] {1, 2, 3, 1}; int x[] = new int[] {0, 0, 0, 0}; assertTrue(CollectionUtil.nextLexicographicElement(x, c)); assertArrayEquals(new int[] {0, 0, 1, 0}, x); assertTrue(CollectionUtil.nextLexicographicElement(x, c)); assertArrayEquals(new int[] {0, 0, 2, 0}, x); assertTrue(CollectionUtil.nextLexicographicElement(x, c)); assertArrayEquals(new int[] {0, 1, 0, 0}, x); assertTrue(CollectionUtil.nextLexicographicElement(x, c)); assertArrayEquals(new int[] {0, 1, 1, 0}, x); assertTrue(CollectionUtil.nextLexicographicElement(x, c)); assertArrayEquals(new int[] {0, 1, 2, 0}, x); assertFalse(CollectionUtil.nextLexicographicElement(x, c)); assertArrayEquals(new int[] {0, 0, 0, 0}, x); assertFalse(CollectionUtil.nextLexicographicElement(new int[] { 0 }, new int[] { 1 })); assertTrue(CollectionUtil.nextLexicographicElement(new int[] { 0 }, new int[] { 2 })); }
|
public static boolean nextLexicographicElement(int x[], int c[]) { assert(x.length == c.length); final int l = x.length; if (l < 1) { return false; } for (int i = l - 1; i >= 0; --i) { ++x[i]; if (x[i] == c[i]) { x[i] = 0; } else { return true; } } return false; }
|
CollectionUtil { public static boolean nextLexicographicElement(int x[], int c[]) { assert(x.length == c.length); final int l = x.length; if (l < 1) { return false; } for (int i = l - 1; i >= 0; --i) { ++x[i]; if (x[i] == c[i]) { x[i] = 0; } else { return true; } } return false; } }
|
CollectionUtil { public static boolean nextLexicographicElement(int x[], int c[]) { assert(x.length == c.length); final int l = x.length; if (l < 1) { return false; } for (int i = l - 1; i >= 0; --i) { ++x[i]; if (x[i] == c[i]) { x[i] = 0; } else { return true; } } return false; } }
|
CollectionUtil { public static boolean nextLexicographicElement(int x[], int c[]) { assert(x.length == c.length); final int l = x.length; if (l < 1) { return false; } for (int i = l - 1; i >= 0; --i) { ++x[i]; if (x[i] == c[i]) { x[i] = 0; } else { return true; } } return false; } static E getElementAtIndex(Collection<E> set, int idx); static int getIndexOfElement(Collection<E> set, Object child); static boolean containsAllAndOnly(List<?> c1, List<?> c2); static boolean nextLexicographicElement(int x[], int c[]); }
|
CollectionUtil { public static boolean nextLexicographicElement(int x[], int c[]) { assert(x.length == c.length); final int l = x.length; if (l < 1) { return false; } for (int i = l - 1; i >= 0; --i) { ++x[i]; if (x[i] == c[i]) { x[i] = 0; } else { return true; } } return false; } static E getElementAtIndex(Collection<E> set, int idx); static int getIndexOfElement(Collection<E> set, Object child); static boolean containsAllAndOnly(List<?> c1, List<?> c2); static boolean nextLexicographicElement(int x[], int c[]); }
|
@Test(expected=IllegalArgumentException.class) public void testConstructionWithNonEmptyList() { ObservableList<Integer> list = new ArrayListModel<Integer>(); list.add(1); d_list = new GuardedObservableList<Integer>(list, new Predicate<Number>() { public boolean evaluate(Number object) { return object.doubleValue() > 0.0; } }); }
|
@Override public void add(int index, E element) { check(element); d_nested.add(index, element); }
|
GuardedObservableList extends AbstractObservableList<E> { @Override public void add(int index, E element) { check(element); d_nested.add(index, element); } }
|
GuardedObservableList extends AbstractObservableList<E> { @Override public void add(int index, E element) { check(element); d_nested.add(index, element); } GuardedObservableList(ObservableList<E> nested, Predicate<? super E> predicate); }
|
GuardedObservableList extends AbstractObservableList<E> { @Override public void add(int index, E element) { check(element); d_nested.add(index, element); } GuardedObservableList(ObservableList<E> nested, Predicate<? super E> predicate); @Override E get(int index); @Override int size(); @Override void add(int index, E element); @Override E set(int index, E element); @Override E remove(int index); }
|
GuardedObservableList extends AbstractObservableList<E> { @Override public void add(int index, E element) { check(element); d_nested.add(index, element); } GuardedObservableList(ObservableList<E> nested, Predicate<? super E> predicate); @Override E get(int index); @Override int size(); @Override void add(int index, E element); @Override E set(int index, E element); @Override E remove(int index); }
|
@Test(expected=IllegalArgumentException.class) public void testAddBadValue() { d_list.add(-1); }
|
@Override public void add(int index, E element) { check(element); d_nested.add(index, element); }
|
GuardedObservableList extends AbstractObservableList<E> { @Override public void add(int index, E element) { check(element); d_nested.add(index, element); } }
|
GuardedObservableList extends AbstractObservableList<E> { @Override public void add(int index, E element) { check(element); d_nested.add(index, element); } GuardedObservableList(ObservableList<E> nested, Predicate<? super E> predicate); }
|
GuardedObservableList extends AbstractObservableList<E> { @Override public void add(int index, E element) { check(element); d_nested.add(index, element); } GuardedObservableList(ObservableList<E> nested, Predicate<? super E> predicate); @Override E get(int index); @Override int size(); @Override void add(int index, E element); @Override E set(int index, E element); @Override E remove(int index); }
|
GuardedObservableList extends AbstractObservableList<E> { @Override public void add(int index, E element) { check(element); d_nested.add(index, element); } GuardedObservableList(ObservableList<E> nested, Predicate<? super E> predicate); @Override E get(int index); @Override int size(); @Override void add(int index, E element); @Override E set(int index, E element); @Override E remove(int index); }
|
@Test(expected=IllegalArgumentException.class) public void testSetBadValue() { d_list.set(1, -1); }
|
@Override public E set(int index, E element) { check(element); return d_nested.set(index, element); }
|
GuardedObservableList extends AbstractObservableList<E> { @Override public E set(int index, E element) { check(element); return d_nested.set(index, element); } }
|
GuardedObservableList extends AbstractObservableList<E> { @Override public E set(int index, E element) { check(element); return d_nested.set(index, element); } GuardedObservableList(ObservableList<E> nested, Predicate<? super E> predicate); }
|
GuardedObservableList extends AbstractObservableList<E> { @Override public E set(int index, E element) { check(element); return d_nested.set(index, element); } GuardedObservableList(ObservableList<E> nested, Predicate<? super E> predicate); @Override E get(int index); @Override int size(); @Override void add(int index, E element); @Override E set(int index, E element); @Override E remove(int index); }
|
GuardedObservableList extends AbstractObservableList<E> { @Override public E set(int index, E element) { check(element); return d_nested.set(index, element); } GuardedObservableList(ObservableList<E> nested, Predicate<? super E> predicate); @Override E get(int index); @Override int size(); @Override void add(int index, E element); @Override E set(int index, E element); @Override E remove(int index); }
|
@Test public void testContentsUpdateAddNone() { ListDataListener mock = createStrictMock(ListDataListener.class); replay(mock); d_outer.addListDataListener(mock); d_inner.add(2, "Haank"); assertEquals(Arrays.asList("Gert", "Jan"), d_outer); verify(mock); }
|
@Override public void add(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter of " + this); if(index < d_indices.size()) { d_inner.add(d_indices.get(index), element); } else { d_inner.add(d_inner.size(), element); } }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public void add(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter of " + this); if(index < d_indices.size()) { d_inner.add(d_indices.get(index), element); } else { d_inner.add(d_inner.size(), element); } } }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public void add(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter of " + this); if(index < d_indices.size()) { d_inner.add(d_indices.get(index), element); } else { d_inner.add(d_inner.size(), element); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public void add(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter of " + this); if(index < d_indices.size()) { d_inner.add(d_indices.get(index), element); } else { d_inner.add(d_inner.size(), element); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public void add(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter of " + this); if(index < d_indices.size()) { d_inner.add(d_indices.get(index), element); } else { d_inner.add(d_inner.size(), element); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
@Test public void testContentsUpdateAddAllIndex() { ListDataListener mock = createStrictMock(ListDataListener.class); mock.intervalAdded(ListDataEventMatcher.eqListDataEvent(new ListDataEvent(d_outer, ListDataEvent.INTERVAL_ADDED, 1, 2))); replay(mock); d_outer.addListDataListener(mock); d_inner.addAll(2, Arrays.asList("Henk", "Bart")); assertEquals(Arrays.asList("Gert", "Henk", "Bart", "Jan"), d_outer); verify(mock); }
|
private void intervalAdded(final int lower, final int upper) { final int delta = upper - lower + 1; final int first = firstAtLeast(lower); updateIndices(first, delta); final int oldSize = d_indices.size(); for(int i = upper; i >= lower; --i) { if (d_filter.evaluate(d_inner.get(i))) { d_indices.add(first, i); } } final int inserted = d_indices.size() - oldSize; if (inserted > 0) { fireIntervalAdded(first, first + inserted - 1); } }
|
FilteredObservableList extends AbstractObservableList<E> { private void intervalAdded(final int lower, final int upper) { final int delta = upper - lower + 1; final int first = firstAtLeast(lower); updateIndices(first, delta); final int oldSize = d_indices.size(); for(int i = upper; i >= lower; --i) { if (d_filter.evaluate(d_inner.get(i))) { d_indices.add(first, i); } } final int inserted = d_indices.size() - oldSize; if (inserted > 0) { fireIntervalAdded(first, first + inserted - 1); } } }
|
FilteredObservableList extends AbstractObservableList<E> { private void intervalAdded(final int lower, final int upper) { final int delta = upper - lower + 1; final int first = firstAtLeast(lower); updateIndices(first, delta); final int oldSize = d_indices.size(); for(int i = upper; i >= lower; --i) { if (d_filter.evaluate(d_inner.get(i))) { d_indices.add(first, i); } } final int inserted = d_indices.size() - oldSize; if (inserted > 0) { fireIntervalAdded(first, first + inserted - 1); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); }
|
FilteredObservableList extends AbstractObservableList<E> { private void intervalAdded(final int lower, final int upper) { final int delta = upper - lower + 1; final int first = firstAtLeast(lower); updateIndices(first, delta); final int oldSize = d_indices.size(); for(int i = upper; i >= lower; --i) { if (d_filter.evaluate(d_inner.get(i))) { d_indices.add(first, i); } } final int inserted = d_indices.size() - oldSize; if (inserted > 0) { fireIntervalAdded(first, first + inserted - 1); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
FilteredObservableList extends AbstractObservableList<E> { private void intervalAdded(final int lower, final int upper) { final int delta = upper - lower + 1; final int first = firstAtLeast(lower); updateIndices(first, delta); final int oldSize = d_indices.size(); for(int i = upper; i >= lower; --i) { if (d_filter.evaluate(d_inner.get(i))) { d_indices.add(first, i); } } final int inserted = d_indices.size() - oldSize; if (inserted > 0) { fireIntervalAdded(first, first + inserted - 1); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
@Test public void testInitialValues() { assertFalse(new ListMinimumSizeModel(new ArrayListModel<String>(), 1).getValue()); assertTrue(new ListMinimumSizeModel(new ArrayListModel<String>(Arrays.asList("Test")), 1).getValue()); assertFalse(new ListMinimumSizeModel(new ArrayListModel<String>(Arrays.asList("Test")), 2).getValue()); assertTrue(new ListMinimumSizeModel(new ArrayListModel<String>(Arrays.asList("Test", "Test")), 2).getValue()); }
|
public Boolean getValue() { return d_val; }
|
ListMinimumSizeModel extends AbstractValueModel { public Boolean getValue() { return d_val; } }
|
ListMinimumSizeModel extends AbstractValueModel { public Boolean getValue() { return d_val; } ListMinimumSizeModel(ListModel list, int minSize); }
|
ListMinimumSizeModel extends AbstractValueModel { public Boolean getValue() { return d_val; } ListMinimumSizeModel(ListModel list, int minSize); Boolean getValue(); void setValue(Object value); }
|
ListMinimumSizeModel extends AbstractValueModel { public Boolean getValue() { return d_val; } ListMinimumSizeModel(ListModel list, int minSize); Boolean getValue(); void setValue(Object value); }
|
@Test public void testContentsUpdateAddAllEnd() { ListDataListener mock = createStrictMock(ListDataListener.class); mock.intervalAdded(ListDataEventMatcher.eqListDataEvent(new ListDataEvent(d_outer, ListDataEvent.INTERVAL_ADDED, 2, 3))); replay(mock); d_outer.addListDataListener(mock); d_inner.addAll(Arrays.asList("Henk", "Bart")); assertEquals(Arrays.asList("Gert", "Jan", "Henk", "Bart"), d_outer); verify(mock); }
|
private void intervalAdded(final int lower, final int upper) { final int delta = upper - lower + 1; final int first = firstAtLeast(lower); updateIndices(first, delta); final int oldSize = d_indices.size(); for(int i = upper; i >= lower; --i) { if (d_filter.evaluate(d_inner.get(i))) { d_indices.add(first, i); } } final int inserted = d_indices.size() - oldSize; if (inserted > 0) { fireIntervalAdded(first, first + inserted - 1); } }
|
FilteredObservableList extends AbstractObservableList<E> { private void intervalAdded(final int lower, final int upper) { final int delta = upper - lower + 1; final int first = firstAtLeast(lower); updateIndices(first, delta); final int oldSize = d_indices.size(); for(int i = upper; i >= lower; --i) { if (d_filter.evaluate(d_inner.get(i))) { d_indices.add(first, i); } } final int inserted = d_indices.size() - oldSize; if (inserted > 0) { fireIntervalAdded(first, first + inserted - 1); } } }
|
FilteredObservableList extends AbstractObservableList<E> { private void intervalAdded(final int lower, final int upper) { final int delta = upper - lower + 1; final int first = firstAtLeast(lower); updateIndices(first, delta); final int oldSize = d_indices.size(); for(int i = upper; i >= lower; --i) { if (d_filter.evaluate(d_inner.get(i))) { d_indices.add(first, i); } } final int inserted = d_indices.size() - oldSize; if (inserted > 0) { fireIntervalAdded(first, first + inserted - 1); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); }
|
FilteredObservableList extends AbstractObservableList<E> { private void intervalAdded(final int lower, final int upper) { final int delta = upper - lower + 1; final int first = firstAtLeast(lower); updateIndices(first, delta); final int oldSize = d_indices.size(); for(int i = upper; i >= lower; --i) { if (d_filter.evaluate(d_inner.get(i))) { d_indices.add(first, i); } } final int inserted = d_indices.size() - oldSize; if (inserted > 0) { fireIntervalAdded(first, first + inserted - 1); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
FilteredObservableList extends AbstractObservableList<E> { private void intervalAdded(final int lower, final int upper) { final int delta = upper - lower + 1; final int first = firstAtLeast(lower); updateIndices(first, delta); final int oldSize = d_indices.size(); for(int i = upper; i >= lower; --i) { if (d_filter.evaluate(d_inner.get(i))) { d_indices.add(first, i); } } final int inserted = d_indices.size() - oldSize; if (inserted > 0) { fireIntervalAdded(first, first + inserted - 1); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
@Test public void testContentsUpdateRemoveNone() { ListDataListener mock = createStrictMock(ListDataListener.class); replay(mock); d_outer.addListDataListener(mock); d_inner.remove("Daan"); assertEquals(Arrays.asList("Gert", "Jan"), d_outer); verify(mock); }
|
@Override public E remove(final int index) { return d_inner.remove((int) d_indices.get(index)); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E remove(final int index) { return d_inner.remove((int) d_indices.get(index)); } }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E remove(final int index) { return d_inner.remove((int) d_indices.get(index)); } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E remove(final int index) { return d_inner.remove((int) d_indices.get(index)); } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E remove(final int index) { return d_inner.remove((int) d_indices.get(index)); } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
@Test public void testContentsUpdateRemoveAll() { ListDataListener mock = createStrictMock(ListDataListener.class); mock.intervalRemoved(ListDataEventMatcher.eqListDataEvent(new ListDataEvent(d_outer, ListDataEvent.INTERVAL_REMOVED, 0, 1))); replay(mock); d_outer.addListDataListener(mock); d_inner.clear(); assertEquals(Collections.emptyList(), d_outer); verify(mock); }
|
private void intervalRemoved(final int lower, final int upper) { final int first = firstAtLeast(lower); if (first >= d_indices.size()) { return; } final int last = firstOver(upper); d_indices.removeAll(new ArrayList<Integer>(d_indices.subList(first, last))); final int delta = upper - lower + 1; updateIndices(first, -delta); if (last > first) { fireIntervalRemoved(first, last - 1); } }
|
FilteredObservableList extends AbstractObservableList<E> { private void intervalRemoved(final int lower, final int upper) { final int first = firstAtLeast(lower); if (first >= d_indices.size()) { return; } final int last = firstOver(upper); d_indices.removeAll(new ArrayList<Integer>(d_indices.subList(first, last))); final int delta = upper - lower + 1; updateIndices(first, -delta); if (last > first) { fireIntervalRemoved(first, last - 1); } } }
|
FilteredObservableList extends AbstractObservableList<E> { private void intervalRemoved(final int lower, final int upper) { final int first = firstAtLeast(lower); if (first >= d_indices.size()) { return; } final int last = firstOver(upper); d_indices.removeAll(new ArrayList<Integer>(d_indices.subList(first, last))); final int delta = upper - lower + 1; updateIndices(first, -delta); if (last > first) { fireIntervalRemoved(first, last - 1); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); }
|
FilteredObservableList extends AbstractObservableList<E> { private void intervalRemoved(final int lower, final int upper) { final int first = firstAtLeast(lower); if (first >= d_indices.size()) { return; } final int last = firstOver(upper); d_indices.removeAll(new ArrayList<Integer>(d_indices.subList(first, last))); final int delta = upper - lower + 1; updateIndices(first, -delta); if (last > first) { fireIntervalRemoved(first, last - 1); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
FilteredObservableList extends AbstractObservableList<E> { private void intervalRemoved(final int lower, final int upper) { final int first = firstAtLeast(lower); if (first >= d_indices.size()) { return; } final int last = firstOver(upper); d_indices.removeAll(new ArrayList<Integer>(d_indices.subList(first, last))); final int delta = upper - lower + 1; updateIndices(first, -delta); if (last > first) { fireIntervalRemoved(first, last - 1); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
@Test public void testContentsUpdateFirstElement() { d_inner.set(0, "Gaart"); assertEquals(Arrays.asList("Jan"), d_outer); d_inner.set(0, "Gert"); assertEquals(Arrays.asList("Gert", "Jan"), d_outer); }
|
@Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); } }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
@Test public void testContentsUpdateLastElement() { d_inner.set(3, "Klees"); assertEquals(Arrays.asList("Gert", "Jan", "Klees"), d_outer); }
|
@Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); } }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
@Test public void testContentsUpdateSetNoChangeExcl() { ListDataListener mock = createStrictMock(ListDataListener.class); replay(mock); d_outer.addListDataListener(mock); d_inner.set(3, "Paard"); assertEquals(Arrays.asList("Gert", "Jan"), d_outer); verify(mock); }
|
@Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); } }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
@Test public void testSetFilter() { ListDataListener mock = createStrictMock(ListDataListener.class); mock.intervalRemoved(ListDataEventMatcher.eqListDataEvent(new ListDataEvent(d_outer, ListDataEvent.INTERVAL_REMOVED, 0, 1))); mock.intervalAdded(ListDataEventMatcher.eqListDataEvent(new ListDataEvent(d_outer, ListDataEvent.INTERVAL_ADDED, 0, 2))); replay(mock); d_outer.addListDataListener(mock); d_outer.setFilter(new Predicate<String>() { public boolean evaluate(String str) { return !str.equals("Gert"); } }); assertEquals(Arrays.asList("Daan", "Jan", "Klaas"), d_outer); verify(mock); }
|
public void setFilter(final Predicate<E> filter) { d_filter = filter; final int oldSize = size(); if(!isEmpty()) { d_indices.clear(); fireIntervalRemoved(0, oldSize - 1); } initializeIndices(); if(!isEmpty()) { fireIntervalAdded(0, size() - 1); } }
|
FilteredObservableList extends AbstractObservableList<E> { public void setFilter(final Predicate<E> filter) { d_filter = filter; final int oldSize = size(); if(!isEmpty()) { d_indices.clear(); fireIntervalRemoved(0, oldSize - 1); } initializeIndices(); if(!isEmpty()) { fireIntervalAdded(0, size() - 1); } } }
|
FilteredObservableList extends AbstractObservableList<E> { public void setFilter(final Predicate<E> filter) { d_filter = filter; final int oldSize = size(); if(!isEmpty()) { d_indices.clear(); fireIntervalRemoved(0, oldSize - 1); } initializeIndices(); if(!isEmpty()) { fireIntervalAdded(0, size() - 1); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); }
|
FilteredObservableList extends AbstractObservableList<E> { public void setFilter(final Predicate<E> filter) { d_filter = filter; final int oldSize = size(); if(!isEmpty()) { d_indices.clear(); fireIntervalRemoved(0, oldSize - 1); } initializeIndices(); if(!isEmpty()) { fireIntervalAdded(0, size() - 1); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
FilteredObservableList extends AbstractObservableList<E> { public void setFilter(final Predicate<E> filter) { d_filter = filter; final int oldSize = size(); if(!isEmpty()) { d_indices.clear(); fireIntervalRemoved(0, oldSize - 1); } initializeIndices(); if(!isEmpty()) { fireIntervalAdded(0, size() - 1); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
@Test public void testSublistUpdating() { ObservableList<String> list = new SortedSetModel<String>(Arrays.asList("Aa", "Ab", "Ba", "Bb")); ObservableList<String> aList = new FilteredObservableList<String>(list, new Predicate<String>(){ public boolean evaluate(String obj) { return obj.charAt(0) == 'A'; }}); ObservableList<String> bList = new FilteredObservableList<String>(list, new Predicate<String>(){ public boolean evaluate(String obj) { return obj.charAt(0) == 'B'; }}); assertEquals(Arrays.asList("Aa", "Ab"), aList); assertEquals(Arrays.asList("Ba", "Bb"), bList); list.add("Ac"); assertEquals(Arrays.asList("Aa", "Ab", "Ac"), aList); assertEquals(Arrays.asList("Ba", "Bb"), bList); }
|
@Override public void add(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter of " + this); if(index < d_indices.size()) { d_inner.add(d_indices.get(index), element); } else { d_inner.add(d_inner.size(), element); } }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public void add(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter of " + this); if(index < d_indices.size()) { d_inner.add(d_indices.get(index), element); } else { d_inner.add(d_inner.size(), element); } } }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public void add(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter of " + this); if(index < d_indices.size()) { d_inner.add(d_indices.get(index), element); } else { d_inner.add(d_inner.size(), element); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public void add(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter of " + this); if(index < d_indices.size()) { d_inner.add(d_indices.get(index), element); } else { d_inner.add(d_inner.size(), element); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public void add(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter of " + this); if(index < d_indices.size()) { d_inner.add(d_indices.get(index), element); } else { d_inner.add(d_inner.size(), element); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
@Test(expected=IllegalArgumentException.class) public void testAddNonAcceptable() { d_outer.add("Maarten"); }
|
@Override public void add(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter of " + this); if(index < d_indices.size()) { d_inner.add(d_indices.get(index), element); } else { d_inner.add(d_inner.size(), element); } }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public void add(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter of " + this); if(index < d_indices.size()) { d_inner.add(d_indices.get(index), element); } else { d_inner.add(d_inner.size(), element); } } }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public void add(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter of " + this); if(index < d_indices.size()) { d_inner.add(d_indices.get(index), element); } else { d_inner.add(d_inner.size(), element); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public void add(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter of " + this); if(index < d_indices.size()) { d_inner.add(d_indices.get(index), element); } else { d_inner.add(d_inner.size(), element); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public void add(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter of " + this); if(index < d_indices.size()) { d_inner.add(d_indices.get(index), element); } else { d_inner.add(d_inner.size(), element); } } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
@Test(expected=IllegalArgumentException.class) public void testSetNonAcceptable() { d_outer.set(1, "Maarten"); }
|
@Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); } }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
FilteredObservableList extends AbstractObservableList<E> { @Override public E set(final int index, final E element) { if(!d_filter.evaluate(element)) throw new IllegalArgumentException("Cannot add " + element + ", it does not pass the filter."); return d_inner.set(d_indices.get(index), element); } FilteredObservableList(final ObservableList<E> inner, final Predicate<E> filter); void setFilter(final Predicate<E> filter); @Override E get(final int index); @Override void add(final int index, final E element); @Override E set(final int index, final E element); @Override E remove(final int index); @Override int size(); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.