com.tangosol.util.NullImplementation Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of coherence Show documentation
Show all versions of coherence Show documentation
Oracle Coherence Community Edition
/*
* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
*
* Licensed under the Universal Permissive License v 1.0 as shown at
* https://oss.oracle.com/licenses/upl.
*/
package com.tangosol.util;
import com.oracle.coherence.common.base.Collector;
import com.oracle.coherence.common.base.Continuation;
import com.oracle.coherence.persistence.AsyncPersistenceException;
import com.oracle.coherence.persistence.OfflinePersistenceInfo;
import com.oracle.coherence.persistence.PersistenceEnvironment;
import com.oracle.coherence.persistence.PersistenceManager;
import com.oracle.coherence.persistence.PersistenceStatistics;
import com.oracle.coherence.persistence.PersistenceTools;
import com.oracle.coherence.persistence.PersistentStore;
import com.tangosol.io.DeltaCompressor;
import com.tangosol.io.ExternalizableLite;
import com.tangosol.io.OutputStreaming;
import com.tangosol.io.ReadBuffer;
import com.tangosol.io.WriteBuffer;
import com.tangosol.io.pof.PofContext;
import com.tangosol.io.pof.PofHandler;
import com.tangosol.io.pof.PofReader;
import com.tangosol.io.pof.PofSerializer;
import com.tangosol.io.pof.PofWriter;
import com.tangosol.io.pof.PortableObject;
import com.tangosol.io.pof.RawQuad;
import com.tangosol.net.Action;
import com.tangosol.net.ActionPolicy;
import com.tangosol.net.AddressProvider;
import com.tangosol.net.BackingMapContext;
import com.tangosol.net.BackingMapManagerContext;
import com.tangosol.net.BackingMapManager;
import com.tangosol.net.CacheService;
import com.tangosol.net.Member;
import com.tangosol.net.MemberIdentityProvider;
import com.tangosol.net.cache.CacheStore;
import com.tangosol.net.partition.DistributionManager;
import com.tangosol.net.partition.PartitionAssignmentStrategy;
import com.tangosol.net.partition.PartitionSet;
import com.tangosol.run.xml.XmlElement;
import com.tangosol.util.processor.AbstractProcessor;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Serializable;
import java.io.Writer;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.InetSocketAddress;
import java.nio.CharBuffer;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
/**
* A collection of classes that do nothing. For each class implemented, a
* factory method will exist following the naming convention "get" plus the
* class or interface name.
*
* @author cp 2000.08.02
*/
public class NullImplementation
extends ClassLoader
{
/**
* Default constructor.
*/
private NullImplementation()
{
super(NullImplementation.class.getClassLoader());
}
// ----- factory methods --------------------------------------------
/**
* Returns an instance of the null enumerator.
*
* @return an Enumeration instance with no values to enumerate.
*/
public static Enumeration getEnumeration()
{
return NullEnumerator.INSTANCE;
}
/**
* Returns an instance of the null iterator.
*
* @return an Iterator instance with no values to enumerate.
*/
public static Iterator getIterator()
{
return NullEnumerator.INSTANCE;
}
/**
* Returns an instance of the null iterable.
*
* @return an Iterable that will return a {@link #getIterator()
* null iterator}
*/
public static Iterable getIterable()
{
return NullEnumerator.INSTANCE;
}
/**
* Returns an instance of the NullSet.
*
* @return an empty immutable Set
*/
public static Set getSet()
{
return NullSet.INSTANCE;
}
/**
* Returns an instance of the NullMap.
*
* @return an empty Map that does nothing
*/
public static Map getMap()
{
return NullMap.INSTANCE;
}
/**
* Returns an instance of the NullObservableMap.
*
* @return an empty ObservableMap and does nothing
*/
public static ObservableMap getObservableMap()
{
return NullObservableMap.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of a Reader.
*
* @return a conforming implementation of Reader that does as little as
* possible
*/
public static Reader getReader()
{
return new NullReader();
}
/**
* Factory method: Obtain a null implementation of a Writer.
*
* @return a conforming implementation of Writer that does as little as
* possible
*/
public static Writer getWriter()
{
return new NullWriter();
}
/**
* Factory method: Obtain a null implementation of a OutputStream.
*
* @return a conforming implementation of OutputStream that does as little
* as possible
*/
public static OutputStream getOutputStream()
{
return new NullOutputStream();
}
/**
* Factory method: Obtain a null implementation of a DataOutput.
*
* @return a conforming implementation of DataOutput that does as little
* as possible
*/
public static DataOutput getDataOutput()
{
return new NullOutputStream();
}
/**
* Factory method: Obtain a null implementation of a Converter.
*
* @return a conforming implementation of Converter that does as little
* as possible
*/
public static Converter getConverter()
{
return NullConverter.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of a ValueExtractor.
*
* @return a ValueExtractor that does not actually extract anything from
* the passed value
*/
public static ValueExtractor getValueExtractor()
{
return NullValueExtractor.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of a ClassLoader.
*
* @return a conforming implementation of ClassLoader that does as little
* as possible
*/
public static ClassLoader getClassLoader()
{
return LOADER;
}
/**
* Factory method: Obtain a null implementation of a PofContext.
*
* @return a conforming implementation of PofContext that does as little
* as possible
*/
public static PofContext getPofContext()
{
return NullPofContext.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of a PofHandler.
*
* @return a conforming implementation of PofHandler that does as little
* as possible
*/
public static PofHandler getPofHandler()
{
return NullPofHandler.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of a BackingMapManagerContext.
*
* @return a conforming implementation of BackingMapManagerContext that does
* as little as possible
*/
public static BackingMapManagerContext getBackingMapManagerContext()
{
return NullBackingMapManagerContext.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of an EntryProcessor.
*
* @return an EntryProcessor implementation that returns Boolean.FALSE
*/
public static InvocableMap.EntryProcessor getEntryProcessor()
{
return NullEntryProcessor.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of a DeltaCompressor.
*
* @return a DeltaCompressor implementation that always returns new buffer
*/
public static DeltaCompressor getDeltaCompressor()
{
return NullDeltaCompressor.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of an ActionPolicy.
*
* @return an ActionPolicy implementation that allows all actions
*/
public static ActionPolicy getActionPolicy()
{
return NullActionPolicy.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of a CacheStore.
*
* @return a CacheStore implementation that does as little as possible
*/
public static CacheStore getCacheStore()
{
return NullCacheStore.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of a PartitionAssignmentStrategy.
*
* @return a PartitionAssignmentStrategy implementation that does as little as possible
*/
public static PartitionAssignmentStrategy getPartitionAssignmentStrategy()
{
return NullPartitionAssignmentStrategy.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of an {@link AddressProvider}.
*
* @return an implementation of AddressProvider that does as little as possible
*/
public static AddressProvider getAddressProvider()
{
return NullAddressProvider.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of a {@link Collector}.
*
* @return an implementation of Collector that does as little as possible
*/
public static Collector getCollector()
{
return (Collector) NullCollector.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of a {@link Continuation}.
*
* @return an implementation of Continuation that does nothing
*/
public static Continuation getContinuation()
{
return (Continuation) NullContinuation.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of a {@link PersistenceEnvironment}.
*
* @return an implementation of PersistenceEnvironment that does as little as possible
*/
public static PersistenceEnvironment getPersistenceEnvironment()
{
return (PersistenceEnvironment) NullPersistenceEnvironment.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of a {@link PersistenceEnvironment}.
*
* @param clz the type of a raw, environment specific object representation
*
* @return an implementation of PersistenceEnvironment that does as little as possible
*/
public static PersistenceEnvironment getPersistenceEnvironment(Class clz)
{
return (PersistenceEnvironment) NullPersistenceEnvironment.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of a {@link PersistenceManager}.
*
* @return an implementation of PersistenceManager that does as little as possible
*/
public static PersistenceManager getPersistenceManager()
{
return (PersistenceManager) NullPersistenceManager.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of a {@link PersistenceManager}.
*
* @param clz the type of a raw, environment specific object representation
*
* @return an implementation of PersistenceManager that does as little as possible
*/
public static PersistenceManager getPersistenceManager(Class clz)
{
return (PersistenceManager) NullPersistenceManager.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of a {@link PersistentStore}.
*
* @return an implementation of PersistentStore that does as little as possible
*/
public static PersistentStore getPersistentStore()
{
return (PersistentStore) NullPersistentStore.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of a {@link PersistentStore}.
*
* @param clz the type of a raw, environment specific object representation
*
* @return an implementation of PersistentStore that does as little as possible
*/
public static PersistentStore getPersistentStore(Class clz)
{
return (PersistentStore) NullPersistentStore.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of a {@link ResourceRegistry}.
*
* @return an implementation of ResourceRegistry that does nothing
*/
public static ResourceRegistry getResourceRegistry()
{
return NullResourceRegistry.INSTANCE;
}
/**
* Factory method: Obtain a null implementation of an {@link AutoCloseable}.
*
* @return an implementation of an AutoCloseable that does nothing
*/
public static AutoCloseable getAutoCloseable()
{
return () -> {};
}
/**
* Returns an immutable empty {@link LongArray}.
*
* @param the type of values the {@link LongArray} would hold
*
* @return an immutable empty {@link LongArray}
*/
@SuppressWarnings("unchecked")
public static LongArray getLongArray()
{
return (LongArray) NullLongArray.INSTANCE;
}
/**
* Return an instance of a null implementation {@link MemberIdentityProvider}.
*
* @return an instance of a null implementation {@link MemberIdentityProvider}
*/
public static MemberIdentityProvider getMemberIdentityProvider()
{
return NullMemberIdentityProvider.INSTANCE;
}
// ----- inner classes ----------------------------------------------
/**
* An empty enumerator.
*/
public static class NullEnumerator
implements Enumeration, Iterator, Iterable
{
// ----- constructors -------------------------------------------
/**
* No public constructor. (The whole point of this class is to minimize
* allocations in cases where there is nothing to enumerate.)
*/
NullEnumerator()
{
}
// ----- Enumerator interface -----------------------------------
/**
* Tests if this enumeration contains more elements.
*
* @return false
*/
public boolean hasMoreElements()
{
return false;
}
/**
* Returns the next element of this enumeration if this enumeration
* object has at least one more element to provide.
*
* @return the next element of this enumeration.
* @exception NoSuchElementException always
*/
public Object nextElement()
{
throw new NoSuchElementException();
}
// ----- Iterator interface -------------------------------------
/**
* Returns true if the iteration has more elements.
*/
public boolean hasNext()
{
return false;
}
/**
* Returns the next element in the interation.
*
* @exception NoSuchElementException iteration has no more elements.
*/
public Object next()
{
throw new NoSuchElementException();
}
/**
* Removes from the underlying Collection the last element returned by the
* Iterator . This method can be called only once per call to next The
* behavior of an Iterator is unspecified if the underlying Collection is
* modified while the iteration is in progress in any way other than by
* calling this method. Optional operation.
*
* @exception IllegalStateException next has not yet been called,
* or remove has already been called after the last call
* to next.
*/
public void remove()
{
throw new IllegalStateException();
}
// ---- Iterable interface ----------------------------------------
/**
* Returns an Iterator instance with no values to enumerate.
*
* @return an Iterator instance with no values to enumerate
*/
public Iterator iterator()
{
return this;
}
// ----- constants ----------------------------------------------
/**
* Since the enumerator contains no information, only one ever has to exist.
*/
public static final NullEnumerator INSTANCE = new NullEnumerator();
}
/**
* An immutable set which contains nothing.
*/
public static class NullSet
extends AbstractSet
implements Serializable, ExternalizableLite, PortableObject
{
// ----- constructors -------------------------------------------
/**
* Default constructor (for ExternalizableLite and PortableObject).
*/
public NullSet()
{
}
// ----- Set interface ------------------------------------------
/**
* Returns an array containing all of the elements in this Set.
* Obeys the general contract of Collection.toArray.
*
* @return an Object array containing all of the elements in this Set
*/
public Object[] toArray()
{
return EMPTY_ARRAY;
}
/**
* Returns an Iterator over the elements contained in this Collection.
*
* @return an Iterator over the elements contained in this Collection
*/
public Iterator iterator()
{
return EMPTY_ITERATOR;
}
/**
* Returns the number of elements in this Collection.
*
* @return the number of elements in this Collection
*/
public int size()
{
return 0;
}
/**
* Returns true if this Collection contains the specified element. More
* formally, returns true if and only if this Collection contains at least
* one element e such that (o==null ? e==null :
* o.equals(e)).
*
* @param o the object to search for in the set
*
* @return true if this set contains the specified object
*/
public boolean contains(Object o)
{
return false;
}
/**
* Ensures that this Collection contains the specified element.
*
* @param o element whose presence in this Collection is to be ensured
*
* @return true if the Collection changed as a result of the call
*/
public boolean add(Object o)
{
return false;
}
/**
* Removes a single instance of the specified element from this Collection,
* if it is present (optional operation). More formally, removes an
* element e such that (o==null ? e==null :
* o.equals(e)), if the Collection contains one or more such
* elements. Returns true if the Collection contained the specified
* element (or equivalently, if the Collection changed as a result of the
* call).
*
* @param o element to be removed from this Collection, if present
*
* @return true if the Collection contained the specified element
*/
public boolean remove(Object o)
{
return false;
}
/**
* Removes all of the elements from this Collection.
*/
public void clear()
{
}
// ----- Object methods -----------------------------------------
/**
* {@inheritDoc}
*/
public boolean equals(Object o)
{
return o instanceof Set && ((Set) o).isEmpty();
}
/**
* {@inheritDoc}
*/
public int hashCode()
{
return 0;
}
// ----- ExternalizableLite interface ---------------------------
/**
* {@inheritDoc}
*/
public void readExternal(DataInput in)
throws IOException
{
}
/**
* {@inheritDoc}
*/
public void writeExternal(DataOutput out)
throws IOException
{
}
// ----- PortableObject interface -------------------------------
/**
* {@inheritDoc}
*/
public void readExternal(PofReader in)
throws IOException
{
}
/**
* {@inheritDoc}
*/
public void writeExternal(PofWriter out)
throws IOException
{
}
// ----- constants ----------------------------------------------
/**
* Since the set contains no information, only one ever has to exist.
*/
public static final Set INSTANCE = new NullSet();
/**
* Since the set contains no information, only one array has to exist.
*/
private static final Object[] EMPTY_ARRAY = new Object[0];
/**
* Since the set contains no information, only one iterator has to
* exist.
*/
private static final Iterator EMPTY_ITERATOR = getIterator();
}
/**
* A Map that contains nothing and does nothing.
*/
public static class NullMap
extends AbstractMap
implements Map, Serializable, ExternalizableLite, PortableObject
{
// ----- constructors -------------------------------------------
/**
* Default constructor (for ExternalizableLite and PortableObject).
*/
public NullMap()
{
}
// ----- Map interface ------------------------------------------
/**
* {@inheritDoc}
*/
public int size()
{
return 0;
}
/**
* {@inheritDoc}
*/
public Object get(Object key)
{
return null;
}
/**
* {@inheritDoc}
*/
public Object put(Object key, Object value)
{
return null;
}
/**
* {@inheritDoc}
*/
public void putAll(Map map)
{
}
/**
* {@inheritDoc}
*/
public Object remove(Object key)
{
return null;
}
/**
* {@inheritDoc}
*/
public boolean containsKey(Object key)
{
return false;
}
/**
* {@inheritDoc}
*/
public boolean containsValue(Object value)
{
return false;
}
/**
* {@inheritDoc}
*/
public Set entrySet()
{
return getSet();
}
/**
* {@inheritDoc}
*/
public Set keySet()
{
return getSet();
}
/**
* {@inheritDoc}
*/
public Collection values()
{
return getSet();
}
// ----- Object methods -----------------------------------------
/**
* {@inheritDoc}
*/
public boolean equals(Object o)
{
return o instanceof Map && ((Map) o).isEmpty();
}
/**
* {@inheritDoc}
*/
public int hashCode()
{
return 0;
}
// ----- ExternalizableLite interface ---------------------------
/**
* {@inheritDoc}
*/
public void readExternal(DataInput in)
throws IOException
{
}
/**
* {@inheritDoc}
*/
public void writeExternal(DataOutput out)
throws IOException
{
}
// ----- PortableObject interface -------------------------------
/**
* {@inheritDoc}
*/
public void readExternal(PofReader in)
throws IOException
{
}
/**
* {@inheritDoc}
*/
public void writeExternal(PofWriter out)
throws IOException
{
}
// ----- constants ----------------------------------------------
/**
* Since the Map contains no information, only one ever has to exist.
*/
public static final Map INSTANCE = new NullMap();
}
/**
* An immutable ObservableMap which contains nothing.
*/
public static class NullObservableMap
extends NullMap
implements ObservableMap
{
// ----- constructors -------------------------------------------
/**
* Default constructor (for ExternalizableLite and PortableObject).
*/
public NullObservableMap()
{
}
// ----- ObservableMap interface --------------------------------
/**
* {@inheritDoc}
*/
public void addMapListener(MapListener listener)
{
}
/**
* {@inheritDoc}
*/
public void removeMapListener(MapListener listener)
{
}
/**
* {@inheritDoc}
*/
public void addMapListener(MapListener listener, Object oKey, boolean fLite)
{
}
/**
* {@inheritDoc}
*/
public void removeMapListener(MapListener listener, Object oKey)
{
}
/**
* {@inheritDoc}
*/
public void addMapListener(MapListener listener, Filter filter, boolean fLite)
{
}
/**
* {@inheritDoc}
*/
public void removeMapListener(MapListener listener, Filter filter)
{
}
// ----- constants ----------------------------------------------
/**
* Since the Map contains no information, only one ever has to exist.
*/
public static final ObservableMap INSTANCE = new NullObservableMap();
}
/**
* A writer that does basically nothing. Note that multiple instances are
* required because the API dictates that the close method must cause
* further invocations to all other methods to throw an IOException.
*
* @author cp 2000.08.02
*/
public static class NullWriter
extends Writer
{
// ----- constructors -------------------------------------------
/**
* Default constructor.
*/
NullWriter()
{
}
// ----- Writer methods -----------------------------------------
/**
* {@inheritDoc}
*/
public void write(char[] cbuf) throws IOException
{
check();
}
/**
* {@inheritDoc}
*/
public void write(char[] cbuf, int off, int len) throws IOException
{
check();
}
/**
* {@inheritDoc}
*/
public void write(int c) throws IOException
{
check();
}
/**
* {@inheritDoc}
*/
public void write(String str) throws IOException
{
check();
}
/**
* {@inheritDoc}
*/
public void write(String str, int off, int len) throws IOException
{
check();
}
/**
* {@inheritDoc}
*/
public void flush() throws IOException
{
check();
}
/**
* {@inheritDoc}
*/
public void close() throws IOException
{
m_fClosed = true;
}
/**
* {@inheritDoc}
*/
private void check() throws IOException
{
if (m_fClosed)
{
// same as PrintWriter
throw new IOException("Stream closed");
}
}
// ----- data members -------------------------------------------
private boolean m_fClosed;
}
/**
* A reader that does basically nothing. Note that multiple instances are
* required because the API dictates that the close method must cause
* further invocations to all other methods to throw an IOException.
*
* @author jh 2012.03.28
*/
public static class NullReader
extends Reader
{
// ----- constructors -------------------------------------------
/**
* Default constructor.
*/
NullReader()
{
}
// ----- Reader methods -----------------------------------------
/**
* {@inheritDoc}
*/
public void mark(int cb) throws IOException
{
check();
super.mark(cb);
}
/**
* {@inheritDoc}
*/
public boolean markSupported()
{
return true;
}
/**
* {@inheritDoc}
*/
public int read() throws IOException
{
check();
return -1;
}
/**
* {@inheritDoc}
*/
public int read(char[] ach) throws IOException
{
check();
return -1;
}
/**
* {@inheritDoc}
*/
public int read(char[] cbuf, int off, int len) throws IOException
{
check();
return -1;
}
/**
* {@inheritDoc}
*/
public int read(CharBuffer buf) throws IOException
{
check();
return -1;
}
/**
* {@inheritDoc}
*/
public boolean ready() throws IOException
{
check();
return true;
}
/**
* {@inheritDoc}
*/
public void reset() throws IOException
{
check();
}
/**
* {@inheritDoc}
*/
public long skip(long ch) throws IOException
{
check();
throw new EOFException();
}
/**
* {@inheritDoc}
*/
public void close() throws IOException
{
m_fClosed = true;
}
// ----- internal -----------------------------------------------
private void check() throws IOException
{
if (m_fClosed)
{
throw new IOException("Stream closed");
}
}
// ----- data members -------------------------------------------
private boolean m_fClosed;
}
/**
* An OutputStream that does basically nothing. Note that multiple
* instances are required because the API dictates that the close method
* must cause further invocations to all other methods to throw an
* IOException.
*
* @author cp 2000.11.01
*/
public static class NullOutputStream
extends OutputStream
implements OutputStreaming, DataOutput
{
// ----- constructors -------------------------------------------
/**
* Default constructor.
*/
NullOutputStream()
{
}
// ----- OutputStream methods -----------------------------------
/**
* {@inheritDoc}
*/
public void write(int b) throws IOException
{
check();
advance(1);
}
/**
* {@inheritDoc}
*/
public void write(byte b[]) throws IOException
{
check();
advance(b.length);
}
/**
* {@inheritDoc}
*/
public void write(byte b[], int off, int len) throws IOException
{
check();
advance(len);
}
/**
* {@inheritDoc}
*/
public void flush() throws IOException
{
check();
}
/**
* {@inheritDoc}
*/
public void close() throws IOException
{
m_fClosed = true;
}
/**
* {@inheritDoc}
*/
public int size()
{
return m_cb;
}
// ------ DataOutput --------------------------------------------
/**
* {@inheritDoc}
*/
public void writeDouble(double v)
throws IOException
{
check();
advance(8);
}
/**
* {@inheritDoc}
*/
public void writeFloat(float v)
throws IOException
{
check();
advance(4);
}
/**
* {@inheritDoc}
*/
public void writeByte(int v)
throws IOException
{
check();
advance(1);
}
/**
* {@inheritDoc}
*/
public void writeChar(int v)
throws IOException
{
check();
advance(2);
}
/**
* {@inheritDoc}
*/
public void writeInt(int v)
throws IOException
{
check();
advance(4);
}
/**
* {@inheritDoc}
*/
public void writeShort(int v)
throws IOException
{
check();
advance(2);
}
/**
* {@inheritDoc}
*/
public void writeLong(long v)
throws IOException
{
check();
advance(8);
}
/**
* {@inheritDoc}
*/
public void writeBoolean(boolean v)
throws IOException
{
check();
advance(1);
}
/**
* {@inheritDoc}
*/
public void writeBytes(String s)
throws IOException
{
check();
advance(s.getBytes().length);
}
/**
* {@inheritDoc}
*/
public void writeChars(String s)
throws IOException
{
check();
advance(s.length() * 2);
}
/**
* {@inheritDoc}
*/
public void writeUTF(String s)
throws IOException
{
writeChars(s); // who cares
}
// ----- internal -----------------------------------------------
private void check() throws IOException
{
if (m_fClosed)
{
// same as PrintStream
throw new IOException("Stream closed");
}
}
private void advance(int cb)
{
cb += m_cb;
m_cb = cb < 0 ? Integer.MAX_VALUE : cb;
}
// ----- data members -------------------------------------------
private boolean m_fClosed;
private int m_cb;
}
/**
* A Converter that does nothing.
*
* @author cp 2002.02.08
*/
public static class NullConverter
implements Converter
{
// ----- constructors -------------------------------------------
/**
* Off-limits constructor.
*/
NullConverter()
{
}
// ----- Converter interface ------------------------------------
/**
* Convert the passed object to another object.
*
* @return the new, converted object
*/
public Object convert(Object o)
{
return o;
}
// ----- constants ----------------------------------------------
/**
* Since the Converter contains no information, only one ever has to
* exist.
*/
public static final NullConverter INSTANCE = new NullConverter();
}
/**
* A ValueExtractor that always results in the passed-in value.
*/
public static class NullValueExtractor
implements ValueExtractor, Serializable, ExternalizableLite, PortableObject
{
// ----- constructors -------------------------------------------
/**
* Default constructor (for ExternalizableLite and PortableObject).
*/
public NullValueExtractor()
{
}
// ----- ValueExtractor interface -------------------------------
/**
* Extract the value from the passed object. The returned value may be
* null. For intrinsic types, the returned value is expected to be a
* standard wrapper type in the same manner that reflection works; for
* example, int would be returned as a java.lang.Integer.
*
* @return the extracted value as an Object; null is an acceptable value
*
* @throws ClassCastException if this ValueExtractor is incompatible with
* the passed object to extract a value from and the
* implementation requires the passed object to be of a
* certain type
* @throws WrapperException if this ValueExtractor encounters an exception
* in the course of extracting the value
* @throws IllegalArgumentException if this ValueExtractor cannot handle
* the passed object for any other reason; an implementor should
* include a descriptive message
*/
public Object extract(Object o)
{
return o;
}
// ----- Object methods -----------------------------------------
/**
* Compare the ValueExtractor with another object to determine equality.
* Two ValueExtractor objects, ve1 and ve2 are considered
* equal iff ve1.extract(o) equals ve2.extract(o) for
* all values of o.
*
* @return true iff this ValueExtractor and the passed object are
* equivalent ValueExtractors
*/
public boolean equals(Object o)
{
return o instanceof NullValueExtractor;
}
/**
* Determine a hash value for the ValueExtractor object according to the
* general {@link Object#hashCode()} contract.
*
* @return an integer hash value for this ValueExtractor object
*/
public int hashCode()
{
// regards to DA
return 42;
}
/**
* Provide a human-readable description of this ValueExtractor object.
*
* @return a human-readable description of this ValueExtractor object
*/
public String toString()
{
return "NullValueExtractor";
}
// ----- ExternalizableLite interface ---------------------------
/**
* {@inheritDoc}
*/
public void readExternal(DataInput in)
throws IOException
{
}
/**
* {@inheritDoc}
*/
public void writeExternal(DataOutput out)
throws IOException
{
}
// ----- PortableObject interface -------------------------------
/**
* {@inheritDoc}
*/
public void readExternal(PofReader in)
throws IOException
{
}
/**
* {@inheritDoc}
*/
public void writeExternal(PofWriter out)
throws IOException
{
}
// ----- constants ----------------------------------------------
/**
* Since the ValueExtractor contains no information, only one ever has to
* exist.
*/
public static final NullValueExtractor INSTANCE = new NullValueExtractor();
}
/**
* An implementation of PofContext that does nothing.
*/
public static class NullPofContext
implements PofContext
{
// ----- constructors -------------------------------------------
/**
* Default constructor.
*/
NullPofContext()
{
}
// ----- PofContext interface -----------------------------------
/**
* {@inheritDoc}
*/
public PofSerializer getPofSerializer(int nTypeId)
{
throw new IllegalArgumentException();
}
/**
* {@inheritDoc}
*/
public int getUserTypeIdentifier(Object o)
{
throw new IllegalArgumentException();
}
/**
* {@inheritDoc}
*/
public int getUserTypeIdentifier(Class clz)
{
throw new IllegalArgumentException();
}
/**
* {@inheritDoc}
*/
public int getUserTypeIdentifier(String sClass)
{
throw new IllegalArgumentException();
}
/**
* {@inheritDoc}
*/
public String getClassName(int nTypeId)
{
throw new IllegalArgumentException();
}
/**
* {@inheritDoc}
*/
public Class getClass(int nTypeId)
{
throw new IllegalArgumentException();
}
/**
* {@inheritDoc}
*/
public boolean isUserType(Object o)
{
return false;
}
/**
* {@inheritDoc}
*/
public boolean isUserType(Class clz)
{
return false;
}
/**
* {@inheritDoc}
*/
public boolean isUserType(String sClass)
{
return false;
}
// ----- Serializer interface -----------------------------------
/**
* {@inheritDoc}
*/
public void serialize(WriteBuffer.BufferOutput out, Object o)
throws IOException
{
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*/
public Object deserialize(ReadBuffer.BufferInput in)
throws IOException
{
throw new UnsupportedOperationException();
}
// ----- constants ----------------------------------------------
/**
* Singleton instance.
*/
public static final NullPofContext INSTANCE = new NullPofContext();
}
/**
* An implementation of PofHandler that does nothing.
*/
public static class NullPofHandler
implements PofHandler
{
// ----- constructors -------------------------------------------
/**
* Default constructor.
*/
NullPofHandler()
{
}
// ----- PofHandler interface -----------------------------------
/**
* {@inheritDoc}
*/
public void registerIdentity(int nId)
{
}
/**
* {@inheritDoc}
*/
public void onNullReference(int iPos)
{
}
/**
* {@inheritDoc}
*/
public void onIdentityReference(int iPos, int nId)
{
}
/**
* {@inheritDoc}
*/
public void onInt16(int iPos, short n)
{
}
/**
* {@inheritDoc}
*/
public void onInt32(int iPos, int n)
{
}
/**
* {@inheritDoc}
*/
public void onInt64(int iPos, long n)
{
}
/**
* {@inheritDoc}
*/
public void onInt128(int iPos, BigInteger n)
{
}
/**
* {@inheritDoc}
*/
public void onFloat32(int iPos, float fl)
{
}
/**
* {@inheritDoc}
*/
public void onFloat64(int iPos, double dfl)
{
}
/**
* {@inheritDoc}
*/
public void onFloat128(int iPos, RawQuad qfl)
{
}
/**
* {@inheritDoc}
*/
public void onDecimal32(int iPos, BigDecimal dec)
{
}
/**
* {@inheritDoc}
*/
public void onDecimal64(int iPos, BigDecimal dec)
{
}
/**
* {@inheritDoc}
*/
public void onDecimal128(int iPos, BigDecimal dec)
{
}
/**
* {@inheritDoc}
*/
public void onBoolean(int iPos, boolean f)
{
}
/**
* {@inheritDoc}
*/
public void onOctet(int iPos, int b)
{
}
/**
* {@inheritDoc}
*/
public void onOctetString(int iPos, Binary bin)
{
}
/**
* {@inheritDoc}
*/
public void onChar(int iPos, char ch)
{
}
/**
* {@inheritDoc}
*/
public void onCharString(int iPos, String s)
{
}
/**
* {@inheritDoc}
*/
public void onDate(int iPos, int nYear, int nMonth, int nDay)
{
}
/**
* {@inheritDoc}
*/
public void onYearMonthInterval(int iPos, int cYears, int cMonths)
{
}
/**
* {@inheritDoc}
*/
public void onTime(int iPos, int nHour, int nMinute, int nSecond,
int nNano, boolean fUTC)
{
}
/**
* {@inheritDoc}
*/
public void onTime(int iPos, int nHour, int nMinute, int nSecond,
int nNano, int nHourOffset, int nMinuteOffset)
{
}
/**
* {@inheritDoc}
*/
public void onTimeInterval(int iPos, int cHours, int cMinutes,
int cSeconds, int cNanos)
{
}
/**
* {@inheritDoc}
*/
public void onDateTime(int iPos, int nYear, int nMonth, int nDay,
int nHour, int nMinute, int nSecond, int nNano, boolean fUTC)
{
}
/**
* {@inheritDoc}
*/
public void onDateTime(int iPos, int nYear, int nMonth, int nDay,
int nHour, int nMinute, int nSecond, int nNano,
int nHourOffset, int nMinuteOffset)
{
}
/**
* {@inheritDoc}
*/
public void onDayTimeInterval(int iPos, int cDays, int cHours,
int cMinutes, int cSeconds, int cNanos)
{
}
/**
* {@inheritDoc}
*/
public void beginCollection(int iPos, int cElements)
{
}
/**
* {@inheritDoc}
*/
public void beginUniformCollection(int iPos, int cElements, int nType)
{
}
/**
* {@inheritDoc}
*/
public void beginArray(int iPos, int cElements)
{
}
/**
* {@inheritDoc}
*/
public void beginUniformArray(int iPos, int cElements, int nType)
{
}
/**
* {@inheritDoc}
*/
public void beginSparseArray(int iPos, int cElements)
{
}
/**
* {@inheritDoc}
*/
public void beginUniformSparseArray(int iPos, int cElements, int nType)
{
}
/**
* {@inheritDoc}
*/
public void beginMap(int iPos, int cElements)
{
}
/**
* {@inheritDoc}
*/
public void beginUniformKeysMap(int iPos, int cElements, int nTypeKeys)
{
}
/**
* {@inheritDoc}
*/
public void beginUniformMap(int iPos, int cElements,
int nTypeKeys, int nTypeValues)
{
}
/**
* {@inheritDoc}
*/
public void beginUserType(int iPos, int nUserTypeId, int nVersionId)
{
}
/**
* {@inheritDoc}
*/
public void endComplexValue()
{
}
// ----- constants ----------------------------------------------
/**
* Singleton instance.
*/
public static final NullPofHandler INSTANCE = new NullPofHandler();
}
/**
* An implementation of BackingMapManagerContext that does nothing.
*/
public static class NullBackingMapManagerContext
implements BackingMapManagerContext
{
// ----- constructors -------------------------------------------
/**
* Default constructor.
*/
NullBackingMapManagerContext()
{
}
// ----- BackingMapManagerContext interface ---------------------
/**
* {@inheritDoc}
*/
public BackingMapManager getManager()
{
return null;
}
/**
* {@inheritDoc}
*/
public CacheService getCacheService()
{
return null;
}
/**
* {@inheritDoc}
*/
public ClassLoader getClassLoader()
{
return null;
}
/**
* {@inheritDoc}
*/
public void setClassLoader(ClassLoader loader)
{
}
/**
* {@inheritDoc}
*/
public Converter getKeyToInternalConverter()
{
return NullConverter.INSTANCE;
}
/**
* {@inheritDoc}
*/
public Converter getKeyFromInternalConverter()
{
return NullConverter.INSTANCE;
}
/**
* {@inheritDoc}
*/
public Converter getValueToInternalConverter()
{
return NullConverter.INSTANCE;
}
/**
* {@inheritDoc}
*/
public Converter getValueFromInternalConverter()
{
return NullConverter.INSTANCE;
}
/**
* {@inheritDoc}
*/
public boolean isKeyOwned(Object oKey)
{
return true;
}
/**
* {@inheritDoc}
*/
public int getKeyPartition(Object oKey)
{
return 0;
}
/**
* {@inheritDoc}
*/
public Set getPartitionKeys(String sCacheName, int nPartition)
{
return null;
}
/**
* {@inheritDoc}
*/
public Map getBackingMap(String sCacheName)
{
return null;
}
/**
* {@inheritDoc}
*/
public Object addInternalValueDecoration(Object oValue, int nDecorId, Object oDecor)
{
return oValue;
}
/**
* {@inheritDoc}
*/
public Object removeInternalValueDecoration(Object oValue, int nDecorId)
{
return oValue;
}
/**
* {@inheritDoc}
*/
public boolean isInternalValueDecorated(Object oValue, int nDecorId)
{
return false;
}
/**
* {@inheritDoc}
*/
public Object getInternalValueDecoration(Object oValue, int nDecorId)
{
return null;
}
/**
* {@inheritDoc}
*/
public BackingMapContext getBackingMapContext(String sCacheName)
{
return null;
}
// ----- XmlConfigurable interface ------------------------------
/**
* {@inheritDoc}
*/
public XmlElement getConfig()
{
return null;
}
/**
* {@inheritDoc}
*/
public void setConfig(XmlElement xml)
{
}
// ----- constants ----------------------------------------------
/**
* Singleton instance.
*/
public static final NullBackingMapManagerContext INSTANCE =
new NullBackingMapManagerContext();
}
/**
* An implementation of an EntryProcessor that does nothing and returns
* Boolean.TRUE as a result of execution.
*/
public static class NullEntryProcessor
extends AbstractProcessor
implements ExternalizableLite, PortableObject
{
/**
* {@inheritDoc}
*/
public Object process(InvocableMap.Entry entry)
{
return Boolean.TRUE;
}
// ----- ExternalizableLite interface ---------------------------
/**
* {@inheritDoc}
*/
public void readExternal(DataInput in)
throws IOException
{
}
/**
* {@inheritDoc}
*/
public void writeExternal(DataOutput out)
throws IOException
{
}
// ----- PortableObject interface -------------------------------
/**
* {@inheritDoc}
*/
public void readExternal(PofReader in)
throws IOException
{
}
/**
* {@inheritDoc}
*/
public void writeExternal(PofWriter out)
throws IOException
{
}
// ----- constants ----------------------------------------------
/**
* Singleton instance.
*/
public static final NullEntryProcessor INSTANCE =
new NullEntryProcessor();
}
/**
* An implementation of a DeltaCompressor that does nothing and always
* returns the new stream.
*/
public static class NullDeltaCompressor
implements DeltaCompressor
{
/**
* {@inheritDoc}
*/
public ReadBuffer extractDelta(ReadBuffer bufOld, ReadBuffer bufNew)
{
return Base.equals(bufOld, bufNew) ? null : bufNew;
}
/**
* {@inheritDoc}
*/
public ReadBuffer applyDelta(ReadBuffer bufOld, ReadBuffer bufDelta)
{
return bufDelta == null ? bufOld : bufDelta;
}
// ----- constants ----------------------------------------------
/**
* Singleton instance.
*/
public static final DeltaCompressor INSTANCE =
new NullDeltaCompressor();
}
/**
* An implementation of an ActionPolicy that allows all actions.
*/
public static class NullActionPolicy
implements ActionPolicy
{
// ----- ActionPolicy interface ---------------------------------
/**
* {@inheritDoc}
*/
public void init(com.tangosol.net.Service service)
{
}
/**
* {@inheritDoc}
*/
public boolean isAllowed(com.tangosol.net.Service service, Action action)
{
return true;
}
// ----- Object methods -----------------------------------------
/**
* {@inheritDoc}
*/
public String toString()
{
return "{NullActionPolicy allowed-actions=*}";
}
// ----- constants ----------------------------------------------
/**
* Singleton instance.
*/
public static final ActionPolicy INSTANCE = new NullActionPolicy();
}
/**
* An implementation of an CacheStore that does nothing.
*/
public static class NullCacheStore
implements CacheStore
{
/**
* {@inheritDoc}
*/
public Object load(Object oKey)
{
return oKey;
}
/**
* {@inheritDoc}
*/
public Map loadAll(Collection colKeys)
{
return NullImplementation.getMap();
}
/**
* {@inheritDoc}
*/
public void store(Object oKey, Object oValue)
{
}
/**
* {@inheritDoc}
*/
public void storeAll(Map mapEntries)
{
}
/**
* {@inheritDoc}
*/
public void erase(Object oKey)
{
}
/**
* {@inheritDoc}
*/
public void eraseAll(Collection colKeys)
{
}
// ----- constants ----------------------------------------------
/**
* Singleton instance.
*/
public static final NullCacheStore INSTANCE = new NullCacheStore();
}
/**
* An implementation of {@link PartitionAssignmentStrategy} that does nothing.
*/
public static class NullPartitionAssignmentStrategy
implements PartitionAssignmentStrategy
{
/**
* {@inheritDoc}
*/
public void init(DistributionManager manager)
{
}
/**
* {@inheritDoc}
*/
public void analyzeOrphans(Map mapConstraints)
{
}
/**
* {@inheritDoc}
*/
public long analyzeDistribution()
{
return 0;
}
/**
* {@inheritDoc}
*/
public String getDescription()
{
return null;
}
// ----- constants ----------------------------------------------
/**
* Singleton instance.
*/
public static final NullPartitionAssignmentStrategy INSTANCE =
new NullPartitionAssignmentStrategy();
}
// ----- inner class: NullAddressProvider ---------------------------
/**
* Null implementation of {@link AddressProvider}.
*/
public static class NullAddressProvider
implements AddressProvider
{
/**
* {@inheritDoc}
*/
public InetSocketAddress getNextAddress()
{
return null;
}
/**
* {@inheritDoc}
*/
public void accept()
{
}
/**
* {@inheritDoc}
*/
public void reject(Throwable eCause)
{
}
// ----- constants ----------------------------------------------
/**
* Singleton instance.
*/
public static final NullAddressProvider INSTANCE = new NullAddressProvider();
}
// ----- inner class: NullCollector ---------------------------------
/**
* A {@link Collector} implementation that does nothing.
*
* @param the value type
*/
public static class NullCollector
implements Collector
{
/**
* {@inheritDoc}
*/
public void add(V value)
{
}
/**
* {@inheritDoc}
*/
public void flush()
{
}
// ----- constants ----------------------------------------------
/**
* Singleton (unchecked) instance of a Collector.
*/
public static final NullCollector INSTANCE = new NullCollector();
}
// ----- inner class: NullContinuation ------------------------------
/**
* A Continuation that does nothing.
*
* @param
*/
public static class NullContinuation
implements Continuation
{
/**
* {@inheritDoc}
*/
public void proceed(R r)
{
}
// ----- constants ----------------------------------------------
/**
* Singleton instance of a NullContinuation.
*/
public static final NullContinuation INSTANCE = new NullContinuation();
}
// ----- inner class: NullPersistenceEnvironment --------------------
/**
* A {@link PersistenceEnvironment} that does nothing.
*
* @param the raw value type
*/
public static class NullPersistenceEnvironment
implements PersistenceEnvironment
{
/**
* {@inheritDoc}
*/
public PersistenceManager openActive()
{
return null;
}
/**
* {@inheritDoc}
*/
public PersistenceManager openSnapshot(String sSnapshot)
{
throw new IllegalArgumentException();
}
/**
* {@inheritDoc}
*/
public PersistenceManager createSnapshot(String sSnapshot, PersistenceManager manager)
{
return NullPersistenceManager.INSTANCE;
}
/**
* {@inheritDoc}
*/
public boolean removeSnapshot(String sSnapshot)
{
return false;
}
/**
* {@inheritDoc}
*/
public String[] listSnapshots()
{
return new String[0];
}
/**
* {@inheritDoc}
*/
public void release()
{
}
// ----- constants ----------------------------------------------
/**
* Singleton instance of a NullPersistenceEnvironment.
*/
public static final NullPersistenceEnvironment INSTANCE = new NullPersistenceEnvironment();
}
// ----- inner class: NullPersistenceManager ------------------------
/**
* A {@link PersistenceManager} that does nothing.
*
* @param the raw value type
*/
public static class NullPersistenceManager
implements PersistenceManager, PersistenceTools
{
/**
* {@inheritDoc}
*/
public String getName()
{
return null;
}
@Override
public PersistentStore createStore(String sId)
{
return NullPersistentStore.INSTANCE;
}
/**
* {@inheritDoc}
*/
public PersistentStore open(String sId, PersistentStore store)
{
return NullPersistentStore.INSTANCE;
}
/**
* {@inheritDoc}
*/
public PersistentStore open(String sId, PersistentStore store, Collector