Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
Jackson Data Binding Source Code
Jackson is "the Java JSON library" or "the best JSON parser for Java". Or simply as "JSON for Java".
Jackson Databind Source Code files are provided in the source packge (jackson-databind-2.14.0-sources.jar). You can download it at Jackson Maven Website.
You can also browse Jackson Databind Source Code below:
✍: FYIcenter.com
⏎ com/fasterxml/jackson/databind/util/internal/LinkedDeque.java
/* * Copyright 2011 Google Inc. All Rights Reserved. * * 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 com.fasterxml.jackson.databind.util.internal; import java.util.AbstractCollection; import java.util.Collection; import java.util.Deque; import java.util.Iterator; import java.util.NoSuchElementException; /** * Linked list implementation of the {@link Deque} interface where the link * pointers are tightly integrated with the element. Linked deques have no * capacity restrictions; they grow as necessary to support usage. They are not * thread-safe; in the absence of external synchronization, they do not support * concurrent access by multiple threads. Null elements are prohibited. * <p> * Most <tt>LinkedDeque</tt> operations run in constant time by assuming that * the {@code Linked} parameter is associated with the deque instance. Any usage * that violates this assumption will result in non-deterministic behavior. * <p> * The iterators returned by this class are <em>not</em> <i>fail-fast</i>: If * the deque is modified at any time after the iterator is created, the iterator * will be in an unknown state. Thus, in the face of concurrent modification, * the iterator risks arbitrary, non-deterministic behavior at an undetermined * time in the future. * * @author ben.manes@gmail.com (Ben Manes) * @param <E> the type of elements held in this collection * @see <a href="http://code.google.com/p/concurrentlinkedhashmap/"> * http://code.google.com/p/concurrentlinkedhashmap/</a> */ final class LinkedDeque<E extends Linked<E>> extends AbstractCollection<E> implements Deque<E> { // This class provides a doubly-linked list that is optimized for the virtual // machine. The first and last elements are manipulated instead of a slightly // more convenient sentinel element to avoid the insertion of null checks with // NullPointerException throws in the byte code. The links to a removed // element are cleared to help a generational garbage collector if the // discarded elements inhabit more than one generation. /** * Pointer to first node. * Invariant: (first == null && last == null) || * (first.prev == null) */ E first; /** * Pointer to last node. * Invariant: (first == null && last == null) || * (last.next == null) */ E last; /** * Links the element to the front of the deque so that it becomes the first * element. * * @param e the unlinked element */ void linkFirst(final E e) { final E f = first; first = e; if (f == null) { last = e; } else { f.setPrevious(e); e.setNext(f); } } /** * Links the element to the back of the deque so that it becomes the last * element. * * @param e the unlinked element */ void linkLast(final E e) { final E l = last; last = e; if (l == null) { first = e; } else { l.setNext(e); e.setPrevious(l); } } /** Unlinks the non-null first element. */ E unlinkFirst() { final E f = first; final E next = f.getNext(); f.setNext(null); first = next; if (next == null) { last = null; } else { next.setPrevious(null); } return f; } /** Unlinks the non-null last element. */ E unlinkLast() { final E l = last; final E prev = l.getPrevious(); l.setPrevious(null); last = prev; if (prev == null) { first = null; } else { prev.setNext(null); } return l; } /** Unlinks the non-null element. */ void unlink(E e) { final E prev = e.getPrevious(); final E next = e.getNext(); if (prev == null) { first = next; } else { prev.setNext(next); e.setPrevious(null); } if (next == null) { last = prev; } else { next.setPrevious(prev); e.setNext(null); } } @Override public boolean isEmpty() { return (first == null); } void checkNotEmpty() { if (isEmpty()) { throw new NoSuchElementException(); } } /** * {@inheritDoc} * <p> * Beware that, unlike in most collections, this method is <em>NOT</em> a * constant-time operation. */ @Override public int size() { int size = 0; for (E e = first; e != null; e = e.getNext()) { size++; } return size; } @Override public void clear() { for (E e = first; e != null;) { E next = e.getNext(); e.setPrevious(null); e.setNext(null); e = next; } first = last = null; } @Override public boolean contains(Object o) { return (o instanceof Linked<?>) && contains((Linked<?>) o); } // A fast-path containment check boolean contains(Linked<?> e) { return (e.getPrevious() != null) || (e.getNext() != null) || (e == first); } /** * Moves the element to the front of the deque so that it becomes the first * element. * * @param e the linked element */ public void moveToFront(E e) { if (e != first) { unlink(e); linkFirst(e); } } /** * Moves the element to the back of the deque so that it becomes the last * element. * * @param e the linked element */ public void moveToBack(E e) { if (e != last) { unlink(e); linkLast(e); } } @Override public E peek() { return peekFirst(); } @Override public E peekFirst() { return first; } @Override public E peekLast() { return last; } @Override public E getFirst() { checkNotEmpty(); return peekFirst(); } @Override public E getLast() { checkNotEmpty(); return peekLast(); } @Override public E element() { return getFirst(); } @Override public boolean offer(E e) { return offerLast(e); } @Override public boolean offerFirst(E e) { if (contains(e)) { return false; } linkFirst(e); return true; } @Override public boolean offerLast(E e) { if (contains(e)) { return false; } linkLast(e); return true; } @Override public boolean add(E e) { return offerLast(e); } @Override public void addFirst(E e) { if (!offerFirst(e)) { throw new IllegalArgumentException(); } } @Override public void addLast(E e) { if (!offerLast(e)) { throw new IllegalArgumentException(); } } @Override public E poll() { return pollFirst(); } @Override public E pollFirst() { return isEmpty() ? null : unlinkFirst(); } @Override public E pollLast() { return isEmpty() ? null : unlinkLast(); } @Override public E remove() { return removeFirst(); } @Override @SuppressWarnings("unchecked") public boolean remove(Object o) { return (o instanceof Linked<?>) && remove((E) o); } // A fast-path removal boolean remove(E e) { if (contains(e)) { unlink(e); return true; } return false; } @Override public E removeFirst() { checkNotEmpty(); return pollFirst(); } @Override public boolean removeFirstOccurrence(Object o) { return remove(o); } @Override public E removeLast() { checkNotEmpty(); return pollLast(); } @Override public boolean removeLastOccurrence(Object o) { return remove(o); } @Override public boolean removeAll(Collection<?> c) { boolean modified = false; for (Object o : c) { modified |= remove(o); } return modified; } @Override public void push(E e) { addFirst(e); } @Override public E pop() { return removeFirst(); } @Override public Iterator<E> iterator() { return new AbstractLinkedIterator(first) { @Override E computeNext() { return cursor.getNext(); } }; } @Override public Iterator<E> descendingIterator() { return new AbstractLinkedIterator(last) { @Override E computeNext() { return cursor.getPrevious(); } }; } abstract class AbstractLinkedIterator implements Iterator<E> { E cursor; /** * Creates an iterator that can can traverse the deque. * * @param start the initial element to begin traversal from */ AbstractLinkedIterator(E start) { cursor = start; } @Override public boolean hasNext() { return (cursor != null); } @Override public E next() { if (!hasNext()) { throw new NoSuchElementException(); } E e = cursor; cursor = computeNext(); return e; } @Override public void remove() { throw new UnsupportedOperationException(); } /** * Retrieves the next element to traverse to or <tt>null</tt> if there are * no more elements. */ abstract E computeNext(); } } /** * An element that is linked on the {@link Deque}. */ interface Linked<T extends Linked<T>> { /** * Retrieves the previous element or <tt>null</tt> if either the element is * unlinked or the first element on the deque. */ T getPrevious(); /** Sets the previous element or <tt>null</tt> if there is no link. */ void setPrevious(T prev); /** * Retrieves the next element or <tt>null</tt> if either the element is * unlinked or the last element on the deque. */ T getNext(); /** Sets the next element or <tt>null</tt> if there is no link. */ void setNext(T next); }
⏎ com/fasterxml/jackson/databind/util/internal/LinkedDeque.java
Or download all of them as a single archive file:
File name: jackson-databind-2.14.0-sources.jar File size: 1187952 bytes Release date: 2022-11-05 Download
⇒ Jackson Annotations Source Code
⇐ Download and Install Jackson Binary Package
2022-03-29, 110733👍, 0💬
Popular Posts:
JDK 11 java.base.jmod is the JMOD file for JDK 11 Base module. JDK 11 Base module compiled class fil...
How to read XML document with DTD validation from socket connections with the socket\DelayedInput.ja.. .
SLF4J API is a simple API that allows to plug in any desired logging library at deployment time. Her...
JDK 11 jdk.jlink.jmod is the JMOD file for JDK 11 JLink tool, which can be invoked by the "jlink" co...
JDK 11 jdk.internal.opt.jmod is the JMOD file for JDK 11 Internal Opt module. JDK 11 Internal Opt mo...