package org.snmp4j.agent.mo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.SortedMap;
import java.util.Vector;
import org.snmp4j.agent.mo.MOTableRow;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.Variable;

/* JADX INFO: loaded from: classes.dex */
public class DefaultMOMutableTableModel<R extends MOTableRow> extends DefaultMOTableModel<R> implements MOMutableTableModel<R> {
    private transient Vector<MOTableModelListener> moTableModelListeners;
    protected MOTableRowFactory<R> rowFactory;

    public class FilteredRowIterator implements Iterator<R> {
        private MOTableRowFilter<R> filter;
        private Iterator<R> iterator;
        private R next;

        FilteredRowIterator(MOTableRowFilter<R> mOTableRowFilter) {
            this.filter = mOTableRowFilter;
            this.iterator = (Iterator<R>) DefaultMOMutableTableModel.this.iterator();
        }

        private void findNext() {
            while (this.iterator.hasNext()) {
                R next = this.iterator.next();
                this.next = next;
                if (this.filter.passesFilter(next)) {
                    return;
                } else {
                    this.next = null;
                }
            }
        }

        @Override // java.util.Iterator
        public boolean hasNext() {
            if (this.next != null) {
                return true;
            }
            findNext();
            return this.next != null;
        }

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

        @Override // java.util.Iterator
        public R next() {
            if (this.next == null) {
                findNext();
            }
            R r = this.next;
            if (r == null) {
                throw new NoSuchElementException();
            }
            this.next = null;
            return r;
        }
    }

    private SortedMap<OID, R> getView(OID oid, OID oid2) {
        return (oid == null && oid2 == null) ? this.rows : oid == null ? this.rows.headMap(oid2) : oid2 == null ? this.rows.tailMap(oid) : this.rows.subMap(oid, oid2);
    }

    public synchronized void addMOTableModelListener(MOTableModelListener mOTableModelListener) {
        if (this.moTableModelListeners == null) {
            this.moTableModelListeners = new Vector<>(2);
        }
        this.moTableModelListeners.add(mOTableModelListener);
    }

    @Override // org.snmp4j.agent.mo.DefaultMOTableModel, org.snmp4j.agent.mo.MOMutableTableModel
    public R addRow(R r) {
        R r2 = (R) super.addRow(r);
        if (this.moTableModelListeners != null) {
            fireTableModelChanged(new MOTableModelEvent(this, 1, r));
        }
        return r2;
    }

    @Override // org.snmp4j.agent.mo.MOMutableTableModel
    public synchronized void clear() {
        fireTableModelChanged(new MOTableModelEvent(this, 3));
        this.rows.clear();
    }

    @Override // org.snmp4j.agent.mo.MOTableRowFactory
    public R createRow(OID oid, Variable[] variableArr) throws UnsupportedOperationException {
        MOTableRowFactory<R> mOTableRowFactory = this.rowFactory;
        if (mOTableRowFactory != null) {
            return (R) mOTableRowFactory.createRow(oid, variableArr);
        }
        throw new UnsupportedOperationException("No row factory");
    }

    protected void fireTableModelChanged(MOTableModelEvent mOTableModelEvent) {
        Vector<MOTableModelListener> vector = this.moTableModelListeners;
        if (vector != null) {
            synchronized (vector) {
                Iterator<MOTableModelListener> it = vector.iterator();
                while (it.hasNext()) {
                    it.next().tableModelChanged(mOTableModelEvent);
                }
            }
        }
    }

    @Override // org.snmp4j.agent.mo.MOTableRowFactory
    public void freeRow(R r) {
        MOTableRowFactory<R> mOTableRowFactory = this.rowFactory;
        if (mOTableRowFactory != null) {
            mOTableRowFactory.freeRow(r);
        }
    }

    @Override // org.snmp4j.agent.mo.MOMutableTableModel
    public MOTableRowFactory<R> getRowFactory() {
        return this.rowFactory;
    }

    public synchronized List<MOTableRow> getRows(OID oid, OID oid2) {
        return new ArrayList(getView(oid, oid2).values());
    }

    public synchronized Iterator<R> iterator(MOTableRowFilter<R> mOTableRowFilter) {
        return new FilteredRowIterator(mOTableRowFilter);
    }

    public synchronized void removeMOTableModelListener(MOTableModelListener mOTableModelListener) {
        if (this.moTableModelListeners != null) {
            this.moTableModelListeners.remove(mOTableModelListener);
        }
    }

    @Override // org.snmp4j.agent.mo.MOMutableTableModel
    public synchronized R removeRow(OID oid) {
        R rRemove;
        rRemove = this.rows.remove(oid);
        if (rRemove != null && this.moTableModelListeners != null) {
            fireTableModelChanged(new MOTableModelEvent(this, 2, rRemove));
        }
        return rRemove;
    }

    public synchronized void removeRows(OID oid, OID oid2) {
        Iterator<Map.Entry<OID, R>> it = (oid == null ? this.rows : this.rows.tailMap(oid)).entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<OID, R> next = it.next();
            if (oid2 != null && oid2.compareTo((Variable) next.getKey()) <= 0) {
                break;
            }
            if (this.moTableModelListeners != null) {
                fireTableModelChanged(new MOTableModelEvent(this, 2, next.getValue()));
            }
            it.remove();
        }
    }

    public void setColumnCount(int i2) {
        this.columnCount = i2;
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // org.snmp4j.agent.mo.MOMutableTableModel
    public <F extends MOTableRowFactory<R>> void setRowFactory(F f2) {
        this.rowFactory = f2;
    }

    public synchronized List<R> getRows(OID oid, OID oid2, MOTableRowFilter<R> mOTableRowFilter) {
        LinkedList linkedList;
        linkedList = new LinkedList();
        for (R r : getView(oid, oid2).values()) {
            if (mOTableRowFilter.passesFilter(r)) {
                linkedList.add(r);
            }
        }
        return linkedList;
    }

    @Override // org.snmp4j.agent.mo.MOMutableTableModel
    public synchronized void clear(MOTableRowFilter<R> mOTableRowFilter) {
        Iterator<R> it = this.rows.values().iterator();
        while (it.hasNext()) {
            R next = it.next();
            if (!mOTableRowFilter.passesFilter(next)) {
                if (this.moTableModelListeners != null) {
                    fireTableModelChanged(new MOTableModelEvent(this, 2, next));
                }
                it.remove();
            }
        }
    }
}