Package com.tangosol.util

Class ConverterCollections.ConverterMapEvent.ConverterMapEventBinaryEntry

    • Constructor Detail

      • ConverterMapEventBinaryEntry

        public ConverterMapEventBinaryEntry​(boolean fNewValue)
        Constructor.
        Parameters:
        fNewValue - specifies whether the value represented by this entry is the new or the old value

    • Method Detail

      • isSynthetic

        public boolean isSynthetic()
        Determine if this Entry has been synthetically mutated. This method returns false if either a non-synthetic update was made or the entry has not been modified.
        Specified by:
        isSynthetic in interface InvocableMap.Entry<K,​V>
        Returns:
        true if the Entry has been synthetically mutated

      • remove

        public void remove​(boolean fSynthetic)
        Remove this Entry from the Map if it is present in the Map.

        This method supports both the operation corresponding to Map.remove(java.lang.Object) as well as synthetic operations such as eviction. If the containing Map does not differentiate between the two, then this method will always be identical to InvocableMap.this.remove(getKey()).

        As of Coherence 12.1.2, if fSynthetic is true and the BackingMap associated with this entry is a ReadWriteBackingMap, this method will bypass the CacheStore or BinaryEntryStore.

        Specified by:
        remove in interface BinaryEntry<K,​V>
        Specified by:
        remove in interface InvocableMap.Entry<K,​V>
        Parameters:
        fSynthetic - pass true only if the removal from the Map should be treated as a synthetic event

      • setValue

        public void setValue​(V value,
                     boolean fSynthetic)
        Store the value corresponding to this entry. If the entry does not exist, then the entry will be created by invoking this method, even with a null value (assuming the Map supports null values).

        Unlike the other form of setValue, this form does not return the previous value, and as a result may be significantly less expensive (in terms of cost of execution) for certain Map implementations.

        As of Coherence 12.1.2, if fSynthetic is true and the BackingMap associated with this entry is a ReadWriteBackingMap, this method will bypass the CacheStore or BinaryEntryStore.

        Specified by:
        setValue in interface BinaryEntry<K,​V>
        Specified by:
        setValue in interface InvocableMap.Entry<K,​V>
        Parameters:
        value - the new value for this Entry
        fSynthetic - pass true only if the insertion into or modification of the Map should be treated as a synthetic event

      • update

        public <T> void update​(ValueUpdater<V,​T> updater,
                       T value)
        Update the Entry's value. Calling this method is semantically equivalent to: 
           V target = entry.getValue();
   updater.update(target, value);
   entry.setValue(target, false);
        The benefit of using this method is that it may allow the Entry implementation to significantly optimize the operation, such as for purposes of delta updates and backup maintenance.
        Specified by:
        update in interface InvocableMap.Entry<K,​V>
        Type Parameters:
        T - the class of the value
        Parameters:
        updater - a ValueUpdater used to modify the Entry's value
        value - the new value for this Entry

      • extract

        public <T,​E> E extract​(ValueExtractor<T,​E> extractor)
        Depending upon the type of the ValueExtractor route the call to the appropriate extract method.
        Specified by:
        extract in interface QueryMap.Entry<K,​V>
        Type Parameters:
        T - the type of the value to extract from
        E - the type of value that will be extracted
        Parameters:
        extractor - the ValueExtractor to pass this Entry or value.
        Returns:
        the extracted value.

      • updateBinaryValue

        public void updateBinaryValue​(Binary binValue)
        Update the binary value for this entry.

        Passing a non-null binary is functionally equivalent to: 

           setValue(getContext().getValueFromInternalConverter().convert(binValue));
        Passing null value is functionally equivalent to removing the entry. 
           remove(false);

        Specified by:
        updateBinaryValue in interface BinaryEntry<K,​V>
        Parameters:
        binValue - new binary value to be stored in this entry or null

      • updateBinaryValue

        public void updateBinaryValue​(Binary binValue,
                              boolean fSynthetic)
        Update the binary value for this entry.

        Passing a non-null binary is functionally equivalent to: 

           setValue(getContext().getValueFromInternalConverter().convert(binValue));
        Passing null value is functionally equivalent to removing the entry. 
           remove(false);
        This method will bypass any CacheStore or BinaryEntryStore implementations, iff fSynthetic is true and the backing map associated with this entry is a ReadWriteBackingMap.

        Specified by:
        updateBinaryValue in interface BinaryEntry<K,​V>
        Parameters:
        binValue - new binary value to be stored in this entry or null
        fSynthetic - pass true only if the insertion into or modification of the Map should be treated as a synthetic event

      • getOriginalValue

        public V getOriginalValue()
        Return an original value for this entry.
        Specified by:
        getOriginalValue in interface BinaryEntry<K,​V>
        Returns:
        an original value for this entry

      • getOriginalBinaryValue

        public Binary getOriginalBinaryValue()
        Return a raw original binary value for this entry.
        Specified by:
        getOriginalBinaryValue in interface BinaryEntry<K,​V>
        Returns:
        a raw original binary value for this entry; null if the original value did not exist

      • getBackingMap

        public ObservableMap<K,​V> getBackingMap()
        Obtain a reference to the backing map that this Entry corresponds to. The returned Map should be used in a read-only manner.

        Note: This method is a shortcut for the getBackingMapContext().getBackingMap() call. As of Coherence 3.7, the returned type has been narrowed to ObservableMap.

        Specified by:
        getBackingMap in interface BinaryEntry<K,​V>
        Returns:
        the backing map reference; null if the entry does not have any backing map association

      • expire

        public void expire​(long cMillis)
        Update the entry with the specified expiry delay.

        Note: this method only has an effect only if the associated backing map implements the CacheMap interface

        Specified by:
        expire in interface BinaryEntry<K,​V>
        Parameters:
        cMillis - the number of milliseconds until the entry will expire; pass CacheMap.EXPIRY_DEFAULT to use the default expiry setting; pass CacheMap.EXPIRY_NEVER to indicate that the entry should never expire

      • getExpiry

        public long getExpiry()
        Return the number of milliseconds remaining before the specified entry is scheduled to expire. If the BinaryEntry.expire(long) method has been called, the returned value will reflect the requested expiry delay. Otherwise if the entry exists, the returned value will represent the time remaining until the entry expires (or CacheMap.EXPIRY_NEVER if the entry will never expire). If the entry does not exist, CacheMap.EXPIRY_DEFAULT will be returned.

        This method will make a "best effort" attempt to determine the expiry time remaining. In some cases, it may not be possible to determine the expiry (e.g. the backing-map does not implement the CacheMap interface), in which case CacheMap.EXPIRY_DEFAULT will be returned.

        Specified by:
        getExpiry in interface BinaryEntry<K,​V>
        Returns:
        the number of milliseconds remaining before the specified entry expires

      • isReadOnly

        public boolean isReadOnly()
        Check whether this BinaryEntry allows data modification operations.
        Specified by:
        isReadOnly in interface BinaryEntry<K,​V>
        Returns:
        true iff the entry is "read-only"