io.micronaut.serde.LimitingStream Maven / Gradle / Ivy
Show all versions of micronaut-serde-api Show documentation
/*
* Copyright 2017-2023 original authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.micronaut.serde;
import io.micronaut.core.annotation.Internal;
import io.micronaut.core.annotation.NonNull;
import io.micronaut.core.type.Argument;
import io.micronaut.serde.config.SerdeConfiguration;
import io.micronaut.serde.exceptions.SerdeException;
/**
* Utility class to check data limits in encoders and decoders. Currently, the only limit that is
* checked is the nesting depth.
*
* This class can be used in both implementation "patterns" for {@link Encoder} (and
* {@link Decoder}): For the same-object pattern, where {@link Encoder#encodeObject(Argument)}
* returns the same instance, the encoder should call {@link #increaseDepth()}, with a
* corresponding {@link #decreaseDepth()} call in {@link Encoder#finishStructure()}. Conversely, if
* the encoder is implemented using the child-object pattern, where
* {@link Encoder#encodeObject(Argument)} returns a child encoder responsible for the subtree, that
* child encoder should be instantiated using the new limits returned by {@link #childLimits()}.
*
* If there is a limit violation, {@link #childLimits()} or {@link #increaseDepth()} will throw an
* exception.
*
* @author Jonas Konrad
* @since 2.0.0
*/
@Internal
public abstract class LimitingStream {
/**
* Default nesting depth limit.
*/
public static final int DEFAULT_MAXIMUM_DEPTH = 1024;
/**
* Default limits, only use this when no {@link SerdeConfiguration} is available.
*/
public static final RemainingLimits DEFAULT_LIMITS = new RemainingLimits(DEFAULT_MAXIMUM_DEPTH);
private int remainingDepth;
public LimitingStream(@NonNull RemainingLimits remainingLimits) {
this.remainingDepth = remainingLimits.remainingDepth;
}
/**
* Get a snapshot of our current limits to be passed to the constructor. This can be used for
* buffering decoders, when a new decoder takes over but no change in depth takes place.
*
* @return The current limits
*/
@NonNull
protected final RemainingLimits ourLimits() {
return new RemainingLimits(remainingDepth);
}
/**
* Get the limits of a new child encoder.
*
* @return The new limits
* @throws SerdeException If there is a nesting depth limit violation
*/
@NonNull
protected final RemainingLimits childLimits() throws SerdeException {
if (remainingDepth == 0) {
reportMaxDepthExceeded();
}
return new RemainingLimits(remainingDepth - 1);
}
/**
* Increase the current depth.
*
* @throws SerdeException If there is a nesting depth limit violation
*/
protected final void increaseDepth() throws SerdeException {
if (remainingDepth == 0) {
reportMaxDepthExceeded();
}
remainingDepth--;
}
/**
* Decrease the current depth, always needs a corresponding {@link #increaseDepth()} call.
*/
protected final void decreaseDepth() {
remainingDepth++;
}
private void reportMaxDepthExceeded() throws SerdeException {
boolean encoder = this instanceof Encoder;
throw new SerdeException("Maximum depth exceeded while " + (encoder ? "serializing" : "deserializing") + ". The maximum nesting depth can be increased, if necessary, using the " + SerdeConfiguration.PREFIX + ".maximum-nesting-depth config property.");
}
/**
* Get the configured limits.
*
* @param configuration The serde configuration
* @return The configured limits
*/
public static RemainingLimits limitsFromConfiguration(SerdeConfiguration configuration) {
return new RemainingLimits(configuration.getMaximumNestingDepth());
}
/**
* This data structure contains the limits for this stream.
*/
public static final class RemainingLimits {
final int remainingDepth;
private RemainingLimits(int remainingDepth) {
this.remainingDepth = remainingDepth;
}
}
}