protected List<Double> readPointList(JsonReader in) throws IOException {

    if (in.peek() == JsonToken.NULL) {
      throw new NullPointerException();
    }

    List<Double> coordinates = new ArrayList<Double>();
    in.beginArray();
    while (in.hasNext()) {
      coordinates.add(in.nextDouble());
    }
    in.endArray();

    if (coordinates.size() > 2) {
      return CoordinateShifterManager.getCoordinateShifter()
              .shiftLonLatAlt(coordinates.get(0), coordinates.get(1), coordinates.get(2));
    }
    return CoordinateShifterManager.getCoordinateShifter()
            .shiftLonLat(coordinates.get(0), coordinates.get(1));
  }
 

private void parseContactPoint(JsonRecord record) throws DcatParseException, IOException {
  while (jsonReader.hasNext()) {
    JsonToken token = jsonReader.peek();
    switch (token) {
      case NAME:
        String attrName = jsonReader.nextName();
        if ("fn".equals(attrName)) {
          storeAttribute("contactPoint", record);
        } else if ("hasEmail".equals(attrName)) {
          storeAttribute("mbox", record);
        } else {
          jsonReader.skipValue();
        }
        break;
      case END_OBJECT:
        return;
      default:
        throw new DcatParseException("Unexpected token in the data: " + token);
    }
  }
}
 

public final TypeAdapter<T> nullSafe() {
    return new TypeAdapter<T>() {
        public void write(JsonWriter out, T value) throws IOException {
            if (value == null) {
                out.nullValue();
            } else {
                TypeAdapter.this.write(out, value);
            }
        }

        public T read(JsonReader reader) throws IOException {
            if (reader.peek() != JsonToken.NULL) {
                return TypeAdapter.this.read(reader);
            }
            reader.nextNull();
            return null;
        }
    };
}
 

@Override
public Iterator<JsonToken> iterator() {
    return new Iterator<JsonToken>() {

        @Override
        public boolean hasNext() {
            JsonToken token = peek();
            return token != JsonToken.END_DOCUMENT;
        }

        @Override
        public JsonToken next() {
            getPath();
            return peek();
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }
    };
}
 

public Number a(JsonReader jsonreader)
{
    if (jsonreader.peek() == JsonToken.NULL)
    {
        jsonreader.nextNull();
        return null;
    }
    Integer integer;
    try
    {
        integer = Integer.valueOf(jsonreader.nextInt());
    }
    catch (NumberFormatException numberformatexception)
    {
        throw new JsonSyntaxException(numberformatexception);
    }
    return integer;
}
 

public Map<String, String> parsePathToValueMap(String json) {
    Map<String, String> result = new HashMap<String, String>();
    SafeJsonReader reader = new SafeJsonReader(json);
    for (JsonToken token : reader) {
             if (BEGIN_ARRAY == token)  reader.beginArray();
        else if (END_ARRAY == token)    reader.endArray();
        else if (BEGIN_OBJECT == token) reader.beginObject();
        else if (END_OBJECT == token)   reader.endObject();
        else if (NAME == token)         reader.nextName();
        else if (STRING == token)       add(reader.getCurrentPath(), reader.nextString(), result);
        else if (NUMBER == token)       add(reader.getCurrentPath(), reader.nextString(), result);
        else if (BOOLEAN == token)      add(reader.getCurrentPath(), Boolean.toString(reader.nextBoolean()), result);
        else if (NULL == token)         reader.nextNull();
    }
    reader.close();
    return result;
}
 

@Override
public PriceLevel read(JsonReader reader) throws IOException {
  if (reader.peek() == JsonToken.NULL) {
    reader.nextNull();
    return null;
  }

  if (reader.peek() == JsonToken.NUMBER) {
    int priceLevel = reader.nextInt();

    switch (priceLevel) {
      case 0:
        return PriceLevel.FREE;
      case 1:
        return PriceLevel.INEXPENSIVE;
      case 2:
        return PriceLevel.MODERATE;
      case 3:
        return PriceLevel.EXPENSIVE;
      case 4:
        return PriceLevel.VERY_EXPENSIVE;
    }
  }

  return PriceLevel.UNKNOWN;
}
 

private byte[] rawRead(JsonReader in) throws IOException {
	@SuppressWarnings("resource")
	UnsafeByteArrayOutputStream out = new UnsafeByteArrayOutputStream(128);
	in.beginArray();
	try {
		while (in.hasNext()) {
			if (in.peek() == JsonToken.NULL) {
				in.nextNull();
				continue;
			}
			out.write(in.nextInt());
		}
	} catch (NumberFormatException e) {
		throw new JsonSyntaxException(e);
	}
	in.endArray();
	out.flush();
	return out.toByteArray();
}
 

@Override
public State read(JsonReader reader) throws IOException {
    if (reader.peek() == JsonToken.NULL) {
        reader.nextNull();
        return null;
    }
    String value = reader.nextString();
    String[] parts = value.split(TYPE_SEPARATOR);
    String valueTypeName = parts[0];
    String valueAsString = parts[1];

    try {
        @SuppressWarnings("unchecked")
        Class<? extends State> valueType = (Class<? extends State>) Class.forName(valueTypeName);
        List<Class<? extends State>> types = Collections.singletonList(valueType);
        return TypeParser.parseState(types, valueAsString);
    } catch (Exception e) {
        logger.warn("Couldn't deserialize state '{}': {}", value, e.getMessage());
    }
    return null;
}
 

@Override
public NUM read(JsonReader in) throws IOException { // not use real adapter for options
    if (in.peek() == JsonToken.NULL) {
        in.nextNull();
        return null;
    }
    final String str = filterReading(in.nextString());
    if (str == null) { // filter makes it null
        return null;
    }
    if (isEmptyToNullReading() && "".equals(str)) {
        return null;
    }
    try {
        if (str != null && str.trim().isEmpty()) { // e.g. "" or " "
            // toNumber() treats empty as null so throw to keep Gson behavior 
            throw new NumberFormatException("because of empty string: [" + str + "]");
        }
        @SuppressWarnings("unchecked")
        final NUM num = (NUM) DfTypeUtil.toNumber(str, getNumberType());
        return num;
    } catch (RuntimeException e) {
        throwJsonPropertyNumberParseFailureException(in, e);
        return null; // unreachable
    }
}
 

private List<String> readLinksArray(final JsonReader reader) throws IOException, EntityProviderException {
  List<String> links = new ArrayList<String>();

  reader.beginArray();
  while (reader.hasNext()) {
    reader.beginObject();
    String nextName = reader.nextName();
    if (FormatJson.URI.equals(nextName) && reader.peek() == JsonToken.STRING) {
      links.add(reader.nextString());
    } else {
      throw new EntityProviderException(EntityProviderException.INVALID_CONTENT.addContent(FormatJson.URI).addContent(nextName));
    }
    reader.endObject();
  }
  reader.endArray();

  return links;
}
 

@Override
public Number read(JsonReader in) throws IOException {
    if (in.peek() == JsonToken.NULL) {
        in.nextNull();
        return null;
    }
    try {
        String result = in.nextString();
        if ("".equals(result)) {
            return null;
        }
        return Integer.parseInt(result);
    } catch (NumberFormatException e) {
        throw new JsonSyntaxException(e);
    }
}
 

/**
 * Parses DCAT using internal listener.
 *
 * @param listener internal listener
 * @throws DcatParseException if parsing DCAT fails
 */
void parse(final ListenerInternal listener) throws DcatParseException, IOException {
  if (!jsonReader.hasNext()) {
    throw new DcatParseException("No more data available.");
  }

  JsonToken token = jsonReader.peek();
  switch (token) {
    case BEGIN_OBJECT:
      version = DcatVersion.DV11;
      jsonReader.beginObject();
      parseContent(listener);
      break;
    case BEGIN_ARRAY:
      jsonReader.beginArray();
      parseRecords(listener);
      break;
    default:
      throw new DcatParseException("Neither array nor object is found.");
  }
}
 

/**
 * 
 * @throws IOException
 * @throws EdmException
 * @throws EntityProviderException
 */
private void readFeed() throws IOException, EdmException, EntityProviderException {
  JsonToken peek = reader.peek();
  if (peek == JsonToken.BEGIN_ARRAY) {
    readArrayContent();
  } else {
    reader.beginObject();
    final String nextName = reader.nextName();
    if (FormatJson.D.equals(nextName)) {
      if (reader.peek() == JsonToken.BEGIN_ARRAY) {
        readArrayContent();
      } else {
        reader.beginObject();
        readFeedContent();
        reader.endObject();
      }
    } else {
      handleName(nextName);
      readFeedContent();
    }

    reader.endObject();
  }
}
 

@Override public Object read(JsonReader in) throws IOException {
  if (in.peek() == JsonToken.NULL) {
    in.nextNull();
    return null;
  }

  List<E> list = new ArrayList<E>();
  in.beginArray();
  while (in.hasNext()) {
    E instance = componentTypeAdapter.read(in);
    list.add(instance);
  }
  in.endArray();

  int size = list.size();
  Object array = Array.newInstance(componentType, size);
  for (int i = 0; i < size; i++) {
    Array.set(array, i, list.get(i));
  }
  return array;
}
 

private TypeAdapter<Number> floatAdapter(boolean serializeSpecialFloatingPointValues) {
  if (serializeSpecialFloatingPointValues) {
    return TypeAdapters.FLOAT;
  }
  return new TypeAdapter<Number>() {
    @Override public Float read(JsonReader in) throws IOException {
      if (in.peek() == JsonToken.NULL) {
        in.nextNull();
        return null;
      }
      return (float) in.nextDouble();
    }
    @Override public void write(JsonWriter out, Number value) throws IOException {
      if (value == null) {
        out.nullValue();
        return;
      }
      float floatValue = value.floatValue();
      checkValidFloatingPoint(floatValue);
      out.value(value);
    }
  };
}
 

@Override
public SystemSettings read(JsonReader reader) throws IOException {
    if (reader.peek() == JsonToken.NULL) {
        return null;
    }

    SystemSettings.Builder builder = SystemSettings.newBuilder();

    reader.beginObject();

    while (reader.peek() != JsonToken.END_OBJECT && reader.hasNext()) {
        String name = reader.nextName();
        switch (name) {
            case USER_STREAM_ACL:
                builder.userStreamAcl(streamAclJsonAdapter.read(reader));
                break;
            case SYSTEM_STREAM_ACL:
                builder.systemStreamAcl(streamAclJsonAdapter.read(reader));
                break;
        }
    }

    reader.endObject();

    return builder.build();
}
 

/**
 * 
 * @param reader
 * @param feedMetadata
 * @throws IOException
 * @throws EntityProviderException
 */
protected static void readInlineCount(final JsonReader reader, final FeedMetadataImpl feedMetadata)
    throws IOException, EntityProviderException {
  if (reader.peek() == JsonToken.STRING && feedMetadata.getInlineCount() == null) {
    int inlineCount;
    try {
      inlineCount = reader.nextInt();
    } catch (final NumberFormatException e) {
      throw new EntityProviderException(EntityProviderException.INLINECOUNT_INVALID.addContent(""), e);
    }
    if (inlineCount >= 0) {
      feedMetadata.setInlineCount(inlineCount);
    } else {
      throw new EntityProviderException(EntityProviderException.INLINECOUNT_INVALID.addContent(inlineCount));
    }
  } else {
    throw new EntityProviderException(EntityProviderException.INLINECOUNT_INVALID.addContent(reader.peek()));
  }
}
 

public Number a(JsonReader jsonreader)
{
    if (jsonreader.peek() == JsonToken.NULL)
    {
        jsonreader.nextNull();
        return null;
    }
    Byte byte1;
    try
    {
        byte1 = Byte.valueOf((byte)jsonreader.nextInt());
    }
    catch (NumberFormatException numberformatexception)
    {
        throw new JsonSyntaxException(numberformatexception);
    }
    return byte1;
}
 

public int nextInt() throws IOException {
    JsonToken token = peek();
    if (token == JsonToken.NUMBER || token == JsonToken.STRING) {
        int result = ((JsonPrimitive) peekStack()).getAsInt();
        popStack();
        return result;
    }
    throw new IllegalStateException("Expected " + JsonToken.NUMBER + " but was " + token);
}
 

@Override public void endObject() throws IOException {
  expect(JsonToken.END_OBJECT);
  popStack(); // empty iterator
  popStack(); // object
  if (stackSize > 0) {
    pathIndices[stackSize - 1]++;
  }
}
 

public StringBuilder read(JsonReader in) throws IOException {
    if (in.peek() != JsonToken.NULL) {
        return new StringBuilder(in.nextString());
    }
    in.nextNull();
    return null;
}
 

private static List<String> extractNamesFromArrayOfObjections(JsonReader jsonReader) throws IOException {
    List<String> names = new ArrayList<>();
    jsonReader.beginArray();
    if (jsonReader.peek().equals(JsonToken.END_ARRAY)) {
        jsonReader.endArray();
        return names;
    }
    jsonReader.beginObject();
    while (jsonReader.hasNext()) {
        String name = jsonReader.nextName();
        if ("name".equals(name)) {
            String s = jsonReader.nextString();
            if (!StringUtils.isBlank(s)) {
                names.add(s);
            }
        } else {
            jsonReader.skipValue();
        }
        if (jsonReader.peek().equals(JsonToken.END_OBJECT)) {
            jsonReader.endObject();
            if (jsonReader.peek().equals(JsonToken.END_ARRAY)) {
                break;
            } else {
                jsonReader.beginObject();
            }
        } else if (jsonReader.peek().equals(JsonToken.BEGIN_OBJECT)) {
            jsonReader.beginObject();
        }
    }
    jsonReader.endArray();
    return names;
}
 

@Override
public Number read(JsonReader in) throws IOException {
  if (in.peek() == JsonToken.NULL) {
    in.nextNull();
    return null;
  }
  try {
    return in.nextInt();
  } catch (NumberFormatException e) {
    throw new JsonSyntaxException(e);
  }
}
 

@Override
public SentryEnvelopeItemHeader read(JsonReader reader) throws IOException {
  if (reader.peek() == JsonToken.NULL) {
    reader.nextNull();
    return null;
  }

  String contentType = null;
  String fileName = null;
  SentryItemType type = SentryItemType.Unknown;
  int length = 0;

  reader.beginObject();
  while (reader.hasNext()) {
    switch (reader.nextName()) {
      case "content_type":
        contentType = reader.nextString();
        break;
      case "filename":
        fileName = reader.nextString();
        break;
      case "type":
        try {
          type = SentryItemType.valueOf(StringUtils.capitalize(reader.nextString()));
        } catch (IllegalArgumentException ignored) {
          // invalid type
        }
        break;
      case "length":
        length = reader.nextInt();
        break;
      default:
        reader.skipValue();
        break;
    }
  }
  reader.endObject();

  return new SentryEnvelopeItemHeader(type, length, contentType, fileName);
}
 

@Override
public UUID read(JsonReader in) throws IOException {
  if (in.peek() == JsonToken.NULL) {
    in.nextNull();
    return null;
  }
  return java.util.UUID.fromString(in.nextString());
}
 

@Override
public byte[] read(JsonReader in) throws IOException {
    if (in.peek() == JsonToken.NULL) {
        in.nextNull();
        return null;
    }

    String base64Encoded = in.nextString();
    return Base64.decode(base64Encoded, Base64.NO_WRAP);
}
 

@Test
public void bsonDouble() throws IOException {
  BsonDouble value = new BsonDouble(1.1);
  check(Jsons.readerAt(value).peek()).is(JsonToken.NUMBER);
  check(Jsons.readerAt(value).nextInt()).is(1);
  check(Jsons.readerAt(value).nextLong()).is(1L);
  check(Jsons.readerAt(value).nextDouble()).is(1.1D);
  check(Jsons.readerAt(value).nextString()).is(Double.toString(1.1));
}
 

public static int startJson(final JsonReader reader) throws EntityProviderException {
  // The enclosing "d" and "results" are optional - so we cannot check for the presence
  // but we have to read over them in case they are present.
  JsonToken token;
  try {
    token = reader.peek();
    int openJsonObjects = 0;
    if (JsonToken.BEGIN_OBJECT == token) {
      reader.beginObject();
      openJsonObjects++;
      token = reader.peek();
      if (JsonToken.NAME == token) {
        String name = reader.nextName();
        if (!("d".equals(name) ^ "results".equals(name))) {
          // TODO I18N
          throw new EntityProviderException(EntityProviderException.COMMON, name +
              " not expected, only d or results");
        }
      }

      token = reader.peek();
      if (JsonToken.BEGIN_OBJECT == token) {
        reader.beginObject();
        openJsonObjects++;
      } else if (JsonToken.BEGIN_ARRAY == token) {
        // TODO I18N
        throw new EntityProviderException(EntityProviderException.COMMON, "Array not expected");
      }
    }

    return openJsonObjects;
  } catch (IOException e) {
    // TODO I18N
    throw new EntityProviderException(EntityProviderException.COMMON, e);
  }
}
 

@Override
public List<List<Point>> read(JsonReader in) throws IOException {

  if (in.peek() == JsonToken.NULL) {
    throw new NullPointerException();
  }

  if (in.peek() == JsonToken.BEGIN_ARRAY) {

    in.beginArray();
    List<List<Point>> points = new ArrayList<>();

    while (in.peek() == JsonToken.BEGIN_ARRAY) {

      in.beginArray();
      List<Point> listOfPoints = new ArrayList<>();

      while (in.peek() == JsonToken.BEGIN_ARRAY) {
        listOfPoints.add(readPoint(in));
      }
      in.endArray();
      points.add(listOfPoints);
    }
    in.endArray();

    return points;
  }

  throw new GeoJsonException("coordinates should be array of array of array of double");
}