content: /*
   *  Copyright 2016-2024 Qameta Software Inc
   *
   *  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
   *
   *      http://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.qameta.allure.allure1;
  
  import com.fasterxml.jackson.core.JsonParser;
  import com.fasterxml.jackson.core.JsonToken;
  import com.fasterxml.jackson.databind.BeanProperty;
  import com.fasterxml.jackson.databind.DeserializationContext;
  import com.fasterxml.jackson.databind.DeserializationFeature;
  import com.fasterxml.jackson.databind.JsonDeserializer;
  import com.fasterxml.jackson.databind.JsonMappingException;
  import com.fasterxml.jackson.databind.deser.UnresolvedForwardReference;
  import com.fasterxml.jackson.databind.deser.impl.ReadableObjectId;
  import com.fasterxml.jackson.databind.deser.std.CollectionDeserializer;
  import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
  import com.fasterxml.jackson.databind.util.ClassUtil;
  
  import java.io.IOException;
  import java.util.Collection;
  
  /**
   * Custom list deserializer that allows to deserialize empty wrapped lists.
   *
   * @author charlie (Dmitry Baev).
   */
  @SuppressWarnings("all")
  public class ListDeserializer extends CollectionDeserializer {
  
      protected ListDeserializer(final CollectionDeserializer src) {
          super(src);
      }
  
      @Override
      public Collection<Object> deserialize(JsonParser p, DeserializationContext ctxt,
                                            Collection<Object> result)
              throws IOException {
          // Ok: must point to START_ARRAY (or equivalent)
          if (!p.isExpectedStartArrayToken()) {
              return result;
          }
          // [databind#631]: Assign current value, to be accessible by custom serializers
          p.setCurrentValue(result);
  
          JsonDeserializer<Object> valueDes = _valueDeserializer;
          final TypeDeserializer typeDeser = _valueTypeDeserializer;
          CollectionReferringAccumulator referringAccumulator =
                  (valueDes.getObjectIdReader() == null) ? null :
                          new CollectionReferringAccumulator(_containerType.getContentType().getRawClass(), result);
  
          JsonToken t;
          while ((t = p.nextToken()) != JsonToken.END_ARRAY) {
              try {
                  Object value;
                  if (t == JsonToken.VALUE_NULL) {
                      if (_skipNullValues) {
                          continue;
                      }
                      value = _nullProvider.getNullValue(ctxt);
                  } else if (typeDeser == null) {
                      value = valueDes.deserialize(p, ctxt);
                  } else {
                      value = valueDes.deserializeWithType(p, ctxt, typeDeser);
                  }
                  if (referringAccumulator != null) {
                      referringAccumulator.add(value);
                  } else {
                      result.add(value);
                  }
              } catch (UnresolvedForwardReference reference) {
                  if (referringAccumulator == null) {
                      throw JsonMappingException
                              .from(p, "Unresolved forward reference but no identity info", reference);
                  }
                  ReadableObjectId.Referring ref = referringAccumulator.handleUnresolvedReference(reference);
                  reference.getRoid().appendReferring(ref);
              } catch (Exception e) {
                  boolean wrap = (ctxt == null) || ctxt.isEnabled(DeserializationFeature.WRAP_EXCEPTIONS);
                  if (!wrap) {
                      ClassUtil.throwIfRTE(e);
                  }
                  throw JsonMappingException.wrapWithPath(e, result, result.size());
              }
          }
          return result;
      }
  
      @Override
      public CollectionDeserializer createContextual(final DeserializationContext ctxt,
                                                     final BeanProperty property) throws JsonMappingException {
          return new ListDeserializer(super.createContextual(ctxt, property));
      }
  }
  