com.fasterxml.jackson.jr/jackson-jr-objects/2.11.0

http://wiki.fasterxml.com/JacksonHome: Simple data-binding that builds directly on jackson-core (streaming), has no other dependencies, and provides additional builder-style content generator (FasterXML)

The Apache Software License, Version 2.0

Tatu Saloranta
Christopher Currie
Paul Brown

directory

Dependencies

directory

Declarations

com
- fasterxml
  - jackson
    - jr
      - ob
        
        JSON
        
        Feature
        
        USE_BIG_DECIMAL_FOR_FLOATS: Feature
        
        READ_JSON_ARRAYS_AS_JAVA_ARRAYS: Feature
        
        READ_ONLY: Feature
        
        PRESERVE_FIELD_ORDERING: Feature
        
        USE_DEFERRED_MAPS: Feature
        
        FAIL_ON_DUPLICATE_MAP_KEYS: Feature
        
        FAIL_ON_UNKNOWN_BEAN_PROPERTY: Feature
        
        WRITE_NULL_PROPERTIES: Feature
        
        WRITE_ENUMS_USING_INDEX: Feature
        
        WRITE_DATES_AS_TIMESTAMP: Feature
        
        PRETTY_PRINT_OUTPUT: Feature
        
        FLUSH_AFTER_WRITE_VALUE: Feature
        
        FAIL_ON_UNKNOWN_TYPE_WRITE: Feature
        
        HANDLE_JAVA_BEANS: Feature
        
        WRITE_READONLY_BEAN_PROPERTIES: Feature
        
        FORCE_REFLECTION_ACCESS: Feature
        
        USE_IS_GETTERS: Feature
        
        USE_FIELDS: Feature
        
        _defaultState: boolean
        
        _affectsCaching: boolean
        
        _mask: int
        
        Feature(boolean): void
        
        Feature(boolean, boolean): void
        
        defaults(): int
        
        cacheBreakers(): int
        
        enabledByDefault(): boolean
        
        affectsCaching(): boolean
        
        mask(): int
        
        isDisabled(int): boolean
        
        isEnabled(int): boolean
        
        ExtContextImpl
        
        _builder: Builder
        
        _rwProvider: ReaderWriterProvider
        
        _rwModifier: ReaderWriterModifier
        
        ExtContextImpl(Builder): void
        
        setTreeCodec(TreeCodec): ExtensionContext
        
        treeCodec(): TreeCodec
        
        insertProvider(ReaderWriterProvider): ExtensionContext
        
        appendProvider(ReaderWriterProvider): ExtensionContext
        
        insertModifier(ReaderWriterModifier): ExtensionContext
        
        appendModifier(ReaderWriterModifier): ExtensionContext
        
        DEFAULT_FEATURES: int
        
        CACHE_FLAGS: int
        
        std: JSON
        
        _jsonFactory: JsonFactory
        
        _treeCodec: TreeCodec
        
        _valueReaderLocator: ValueReaderLocator
        
        _valueWriterLocator: ValueWriterLocator
        
        _reader: JSONReader
        
        _writer: JSONWriter
        
        _features: int
        
        _prettyPrinter: PrettyPrinter
        
        Builder
        
        _features: int
        
        _prettyPrinter: PrettyPrinter
        
        _streamFactory: JsonFactory
        
        _treeCodec: TreeCodec
        
        _reader: JSONReader
        
        _writer: JSONWriter
        
        _mapBuilder: MapBuilder
        
        _collectionBuilder: CollectionBuilder
        
        _extContext: ExtContextImpl
        
        Builder(JsonFactory): void
        
        build(): JSON
        
        register(JacksonJrExtension): Builder
        
        set(Feature, boolean): Builder
        
        enable(Feature[]): Builder
        
        disable(Feature[]): Builder
        
        prettyPrinter(PrettyPrinter): Builder
        
        treeCodec(TreeCodec): Builder
        
        jsonReader(JSONReader): Builder
        
        jsonWriter(JSONWriter): Builder
        
        collectionBuilder(CollectionBuilder): Builder
        
        mapBuilder(MapBuilder): Builder
        
        isEnabled(Feature): boolean
        
        featureMask(): int
        
        prettyPrinter(): PrettyPrinter
        
        streamFactory(): JsonFactory
        
        treeCodec(): TreeCodec
        
        readerWriterModifier(): ReaderWriterModifier
        
        readerWriterProvider(): ReaderWriterProvider
        
        jsonReader(): JSONReader
        
        jsonWriter(): JSONWriter
        
        mapBuilder(): MapBuilder
        
        collectionBuilder(): CollectionBuilder
        
        JSON(): void
        
        JSON(JsonFactory): void
        
        JSON(Builder): void
        
        builder(): Builder
        
        builder(JsonFactory): Builder
        
        JSON(JSON, int, JsonFactory, TreeCodec, JSONReader, JSONWriter, PrettyPrinter): void
        
        JSON(JSON, ValueReaderLocator, ValueWriterLocator): void
        
        _defaultReader(): JSONReader
        
        _defaultWriter(): JSONWriter
        
        asCodec(): ObjectCodec
        
        version(): Version
        
        with(PrettyPrinter): JSON
        
        with(Feature, boolean): JSON
        
        with(Feature[]): JSON
        
        without(Feature[]): JSON
        
        _with(int): JSON
        
        with(JsonFactory): JSON
        
        with(TreeCodec): JSON
        
        with(JSONReader): JSON
        
        with(JSONWriter): JSON
        
        with(MapBuilder): JSON
        
        with(CollectionBuilder): JSON
        
        with(ReaderWriterProvider): JSON
        
        _with(int, JsonFactory, TreeCodec, JSONReader, JSONWriter, PrettyPrinter): JSON
        
        getTreeCodec(): TreeCodec
        
        getStreamingFactory(): JsonFactory
        
        isEnabled(Feature): boolean
        
        createParser(Object): JsonParser
        
        asString(Object): String
        
        asBytes(Object): byte[]
        
        write(Object, JsonGenerator): void
        
        write(Object, OutputStream): void
        
        write(Object, Writer): void
        
        write(Object, File): void
        
        composeUsing(JsonGenerator): JSONComposer<OutputStream>
        
        composeTo(OutputStream): JSONComposer<OutputStream>
        
        composeTo(Writer): JSONComposer<OutputStream>
        
        composeTo(File): JSONComposer<OutputStream>
        
        composeString(): JSONComposer<String>
        
        composeBytes(): JSONComposer<byte[]>
        
        composeList(): CollectionComposer<ComposerBase, List<Object>>
        
        composeCollection(Collection): CollectionComposer<ComposerBase, Collection>
        
        composeMap(): MapComposer<ComposerBase>
        
        composeMap(Map<String, Object>): MapComposer<ComposerBase>
        
        listFrom(Object): List<Object>
        
        listOfFrom(Class<Object>, Object): List<Object>
        
        arrayFrom(Object): Object[]
        
        arrayOfFrom(Class<Object>, Object): Object[]
        
        mapFrom(Object): Map<String, Object>
        
        mapOfFrom(Class<Object>, Object): Map<String, Object>
        
        beanFrom(Class<Object>, Object): Object
        
        anyFrom(Object): Object
        
        treeFrom(Object): TreeNode
        
        beanSequenceFrom(Class<Object>, Object): ValueIterator<Object>
        
        anySequenceFrom(Object): ValueIterator<Object>
        
        treeSequenceFrom(Object): ValueIterator<TreeNode>
        
        createArrayNode(): TreeNode
        
        createObjectNode(): TreeNode
        
        _writeAndClose(Object, JsonGenerator): void
        
        _writerForOperation(JsonGenerator): JSONWriter
        
        _readerForOperation(JsonParser): JSONReader
        
        _parser(Object): JsonParser
        
        _initForReading(JsonParser): JsonParser
        
        _config(JsonGenerator): JsonGenerator
        
        _config(JsonParser): JsonParser
        
        _closeWithError(Closeable, Exception): Object
        
        _close(Closeable): void
        
        _throw(Exception): Object
        
        _noTreeCodec(String): void
        
        JSONComposer
        
        _features: int
        
        _closeGenerator: boolean
        
        _result: Object
        
        _stringWriter: SegmentedStringWriter
        
        _byteWriter: ByteArrayBuilder
        
        JSONComposer(int, JsonGenerator, boolean): void
        
        JSONComposer(int, JsonGenerator, SegmentedStringWriter): void
        
        JSONComposer(int, JsonGenerator, ByteArrayBuilder): void
        
        JSONComposer(int, Object): void
        
        streamComposer(int, JsonGenerator, boolean): JSONComposer<Object>
        
        stringComposer(int, JsonGenerator, SegmentedStringWriter): JSONComposer<String>
        
        bytesComposer(int, JsonGenerator, ByteArrayBuilder): JSONComposer<byte[]>
        
        collectionComposer(int, Collection): JSONComposer<Collection>
        
        mapComposer(int, Map<String, Object>): JSONComposer<Map<String, Object>>
        
        finish(): Object
        
        _start(): JSONComposer<Object>
        
        _finish(): Object
        
        JSONObjectException
        
        serialVersionUID: long
        
        MAX_REFS_TO_LIST: int
        
        Reference
        
        serialVersionUID: long
        
        _from: Object
        
        _fieldName: String
        
        _index: int
        
        Reference(): void
        
        Reference(Object): void
        
        Reference(Object, String): void
        
        Reference(Object, int): void
        
        setFrom(Object): void
        
        setFieldName(String): void
        
        setIndex(int): void
        
        getFrom(): Object
        
        getFieldName(): String
        
        getIndex(): int
        
        toString(): String
        
        _path: LinkedList<Reference>
        
        JSONObjectException(String): void
        
        JSONObjectException(String, Throwable): void
        
        JSONObjectException(String, JsonLocation): void
        
        JSONObjectException(String, JsonLocation, Throwable): void
        
        from(JsonParser, String): JSONObjectException
        
        from(JsonParser, String, Object[]): JSONObjectException
        
        from(JsonParser, Throwable, String, Object[]): JSONObjectException
        
        fromUnexpectedIOE(IOException): JSONObjectException
        
        wrapWithPath(Throwable, Object, String): JSONObjectException
        
        wrapWithPath(Throwable, Object, int): JSONObjectException
        
        wrapWithPath(Throwable, Reference): JSONObjectException
        
        getPath(): List<Reference>
        
        getPathReference(): String
        
        getPathReference(StringBuilder): StringBuilder
        
        prependPath(Object, String): void
        
        prependPath(Object, int): void
        
        prependPath(Reference): void
        
        getLocalizedMessage(): String
        
        getMessage(): String
        
        _buildMessage(): String
        
        toString(): String
        
        _appendPathDesc(StringBuilder): void
        
        JacksonJrExtension
        
        register(ExtensionContext): void
        
        PackageVersion
        
        VERSION: Version
        
        version(): Version
        
        ValueIterator
        
        MODE_BEAN: int
        
        MODE_ANY: int
        
        MODE_TREE: int
        
        EMPTY_ITERATOR: ValueIterator<Object>
        
        STATE_CLOSED: int
        
        STATE_NEED_RESYNC: int
        
        STATE_MAY_HAVE_VALUE: int
        
        STATE_HAS_VALUE: int
        
        _mode: int
        
        _type: Class<Object>
        
        _reader: JSONReader
        
        _treeCodec: TreeCodec
        
        _parser: JsonParser
        
        _seqContext: JsonStreamContext
        
        _closeParser: boolean
        
        _state: int
        
        ValueIterator(int, Class<Object>, JsonParser, JSONReader, TreeCodec, boolean): void
        
        emptyIterator(): ValueIterator<Object>
        
        hasNext(): boolean
        
        next(): Object
        
        remove(): void
        
        close(): void
        
        hasNextValue(): boolean
        
        nextValue(): Object
        
        readAll(): List<Object>
        
        readAll(List): List
        
        readAll(Collection): Collection
        
        getParser(): JsonParser
        
        getCurrentLocation(): JsonLocation
        
        _resync(): void
        
        _throwNoSuchElement(): Object
        
        _handleMappingException(JSONObjectException): Object
        
        _handleIOException(IOException): Object
        
        api
        
        CollectionBuilder
        
        EMPTY_ARRAY: Object[]
        
        _features: int
        
        _collectionType: Class<Object>
        
        CollectionBuilder(int, Class<Object>): void
        
        defaultImpl(): CollectionBuilder
        
        newBuilder(int): CollectionBuilder
        
        newBuilder(Class<Object>): CollectionBuilder
        
        newBuilder(): CollectionBuilder
        
        isEnabled(Feature): boolean
        
        start(): CollectionBuilder
        
        add(Object): CollectionBuilder
        
        buildCollection(): Collection<Object>
        
        buildArray(): Object[]
        
        buildArray(Class<Object>): Object[]
        
        emptyCollection(): Collection<Object>
        
        emptyArray(): Object[]
        
        emptyArray(Class<Object>): Object[]
        
        singletonCollection(Object): Collection<Object>
        
        singletonArray(Object): Object[]
        
        singletonArray(Class<Object>, Object): Object[]
        
        Default
        
        _current: Collection<Object>
        
        Default(int, Class<Object>): void
        
        newBuilder(int): CollectionBuilder
        
        newBuilder(Class<Object>): CollectionBuilder
        
        start(): CollectionBuilder
        
        buildCollection(): Collection<Object>
        
        buildArray(): Object[]
        
        add(Object): CollectionBuilder
        
        emptyCollection(): Collection<Object>
        
        _list(int): Collection<Object>
        
        ExtensionContext
        
        setTreeCodec(TreeCodec): ExtensionContext
        
        treeCodec(): TreeCodec
        
        insertProvider(ReaderWriterProvider): ExtensionContext
        
        appendProvider(ReaderWriterProvider): ExtensionContext
        
        insertModifier(ReaderWriterModifier): ExtensionContext
        
        appendModifier(ReaderWriterModifier): ExtensionContext
        
        MapBuilder
        
        _features: int
        
        _checkDups: boolean
        
        _mapType: Class<Object>
        
        MapBuilder(int, Class<Object>): void
        
        defaultImpl(): MapBuilder
        
        newBuilder(int): MapBuilder
        
        newBuilder(Class<Object>): MapBuilder
        
        newBuilder(): MapBuilder
        
        isEnabled(Feature): boolean
        
        start(): MapBuilder
        
        put(String, Object): MapBuilder
        
        build(): Map<String, Object>
        
        emptyMap(): Map<String, Object>
        
        singletonMap(String, Object): Map<String, Object>
        
        Default
        
        _current: Map<String, Object>
        
        Default(int, Class<Object>): void
        
        newBuilder(int): MapBuilder
        
        newBuilder(Class<Object>): MapBuilder
        
        start(): MapBuilder
        
        build(): Map<String, Object>
        
        put(String, Object): MapBuilder
        
        emptyMap(): Map<String, Object>
        
        _map(int): Map<String, Object>
        
        ReaderWriterModifier
        
        pojoDefinitionForDeserialization(JSONReader, Class<Object>): POJODefinition
        
        pojoDefinitionForSerialization(JSONWriter, Class<Object>): POJODefinition
        
        modifyValueReader(JSONReader, Class<Object>, ValueReader): ValueReader
        
        modifyValueWriter(JSONWriter, Class<Object>, ValueWriter): ValueWriter
        
        overrideStandardValueWriter(JSONWriter, Class<Object>, int): ValueWriter
        
        Pair
        
        _primary: ReaderWriterModifier
        
        _secondary: ReaderWriterModifier
        
        Pair(ReaderWriterModifier, ReaderWriterModifier): void
        
        of(ReaderWriterModifier, ReaderWriterModifier): ReaderWriterModifier
        
        pojoDefinitionForDeserialization(JSONReader, Class<Object>): POJODefinition
        
        pojoDefinitionForSerialization(JSONWriter, Class<Object>): POJODefinition
        
        modifyValueReader(JSONReader, Class<Object>, ValueReader): ValueReader
        
        modifyValueWriter(JSONWriter, Class<Object>, ValueWriter): ValueWriter
        
        overrideStandardValueWriter(JSONWriter, Class<Object>, int): ValueWriter
        
        ReaderWriterProvider
        
        findValueReader(JSONReader, Class<Object>): ValueReader
        
        findCollectionReader(JSONReader, Class<Object>, ResolvedType, ValueReader): ValueReader
        
        findMapReader(JSONReader, Class<Object>, ResolvedType, ValueReader): ValueReader
        
        findValueWriter(JSONWriter, Class<Object>): ValueWriter
        
        Pair
        
        _secondary: ReaderWriterProvider
        
        _primary: ReaderWriterProvider
        
        Pair(ReaderWriterProvider, ReaderWriterProvider): void
        
        of(ReaderWriterProvider, ReaderWriterProvider): ReaderWriterProvider
        
        findValueReader(JSONReader, Class<Object>): ValueReader
        
        findCollectionReader(JSONReader, Class<Object>, ResolvedType, ValueReader): ValueReader
        
        findMapReader(JSONReader, Class<Object>, ResolvedType, ValueReader): ValueReader
        
        findValueWriter(JSONWriter, Class<Object>): ValueWriter
        
        ValueReader
        
        _valueType: Class<Object>
        
        ValueReader(Class<Object>): void
        
        read(JSONReader, JsonParser): Object
        
        readNext(JSONReader, JsonParser): Object
        
        valueType(): Class<Object>
        
        _tokenDesc(JsonParser): String
        
        _tokenDesc(JsonParser, JsonToken): String
        
        ValueWriter
        
        writeValue(JSONWriter, JsonGenerator, Object): void
        
        valueType(): Class<Object>
        
        comp
        
        ArrayComposer
        
        _parent: ComposerBase
        
        ArrayComposer(ComposerBase, JsonGenerator): void
        
        _start(): ArrayComposer<ComposerBase>
        
        _finish(): Object
        
        end(): ComposerBase
        
        CollectionComposer
        
        _parent: ComposerBase
        
        _collection: Collection
        
        CollectionComposer(ComposerBase): void
        
        CollectionComposer(Collection): void
        
        rootComposer(Collection): CollectionComposer<ComposerBase, Collection>
        
        flush(): void
        
        _start(): CollectionComposer<ComposerBase, Collection>
        
        _finish(): Collection
        
        startArray(): CollectionComposer<CollectionComposer<ComposerBase, Collection>, Collection>
        
        startObject(): MapComposer<CollectionComposer<ComposerBase, Collection>>
        
        finish(): Collection
        
        add(int): CollectionComposer<ComposerBase, Collection>
        
        add(long): CollectionComposer<ComposerBase, Collection>
        
        add(double): CollectionComposer<ComposerBase, Collection>
        
        add(String): CollectionComposer<ComposerBase, Collection>
        
        add(CharSequence): CollectionComposer<ComposerBase, Collection>
        
        addNull(): CollectionComposer<ComposerBase, Collection>
        
        add(boolean): CollectionComposer<ComposerBase, Collection>
        
        addObject(Object): CollectionComposer<ComposerBase, Collection>
        
        end(): ComposerBase
        
        constructCollection(): Collection
        
        _closeChild(): void
        
        ComposerBase
        
        _child: ComposerBase
        
        _open: boolean
        
        ComposerBase(): void
        
        _start(): ComposerBase
        
        _finish(): Object
        
        _safeFinish(): Object
        
        _childClosed(): void
        
        _illegalCall(): IllegalStateException
        
        _startArray(ComposerBase, JsonGenerator): ArrayComposer<ComposerBase>
        
        _startObject(ComposerBase, JsonGenerator): ObjectComposer<ComposerBase>
        
        _startCollection(ComposerBase): CollectionComposer<ComposerBase, Collection>
        
        _startMap(ComposerBase): MapComposer<ComposerBase>
        
        MapComposer
        
        _fieldName: String
        
        _parent: ComposerBase
        
        _map: Map<String, Object>
        
        MapComposer(ComposerBase): void
        
        MapComposer(Map<String, Object>): void
        
        rootComposer(Map<String, Object>): MapComposer<ComposerBase>
        
        flush(): void
        
        _start(): MapComposer<ComposerBase>
        
        _finish(): Map<String, Object>
        
        startArrayField(String): CollectionComposer<MapComposer<ComposerBase>, Collection>
        
        startArrayField(SerializableString): CollectionComposer<MapComposer<ComposerBase>, Collection>
        
        startObjectField(String): MapComposer<MapComposer<ComposerBase>>
        
        startObjectField(SerializableString): MapComposer<MapComposer<ComposerBase>>
        
        end(): ComposerBase
        
        finish(): Map<String, Object>
        
        put(String, boolean): MapComposer<ComposerBase>
        
        putNull(String): MapComposer<ComposerBase>
        
        put(String, int): MapComposer<ComposerBase>
        
        put(String, long): MapComposer<ComposerBase>
        
        put(String, double): MapComposer<ComposerBase>
        
        put(String, String): MapComposer<ComposerBase>
        
        put(String, CharSequence): MapComposer<ComposerBase>
        
        constructMap(): Map<String, Object>
        
        _closeChild(): void
        
        ObjectComposer
        
        _parent: ComposerBase
        
        _generator: JsonGenerator
        
        ObjectComposer(ComposerBase, JsonGenerator): void
        
        flush(): void
        
        _start(): ObjectComposer<ComposerBase>
        
        _finish(): Object
        
        startArrayField(String): ArrayComposer<ObjectComposer<ComposerBase>>
        
        startArrayField(SerializableString): ArrayComposer<ObjectComposer<ComposerBase>>
        
        startObjectField(String): ObjectComposer<ObjectComposer<ComposerBase>>
        
        startObjectField(SerializableString): ObjectComposer<ObjectComposer<ComposerBase>>
        
        end(): ComposerBase
        
        put(String, boolean): ObjectComposer<ComposerBase>
        
        putNull(String): ObjectComposer<ComposerBase>
        
        putObject(String, Object): ObjectComposer<ComposerBase>
        
        put(String, int): ObjectComposer<ComposerBase>
        
        put(String, long): ObjectComposer<ComposerBase>
        
        put(String, double): ObjectComposer<ComposerBase>
        
        put(String, String): ObjectComposer<ComposerBase>
        
        put(String, CharSequence): ObjectComposer<ComposerBase>
        
        _closeChild(): void
        
        SequenceComposer
        
        _generator: JsonGenerator
        
        SequenceComposer(JsonGenerator): void
        
        flush(): void
        
        startArray(): ArrayComposer<SequenceComposer>
        
        startObject(): ObjectComposer<SequenceComposer>
        
        add(int): SequenceComposer
        
        add(long): SequenceComposer
        
        add(double): SequenceComposer
        
        add(String): SequenceComposer
        
        add(CharSequence): SequenceComposer
        
        addNull(): SequenceComposer
        
        add(boolean): SequenceComposer
        
        addObject(Object): SequenceComposer
        
        _closeChild(): void
        
        _this(): SequenceComposer
        
        impl
        
        AnyReader
        
        std: AnyReader
        
        AnyReader(): void
        
        readNext(JSONReader, JsonParser): Object
        
        read(JSONReader, JsonParser): Object
        
        readFromObject(JSONReader, JsonParser, MapBuilder): Map<String, Object>
        
        readArrayFromArray(JSONReader, JsonParser, CollectionBuilder): Object[]
        
        readCollectionFromArray(JSONReader, JsonParser, CollectionBuilder): Collection<Object>
        
        fromNull(): Object
        
        fromBoolean(boolean): Object
        
        fromKey(String): String
        
        fromString(String): Object
        
        fromEmbedded(Object): Object
        
        ArrayReader
        
        _elementType: Class<Object>
        
        _valueReader: ValueReader
        
        ArrayReader(Class<Object>, Class<Object>, ValueReader): void
        
        readNext(JSONReader, JsonParser): Object
        
        read(JSONReader, JsonParser): Object
        
        BeanPropertyIntrospector
        
        NO_PROPS: Prop[]
        
        INSTANCE: BeanPropertyIntrospector
        
        BeanPropertyIntrospector(): void
        
        instance(): BeanPropertyIntrospector
        
        pojoDefinitionForDeserialization(JSONReader, Class<Object>): POJODefinition
        
        pojoDefinitionForSerialization(JSONWriter, Class<Object>): POJODefinition
        
        _construct(Class<Object>): POJODefinition
        
        _introspect(Class<Object>, Map<String, PropBuilder>): void
        
        _propFrom(Map<String, PropBuilder>, String): PropBuilder
        
        decap(String): String
        
        BeanPropertyReader
        
        _name: String
        
        _valueReader: ValueReader
        
        _setter: Method
        
        _field: Field
        
        BeanPropertyReader(String, Field, Method): void
        
        BeanPropertyReader(BeanPropertyReader, ValueReader): void
        
        withReader(ValueReader): BeanPropertyReader
        
        genericSetterType(): Type
        
        rawSetterType(): Class<Object>
        
        getReader(): ValueReader
        
        getName(): String
        
        setValueFor(Object, Object): void
        
        _bean(): String
        
        _rawType(): Class<Object>
        
        toString(): String
        
        BeanPropertyWriter
        
        name: SerializedString
        
        typeId: int
        
        _field: Field
        
        _getter: Method
        
        BeanPropertyWriter(int, String, Field, Method): void
        
        withName(String): BeanPropertyWriter
        
        getValueFor(Object): Object
        
        _bean(): String
        
        BeanReader
        
        _propsByName: Map<String, BeanPropertyReader>
        
        _aliasMapping: Map<String, String>
        
        _ignorableNames: Set<String>
        
        _defaultCtor: Constructor<Object>
        
        _stringCtor: Constructor<Object>
        
        _longCtor: Constructor<Object>
        
        BeanReader(Class<Object>, Map<String, BeanPropertyReader>, Constructor<Object>, Constructor<Object>, Constructor<Object>, Set<String>, Map<String, String>): void
        
        BeanReader(Class<Object>, Map<String, BeanPropertyReader>, Constructor<Object>, Constructor<Object>, Constructor<Object>): void
        
        propertiesByName(): Map<String, BeanPropertyReader>
        
        findProperty(String): BeanPropertyReader
        
        _findAlias(String): BeanPropertyReader
        
        readNext(JSONReader, JsonParser): Object
        
        read(JSONReader, JsonParser): Object
        
        create(): Object
        
        create(String): Object
        
        create(long): Object
        
        handleUnknown(JSONReader, JsonParser, String): void
        
        _reportProblem(JsonParser): IOException
        
        BeanWriter
        
        _properties: BeanPropertyWriter[]
        
        _valueType: Class<Object>
        
        BeanWriter(Class<Object>, BeanPropertyWriter[]): void
        
        writeValue(JSONWriter, JsonGenerator, Object): void
        
        valueType(): Class<Object>
        
        ClassKey
        
        _className: String
        
        _class: Class<Object>
        
        _flags: int
        
        _hashCode: int
        
        ClassKey(): void
        
        ClassKey(Class<Object>, int): void
        
        with(Class<Object>, int): ClassKey
        
        equals(Object): boolean
        
        hashCode(): int
        
        toString(): String
        
        CollectionReader
        
        _collectionType: Class<Object>
        
        _valueReader: ValueReader
        
        CollectionReader(Class<Object>, ValueReader): void
        
        readNext(JSONReader, JsonParser): Object
        
        read(JSONReader, JsonParser): Object
        
        DeferredMap
        
        _map: Map<String, Object>
        
        _entries: Object[]
        
        _end: int
        
        _ordered: boolean
        
        DeferredMap(boolean): void
        
        DeferredMap(boolean, int): void
        
        put(String, Object): Object
        
        entrySet(): Set<Entry<String, Object>>
        
        size(): int
        
        isEmpty(): boolean
        
        containsValue(Object): boolean
        
        containsKey(Object): boolean
        
        get(Object): Object
        
        remove(Object): Object
        
        clear(): void
        
        keySet(): Set<String>
        
        values(): Collection<Object>
        
        equals(Object): boolean
        
        hashCode(): int
        
        toString(): String
        
        clone(): Object
        
        buildIfNeeded(): void
        
        _newSize(int): int
        
        _buildMap(int): Map<String, Object>
        
        EnumReader
        
        _byIndex: Object[]
        
        _byName: Map<String, Object>
        
        EnumReader(Class<Object>, Object[], Map<String, Object>): void
        
        desc(): String
        
        readNext(JSONReader, JsonParser): Object
        
        read(JSONReader, JsonParser): Object
        
        _enum(String): Object
        
        JSONAsObjectCodec
        
        _json: JSON
        
        _jsonFactory: JsonFactory
        
        _treeCodec: TreeCodec
        
        JSONAsObjectCodec(JSON): void
        
        JSONAsObjectCodec(JSON, JsonFactory): void
        
        JSONAsObjectCodec(JSON, JsonFactory, TreeCodec): void
        
        version(): Version
        
        readValue(JsonParser, Class<Object>): Object
        
        readValue(JsonParser, TypeReference<Object>): Object
        
        readValue(JsonParser, ResolvedType): Object
        
        readValues(JsonParser, Class<Object>): Iterator<Object>
        
        readValues(JsonParser, TypeReference<Object>): Iterator<Object>
        
        readValues(JsonParser, ResolvedType): Iterator<Object>
        
        _noTypeReference(): JSONObjectException
        
        writeValue(JsonGenerator, Object): void
        
        createObjectNode(): TreeNode
        
        createArrayNode(): TreeNode
        
        missingNode(): TreeNode
        
        nullNode(): TreeNode
        
        readTree(JsonParser): TreeNode
        
        writeTree(JsonGenerator, TreeNode): void
        
        treeAsTokens(TreeNode): JsonParser
        
        treeToValue(TreeNode, Class<Object>): Object
        
        getFactory(): JsonFactory
        
        getJsonFactory(): JsonFactory
        
        _checkTreeCodec(): TreeCodec
        
        _checkResultType(Class<Object>, Object): void
        
        JSONReader
        
        _mapBuilder: MapBuilder
        
        _collectionBuilder: CollectionBuilder
        
        _features: int
        
        _treeCodec: TreeCodec
        
        _readerLocator: ValueReaderLocator
        
        _parser: JsonParser
        
        JSONReader(CollectionBuilder, MapBuilder): void
        
        JSONReader(JSONReader, int, ValueReaderLocator, TreeCodec, JsonParser): void
        
        withCacheCheck(int): JSONReader
        
        with(MapBuilder): JSONReader
        
        with(CollectionBuilder): JSONReader
        
        _with(CollectionBuilder, MapBuilder): JSONReader
        
        perOperationInstance(int, ValueReaderLocator, TreeCodec, JsonParser): JSONReader
        
        arraysAsLists(): boolean
        
        isEnabled(Feature): boolean
        
        readValue(): Object
        
        readMap(): Map<String, Object>
        
        readList(): List<Object>
        
        readArray(): Object[]
        
        readBean(Class<Object>): Object
        
        readArrayOf(Class<Object>): Object[]
        
        readListOf(Class<Object>): List<Object>
        
        readMapOf(Class<Object>): Map<String, Object>
        
        readTree(): TreeNode
        
        _mapBuilder(Class<Object>): MapBuilder
        
        _collectionBuilder(Class<Object>): CollectionBuilder
        
        JSONWriter
        
        writeBigIntegerValue(BigInteger): void
        
        DEFAULT_TIMEZONE: TimeZone
        
        _treeCodec: TreeCodec
        
        _writerLocator: ValueWriterLocator
        
        _generator: JsonGenerator
        
        _timezone: TimeZone
        
        _features: int
        
        _writeNullValues: boolean
        
        JSONWriter(): void
        
        JSONWriter(JSONWriter, int, ValueWriterLocator, TreeCodec, JsonGenerator): void
        
        withCacheCheck(int): JSONWriter
        
        perOperationInstance(int, ValueWriterLocator, TreeCodec, JsonGenerator): JSONWriter
        
        isEnabled(Feature): boolean
        
        writeValue(Object): void
        
        writeField(String, Object, int): void
        
        _writeValue(Object, int): void
        
        writeCollectionValue(Collection<Object>): void
        
        writeCollectionField(String, Collection<Object>): void
        
        writeIterableValue(Iterable<Object>): void
        
        writeIterableField(String, Iterable<Object>): void
        
        writeListValue(List<Object>): void
        
        writeListField(String, List<Object>): void
        
        writeMapValue(Map<Object, Object>): void
        
        writeMapField(String, Map<Object, Object>): void
        
        writeObjectArrayValue(Object[]): void
        
        writeObjectArrayField(String, Object[]): void
        
        writeIntArrayValue(int[]): void
        
        writeIntArrayField(String, int[]): void
        
        writeLongArrayValue(long[]): void
        
        writeLongArrayField(String, long[]): void
        
        writeBooleanArrayValue(boolean[]): void
        
        writeBooleanArrayField(String, boolean[]): void
        
        writeTreeNodeValue(TreeNode): void
        
        writeTreeNodeField(String, TreeNode): void
        
        writeBooleanValue(boolean): void
        
        writeBooleanField(String, boolean): void
        
        writeIntValue(int): void
        
        writeIntField(String, int): void
        
        writeLongValue(long): void
        
        writeBigIntegerField(String, BigInteger): void
        
        writeLongField(String, long): void
        
        writeDoubleValue(double): void
        
        writeDoubleField(String, double): void
        
        writeBigDecimalValue(BigDecimal): void
        
        writeBigDecimalField(String, BigDecimal): void
        
        writeStringValue(String): void
        
        writeStringField(String, String): void
        
        writeStringLikeValue(String, int): void
        
        writeStringLikeField(String, String, int): void
        
        writeBinaryValue(byte[]): void
        
        writeBinaryField(String, byte[]): void
        
        writeNullValue(): void
        
        writeNullField(String): void
        
        writeNullField(SerializedString): void
        
        writeDateValue(Date): void
        
        writeDateField(String, Date): void
        
        writeEnumValue(Enum<Enum>): void
        
        writeEnumField(String, Enum<Enum>): void
        
        writeBeanValue(BeanPropertyWriter[], Object): void
        
        writeUnknownValue(Object): void
        
        writeUnknownField(String, Object): void
        
        _checkUnknown(Object): void
        
        keyToString(Object): String
        
        dateToString(Date): String
        
        _badType(int, Object): void
        
        MapReader
        
        _mapType: Class<Object>
        
        _valueReader: ValueReader
        
        MapReader(Class<Object>, ValueReader): void
        
        readNext(JSONReader, JsonParser): Object
        
        read(JSONReader, JsonParser): Object
        
        _reportProblem(JsonParser): JSONObjectException
        
        POJODefinition
        
        _type: Class<Object>
        
        _properties: Prop[]
        
        _ignorableNames: Set<String>
        
        defaultCtor: Constructor<Object>
        
        stringCtor: Constructor<Object>
        
        longCtor: Constructor<Object>
        
        POJODefinition(Class<Object>, Prop[], Constructor<Object>, Constructor<Object>, Constructor<Object>): void
        
        POJODefinition(POJODefinition, Prop[], Set<String>): void
        
        withProperties(Collection<Prop>): POJODefinition
        
        withIgnorals(Set<String>): POJODefinition
        
        getProperties(): List<Prop>
        
        properties(): Prop[]
        
        getIgnorableNames(): Set<String>
        
        Prop
        
        name: String
        
        field: Field
        
        setter: Method
        
        getter: Method
        
        isGetter: Method
        
        aliases: Collection<String>
        
        Prop(String, Field, Method, Method, Method, Collection<String>): void
        
        builder(String): PropBuilder
        
        hasSetter(): boolean
        
        hasAliases(): boolean
        
        aliases(): Iterable<String>
        
        PropBuilder
        
        _isGetter: Method
        
        _name: String
        
        _field: Field
        
        _setter: Method
        
        _getter: Method
        
        PropBuilder(String): void
        
        build(): Prop
        
        withField(Field): PropBuilder
        
        withSetter(Method): PropBuilder
        
        withGetter(Method): PropBuilder
        
        withIsGetter(Method): PropBuilder
        
        SimpleValueReader
        
        _typeId: int
        
        SimpleValueReader(Class<Object>, int): void
        
        readNext(JSONReader, JsonParser): Object
        
        read(JSONReader, JsonParser): Object
        
        _readBinary(JsonParser): byte[]
        
        _readIntArray(JsonParser): int[]
        
        _fetchLong(JsonParser): long
        
        _nextString(JsonParser): String
        
        _nextInt(JsonParser): int
        
        _nextLong(JsonParser): long
        
        ValueLocatorBase
        
        SER_UNKNOWN: int
        
        SER_MAP: int
        
        SER_LIST: int
        
        SER_COLLECTION: int
        
        SER_OBJECT_ARRAY: int
        
        SER_INT_ARRAY: int
        
        SER_LONG_ARRAY: int
        
        SER_BOOLEAN_ARRAY: int
        
        SER_TREE_NODE: int
        
        SER_STRING: int
        
        SER_CHARACTER_SEQUENCE: int
        
        SER_CHAR_ARRAY: int
        
        SER_BYTE_ARRAY: int
        
        SER_NUMBER_BYTE: int
        
        SER_NUMBER_SHORT: int
        
        SER_NUMBER_INTEGER: int
        
        SER_NUMBER_LONG: int
        
        SER_NUMBER_FLOAT: int
        
        SER_NUMBER_DOUBLE: int
        
        SER_NUMBER_BIG_INTEGER: int
        
        SER_NUMBER_BIG_DECIMAL: int
        
        SER_BOOLEAN: int
        
        SER_CHAR: int
        
        SER_ENUM: int
        
        SER_DATE: int
        
        SER_CALENDAR: int
        
        SER_CLASS: int
        
        SER_FILE: int
        
        SER_UUID: int
        
        SER_URL: int
        
        SER_URI: int
        
        SER_ITERABLE: int
        
        CACHE_FLAGS: int
        
        _findSimpleType(Class<Object>, boolean): int
        
        ValueReaderLocator
        
        MAX_CACHED_READERS: int
        
        _typeResolver: TypeResolver
        
        _readerProvider: ReaderWriterProvider
        
        _readerModifier: ReaderWriterModifier
        
        _knownReaders: ConcurrentHashMap<ClassKey, ValueReader>
        
        _incompleteReaders: Map<ClassKey, ValueReader>
        
        _readerLock: Object
        
        _features: int
        
        _readContext: JSONReader
        
        _key: ClassKey
        
        ValueReaderLocator(ReaderWriterProvider, ReaderWriterModifier): void
        
        ValueReaderLocator(ValueReaderLocator, int, JSONReader): void
        
        ValueReaderLocator(ValueReaderLocator, ReaderWriterProvider, ReaderWriterModifier): void
        
        blueprint(ReaderWriterProvider, ReaderWriterModifier): ValueReaderLocator
        
        with(ReaderWriterProvider): ValueReaderLocator
        
        with(ReaderWriterModifier): ValueReaderLocator
        
        perOperationInstance(JSONReader, int): ValueReaderLocator
        
        readerWriterProvider(): ReaderWriterProvider
        
        readerWriterModifier(): ReaderWriterModifier
        
        findReader(Class<Object>): ValueReader
        
        createReader(Class<Object>, Class<Object>, Type): ValueReader
        
        _createReader(Class<Object>, Class<Object>, Type): ValueReader
        
        arrayReader(Class<Object>, Class<Object>): ValueReader
        
        enumReader(Class<Object>): ValueReader
        
        collectionReader(Class<Object>, Type): ValueReader
        
        collectionReader(Class<Object>, ResolvedType): ValueReader
        
        mapReader(Class<Object>, Type): ValueReader
        
        mapReader(Class<Object>, ResolvedType): ValueReader
        
        beanReader(Class<Object>): ValueReader
        
        _resolveBeanDef(Class<Object>): POJODefinition
        
        _resolveBeanForDeser(Class<Object>, POJODefinition): BeanReader
        
        _bindings(Class<Object>): TypeBindings
        
        ValueWriterLocator
        
        NO_PROPS_FOR_WRITE: BeanPropertyWriter[]
        
        _knownSerTypes: ConcurrentHashMap<ClassKey, Integer>
        
        _knownWriters: CopyOnWriteArrayList<ValueWriter>
        
        _writerProvider: ReaderWriterProvider
        
        _writerModifier: ReaderWriterModifier
        
        _features: int
        
        _writeContext: JSONWriter
        
        _key: ClassKey
        
        _prevClass: Class<Object>
        
        _prevType: int
        
        ValueWriterLocator(int, ReaderWriterProvider, ReaderWriterModifier): void
        
        ValueWriterLocator(ValueWriterLocator, int, JSONWriter): void
        
        blueprint(ReaderWriterProvider, ReaderWriterModifier): ValueWriterLocator
        
        with(ReaderWriterProvider): ValueWriterLocator
        
        with(ReaderWriterModifier): ValueWriterLocator
        
        perOperationInstance(JSONWriter, int): ValueWriterLocator
        
        getValueWriter(int): ValueWriter
        
        findSerializationType(Class<Object>): int
        
        _resolveBeanDef(Class<Object>): POJODefinition
        
        _findPOJOSerializationType(Class<Object>): int
        
        _modifyAndRegisterWriter(Class<Object>, ValueWriter): int
        
        _registerWriter(Class<Object>, ValueWriter): int
        
        _resolveBeanForSer(Class<Object>, POJODefinition): BeanPropertyWriter[]
      - type
        
        ClassStack
        
        _p: ClassStack
        
        _curr: Class<Object>
        
        _selfRefs: ArrayList<RecursiveType>
        
        ClassStack(Class<Object>): void
        
        ClassStack(ClassStack, Class<Object>): void
        
        child(Class<Object>): ClassStack
        
        addSelfReference(RecursiveType): void
        
        resolveSelfReferences(ResolvedType): void
        
        find(Class<Object>): ClassStack
        
        RecursiveType
        
        serialVersionUID: long
        
        _referencedType: ResolvedType
        
        RecursiveType(Class<Object>, TypeBindings): void
        
        setReference(ResolvedType): void
        
        selfRefType(): ResolvedType
        
        equals(Object): boolean
        
        ResolvedType
        
        serialVersionUID: long
        
        NO_TYPES: ResolvedType[]
        
        T_ARRAY: int
        
        T_INTERFACE: int
        
        T_PRIMITIVE: int
        
        T_RECURSIVE: int
        
        T_REGULAR: int
        
        _kind: int
        
        _erasedType: Class<Object>
        
        _bindings: TypeBindings
        
        _interfaces: ResolvedType[]
        
        _elemType: ResolvedType
        
        _super: ResolvedType
        
        ResolvedType(Class<Object>): void
        
        ResolvedType(Class<Object>, TypeBindings): void
        
        ResolvedType(Class<Object>, TypeBindings, ResolvedType): void
        
        ResolvedType(Class<Object>, TypeBindings, ResolvedType[]): void
        
        ResolvedType(Class<Object>, ResolvedType, TypeBindings, ResolvedType[]): void
        
        ResolvedType(int, Class<Object>, ResolvedType, TypeBindings, ResolvedType[], ResolvedType): void
        
        erasedType(): Class<Object>
        
        elementType(): ResolvedType
        
        parentType(): ResolvedType
        
        isArray(): boolean
        
        implInterfaces(): List<ResolvedType>
        
        typeParams(): List<ResolvedType>
        
        typeBindings(): TypeBindings
        
        typeParametersFor(Class<Object>): List<ResolvedType>
        
        findSupertype(Class<Object>): ResolvedType
        
        getDesc(): String
        
        appendDesc(StringBuilder): StringBuilder
        
        toString(): String
        
        hashCode(): int
        
        equals(Object): boolean
        
        _appendClassDesc(StringBuilder): StringBuilder
        
        TypeBindings
        
        serialVersionUID: long
        
        NO_STRINGS: String[]
        
        NO_TYPES: ResolvedType[]
        
        EMPTY: TypeBindings
        
        _names: String[]
        
        _types: ResolvedType[]
        
        _unboundVariables: String[]
        
        _hashCode: int
        
        TypeBindings(String[], ResolvedType[], String[]): void
        
        emptyBindings(): TypeBindings
        
        create(Class<Object>, List<ResolvedType>): TypeBindings
        
        create(Class<Object>, ResolvedType[]): TypeBindings
        
        withUnboundVariable(String): TypeBindings
        
        findBoundType(String): ResolvedType
        
        isEmpty(): boolean
        
        size(): int
        
        getBoundName(int): String
        
        getBoundType(int): ResolvedType
        
        getTypeParameters(): List<ResolvedType>
        
        hasUnbound(String): boolean
        
        toString(): String
        
        hashCode(): int
        
        equals(Object): boolean
        
        typeParameterArray(): ResolvedType[]
        
        TypeResolver
        
        serialVersionUID: long
        
        NO_TYPES: ResolvedType[]
        
        TYPE_OBJECT: ResolvedType
        
        _primitives: HashMap<ClassKey, ResolvedType>
        
        static class initializer
        
        _cache: Map<ClassKey, ResolvedType>
        
        TypeResolver(): void
        
        readResolve(): Object
        
        resolve(TypeBindings, Type): ResolvedType
        
        _fromAny(ClassStack, Type, TypeBindings): ResolvedType
        
        _fromClass(ClassStack, Class<Object>, TypeBindings): ResolvedType
        
        _constructType(ClassStack, Class<Object>, TypeBindings): ResolvedType
        
        _resolveSuperInterfaces(ClassStack, Class<Object>, TypeBindings): ResolvedType[]
        
        _resolveSuperClass(ClassStack, Class<Object>, TypeBindings): ResolvedType
        
        _fromParamType(ClassStack, ParameterizedType, TypeBindings): ResolvedType
        
        _fromVariable(ClassStack, TypeVariable<GenericDeclaration>, TypeBindings): ResolvedType

directory

Java files

com/fasterxml/jackson/jr/

directory

Class files

com/fasterxml/jackson/jr/