Question related to POF configuration and use-subclasses

Question

Hi,
I noticed that the default POF configuration in coherence.jar (coherence-pof-config.xml) forces the use-subclasses flag to true (the ultimate use-subclasses value is true if whichever loaded POF configuration file specifies it to be true), and thus making it impossible to get error messages if a certain subclass of a registered type is not registered specifically in the POF-configuration, and users may silently lose data this way.
My question is:
Is the use-subclasses flag in the coherence-pof-config.xml set to true only because of Throwable-s, or are there other Coherence-provided classes which are serialized by subclass resolution and thus depend on the use-subclasses flag being true?
If only the Throwable-s depend on that, then instead of setting it to true, we can set it to false and use the following class instead of ConfigurablePofContext as the Serializer class for the POF-enabled services:
import com.tangosol.io.pof.ConfigurablePofContext;
import com.tangosol.run.xml.XmlElement;
* This class extends ConfigurablePofContext with the possibility to
* configurably disable the subclass-allowed setting forced true in the
* coherence-pof-config.xml, and still be able to use ThrowablePofSerializer for
* each not specifically configured Throwable subclass.
* @author Robert Varga
public class ThrowableAwareConfigurablePofContext extends
      ConfigurablePofContext {
    * By setting this flag to true, it is possible to disable subclass
    * resolution. Interface resolution remains untouched.
   private boolean m_fDisableSubclassAllowed;
    * {@inheritDoc}
   public ThrowableAwareConfigurablePofContext() {
    * {@inheritDoc}
    * @param sLocator
   public ThrowableAwareConfigurablePofContext(String sLocator) {
      super(sLocator);
    * {@inheritDoc}
    * @param xml
   public ThrowableAwareConfigurablePofContext(XmlElement xml) {
      super(xml);
    * Sets the {@link #m_fDisableSubclassAllowed} flag. You can set this as an
    * <init-param> in the Coherence cache configuration file.
    * @param disableSubclassAllowed
   public void setDisableSubclassAllowed(boolean disableSubclassAllowed) {
      this.m_fDisableSubclassAllowed = disableSubclassAllowed;
    * @return false if disableSubclassAllowed is true, or result from the super
    *         implementation otherwise.
   @Override
   protected boolean isSubclassAllowed() {
      return (!m_fDisableSubclassAllowed) && super.isSubclassAllowed();
    * If the super implementation could not resolve the type id for the class,
    * and subclass-allowed is disabled and clz is a {@link java.lang.Throwable}
    * subclass then it falls back to the configuration for
    * {@link java.lang.Throwable}.
   @Override
   protected int getInheritedUserTypeIdentifier(Class clz) {
      int result = super.getInheritedUserTypeIdentifier(clz);
      if (result == -1 && !isSubclassAllowed()
            && Throwable.class.isAssignableFrom(clz)) {
         result = getUserTypeIdentifier(Throwable.class);
      return result;
}Thanks and best regards,
Robert

Answer 1

dcarrano wrote:
Hi Robert,
If you are only interested in Java you are correct.
If you need more detail please let me know but I hope this answers your question.
Best regards,
-DaveHi Dave,
I am also interested in other environments, so I need more detail.
I am looking at the portability of my POF Serializer generator in which I assume that use-subclasses is false, because supporting use-subclasses being true would be quite hard to define, not to mention implement.
Thanks and best regards,
Robert