Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.fasterxml.jackson.databind.deser.std;
  
  import java.util.Locale;
  import java.util.UUID;
  
Base class for simple key deserializers.
 
 public abstract class StdKeyDeserializer
     extends KeyDeserializer
     implements java.io.Serializable
 {
     private static final long serialVersionUID = 1L;
 
     final protected Class<?> _keyClass;
 
     protected StdKeyDeserializer(Class<?> cls) {  = cls; }
 
     @Override
     public final Object deserializeKey(String keyDeserializationContext ctxt)
         throws IOExceptionJsonProcessingException
     {
         if (key == null) { // is this even legal call?
             return null;
         }
         try {
             Object result = _parse(keyctxt);
             if (result != null) {
                 return result;
             }
         } catch (Exception re) {
             throw ctxt.weirdKeyException(key"not a valid representation: "+re.getMessage());
         }
         	return null;
         }
         throw ctxt.weirdKeyException(key"not a valid representation");
     }
 
     public Class<?> getKeyClass() { return ; }
 
     protected abstract Object _parse(String keyDeserializationContext ctxtthrows Exception;
 
     /*
     /**********************************************************
     /* Helper methods for sub-classes
     /**********************************************************
      */
 
     protected int _parseInt(String keythrows IllegalArgumentException
     {
         return Integer.parseInt(key);
     }
 
     protected long _parseLong(String keythrows IllegalArgumentException
     {
         return Long.parseLong(key);
     }
 
     protected double _parseDouble(String keythrows IllegalArgumentException
     {
         return NumberInput.parseDouble(key);
     }
 
     /*
     /**********************************************************
     /* First: the standard "String as String" deserializer
     /**********************************************************
      */
 
     @JacksonStdImpl
     final static class StringKD extends StdKeyDeserializer
     {
         private static final long serialVersionUID = 1L;
 
         private final static StringKD sString = new StringKD(String.class);
         private final static StringKD sObject = new StringKD(Object.class);
         
         private StringKD(Class<?> nominalType) { super(nominalType); }
 
         public static StringKD forType(Class<?> nominalType)
         {
             if (nominalType == String.class) {
                 return ;
             }
             if (nominalType == Object.class) {
                 return ;
             }
            return new StringKD(nominalType);
        }
        
        @Override
        public String _parse(String keyDeserializationContext ctxtthrows JsonMappingException {
            return key;
        }
    }    
    
    /*
    /**********************************************************
    /* Key deserializer implementations; wrappers
    /**********************************************************
     */
    final static class BoolKD extends StdKeyDeserializer
    {
        private static final long serialVersionUID = 1L;
        BoolKD() { super(Boolean.class); }
        @Override
        public Boolean _parse(String keyDeserializationContext ctxtthrows JsonMappingException
        {
            if ("true".equals(key)) {
                return .;
            }
            if ("false".equals(key)) {
                return .;
            }
            throw ctxt.weirdKeyException(key"value not 'true' or 'false'");
        }
    }
    final static class ByteKD extends StdKeyDeserializer
    {
        private static final long serialVersionUID = 1L;
        ByteKD() { super(Byte.class); }
        @Override
        {
            int value = _parseInt(key);
            // as per [JACKSON-804], allow range up to 255, inclusive
            if (value < . || value > 255) {
                throw ctxt.weirdKeyException(key"overflow, value can not be represented as 8-bit value");
            }
            return Byte.valueOf((bytevalue);
        }
    }
    final static class ShortKD extends StdKeyDeserializer
    {
        private static final long serialVersionUID = 1L;
        ShortKD() { super(Integer.class); }
        @Override
        {
            int value = _parseInt(key);
            if (value < . || value > .) {
                throw ctxt.weirdKeyException(key"overflow, value can not be represented as 16-bit value");
            }
            return Short.valueOf((shortvalue);
        }
    }

    
Dealing with Characters is bit trickier: let's assume it must be a String, and that Unicode numeric value is never used.
    final static class CharKD extends StdKeyDeserializer
    {
        private static final long serialVersionUID = 1L;
        CharKD() { super(Character.class); }
        @Override
        {
            if (key.length() == 1) {
                return Character.valueOf(key.charAt(0));
            }
            throw ctxt.weirdKeyException(key"can only convert 1-character Strings");
        }
    }
    final static class IntKD extends StdKeyDeserializer
    {
        private static final long serialVersionUID = 1L;
        IntKD() { super(Integer.class); }
        @Override
        {
            return _parseInt(key);
        }
    }
    final static class LongKD extends StdKeyDeserializer
    {
        private static final long serialVersionUID = 1L;
        LongKD() { super(Long.class); }
        @Override
        public Long _parse(String keyDeserializationContext ctxtthrows JsonMappingException
        {
            return _parseLong(key);
        }
    }
    final static class DoubleKD extends StdKeyDeserializer
    {
        private static final long serialVersionUID = 1L;
        DoubleKD() { super(Double.class); }
        @Override
        public Double _parse(String keyDeserializationContext ctxtthrows JsonMappingException
        {
            return _parseDouble(key);
        }
    }
    final static class FloatKD extends StdKeyDeserializer
    {
        private static final long serialVersionUID = 1L;
        FloatKD() { super(Float.class); }
        @Override
        public Float _parse(String keyDeserializationContext ctxtthrows JsonMappingException
        {
            /* 22-Jan-2009, tatu: Bounds/range checks would be tricky
             *   here, so let's not bother even trying...
             */
            return Float.valueOf((float_parseDouble(key));
        }
    }
    final static class LocaleKD extends StdKeyDeserializer {
        private static final long serialVersionUID = 1L;
        LocaleKD() { super(Locale.class);  = new JdkDeserializers.LocaleDeserializer();}
        @Override
        protected Locale _parse(String keyDeserializationContext ctxtthrows JsonMappingException {
            try {
                return ._deserialize(key,ctxt);
            } catch (IOException e) {
                throw ctxt.weirdKeyException(key"unable to parse key as locale");
            }
        }
    }
    /*
    /**********************************************************
    /* Key deserializer implementations; other
    /**********************************************************
     */

    
Key deserializer that wraps a "regular" deserializer (but one that must recognize FIELD_NAMEs as text!) to reuse existing handlers as key handlers.
    final static class DelegatingKD
        extends KeyDeserializer // note: NOT the std one
        implements java.io.Serializable
    {
        private static final long serialVersionUID = 1L;
        final protected Class<?> _keyClass;
        protected final JsonDeserializer<?> _delegate;
        
        protected DelegatingKD(Class<?> clsJsonDeserializer<?> deser) {
             = cls;
             = deser;
        }
        @Override
        public final Object deserializeKey(String keyDeserializationContext ctxt)
            throws IOExceptionJsonProcessingException
        {
            if (key == null) { // is this even legal call?
                return null;
            }
            try {
                // Ugh... should not have to give parser which may or may not be correct one...
                Object result = .deserialize(ctxt.getParser(), ctxt);
                if (result != null) {
                    return result;
                }
            } catch (Exception re) {
                throw ctxt.weirdKeyException(key"not a valid representation: "+re.getMessage());
            }
            throw ctxt.weirdKeyException(key"not a valid representation");
        }
        public Class<?> getKeyClass() { return ; }
    }
     
    final static class EnumKD extends StdKeyDeserializer
    {
        private static final long serialVersionUID = 1L;
        protected final EnumResolver<?> _resolver;
        protected final AnnotatedMethod _factory;
        protected EnumKD(EnumResolver<?> erAnnotatedMethod factory) {
            super(er.getEnumClass());
             = er;
             = factory;
        }
        @Override
        public Object _parse(String keyDeserializationContext ctxtthrows JsonMappingException
        {
            if ( != null) {
                try {
                    return .call1(key);
                } catch (Exception e) {
                    ClassUtil.unwrapAndThrowAsIAE(e);
                }
            }
            Enum<?> e = .findEnum(key);
            if (e == null && !ctxt.getConfig().isEnabled(.)) {
                throw ctxt.weirdKeyException(key"not one of values for Enum class");
            }
            return e;
        }
    }
    
    
Key deserializer that calls a single-string-arg constructor to instantiate desired key type.
    final static class StringCtorKeyDeserializer extends StdKeyDeserializer
    {
        private static final long serialVersionUID = 1L;
        protected final Constructor<?> _ctor;
        public StringCtorKeyDeserializer(Constructor<?> ctor) {
            super(ctor.getDeclaringClass());
             = ctor;
        }
        @Override
        public Object _parse(String keyDeserializationContext ctxtthrows Exception
        {
            return .newInstance(key);
        }
    }

    
Key deserializer that calls a static no-args factory method to instantiate desired key type.
    final static class StringFactoryKeyDeserializer extends StdKeyDeserializer
    {
        private static final long serialVersionUID = 1L;
        final Method _factoryMethod;
        public StringFactoryKeyDeserializer(Method fm) {
            super(fm.getDeclaringClass());
             = fm;
        }
        @Override
        public Object _parse(String keyDeserializationContext ctxtthrows Exception
        {
            return .invoke(nullkey);
        }
    }
    // as per [JACKSON-657]
    final static class DateKD extends StdKeyDeserializer
    {
        private static final long serialVersionUID = 1L;
        protected DateKD() {
            super(java.util.Date.class);
        }
        @Override
        public Object _parse(String keyDeserializationContext ctxt)
            throws IllegalArgumentExceptionJsonMappingException
        {
            return ctxt.parseDate(key);
        }
    }
        
    // as per [JACKSON-657]
    final static class CalendarKD extends StdKeyDeserializer
    {
        private static final long serialVersionUID = 1L;
        protected CalendarKD() {
            super(java.util.Calendar.class);
        }
        @Override
        public Object _parse(String keyDeserializationContext ctxt)
            throws IllegalArgumentExceptionJsonMappingException
        {
            java.util.Date date = ctxt.parseDate(key);
            return (date == null)  ? null : ctxt.constructCalendar(date);
        }
    }
    // as per [JACKSON-726]
    final static class UuidKD extends StdKeyDeserializer
    {
        private static final long serialVersionUID = 1L;
        protected UuidKD() {
            super(UUID.class);
        }
        @Override
        public Object _parse(String keyDeserializationContext ctxt)
            throws IllegalArgumentExceptionJsonMappingException
        {
            return UUID.fromString(key);
        }
    }
New to GrepCode? Check out our FAQ X