org.glassfish.jersey.media/jersey-media-json-jackson/2.30.1

https://projects.eclipse.org/projects/ee4j.jersey/project/jersey-media-json-jackson: Jersey JSON Jackson (2.x) entity providers support module. (Eclipse Foundation)

Petr Bouda
Pavel Bucek (Oracle Corporation)
Michal Gajdos
Petr Janouch
Libor Kramolis
Adam Lindenthal
Jakub Podlesak (Oracle Corporation)
Marek Potociar
Stepan Vavra

Roman Grigoriadi (Oracle Corporation)
Lukas Jungmann (Oracle Corporation)
Dmitry Kornilov (Oracle Corporation)
Tomas Kraus (Oracle Corporation)
Tomas Langer (Oracle Corporation)
Maxim Nesen (Oracle Corporation)
Santiago Pericas-Geertsen (Oracle Corporation)
Jan Supol (Oracle Corporation)

directory

Dependencies

com.fasterxml.jackson.core/jackson-annotations/2.10.1
com.fasterxml.jackson.core/jackson-core/2.10.1
com.fasterxml.jackson.core/jackson-databind/2.10.1
com.fasterxml.jackson.module/jackson-module-jaxb-annotations/2.10.1
jakarta.activation/jakarta.activation-api/1.2.1
jakarta.annotation/jakarta.annotation-api/1.3.5
jakarta.ws.rs/jakarta.ws.rs-api/2.1.6
jakarta.xml.bind/jakarta.xml.bind-api/2.3.2
java/11
org.glassfish.hk2.external/jakarta.inject/2.6.1
org.glassfish.hk2/osgi-resource-locator/1.0.3
org.glassfish.jersey.core/jersey-common/2.30.1
org.glassfish.jersey.ext/jersey-entity-filtering/2.30.1

directory

Declarations

org
- glassfish
  - jersey
    - jackson
      - JacksonFeature
        
        JSON_FEATURE: String
        
        registerExceptionMappers: boolean
        
        JacksonFeature(): void
        
        JacksonFeature(boolean): void
        
        withExceptionMappers(): JacksonFeature
        
        withoutExceptionMappers(): JacksonFeature
        
        configure(FeatureContext): boolean
      - internal
        
        FilteringJacksonJaxbJsonProvider
        
        provider: Provider<ObjectProvider<FilterProvider>>
        
        _configForWriting(ObjectMapper, Annotation[], Class<Object>): JsonEndpointConfig
        
        $1
        
        findFilterId(Annotated): Object
        
        writeTo(Object, Class<Object>, Type, Annotation[], MediaType, MultivaluedMap<String, Object>, OutputStream): void
        
        FilteringObjectWriterModifier
        
        original: ObjectWriterModifier
        
        filterProvider: FilterProvider
        
        FilteringObjectWriterModifier(FilterProvider, ObjectWriterModifier): void
        
        modify(EndpointConfigBase<EndpointConfigBase>, MultivaluedMap<String, Object>, Object, ObjectWriter, JsonGenerator): ObjectWriter
        
        $FilteringObjectWriterModifier$1
        
        findFilter(Object): BeanPropertyFilter
        
        findPropertyFilter(Object, Object): PropertyFilter
        
        JacksonAutoDiscoverable
        
        configure(FeatureContext): void
        
        JacksonFilteringFeature
        
        configure(FeatureContext): boolean
        
        Binder
        
        configure(): void
        
        $Binder$1
        
        $Binder$2
        
        JacksonObjectProvider
        
        transform(ObjectGraph): FilterProvider
        
        createSubfilters(Class<Object>, Map<String, ObjectGraph>): Map<String, FilteringPropertyFilter>
        
        createSubfilters(String, Class<Object>, Map<String, ObjectGraph>, Set<String>): Map<String, FilteringPropertyFilter>
        
        FilteringFilterProvider
        
        root: FilteringPropertyFilter
        
        stack: Stack<FilteringPropertyFilter>
        
        FilteringFilterProvider(FilteringPropertyFilter): void
        
        findFilter(Object): BeanPropertyFilter
        
        findPropertyFilter(Object, Object): PropertyFilter
        
        FilteringPropertyFilter
        
        entityClass: Class<Object>
        
        fields: Set<String>
        
        subfilters: Map<String, FilteringPropertyFilter>
        
        FilteringPropertyFilter(Class<Object>, Set<String>, Map<String, FilteringPropertyFilter>): void
        
        include(String): boolean
        
        serializeAsField(Object, JsonGenerator, SerializerProvider, PropertyWriter): void
        
        serializeAsElement(Object, JsonGenerator, SerializerProvider, PropertyWriter): void
        
        depositSchemaProperty(PropertyWriter, ObjectNode, SerializerProvider): void
        
        depositSchemaProperty(PropertyWriter, JsonObjectFormatVisitor, SerializerProvider): void
        
        findSubfilter(String): FilteringPropertyFilter
        
        getEntityClass(): Class<Object>
        
        jackson
        
        jaxrs
        
        annotation
        
        JacksonFeatures
        
        deserializationEnable(): DeserializationFeature[]
        
        deserializationDisable(): DeserializationFeature[]
        
        serializationEnable(): SerializationFeature[]
        
        serializationDisable(): SerializationFeature[]
        
        base
        
        JsonMappingExceptionMapper
        
        toResponse(JsonMappingException): Response
        
        JsonParseExceptionMapper
        
        toResponse(JsonParseException): Response
        
        ProviderBase
        
        HEADER_CONTENT_TYPE_OPTIONS: String
        
        DEFAULT_UNTOUCHABLES: HashSet<ClassKey>
        
        static class initializer
        
        DEFAULT_UNREADABLES: Class[]
        
        DEFAULT_UNWRITABLES: Class[]
        
        JAXRS_FEATURE_DEFAULTS: int
        
        _mapperConfig: MapperConfiguratorBase
        
        _cfgCustomUntouchables: HashMap<ClassKey, Boolean>
        
        _cfgCheckCanSerialize: boolean
        
        _cfgCheckCanDeserialize: boolean
        
        _jaxRSFeatures: int
        
        _defaultReadView: Class<Object>
        
        _defaultWriteView: Class<Object>
        
        _untouchables: HashSet<ClassKey>
        
        _unreadableClasses: Class[]
        
        _unwritableClasses: Class[]
        
        _readers: LRUMap<AnnotationBundleKey, EndpointConfigBase>
        
        _writers: LRUMap<AnnotationBundleKey, EndpointConfigBase>
        
        _noContentExceptionRef: AtomicReference<IOException>
        
        ProviderBase(MapperConfiguratorBase): void
        
        ProviderBase(): void
        
        checkCanDeserialize(boolean): void
        
        checkCanSerialize(boolean): void
        
        addUntouchable(Class<Object>): void
        
        removeUntouchable(Class<Object>): void
        
        setAnnotationsToUse(Annotations[]): void
        
        setMapper(ObjectMapper): void
        
        setDefaultReadView(Class<Object>): ProviderBase
        
        setDefaultWriteView(Class<Object>): ProviderBase
        
        setDefaultView(Class<Object>): ProviderBase
        
        configure(JaxRSFeature, boolean): ProviderBase
        
        enable(JaxRSFeature): ProviderBase
        
        enable(JaxRSFeature, JaxRSFeature[]): ProviderBase
        
        disable(JaxRSFeature): ProviderBase
        
        disable(JaxRSFeature, JaxRSFeature[]): ProviderBase
        
        isEnabled(JaxRSFeature): boolean
        
        configure(DeserializationFeature, boolean): ProviderBase
        
        enable(DeserializationFeature): ProviderBase
        
        disable(DeserializationFeature): ProviderBase
        
        configure(SerializationFeature, boolean): ProviderBase
        
        enable(SerializationFeature): ProviderBase
        
        disable(SerializationFeature): ProviderBase
        
        enable(Feature): ProviderBase
        
        enable(Feature): ProviderBase
        
        disable(Feature): ProviderBase
        
        disable(Feature): ProviderBase
        
        configure(Feature, boolean): ProviderBase
        
        configure(Feature, boolean): ProviderBase
        
        hasMatchingMediaTypeForReading(MediaType): boolean
        
        hasMatchingMediaTypeForWriting(MediaType): boolean
        
        hasMatchingMediaType(MediaType): boolean
        
        _locateMapperViaProvider(Class<Object>, MediaType): ObjectMapper
        
        _configForReading(ObjectMapper, Annotation[], Class<Object>): EndpointConfigBase
        
        _configForWriting(ObjectMapper, Annotation[], Class<Object>): EndpointConfigBase
        
        _configForReading(ObjectReader, Annotation[]): EndpointConfigBase
        
        _configForWriting(ObjectWriter, Annotation[]): EndpointConfigBase
        
        getSize(Object, Class<Object>, Type, Annotation[], MediaType): long
        
        isWriteable(Class<Object>, Type, Annotation[], MediaType): boolean
        
        writeTo(Object, Class<Object>, Type, Annotation[], MediaType, MultivaluedMap<String, Object>, OutputStream): void
        
        findEncoding(MediaType, MultivaluedMap<String, Object>): JsonEncoding
        
        _modifyHeaders(Object, Class<Object>, Type, Annotation[], MultivaluedMap<String, Object>, EndpointConfigBase): void
        
        _createGenerator(ObjectWriter, OutputStream, JsonEncoding): JsonGenerator
        
        _endpointForWriting(Object, Class<Object>, Type, Annotation[], MediaType, MultivaluedMap<String, Object>): EndpointConfigBase
        
        isReadable(Class<Object>, Type, Annotation[], MediaType): boolean
        
        readFrom(Class<Object>, Type, Annotation[], MediaType, MultivaluedMap<String, String>, InputStream): Object
        
        _createParser(ObjectReader, InputStream): JsonParser
        
        _endpointForReading(Class<Object>, Type, Annotation[], MediaType, MultivaluedMap<String, String>): EndpointConfigBase
        
        locateMapper(Class<Object>, MediaType): ObjectMapper
        
        _isSpecialReadable(Class<Object>): boolean
        
        _isIgnorableForReading(ClassKey): boolean
        
        _isIgnorableForWriting(ClassKey): boolean
        
        _createNoContentException(): IOException
        
        _containedIn(Class<Object>, HashSet<ClassKey>): boolean
        
        _findCustomUntouchable(Class<Object>): Boolean
        
        findSuperTypes(Class<Object>, Class<Object>): List<Class<Object>>
        
        findSuperTypes(Class<Object>, Class<Object>, List<Class<Object>>): List<Class<Object>>
        
        _addSuperTypes(Class<Object>, Class<Object>, Collection<Class<Object>>, boolean): void
        
        _this(): ProviderBase
        
        cfg
        
        AnnotationBundleKey
        
        NO_ANNOTATIONS: Annotation[]
        
        _annotations: Annotation[]
        
        _type: Class<Object>
        
        _annotationsCopied: boolean
        
        _hashCode: int
        
        AnnotationBundleKey(Annotation[], Class<Object>): void
        
        AnnotationBundleKey(Annotation[], Class<Object>, int): void
        
        calcHash(Annotation[]): int
        
        immutableKey(): AnnotationBundleKey
        
        hashCode(): int
        
        toString(): String
        
        equals(Object): boolean
        
        _equals(Annotation[]): boolean
        
        Annotations
        
        JACKSON: Annotations
        
        JAXB: Annotations
        
        EndpointConfigBase
        
        _config: MapperConfig<MapperConfig>
        
        _activeView: Class<Object>
        
        _rootName: String
        
        _deserEnable: DeserializationFeature[]
        
        _deserDisable: DeserializationFeature[]
        
        _reader: ObjectReader
        
        _serEnable: SerializationFeature[]
        
        _serDisable: SerializationFeature[]
        
        _writer: ObjectWriter
        
        EndpointConfigBase(MapperConfig<MapperConfig>): void
        
        add(Annotation[], boolean): EndpointConfigBase
        
        addAnnotation(Class<Annotation>, Annotation, boolean): void
        
        initReader(ObjectReader): EndpointConfigBase
        
        initWriter(ObjectWriter): EndpointConfigBase
        
        getRootName(): String
        
        getActiveView(): Class<Object>
        
        getReader(): ObjectReader
        
        getWriter(): ObjectWriter
        
        modifyBeforeWrite(Object): Object
        
        nullIfEmpty(Object[]): Object[]
        
        JaxRSFeature
        
        ALLOW_EMPTY_INPUT: JaxRSFeature
        
        ADD_NO_SNIFF_HEADER: JaxRSFeature
        
        DYNAMIC_OBJECT_MAPPER_LOOKUP: JaxRSFeature
        
        CACHE_ENDPOINT_READERS: JaxRSFeature
        
        CACHE_ENDPOINT_WRITERS: JaxRSFeature
        
        _defaultState: boolean
        
        JaxRSFeature(boolean): void
        
        collectDefaults(): int
        
        enabledByDefault(): boolean
        
        getMask(): int
        
        enabledIn(int): boolean
        
        MapperConfiguratorBase
        
        _mapper: ObjectMapper
        
        _defaultMapper: ObjectMapper
        
        _defaultAnnotationsToUse: Annotations[]
        
        _jaxbIntrospectorClass: Class<AnnotationIntrospector>
        
        MapperConfiguratorBase(ObjectMapper, Annotations[]): void
        
        getConfiguredMapper(): ObjectMapper
        
        getDefaultMapper(): ObjectMapper
        
        mapper(): ObjectMapper
        
        _resolveIntrospectors(Annotations[]): AnnotationIntrospector
        
        setMapper(ObjectMapper): void
        
        setAnnotationsToUse(Annotations[]): void
        
        configure(DeserializationFeature, boolean): void
        
        configure(SerializationFeature, boolean): void
        
        configure(Feature, boolean): void
        
        configure(Feature, boolean): void
        
        _setAnnotations(ObjectMapper, Annotations[]): void
        
        ObjectReaderInjector
        
        _threadLocal: ThreadLocal<ObjectReaderModifier>
        
        _hasBeenSet: AtomicBoolean
        
        ObjectReaderInjector(): void
        
        set(ObjectReaderModifier): void
        
        get(): ObjectReaderModifier
        
        getAndClear(): ObjectReaderModifier
        
        ObjectReaderModifier
        
        modify(EndpointConfigBase<EndpointConfigBase>, MultivaluedMap<String, String>, JavaType, ObjectReader, JsonParser): ObjectReader
        
        ObjectWriterInjector
        
        _threadLocal: ThreadLocal<ObjectWriterModifier>
        
        _hasBeenSet: AtomicBoolean
        
        ObjectWriterInjector(): void
        
        set(ObjectWriterModifier): void
        
        get(): ObjectWriterModifier
        
        getAndClear(): ObjectWriterModifier
        
        ObjectWriterModifier
        
        modify(EndpointConfigBase<EndpointConfigBase>, MultivaluedMap<String, Object>, Object, ObjectWriter, JsonGenerator): ObjectWriter
        
        json
        
        JacksonJaxbJsonProvider
        
        DEFAULT_ANNOTATIONS: Annotations[]
        
        JacksonJaxbJsonProvider(): void
        
        JacksonJaxbJsonProvider(Annotations[]): void
        
        JacksonJaxbJsonProvider(ObjectMapper, Annotations[]): void
        
        JacksonJsonProvider
        
        MIME_JAVASCRIPT: String
        
        MIME_JAVASCRIPT_MS: String
        
        BASIC_ANNOTATIONS: Annotations[]
        
        _jsonpFunctionName: String
        
        _providers: Providers
        
        JacksonJsonProvider(): void
        
        JacksonJsonProvider(Annotations[]): void
        
        JacksonJsonProvider(ObjectMapper): void
        
        JacksonJsonProvider(ObjectMapper, Annotations[]): void
        
        version(): Version
        
        setJSONPFunctionName(String): void
        
        hasMatchingMediaType(MediaType): boolean
        
        _locateMapperViaProvider(Class<Object>, MediaType): ObjectMapper
        
        _configForReading(ObjectReader, Annotation[]): JsonEndpointConfig
        
        _configForWriting(ObjectWriter, Annotation[]): JsonEndpointConfig
        
        JsonEndpointConfig
        
        _jsonp: Def
        
        JsonEndpointConfig(MapperConfig<MapperConfig>): void
        
        forReading(ObjectReader, Annotation[]): JsonEndpointConfig
        
        forWriting(ObjectWriter, Annotation[], String): JsonEndpointConfig
        
        addAnnotation(Class<Annotation>, Annotation, boolean): void
        
        modifyBeforeWrite(Object): Object
        
        applyJSONP(Object): Object
        
        JsonMapperConfigurator
        
        JsonMapperConfigurator(ObjectMapper, Annotations[]): void
        
        getConfiguredMapper(): ObjectMapper
        
        getDefaultMapper(): ObjectMapper
        
        mapper(): ObjectMapper
        
        _resolveIntrospectors(Annotations[]): AnnotationIntrospector
        
        _resolveIntrospector(Annotations): AnnotationIntrospector
        
        PackageVersion
        
        VERSION: Version
        
        version(): Version
        
        annotation
        
        JSONP
        
        value(): String
        
        prefix(): String
        
        suffix(): String
        
        Def
        
        method: String
        
        prefix: String
        
        suffix: String
        
        Def(String): void
        
        Def(JSONP): void
        
        emptyAsNull(String): String
        
        util
        
        ClassKey
        
        _className: String
        
        _class: Class<Object>
        
        _hashCode: int
        
        ClassKey(): void
        
        ClassKey(Class<Object>): void
        
        reset(Class<Object>): void
        
        compareTo(ClassKey): int
        
        equals(Object): boolean
        
        hashCode(): int
        
        toString(): String
        
        EndpointAsBeanProperty
        
        serialVersionUID: long
        
        ENDPOINT_NAME: PropertyName
        
        NO_ANNOTATIONS: AnnotationMap
        
        _rawAnnotations: Annotation[]
        
        _annotations: AnnotationMap
        
        EndpointAsBeanProperty(PropertyName, JavaType, Annotation[]): void
        
        EndpointAsBeanProperty(EndpointAsBeanProperty, JavaType): void
        
        withType(JavaType): Std
        
        getAnnotation(Class<Annotation>): Annotation
        
        annotations(): AnnotationMap
        
        LRUMap
        
        _maxEntries: int
        
        LRUMap(int, int): void
        
        removeEldestEntry(Entry<Object, Object>): boolean

directory

Java files

org/glassfish/jersey/jackson/

directory

Class files

org/glassfish/jersey/jackson/