Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.fasterxml.jackson.databind;
  
Simple interface for extensions that can be registered with ObjectMapper to provide a well-defined set of extensions to default functionality; such as support for new data types.
 
 public abstract class Module
     implements Versioned
 {
     /*
     /**********************************************************
     /* Simple accessors
     /**********************************************************
      */
    
    
Method that returns identifier for module; this can be used by Jackson for informational purposes, as well as in associating extensions with module that provides them.
 
     public abstract String getModuleName();

    
Method that returns version of this module. Can be used by Jackson for informational purposes.
 
 //  @Override
     public abstract Version version();
 
     /*
     /**********************************************************
     /* Life-cycle: registration
     /**********************************************************
      */
    
    
Method called by ObjectMapper when module is registered. It is called to let module register functionality it provides, using callback methods passed-in context object exposes.
 
     public abstract void setupModule(SetupContext context);
     
     /*
     /**********************************************************
     /* Helper types
     /**********************************************************
      */

    
Interface Jackson exposes to modules for purpose of registering extended functionality. Usually implemented by ObjectMapper, but modules should NOT rely on this -- if they do require access to mapper instance, they need to call getOwner() method.
 
     public static interface SetupContext
     {
         /*
         /**********************************************************
         /* Simple accessors
         /**********************************************************
          */
        
        
Method that returns version information about ObjectMapper that implements this context. Modules can use this to choose different settings or initialization order; or even decide to fail set up completely if version is compatible with module.
 
         public Version getMapperVersion();

        
Fallback access method that allows modules to refer to the ObjectMapper that provided this context. It should NOT be needed by most modules; and ideally should not be used -- however, there may be cases where this may be necessary due to various design constraints.

NOTE: use of this method is discouraged, as it allows access to things Modules typically should not modify. It is included, however, to allow access to new features in cases where Module API has not yet been extended, or there are oversights.

Return value is chosen to not leak dependency to ObjectMapper; however, instance will always be of that type. This is why return value is declared generic, to allow caller to specify context to often avoid casting.

Since:
2.0
        public <C extends ObjectCodec> C getOwner();

        
Accessor for finding com.fasterxml.jackson.databind.type.TypeFactory that is currently configured by the context.

NOTE: since it is possible that other modules might change or replace TypeFactory, use of this method adds order-dependency for registrations.

Since:
2.0
        public TypeFactory getTypeFactory();
        
        public boolean isEnabled(MapperFeature f);
        
        public boolean isEnabled(DeserializationFeature f);
        public boolean isEnabled(SerializationFeature f);
        public boolean isEnabled(JsonFactory.Feature f);
        
        public boolean isEnabled(JsonParser.Feature f);
        public boolean isEnabled(JsonGenerator.Feature f);
        
        /*
        /**********************************************************
        /* Handler registration; serializers/deserializers
        /**********************************************************
         */
        
        
Method that module can use to register additional deserializers to use for handling types.

Parameters:
d Object that can be called to find deserializer for types supported by module (null returned for non-supported types)
        public void addDeserializers(Deserializers d);

        
Method that module can use to register additional deserializers to use for handling Map key values (which are separate from value deserializers because they are always serialized from String values)
        public void addKeyDeserializers(KeyDeserializers s);
        
        
Method that module can use to register additional serializers to use for handling types.

Parameters:
s Object that can be called to find serializer for types supported by module (null returned for non-supported types)
        public void addSerializers(Serializers s);

        
Method that module can use to register additional serializers to use for handling Map key values (which are separate from value serializers because they must write JsonToken.FIELD_NAME instead of String value).
        public void addKeySerializers(Serializers s);
        /*
        /**********************************************************
        /* Handler registration; other
        /**********************************************************
         */
        
        
Method that module can use to register additional modifier objects to customize configuration and construction of bean deserializers.

Parameters:
mod Modifier to register
        public void addBeanDeserializerModifier(BeanDeserializerModifier mod);

        
Method that module can use to register additional modifier objects to customize configuration and construction of bean serializers.

Parameters:
mod Modifier to register
        public void addBeanSerializerModifier(BeanSerializerModifier mod);

        
Method that module can use to register additional AbstractTypeResolver instance, to handle resolution of abstract to concrete types (either by defaulting, or by materializing).

Parameters:
resolver Resolver to add.
        public void addAbstractTypeResolver(AbstractTypeResolver resolver);

        
Method that module can use to register additional com.fasterxml.jackson.databind.type.TypeModifier instance, which can augment JavaType instances constructed by com.fasterxml.jackson.databind.type.TypeFactory.

Parameters:
modifier to add
        public void addTypeModifier(TypeModifier modifier);

        
Method that module can use to register additional com.fasterxml.jackson.databind.deser.ValueInstantiators, by adding com.fasterxml.jackson.databind.deser.ValueInstantiators object that gets called when instantatiator is needed by a deserializer.

Parameters:
instantiators Object that can provide com.fasterxml.jackson.databind.deser.ValueInstantiators for constructing POJO values during deserialization
        public void addValueInstantiators(ValueInstantiators instantiators);
        
        
Method for registering specified AnnotationIntrospector as the highest priority introspector (will be chained with existing introspector(s) which will be used as fallbacks for cases this introspector does not handle)

Parameters:
ai Annotation introspector to register.
        public void insertAnnotationIntrospector(AnnotationIntrospector ai);

        
Method for registering specified AnnotationIntrospector as the lowest priority introspector, chained with existing introspector(s) and called as fallback for cases not otherwise handled.

Parameters:
ai Annotation introspector to register.
        public void appendAnnotationIntrospector(AnnotationIntrospector ai);

        
Method for registering specified classes as subtypes (of supertype(s) they have)
        public void registerSubtypes(Class<?>... subtypes);

        
Method for registering specified classes as subtypes (of supertype(s) they have), using specified type names.
        public void registerSubtypes(NamedType... subtypes);
        
        
Method used for defining mix-in annotations to use for augmenting specified class or interface. All annotations from mixinSource are taken to override annotations that target (or its supertypes) has.

Note: mix-ins are registered both for serialization and deserialization (which can be different internally).

Note: currently only one set of mix-in annotations can be defined for a single class; so if multiple modules register mix-ins, highest priority one (last one registered) will have priority over other modules.

Parameters:
target Class (or interface) whose annotations to effectively override
mixinSource Class (or interface) whose annotations are to be "added" to target's annotations, overriding as necessary
        public void setMixInAnnotations(Class<?> targetClass<?> mixinSource);

        
Add a deserialization problem handler

Parameters:
handler The deserialization problem handler
    }
New to GrepCode? Check out our FAQ X