Public

Standard Constructor (with a BinaryEntry).

<init>

getBinaryValue

getContext

getBinaryKey

getExpiry

getKey

getOriginalBinaryValue

getOriginalValue

getSerializer

getValue

Sets the BackingMapManagerContext for the Entry.

setContext

setOriginalBinaryValue

setValue

StringBuilder

Parsing JSON documents to java classes using gson

An "abstract" representation of a file system entity identified by a pathname.
The pathname may be a

java.io.File

Signals a general, I/O-related error. Error details may be specified when
calling the constructor, a

java.io.IOException

An Executor that provides methods to manage termination and methods that can
produce a Future for tr

java.util.concurrent.ExecutorService

javax.imageio.ImageIO

org.hibernate.mapping.Table

The LoggerFactory is a utility class producing Loggers for various logging APIs,
most notably for lo

org.slf4j.LoggerFactory

requestLocationUpdates

getApplicationContext

putExtra

/**
     * The eraseAll method will distribute a collection of erased entries using the {@link EventDistributor}.
     *
     * @param setEntries The entries that were erased
     */

/**
     * The storeAll method distributes a batch of events with the {@link EventDistributor}.
     * The method ensures that each entry wasn't marked for delete (delete events are not distributed here,
     * they're distributed on erase). It will then decorate the BinaryEntry with the {@link ClusterMetaInfo} and
     * request that the {@link EventDistributor} distributed the operation.
     *
     * @param colEntries the collection of Entries that were stored
     */

"Expecting instanceof BackingMapBinaryEntry"

// ensure the BinaryValue we're sending contains the expiry

/**
     * Rebuilds an {@link EventChannel} by sending it a copy of the underlying {@link NamedCache} as a set of
     * insert {@link Event}s.
     */

"Commencing propagation of entries using the EventChannelController {0}"

// enable the EventChannelController (if we were disabled)

// attempt to start the channel (as we need it for propagation)

// determine the service and context in which to operate together with the required converters

// determine the local cluster meta info for decorating entries being sent

// create a standard set of decorations for entries being set

// determine the maximum number of entries to put in a batch for propagation

// determine the number of partitions (we'll be doing this on a partition-by-partition basis)

"Approximately {0} entries to propagate contained with in {1} partitions (using a batch size of {2})"

// define a suitable partition set for the partition we require

"Propagating {0} entries contained in partition {1}"

// send the entries in the partition (batched)

// determine the entry to add to the batch

// create suitable binary representations of the entry key and value

// decorate the binary value with the source cluster

// create a event representing the Entry that is to be propagated

// wait the inter-batch delay (if there is one)

// empty the batch of events for the next batch

// is there anything in the batch we haven't sent yet?

"Interrupted while propagating entries with the EventChannelController {0}. Reverting to the {1} state."

"Failed to start propagating entries with the EventChannelController {0} due to {1}. Reverting to the {2} state."

"Failed to propagate entries with the EventChannelController {0} due to {1}. Reverting to the {2} state."

// disable the EventChannelController internals

"Completed propagation of entries using the EventChannelController {0}"

/**
     * The store method requests than an entry be distributed using the configured
     * {@link com.oracle.coherence.patterns.eventdistribution.EventDistributorBuilder}. The method checks to see that the entry wasn't
     * marked for removal (removes are not distributed here, they're distributed on erase). It will then
     * decorates the BinaryEntry with the affilitate associated and requests that
     * the {@link com.oracle.coherence.patterns.eventdistribution.EventDistributorBuilder} distribute the event.
     *
     * @param entry The BinaryEntry that was stored
     */

/**
     * The erase method distributes an {@link EntryRemovedEvent} with the {@link EventDistributor}.
     *
     * @param entry The entry that was erased
     */

// If the entry was marked for erase we are erasing the original value.

// If an entry is not marked for erase it is originating locally.

// We decorate the entry with the local cluster global name regardless

// of whether the entry was decorated earlier.  This allows

// this cluster to take ownership of the entry and permits it to

// Without forcing this decoration an erase operation will retain

// an old cluster name and not get propagated to that cluster.

How to use com.oracle.coherence.patterns.eventdistribution.events.DistributableEntryconstructor

Best Java code snippets using com.oracle.coherence.patterns.eventdistribution.events.DistributableEntry.<init> (Showing top 5 results out of 315)

How to use
com.oracle.coherence.patterns.eventdistribution.events.DistributableEntry
constructor