Module org.opendaylight.yangtools.yang.data.codec.gson
Package org.opendaylight.yangtools.yang.data.codec.gson

Enum JSONCodecFactorySupplier

    • Method Detail

      • values

        public static JSONCodecFactorySupplier[] values()
        Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows: 
        for (JSONCodecFactorySupplier c : JSONCodecFactorySupplier.values())
    System.out.println(c);
        Returns:
        an array containing the constants of this enum type, in the order they are declared

      • valueOf

        public static JSONCodecFactorySupplier valueOf​(String name)
        Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
        Parameters:
        name - the name of the enum constant to be returned.
        Returns:
        the enum constant with the specified name
        Throws:
        IllegalArgumentException - if this enum type has no constant with the specified name
        NullPointerException - if the argument is null

      • getPrecomputed

        public @NonNull JSONCodecFactory getPrecomputed​(@NonNull org.opendaylight.yangtools.yang.model.api.SchemaContext context)
        Get a thread-safe, eagerly-caching JSONCodecFactory for a SchemaContext. This method can, and will, return the same instance as long as the associated SchemaContext is present. Returned object can be safely used by multiple threads concurrently. If the SchemaContext instance does not have a cached instance of JSONCodecFactory, it will be completely precomputed before this method will return.

        Choosing this implementation is appropriate when the memory overhead of keeping a full codec tree is not as great a concern as predictable performance. When compared to the implementation returned by getShared(SchemaContext), this implementation is expected to offer higher performance and have lower peak memory footprint when most of the SchemaContext is actually in use.

        For call sites which do not want to pay the CPU cost of pre-computing this implementation, but still would like to use it if is available (by being populated by some other caller), you can use getPrecomputedIfAvailable(SchemaContext).

        Parameters:
        context - SchemaContext instance
        Returns:
        A sharable JSONCodecFactory
        Throws:
        NullPointerException - if context is null

      • getPrecomputedIfAvailable

        public @NonNull Optional<JSONCodecFactory> getPrecomputedIfAvailable​(@NonNull org.opendaylight.yangtools.yang.model.api.SchemaContext context)
        Get a thread-safe, eagerly-caching JSONCodecFactory for a SchemaContext, if it is available. This method is a non-blocking equivalent of getPrecomputed(SchemaContext) for use in code paths where the potential of having to pre-compute the implementation is not acceptable. One such scenario is when the code base wants to opportunistically take advantage of pre-computed version, but is okay with a fallback to a different implementation.
        Parameters:
        context - SchemaContext instance
        Returns:
        A sharable JSONCodecFactory, or absent if such an implementation is not available.
        Throws:
        NullPointerException - if context is null

      • getShared

        public @NonNull JSONCodecFactory getShared​(@NonNull org.opendaylight.yangtools.yang.model.api.SchemaContext context)
        Get a thread-safe, lazily-caching JSONCodecFactory for a SchemaContext. This method can, and will, return the same instance as long as the associated SchemaContext is present or the factory is not invalidated by memory pressure. Returned object can be safely used by multiple threads concurrently.

        Choosing this implementation is a safe default, as it will not incur prohibitive blocking, nor will it tie up memory in face of pressure.

        Parameters:
        context - SchemaContext instance
        Returns:
        A sharable JSONCodecFactory
        Throws:
        NullPointerException - if context is null

      • createLazy

        public @NonNull JSONCodecFactory createLazy​(@NonNull org.opendaylight.yangtools.yang.model.api.SchemaContext context)
        Create a new thread-unsafe, lazily-caching JSONCodecFactory for a SchemaContext. This method will return distinct objects every time it is invoked. Returned object may not be used from multiple threads concurrently.

        This implementation is appropriate for one-off serialization from a single thread. It will aggressively cache codecs for reuse and will tie them up in memory until the factory is freed.

        Parameters:
        context - SchemaContext instance
        Returns:
        A non-sharable JSONCodecFactory
        Throws:
        NullPointerException - if context is null

      • createSimple

        public @NonNull JSONCodecFactory createSimple​(@NonNull org.opendaylight.yangtools.yang.model.api.SchemaContext context)
        Create a simplistic, thread-safe JSONCodecFactory for a SchemaContext. This method will return distinct objects every time it is invoked. Returned object may be use from multiple threads concurrently.

        This implementation exists mostly for completeness only, as it does not perform any caching at all and each codec is computed every time it is requested. This may be useful in extremely constrained environments, where memory footprint is more critical than performance.

        Parameters:
        context - SchemaContext instance
        Returns:
        A non-sharable JSONCodecFactory
        Throws:
        NullPointerException - if context is null.