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.List;
 import java.util.Map;
 
A static catalog containing simple types only. Once created, this catalog is immutable. For bindings accessed by a PersistComparator during recovery, the SimpleCatalog provides formats for all simple types. To reduce redundant format objects, the SimpleCatalog's formats are copied when creating a regular PersistCatalog. This class also contains utility methods for dealing with primitives.

Author(s):
Mark Hayes
 
 public class SimpleCatalog implements Catalog {
 
     private static final Map<StringClasskeywordToPrimitive;
     static {
          = new HashMap<StringClass>(8);
         .put("boolean".);
         .put("char".);
         .put("byte".);
         .put("short".);
         .put("int".);
         .put("long".);
         .put("float".);
         .put("double".);
     }
 
     private static final Map<ClassClassprimitiveTypeToWrapper;
     static {
          = new HashMap<ClassClass>(8);
         .put(.Boolean.class);
         .put(.Byte.class);
         .put(.Short.class);
         .put(.Integer.class);
         .put(.Long.class);
         .put(.Float.class);
         .put(.Double.class);
     }
 
     private static final SimpleCatalog instance = new SimpleCatalog(null);
 
     static boolean isSimpleType(Class type) {
         return ..containsKey(type.getName());
     }
 
     static Class primitiveToWrapper(Class type) {
         Class cls = .get(type);
         if (cls == null) {
             throw DbCompat.unexpectedState(type.getName());
         }
         return cls;
     }
 
     public static Class resolveClass(String classNameClassLoader loader)
         throws ClassNotFoundException {
 
         Class cls = .get(className);
         if (cls == null) {
             cls = ClassResolver.resolveClass(classNameloader);
         }
         return cls;
     }
 
     public static Class resolveKeyClass(String classNameClassLoader loader) {
         Class cls = .get(className);
         if (cls != null) {
             cls = .get(cls);
         } else {
             try {
                 cls = ClassResolver.resolveClass(classNameloader);
             } catch (ClassNotFoundException e) {
                 throw new IllegalArgumentException
                     ("Key class not found: " + className);
             }
         }
         return cls;
     }
    public static String keyClassName(String className) {
        Class cls = .get(className);
        if (cls != null) {
            cls = .get(cls);
            return cls.getName();
        } else {
            return className;
        }
    }
    static List<FormatgetAllSimpleFormats(ClassLoader loader) {
        return new ArrayList<Format>(new SimpleCatalog(loader).);
    }
    static boolean addMissingSimpleFormats(ClassLoader loader,
                                           List<FormatcopyToList) {
        boolean anyCopied = false;
        SimpleCatalog tempCatalog = null;
        for (int i = 0; i <= .i += 1) {
            final Format thisFormat = ..get(i);
            final Format otherFormat = copyToList.get(i);
            if (thisFormat != null && otherFormat == null) {
                assert thisFormat.getWrapperFormat() == null;
                if (tempCatalog == null) {
                    tempCatalog = new SimpleCatalog(loader);
                }
                copyToList.set(itempCatalog.formatList.get(i));
                anyCopied = true;
            }
        }
        return anyCopied;
    }
    private final ClassLoader classLoader;
    private final List<SimpleFormatformatList;
    private final Map<StringSimpleFormatformatMap;
    SimpleCatalog(final ClassLoader classLoader) {
        this. = classLoader;
        /*
         * Reserve slots for all predefined IDs, so that that next ID assigned
         * will be Format.ID_PREDEFINED plus one.
         */
        int initCapacity = . * 2;
         = new ArrayList<SimpleFormat>(initCapacity);
         = new HashMap<StringSimpleFormat>(initCapacity);
        for (int i = 0; i <= .i += 1) {
            .add(null);
        }
        /* Initialize all predefined formats.  */
        setFormat(.,     new SimpleFormat.FBool(thistrue));
        setFormat(.,   new SimpleFormat.FBool(thisfalse));
        setFormat(.,     new SimpleFormat.FByte(thistrue));
        setFormat(.,   new SimpleFormat.FByte(thisfalse));
        setFormat(.,    new SimpleFormat.FShort(thistrue));
        setFormat(.,  new SimpleFormat.FShort(thisfalse));
        setFormat(.,      new SimpleFormat.FInt(thistrue));
        setFormat(.,    new SimpleFormat.FInt(thisfalse));
        setFormat(.,     new SimpleFormat.FLong(thistrue));
        setFormat(.,   new SimpleFormat.FLong(thisfalse));
        setFormat(.,    new SimpleFormat.FFloat(thistrue));
        setFormat(.,  new SimpleFormat.FFloat(thisfalse));
        setFormat(.,   new SimpleFormat.FDouble(thistrue));
        setFormat(.new SimpleFormat.FDouble(thisfalse));
        setFormat(.,     new SimpleFormat.FChar(thistrue));
        setFormat(.,   new SimpleFormat.FChar(thisfalse));
        setFormat(.,   new SimpleFormat.FString(this));
        setFormat(.,   new SimpleFormat.FBigInt(this));
        setFormat(.,   new SimpleFormat.FBigDec(this));
        setFormat(.,     new SimpleFormat.FDate(this));
        /* Tell primitives about their wrapper class. */
    }

    
Sets a format for which space in the formatList has been preallocated, and makes it the current format for the class.
    private void setFormat(int idSimpleFormat format) {
        format.setId(id);
        format.initializeIfNeeded(thisnull /*model*/);
        .set(idformat);
        .put(format.getClassName(), format);
    }

    
Tells a primitive format about the format for its corresponding primitive wrapper class.
    private void setWrapper(int primitiveIdint wrapperId) {
        SimpleFormat primitiveFormat = .get(primitiveId);
        SimpleFormat wrapperFormat = .get(wrapperId);
        primitiveFormat.setWrapperFormat(wrapperFormat);
    }
    public int getInitVersion(Format formatboolean forReader) {
        return .;
    }
    public Format getFormat(int formatIdboolean expectStored) {
        Format format;
        try {
            format = .get(formatId);
            if (format == null) {
                throw DbCompat.unexpectedState
                    ("Not a simple type: " + formatId);
            }
            return format;
        } catch (NoSuchElementException e) {
            throw DbCompat.unexpectedState
                ("Not a simple type: " + formatId);
        }
    }
    public Format getFormat(Class clsboolean checkEntitySubclassIndexes) {
        Format format = .get(cls.getName());
        if (format == null) {
            throw new IllegalArgumentException
                ("Not a simple type: " + cls.getName());
        }
        return format;
    }
    public Format getFormat(String className) {
        return .get(className);
    }
    public Format createFormat(String clsName,
                               Map<StringFormatnewFormats) {
        throw DbCompat.unexpectedState();
    }
    public Format createFormat(Class typeMap<StringFormatnewFormats) {
        throw DbCompat.unexpectedState();
    }
    public boolean isRawAccess() {
        return false;
    }
    public Object convertRawObject(RawObject oIdentityHashMap converted) {
        throw DbCompat.unexpectedState();
    }
    public Class resolveClass(String clsName)
        throws ClassNotFoundException {
        return SimpleCatalog.resolveClass(clsName);
    }
    public Class resolveKeyClass(String clsName) {
        return SimpleCatalog.resolveKeyClass(clsName);
    }
    
    /* Registering proxy is not allowed for SimpleType. */
    public static boolean allowRegisterProxy(Class type) {
        return !isSimpleType(type);
    }
New to GrepCode? Check out our FAQ X