package org.snmp4j.agent.util;

import java.util.Iterator;
import java.util.LinkedList;
import org.snmp4j.mp.SnmpConstants;

/* JADX INFO: loaded from: classes.dex */
public class TemporaryList<T> {
    public static final int DEFAULT_ITEM_TIMEOUT = 300000;
    private LinkedList<TemporaryList<T>.TemporaryListItem<T>> list;
    private int timeout;

    class TemporaryListItem<T> {
        private T item;
        private long timeOfMaturity;

        public TemporaryListItem(T t) {
            this.item = t;
            this.timeOfMaturity = System.nanoTime() + ((long) (TemporaryList.this.timeout * SnmpConstants.MILLISECOND_TO_NANOSECOND));
        }

        public boolean atMaturity(long j2) {
            return j2 > this.timeOfMaturity;
        }

        public boolean equals(Object obj) {
            return (obj instanceof TemporaryList) && this.item.equals(obj);
        }

        public T getItem() {
            return this.item;
        }

        public long getTimeOfMaturity() {
            return this.timeOfMaturity;
        }

        public int hashCode() {
            return this.item.hashCode();
        }
    }

    class TemporaryListIterator<T> implements Iterator<T> {
        private Iterator<TemporaryList<T>.TemporaryListItem<T>> iterator;

        public TemporaryListIterator(LinkedList<TemporaryList<T>.TemporaryListItem<T>> linkedList) {
            this.iterator = linkedList.iterator();
        }

        @Override // java.util.Iterator
        public boolean hasNext() {
            return this.iterator.hasNext();
        }

        @Override // java.util.Iterator
        public T next() {
            return this.iterator.next().getItem();
        }

        @Override // java.util.Iterator
        public void remove() {
            this.iterator.remove();
        }
    }

    public TemporaryList() {
        this.timeout = DEFAULT_ITEM_TIMEOUT;
        this.list = new LinkedList<>();
    }

    public synchronized void add(T t) {
        long jNanoTime = System.nanoTime();
        if (this.list.size() > 0 && this.list.getFirst().atMaturity(jNanoTime)) {
            this.list.removeFirst();
        }
        if (this.list.size() > 0 && this.list.getLast().atMaturity(jNanoTime)) {
            this.list.removeLast();
        }
        this.list.addFirst(new TemporaryListItem<>(t));
    }

    public synchronized void clear() {
        this.list.clear();
    }

    public synchronized boolean contains(T t) {
        Iterator<TemporaryList<T>.TemporaryListItem<T>> it = this.list.iterator();
        while (it.hasNext()) {
            if (it.next().getItem().equals(t)) {
                return true;
            }
        }
        return false;
    }

    public int getTimeout() {
        return this.timeout;
    }

    public Iterator<T> iterator() {
        return new TemporaryListIterator(this.list);
    }

    public synchronized boolean remove(T t) {
        long jNanoTime = System.nanoTime();
        Iterator<TemporaryList<T>.TemporaryListItem<T>> it = this.list.iterator();
        while (it.hasNext()) {
            TemporaryList<T>.TemporaryListItem<T> next = it.next();
            if (next.getItem().equals(t)) {
                it.remove();
                return true;
            }
            if (next.atMaturity(jNanoTime)) {
                it.remove();
            }
        }
        return false;
    }

    public void setTimeout(int i2) {
        this.timeout = i2;
    }

    public int size() {
        return this.list.size();
    }

    public TemporaryList(int i2) {
        this.timeout = DEFAULT_ITEM_TIMEOUT;
        this.list = new LinkedList<>();
        this.timeout = i2;
    }
}