Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*-
   * See the file LICENSE for redistribution information.
   *
   * Copyright (c) 2002, 2013 Oracle and/or its affiliates.  All rights reserved.
   *
   */
  
  package com.sleepycat.persist.impl;
  
 import java.util.Map;
 import java.util.Set;
 
Format for types proxied by a PersistentProxy.

Author(s):
Mark Hayes
 
 public class ProxiedFormat extends Format {
 
     private static final long serialVersionUID = -1000032651995478768L;
 
     private Format proxyFormat;
     private transient String proxyClassName;
 
     ProxiedFormat(Catalog catalogClass proxiedTypeString proxyClassName) {
         super(catalogproxiedType);
         this. = proxyClassName;
     }

    
Returns the proxy class name. The proxyClassName field is non-null for a constructed object and null for a de-serialized object. Whenever the proxyClassName field is null (for a de-serialized object), the proxyFormat will be non-null.
 
     private String getProxyClassName() {
         if ( != null) {
             return ;
         } else {
             assert  != null;
             return .getClassName();
         }
     }

    
In the future if we implement container proxies, which support nested references to the container, then we will return false if this is a container proxy. [#15815]
 
     @Override
     boolean areNestedRefsProhibited() {
         return true;
     }
 
     @Override
     void collectRelatedFormats(Catalog catalog,
                                Map<StringFormatnewFormats) {
         /* Collect the proxy format. */
         assert  != null;
         catalog.createFormat(newFormats);
     }
 
     @Override
     void initialize(Catalog catalogEntityModel modelint initVersion) {
         /* Set the proxy format for a new (never initialized) format. */
         if ( == null) {
             assert  != null;
              = catalog.getFormat();
         }
         /* Make the linkage from proxy format to proxied format. */
         .setProxiedFormat(this);
     }
 
     @Override
     Object newArray(int len) {
         return Array.newInstance(getType(), len);
     }
 
     @Override
     public Object newInstance(EntityInput inputboolean rawAccess)
         throws RefreshException {
 
         Reader reader = .getReader();
         if (rawAccess) {
             return reader.newInstance(nulltrue);
         } else {
 
             /* 
              * Note that the read object will not be a PersistentProxy if
              * a class converter mutation is used.  In this case, the reader 
              * will be ConverterReader. ConverterReader.readObject
              * will call ProxiedFormat.convertRawObject, which will call
              * PersistentProxy.convertProxy to convert the proxy. So we do not
             * need another call to the convertProxy method.  [#19312]
             */
            Object o = reader.readObject(reader.newInstance(nullfalse), 
                                         inputfalse);
            if (o instanceof PersistentProxy) {
                o = ((PersistentProxyo).convertProxy();
            }
            return o;
        }
    }
    @Override
    public Object readObject(Object oEntityInput inputboolean rawAccess)
        throws RefreshException {
        if (rawAccess) {
            o = .getReader().readObject(oinputtrue);
        }
        /* Else, do nothing here -- newInstance reads the value. */
        return o;
    }
    @Override
    void writeObject(Object oEntityOutput outputboolean rawAccess)
        throws RefreshException {
        if (rawAccess) {
            .writeObject(ooutputtrue);
        } else {
            PersistentProxy proxy =
                (PersistentProxy.newInstance(nullfalse);
            proxy.initializeProxy(o);
            .writeObject(proxyoutputfalse);
        }
    }
    @Override
                            boolean rawAccess,
                            RawObject rawObject,
                            IdentityHashMap converted)
        throws RefreshException {
            (catalograwAccessrawObjectconverted);
        Object o = proxy.convertProxy();
        converted.put(rawObjecto);
        return o;
    }
    @Override
    void skipContents(RecordInput input)
        throws RefreshException {
        .skipContents(input);
    }
    @Override
    void copySecMultiKey(RecordInput inputFormat keyFormatSet results)
        throws RefreshException {
        CollectionProxy.copyElements(inputthiskeyFormatresults);
    }
    @Override
    boolean evolve(Format newFormatParamEvolver evolver) {
        if (!(newFormatParam instanceof ProxiedFormat)) {
            
            /* 
             * A workaround for reading the BigDecimal data stored by 
             * BigDecimal proxy before je4.1. 
             * 
             * The BigDecimal proxy has a proxied format for BigDecimal, which 
             * is a built-in SimpleType. We will evolve this ProxiedFormat of 
             * BigDecimal to the SimpleFormat. In other words, the conversion 
             * from a BigDecimal proxied format to a BigDecimal SimpleFormat is 
             * allowed, and the old format can be used as the reader of the old 
             * data.
             */
            if (newFormatParam.allowEvolveFromProxy()) {
                evolver.useEvolvedFormat(thisthisnewFormatParam);
                return true;
            }
            evolver.addEvolveError
                (thisnewFormatParamnull,
                 "A proxied class may not be changed to a different type");
            return false;
        }
        ProxiedFormat newFormat = (ProxiedFormatnewFormatParam;
        if (!evolver.evolveFormat()) {
            return false;
        }
        Format newProxyFormat = .getLatestVersion();
        if (!newProxyFormat.getClassName().equals
                (newFormat.getProxyClassName())) {
            evolver.addEvolveError
                (thisnewFormatnull,
                 "The proxy class for this type has been changed from: " +
                 newProxyFormat.getClassName() + " to: " +
                 newFormat.getProxyClassName());
            return false;
        }
        if (newProxyFormat != ) {
            evolver.useEvolvedFormat(thisthisnewFormat);
        } else {
            evolver.useOldFormat(thisnewFormat);
        }
        return true;
    }
New to GrepCode? Check out our FAQ X