package org.snmp4j.agent.mo;

import java.io.IOException;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.Vector;
import java.util.WeakHashMap;
import org.snmp4j.agent.DefaultMOScope;
import org.snmp4j.agent.MOScope;
import org.snmp4j.agent.ManagedObject;
import org.snmp4j.agent.SerializableManagedObject;
import org.snmp4j.agent.io.IndexedVariables;
import org.snmp4j.agent.io.MOInput;
import org.snmp4j.agent.io.MOOutput;
import org.snmp4j.agent.io.Sequence;
import org.snmp4j.agent.mo.MOColumn;
import org.snmp4j.agent.mo.MOTableModel;
import org.snmp4j.agent.mo.MOTableRow;
import org.snmp4j.agent.request.Request;
import org.snmp4j.agent.request.SubRequest;
import org.snmp4j.agent.util.OIDScope;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.smi.Null;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.Variable;
import org.snmp4j.smi.VariableBinding;

/* JADX INFO: loaded from: classes.dex */
public class DefaultMOTable<R extends MOTableRow, C extends MOColumn, M extends MOTableModel<R>> implements MOTable<R, C, M>, MOScope, SerializableManagedObject {
    private C[] columns;
    private MOTableIndex indexDef;
    private boolean isVolatile;
    protected transient Vector<MOChangeListener> moChangeListeners;
    protected transient Vector<MOTableRowListener<R>> moTableRowListeners;
    protected M model;
    protected WeakHashMap<Request, Map<OID, R>> newRows;
    private OID oid;
    protected WeakHashMap<Request, Map<OID, ChangeSet>> pendingChanges;
    private transient WeakHashMap<Request, RowCacheEntry> walkCache;
    private static LogAdapter logger = LogFactory.getLogger(DefaultMOTable.class);
    private static Comparator columnComparator = new Comparator() { // from class: org.snmp4j.agent.mo.DefaultMOTable.1
        @Override // java.util.Comparator
        public int compare(Object obj, Object obj2) {
            return (obj instanceof MOColumn ? ((MOColumn) obj).getColumnID() : ((Integer) obj).intValue()) - (obj2 instanceof MOColumn ? ((MOColumn) obj2).getColumnID() : ((Integer) obj2).intValue());
        }
    };

    class CellProxy implements ManagedObject {
        private MOTableCellInfo cellInfo;
        private MOScope scope;

        public CellProxy(MOTableCellInfo mOTableCellInfo) {
            this.cellInfo = mOTableCellInfo;
            this.scope = new OIDScope(mOTableCellInfo.getCellOID());
        }

        @Override // org.snmp4j.agent.ManagedObject
        public void cleanup(SubRequest subRequest) {
            DefaultMOTable.this.cleanup(subRequest);
        }

        @Override // org.snmp4j.agent.ManagedObject
        public void commit(SubRequest subRequest) {
            DefaultMOTable.this.commit(subRequest);
        }

        @Override // org.snmp4j.agent.ManagedObject
        public OID find(MOScope mOScope) {
            if (mOScope.isCovered(this.scope)) {
                return this.cellInfo.getCellOID();
            }
            return null;
        }

        @Override // org.snmp4j.agent.ManagedObject
        public void get(SubRequest subRequest) {
            DefaultMOTable.this.get(subRequest);
        }

        @Override // org.snmp4j.agent.ManagedObject
        public MOScope getScope() {
            return this.scope;
        }

        public MOTable getTable() {
            return DefaultMOTable.this;
        }

        @Override // org.snmp4j.agent.ManagedObject
        public boolean next(SubRequest subRequest) {
            return DefaultMOTable.this.next(subRequest);
        }

        @Override // org.snmp4j.agent.ManagedObject
        public void prepare(SubRequest subRequest) {
            DefaultMOTable.this.prepare(subRequest);
        }

        @Override // org.snmp4j.agent.ManagedObject
        public void undo(SubRequest subRequest) {
            DefaultMOTable.this.undo(subRequest);
        }
    }

    public static class ChangeSet implements MOTableRow {
        private OID index;
        private int lastChangedColumn = -1;
        private Variable[] values;

        public ChangeSet(OID oid, Variable[] variableArr) {
            this.index = oid;
            this.values = variableArr;
        }

        @Override // org.snmp4j.agent.mo.MOTableRow
        public MOTableRow getBaseRow() {
            return null;
        }

        @Override // org.snmp4j.agent.mo.MOTableRow
        public OID getIndex() {
            return this.index;
        }

        public int getLastChangedColumn() {
            return this.lastChangedColumn;
        }

        @Override // org.snmp4j.agent.mo.MOTableRow
        public Variable getValue(int i2) {
            return this.values[i2];
        }

        @Override // org.snmp4j.agent.mo.MOTableRow, org.snmp4j.agent.mo.MOMutableTableRow
        public void setBaseRow(MOTableRow mOTableRow) {
            throw new UnsupportedOperationException();
        }

        public void setValue(int i2, Variable variable) {
            this.values[i2] = variable;
            this.lastChangedColumn = i2;
        }

        @Override // org.snmp4j.agent.mo.MOTableRow
        public int size() {
            return this.values.length;
        }
    }

    private static class RowCacheEntry {
        private MOTableRow row;
        private OID searchLowerBound;
        private boolean searchLowerBoundIncluded;

        RowCacheEntry(MOTableRow mOTableRow, OID oid, boolean z) {
            this.row = mOTableRow;
            this.searchLowerBound = oid;
            this.searchLowerBoundIncluded = z;
        }
    }

    public DefaultMOTable(OID oid, MOTableIndex mOTableIndex, C[] cArr) {
        this(oid, mOTableIndex, cArr, new DefaultMOMutableTableModel());
    }

    private void addWalkCacheEntry(SubRequest subRequest, OID oid, boolean z, MOTableRow mOTableRow) {
        if (this.walkCache == null) {
            this.walkCache = new WeakHashMap<>(4);
        }
        this.walkCache.put(subRequest.getRequest(), new RowCacheEntry(mOTableRow, oid, z));
    }

    private MOTableCellInfo getNextCell(int i2, OID oid, boolean z) {
        R next;
        int i3 = i2;
        while (i3 < this.columns.length) {
            Iterator<R> itTailIterator = this.model.tailIterator(oid);
            if (itTailIterator.hasNext()) {
                if (oid != null && !z) {
                    R next2 = itTailIterator.next();
                    if (next2.getIndex().compareTo((Variable) oid) > 0) {
                        return new CellInfo(this, next2.getIndex(), i3, this.columns[i3].getColumnID(), next2);
                    }
                }
                if (itTailIterator.hasNext() && (next = itTailIterator.next()) != null) {
                    return new CellInfo(this, next.getIndex(), i3, this.columns[i3].getColumnID(), next);
                }
            } else if (oid == null) {
                return null;
            }
            i3++;
            z = true;
            oid = null;
        }
        return null;
    }

    private RowCacheEntry getWalkCacheEntry(SubRequest subRequest, MOTableCellInfo mOTableCellInfo, boolean z) {
        RowCacheEntry rowCacheEntry;
        WeakHashMap<Request, RowCacheEntry> weakHashMap = this.walkCache;
        if (weakHashMap == null || (rowCacheEntry = weakHashMap.get(subRequest.getRequest())) == null) {
            return null;
        }
        if ((rowCacheEntry.searchLowerBound == null && mOTableCellInfo.getIndex() == null) || (rowCacheEntry.searchLowerBound != null && rowCacheEntry.searchLowerBound.equals(mOTableCellInfo.getIndex()) && z == rowCacheEntry.searchLowerBoundIncluded)) {
            return rowCacheEntry;
        }
        return null;
    }

    private void registerColumns() {
        for (C c2 : this.columns) {
            c2.setTable(this);
        }
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public synchronized void addMOChangeListener(MOChangeListener mOChangeListener) {
        if (this.moChangeListeners == null) {
            this.moChangeListeners = new Vector<>(2);
        }
        this.moChangeListeners.add(mOChangeListener);
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public synchronized void addMOTableRowListener(MOTableRowListener<R> mOTableRowListener) {
        if (this.moTableRowListeners == null) {
            this.moTableRowListeners = new Vector<>(2);
        }
        this.moTableRowListeners.add(mOTableRowListener);
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public R addNewRow(OID oid, Variable[] variableArr) {
        R r = (R) createRow(oid, variableArr);
        if (r != null) {
            addRow(r);
        }
        return r;
    }

    protected synchronized ChangeSet addPendingChanges(SubRequest subRequest, MOTableRow mOTableRow, boolean z) {
        ChangeSet changeSet;
        if (this.pendingChanges == null) {
            this.pendingChanges = new WeakHashMap<>(4);
        }
        Map<OID, ChangeSet> map = this.pendingChanges.get(subRequest.getRequest());
        if (map == null) {
            map = new HashMap<>(5);
            this.pendingChanges.put(subRequest.getRequest(), map);
        }
        Variable[] variableArr = new Variable[getColumnCount()];
        int changesFromRequest = getChangesFromRequest(mOTableRow.getIndex(), mOTableRow, subRequest, variableArr, z, z);
        changeSet = new ChangeSet(mOTableRow.getIndex(), variableArr);
        changeSet.lastChangedColumn = changesFromRequest;
        map.put(mOTableRow.getIndex(), changeSet);
        return changeSet;
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public boolean addRow(R r) {
        if (!(this.model instanceof MOMutableTableModel)) {
            return false;
        }
        MOTableRowEvent<R> mOTableRowEvent = new MOTableRowEvent<>((Object) this, (MOTable) this, (MOTableRow) r, 2, true);
        fireRowChanged(mOTableRowEvent);
        if (mOTableRowEvent.getVetoStatus() != 0) {
            return false;
        }
        ((MOMutableTableModel) this.model).addRow(r);
        return true;
    }

    @Override // org.snmp4j.agent.ManagedObject
    public void cleanup(SubRequest subRequest) {
        MOTableCellInfo cellInfo = getCellInfo(subRequest.getVariableBinding().getOid());
        if (cellInfo.getIndex() == null || cellInfo.getColumn() < 0) {
            return;
        }
        MOColumn column = getColumn(cellInfo.getColumn());
        if (logger.isDebugEnabled()) {
            logger.debug("Cleaning-up sub-request (" + subRequest.getVariableBinding() + ") for column: " + column);
        }
        MOMutableTableRow mOMutableTableRow = (MOMutableTableRow) this.model.getRow(cellInfo.getIndex());
        if (mOMutableTableRow != null && (column instanceof MOMutableColumn)) {
            ((MOMutableColumn) column).cleanup(subRequest, mOMutableTableRow, cellInfo.getColumn());
        }
        if ((mOMutableTableRow instanceof MOMutableRow2PC) && isChangeSetComplete(subRequest, mOMutableTableRow.getIndex(), cellInfo.getColumn())) {
            ((MOMutableRow2PC) mOMutableTableRow).cleanupRow(subRequest, getPendingChangeSet(subRequest, mOMutableTableRow.getIndex()));
        }
        subRequest.completed();
    }

    @Override // org.snmp4j.agent.ManagedObject
    public void commit(SubRequest subRequest) {
        R row;
        MOTableCellInfo cellInfo = getCellInfo(subRequest.getVariableBinding().getOid());
        MOMutableColumn mOMutableColumn = (MOMutableColumn) getColumn(cellInfo.getColumn());
        if (logger.isDebugEnabled()) {
            logger.debug("Committing sub-request (" + subRequest.getVariableBinding() + ") for column: " + mOMutableColumn);
        }
        synchronized (this.model) {
            if (hasNewRows(subRequest.getRequest())) {
                row = getNewRows(subRequest.getRequest()).get(cellInfo.getIndex());
                if (!this.model.containsRow(row.getIndex()) && !addRow(row)) {
                    subRequest.setErrorStatus(13);
                    return;
                }
            } else {
                row = this.model.getRow(cellInfo.getIndex());
            }
            Variable value = null;
            if (this.moChangeListeners != null) {
                value = row.getValue(cellInfo.getColumn());
                fireBeforeMOChange(new MOChangeEvent(this, new CellProxy(cellInfo), cellInfo.getCellOID(), value, subRequest.getVariableBinding().getVariable(), false));
            }
            Variable variable = value;
            ChangeSet pendingChangeSet = getPendingChangeSet(subRequest, cellInfo.getIndex());
            mOMutableColumn.commit(subRequest, row, pendingChangeSet, cellInfo.getColumn());
            if (this.moChangeListeners != null) {
                fireAfterMOChange(new MOChangeEvent(this, new CellProxy(cellInfo), cellInfo.getCellOID(), variable, subRequest.getVariableBinding().getVariable(), false));
            }
            if (isChangeSetComplete(subRequest, cellInfo.getIndex(), cellInfo.getColumn())) {
                if (row instanceof MOMutableRow2PC) {
                    ((MOMutableRow2PC) row).commitRow(subRequest, pendingChangeSet);
                }
                if (this.moTableRowListeners != null) {
                    fireRowChanged(new MOTableRowEvent<>(this, this, row, 4));
                }
            }
        }
    }

    @Override // org.snmp4j.agent.MOScope
    public boolean covers(OID oid) {
        return isCovered(new DefaultMOScope(oid, true, oid, true));
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public R createRow(OID oid, Variable[] variableArr) {
        if (!(this.model instanceof MOMutableTableModel)) {
            return null;
        }
        if (variableArr.length < getColumnCount()) {
            Variable[] defaultValues = getDefaultValues();
            System.arraycopy(variableArr, 0, defaultValues, 0, variableArr.length);
            variableArr = defaultValues;
        }
        R r = (R) ((MOMutableTableModel) this.model).createRow(oid, variableArr);
        MOTableRowEvent<R> mOTableRowEvent = new MOTableRowEvent<>((Object) this, (MOTable) this, (MOTableRow) r, 1, true);
        fireRowChanged(mOTableRowEvent);
        if (mOTableRowEvent.getVetoStatus() == 0) {
            return r;
        }
        return null;
    }

    @Override // org.snmp4j.agent.mo.MOTable, org.snmp4j.agent.ManagedObject
    public OID find(MOScope mOScope) {
        MOTableCellInfo mOTableCellInfoFindCell = findCell(mOScope, null);
        if (mOTableCellInfoFindCell != null) {
            return mOTableCellInfoFindCell.getCellOID();
        }
        return null;
    }

    protected MOTableCellInfo findCell(MOScope mOScope, SubRequest subRequest) {
        int i2;
        boolean z;
        MOTableCellInfo cellInfo;
        synchronized (this.model) {
            update(mOScope, subRequest);
            if (this.model.isEmpty()) {
                return null;
            }
            MOTableCellInfo cellInfo2 = getCellInfo(mOScope.getLowerBound());
            int column = cellInfo2.getColumn();
            if (column < 0) {
                i2 = (-column) - 1;
                z = false;
            } else {
                i2 = column;
                z = true;
            }
            if (i2 >= this.columns.length) {
                return null;
            }
            boolean z2 = !z || mOScope.isLowerIncluded();
            RowCacheEntry walkCacheEntry = subRequest != null ? getWalkCacheEntry(subRequest, cellInfo2, z2) : null;
            if (walkCacheEntry != null) {
                cellInfo = new CellInfo(this, walkCacheEntry.row.getIndex(), i2, cellInfo2.getColumnID(), walkCacheEntry.row);
            } else {
                MOTableCellInfo nextCell = getNextCell(i2, cellInfo2.getIndex(), z2);
                if (subRequest != null && nextCell != null && nextCell.getColumn() == i2) {
                    addWalkCacheEntry(subRequest, cellInfo2.getIndex(), z2, ((CellInfo) nextCell).row);
                }
                cellInfo = nextCell;
            }
            if (cellInfo == null || !mOScope.isCovered(new OIDScope(cellInfo.getCellOID()))) {
                return null;
            }
            return cellInfo;
        }
    }

    protected void fireAfterMOChange(MOChangeEvent mOChangeEvent) {
        Vector<MOChangeListener> vector = this.moChangeListeners;
        if (vector != null) {
            int size = vector.size();
            for (int i2 = 0; i2 < size; i2++) {
                vector.elementAt(i2).afterMOChange(mOChangeEvent);
            }
        }
    }

    protected void fireAfterPrepareMOChange(MOChangeEvent mOChangeEvent) {
        Vector<MOChangeListener> vector = this.moChangeListeners;
        if (vector != null) {
            int size = vector.size();
            for (int i2 = 0; i2 < size; i2++) {
                vector.elementAt(i2).afterPrepareMOChange(mOChangeEvent);
            }
        }
    }

    protected void fireBeforeMOChange(MOChangeEvent mOChangeEvent) {
        Vector<MOChangeListener> vector = this.moChangeListeners;
        if (vector != null) {
            int size = vector.size();
            for (int i2 = 0; i2 < size; i2++) {
                vector.elementAt(i2).beforeMOChange(mOChangeEvent);
            }
        }
    }

    protected void fireBeforePrepareMOChange(MOChangeEvent mOChangeEvent) {
        Vector<MOChangeListener> vector = this.moChangeListeners;
        if (vector != null) {
            int size = vector.size();
            for (int i2 = 0; i2 < size; i2++) {
                vector.elementAt(i2).beforePrepareMOChange(mOChangeEvent);
            }
        }
    }

    protected void fireRowChanged(MOTableRowEvent<R> mOTableRowEvent) {
        Vector<MOTableRowListener<R>> vector = this.moTableRowListeners;
        if (vector != null) {
            Iterator<MOTableRowListener<R>> it = vector.iterator();
            while (it.hasNext()) {
                it.next().rowChanged(mOTableRowEvent);
            }
        }
    }

    @Override // org.snmp4j.agent.ManagedObject
    public void get(SubRequest subRequest) {
        MOTableCellInfo cellInfo = getCellInfo(subRequest.getVariableBinding().getOid());
        if (cellInfo.getIndex() != null && cellInfo.getColumn() >= 0 && cellInfo.getColumn() < this.columns.length) {
            update(subRequest.getScope(), subRequest);
            MOColumn column = getColumn(cellInfo.getColumn());
            MOTableRow row = this.model.getRow(cellInfo.getIndex());
            if (row == null) {
                subRequest.getVariableBinding().setVariable(Null.noSuchInstance);
            } else if (column != null) {
                column.get(subRequest, row, cellInfo.getColumn());
            } else {
                subRequest.getStatus().setErrorStatus(6);
            }
        } else if (cellInfo.getColumn() >= 0) {
            subRequest.getVariableBinding().setVariable(Null.noSuchInstance);
        } else {
            subRequest.getVariableBinding().setVariable(Null.noSuchObject);
        }
        subRequest.completed();
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public MOTableCellInfo getCellInfo(OID oid) {
        return new CellInfo(this, oid);
    }

    public OID getCellOID(OID oid, int i2) {
        OID oid2 = new OID(this.oid);
        oid2.append(this.columns[i2].getColumnID());
        oid2.append(oid);
        return oid2;
    }

    protected int getChangesFromRequest(OID oid, MOTableRow mOTableRow, SubRequest subRequest, Variable[] variableArr, boolean z, boolean z2) {
        int column;
        Variable variable;
        if (z) {
            for (int i2 = 0; i2 < variableArr.length && i2 < getColumnCount(); i2++) {
                C[] cArr = this.columns;
                if (cArr[i2] instanceof MOMutableColumn) {
                    variableArr[i2] = ((MOMutableColumn) cArr[i2]).getDefaultValue();
                }
            }
        }
        int i3 = -1;
        for (SubRequest subRequest2 : subRequest.getRequest()) {
            MOTableCellInfo cellInfo = getCellInfo(subRequest2.getVariableBinding().getOid());
            if (oid.equals(cellInfo.getIndex()) && (column = cellInfo.getColumn()) >= 0 && column < variableArr.length && (variable = subRequest2.getVariableBinding().getVariable()) != null && (mOTableRow == null || z2 || mOTableRow.size() <= column || !variable.equals(mOTableRow.getValue(column)))) {
                variableArr[column] = variable;
                i3 = column;
            }
        }
        return i3;
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public C getColumn(int i2) {
        return this.columns[i2];
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public int getColumnCount() {
        return this.columns.length;
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public int getColumnIndex(int i2) {
        return Arrays.binarySearch(this.columns, Integer.valueOf(i2), columnComparator);
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public C[] getColumns() {
        return this.columns;
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public Variable[] getDefaultValues() {
        int columnCount = getColumnCount();
        Variable[] variableArr = new Variable[columnCount];
        for (int i2 = 0; i2 < columnCount; i2++) {
            C[] cArr = this.columns;
            if (cArr[i2] instanceof MOMutableColumn) {
                variableArr[i2] = ((MOMutableColumn) cArr[i2]).getDefaultValue();
            }
        }
        return variableArr;
    }

    @Override // org.snmp4j.agent.RegisteredManagedObject
    public OID getID() {
        return getLowerBound();
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public MOTableIndex getIndexDef() {
        return this.indexDef;
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public final OID getIndexPart(OID oid) {
        int size = this.oid.size() + 1;
        if (oid.size() <= size || !oid.startsWith(this.oid)) {
            return null;
        }
        return new OID(oid.getValue(), size, oid.size() - size);
    }

    @Override // org.snmp4j.agent.MOScope
    public OID getLowerBound() {
        return this.oid;
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public M getModel() {
        return this.model;
    }

    protected Map<OID, R> getNewRows(Request request) {
        if (this.newRows == null) {
            this.newRows = new WeakHashMap<>(4);
        }
        Map<OID, R> map = this.newRows.get(request);
        if (map != null) {
            return map;
        }
        HashMap map2 = new HashMap(5);
        this.newRows.put(request, map2);
        return map2;
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public OID getOID() {
        return this.oid;
    }

    protected ChangeSet getPendingChangeSet(SubRequest subRequest, OID oid) {
        Map<OID, ChangeSet> map;
        WeakHashMap<Request, Map<OID, ChangeSet>> weakHashMap = this.pendingChanges;
        if (weakHashMap == null || (map = weakHashMap.get(subRequest.getRequest())) == null) {
            return null;
        }
        return map.get(oid);
    }

    protected Variable[] getPersistentValues(MOTableRow mOTableRow) {
        int size = mOTableRow.size();
        Variable[] variableArr = new Variable[size];
        for (int i2 = 0; i2 < size && i2 < getColumnCount(); i2++) {
            variableArr[i2] = getColumn(i2).getStoreValue(mOTableRow, i2);
        }
        return variableArr;
    }

    @Override // org.snmp4j.agent.ManagedObject
    public MOScope getScope() {
        return this;
    }

    @Override // org.snmp4j.agent.MOScope
    public OID getUpperBound() {
        OID oid = new OID(this.oid);
        int size = this.oid.size() - 1;
        oid.set(size, this.oid.get(size) + 1);
        return oid;
    }

    @Override // org.snmp4j.agent.mo.MOTable, org.snmp4j.agent.ManagedObjectValueAccess
    public Variable getValue(OID oid) {
        MOTableCellInfo cellInfo = getCellInfo(oid);
        if (cellInfo.getIndex() == null || cellInfo.getColumn() < 0 || cellInfo.getColumn() >= this.columns.length) {
            return null;
        }
        return getValue(cellInfo.getIndex(), cellInfo.getColumn());
    }

    protected boolean hasNewRows(Request request) {
        WeakHashMap<Request, Map<OID, R>> weakHashMap = this.newRows;
        return (weakHashMap == null || weakHashMap.get(request) == null) ? false : true;
    }

    /* JADX WARN: Removed duplicated region for block: B:9:0x0010  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    protected synchronized boolean isChangeSetComplete(org.snmp4j.agent.request.SubRequest r1, org.snmp4j.smi.OID r2, int r3) {
        /*
            r0 = this;
            monitor-enter(r0)
            org.snmp4j.agent.mo.DefaultMOTable$ChangeSet r1 = r0.getPendingChangeSet(r1, r2)     // Catch: java.lang.Throwable -> L13
            if (r1 == 0) goto L10
            int r1 = r1.getLastChangedColumn()     // Catch: java.lang.Throwable -> L13
            if (r1 != r3) goto Le
            goto L10
        Le:
            r1 = 0
            goto L11
        L10:
            r1 = 1
        L11:
            monitor-exit(r0)
            return r1
        L13:
            r1 = move-exception
            monitor-exit(r0)
            throw r1
        */
        throw new UnsupportedOperationException("Method not decompiled: org.snmp4j.agent.mo.DefaultMOTable.isChangeSetComplete(org.snmp4j.agent.request.SubRequest, org.snmp4j.smi.OID, int):boolean");
    }

    @Override // org.snmp4j.agent.MOScope
    public boolean isCovered(MOScope mOScope) {
        return DefaultMOScope.covers(this, mOScope);
    }

    @Override // org.snmp4j.agent.MOScope
    public boolean isLowerIncluded() {
        return false;
    }

    @Override // org.snmp4j.agent.MOScope
    public boolean isOverlapping(MOScope mOScope) {
        return DefaultMOScope.overlaps(this, mOScope);
    }

    @Override // org.snmp4j.agent.MOScope
    public boolean isUpperIncluded() {
        return false;
    }

    @Override // org.snmp4j.agent.SerializableManagedObject
    public boolean isVolatile() {
        return this.isVolatile;
    }

    @Override // org.snmp4j.agent.SerializableManagedObject
    public void load(MOInput mOInput) throws IOException {
        if (mOInput.getImportMode() == 1) {
            int iRemoveAll = removeAll();
            if (logger.isDebugEnabled()) {
                logger.debug("Removed " + iRemoveAll + " rows from " + getID() + " because importing with a REPLACE import mode");
            }
        }
        Sequence sequence = mOInput.readSequence();
        for (int i2 = 0; i2 < sequence.getSize(); i2++) {
            IndexedVariables indexedVariables = mOInput.readIndexedVariables();
            Variable[] values = indexedVariables.getValues();
            for (int i3 = 0; i3 < values.length && i3 < getColumnCount(); i3++) {
                values[i3] = getColumn(i3).getRestoreValue(values, i3);
            }
            boolean zContainsRow = this.model.containsRow(indexedVariables.getIndex());
            if (mOInput.getImportMode() == 4 && zContainsRow) {
                logger.debug("Row '" + indexedVariables.getIndex() + "' not imported because it already exists in table " + getID() + " and import mode is CREATE");
            } else {
                if (zContainsRow) {
                    removeRow(indexedVariables.getIndex());
                }
                if (zContainsRow || mOInput.getImportMode() == 4 || mOInput.getImportMode() == 1 || mOInput.getImportMode() == 2) {
                    MOTableRow defaultMOTableRow = null;
                    try {
                        defaultMOTableRow = createRow(indexedVariables.getIndex(), indexedVariables.getValues());
                    } catch (UnsupportedOperationException e2) {
                        logger.debug("Could not create row by row factory: " + e2.getMessage());
                    }
                    if (defaultMOTableRow == null) {
                        defaultMOTableRow = new DefaultMOTableRow(indexedVariables.getIndex(), indexedVariables.getValues());
                        fireRowChanged(new MOTableRowEvent<>(this, this, defaultMOTableRow, 1));
                    }
                    if (logger.isDebugEnabled()) {
                        logger.debug("Loaded row " + defaultMOTableRow + " into table " + getOID());
                    }
                    addRow(defaultMOTableRow);
                }
            }
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:12:0x003d  */
    @Override // org.snmp4j.agent.ManagedObject
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public boolean next(org.snmp4j.agent.request.SubRequest r7) {
        /*
            r6 = this;
            org.snmp4j.agent.DefaultMOScope r0 = new org.snmp4j.agent.DefaultMOScope
            org.snmp4j.agent.MOScope r1 = r7.getScope()
            r0.<init>(r1)
        L9:
            org.snmp4j.agent.mo.MOTableCellInfo r1 = r6.findCell(r0, r7)
            r2 = 0
            if (r1 == 0) goto L98
            C extends org.snmp4j.agent.mo.MOColumn[] r3 = r6.columns
            int r4 = r1.getColumn()
            r3 = r3[r4]
            org.snmp4j.agent.MOAccess r3 = r3.getAccess()
            boolean r3 = r3.isAccessibleForRead()
            r4 = 1
            if (r3 == 0) goto L6c
            boolean r3 = r1 instanceof org.snmp4j.agent.mo.DefaultMOTable.CellInfo
            if (r3 == 0) goto L3d
            r3 = r1
            org.snmp4j.agent.mo.DefaultMOTable$CellInfo r3 = (org.snmp4j.agent.mo.DefaultMOTable.CellInfo) r3
            org.snmp4j.agent.mo.MOTableRow r5 = r3.getRow()
            if (r5 == 0) goto L3d
            org.snmp4j.agent.mo.MOTableRow r3 = r3.getRow()
            int r5 = r1.getColumn()
            org.snmp4j.smi.Variable r3 = r6.getValue(r3, r5)
            goto L49
        L3d:
            org.snmp4j.smi.OID r3 = r1.getIndex()
            int r5 = r1.getColumn()
            org.snmp4j.smi.Variable r3 = r6.getValue(r3, r5)
        L49:
            if (r3 != 0) goto L56
            org.snmp4j.smi.OID r1 = r1.getCellOID()
            r0.setLowerBound(r1)
            r0.setLowerIncluded(r2)
            goto L9
        L56:
            org.snmp4j.smi.VariableBinding r0 = r7.getVariableBinding()
            org.snmp4j.smi.OID r1 = r1.getCellOID()
            r0.setOid(r1)
            org.snmp4j.smi.VariableBinding r0 = r7.getVariableBinding()
            r0.setVariable(r3)
            r7.completed()
            return r4
        L6c:
            int r3 = r1.getColumn()
            int r3 = r3 + r4
            int r5 = r6.getColumnCount()
            if (r3 >= r5) goto L98
            org.snmp4j.smi.OID r3 = new org.snmp4j.smi.OID
            org.snmp4j.smi.OID r5 = r6.getOID()
            r3.<init>(r5)
            C extends org.snmp4j.agent.mo.MOColumn[] r5 = r6.columns
            int r1 = r1.getColumn()
            int r1 = r1 + r4
            r1 = r5[r1]
            int r1 = r1.getColumnID()
            r3.append(r1)
            r0.setLowerBound(r3)
            r0.setLowerIncluded(r2)
            goto L9
        L98:
            return r2
        */
        throw new UnsupportedOperationException("Method not decompiled: org.snmp4j.agent.mo.DefaultMOTable.next(org.snmp4j.agent.request.SubRequest):boolean");
    }

    @Override // org.snmp4j.agent.ManagedObject
    public void prepare(SubRequest subRequest) {
        MOTableRow mOTableRow;
        boolean z;
        MOTableCellInfo cellInfo = getCellInfo(subRequest.getVariableBinding().getOid());
        if (cellInfo.getIndex() == null) {
            subRequest.getStatus().setErrorStatus(18);
            return;
        }
        if (cellInfo.getColumn() < 0 || cellInfo.getColumn() >= this.columns.length) {
            subRequest.getStatus().setErrorStatus(11);
            return;
        }
        MOColumn column = getColumn(cellInfo.getColumn());
        if (logger.isDebugEnabled()) {
            logger.debug("Preparing sub-request (" + subRequest.getVariableBinding() + ") for column: " + column);
        }
        if (!(column instanceof MOMutableColumn) || !column.getAccess().isAccessibleForWrite()) {
            subRequest.getStatus().setErrorStatus(17);
            return;
        }
        MOMutableColumn mOMutableColumn = (MOMutableColumn) column;
        if (!getIndexDef().isValidIndex(cellInfo.getIndex())) {
            if (logger.isDebugEnabled()) {
                logger.debug("Invalid index '" + cellInfo.getIndex() + "' for row creation in table " + getID());
            }
            subRequest.getStatus().setErrorStatus(11);
            return;
        }
        MOTableRow row = this.model.getRow(cellInfo.getIndex());
        if (row == null) {
            mOTableRow = getNewRows(subRequest.getRequest()).get(cellInfo.getIndex());
            z = true;
        } else {
            mOTableRow = row;
            z = false;
        }
        if (mOTableRow != null) {
            prepare(subRequest, cellInfo, mOMutableColumn, mOTableRow, z);
            subRequest.completed();
            return;
        }
        if (!(this.model instanceof MOMutableTableModel)) {
            subRequest.getStatus().setErrorStatus(11);
            return;
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Trying to create new row '" + cellInfo.getIndex() + "'");
        }
        try {
            MOTableRow mOTableRowCreateRow = createRow(subRequest, cellInfo, (MOMutableTableModel) this.model);
            if (mOTableRowCreateRow == null) {
                subRequest.getStatus().setErrorStatus(11);
            } else {
                prepare(subRequest, cellInfo, mOMutableColumn, mOTableRowCreateRow, true);
                subRequest.completed();
            }
        } catch (UnsupportedOperationException unused) {
            subRequest.getStatus().setErrorStatus(11);
        }
    }

    public int removeAll() {
        if (!(this.model instanceof MOMutableTableModel)) {
            return -1;
        }
        int i2 = 0;
        while (this.model.getRowCount() > 0) {
            MOTableRow mOTableRowFirstRow = this.model.firstRow();
            if (mOTableRowFirstRow != null) {
                MOTableRowEvent<R> mOTableRowEvent = new MOTableRowEvent<>((Object) this, (MOTable<MOTableRow, ? extends MOColumn, ? extends MOTableModel<MOTableRow>>) this, mOTableRowFirstRow, 3, true);
                fireRowChanged(mOTableRowEvent);
                if (mOTableRowEvent.getVetoStatus() == 0) {
                    ((MOMutableTableModel) this.model).removeRow(mOTableRowFirstRow.getIndex());
                }
                i2++;
            }
        }
        return i2;
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public synchronized void removeMOChangeListener(MOChangeListener mOChangeListener) {
        if (this.moChangeListeners != null) {
            this.moChangeListeners.remove(mOChangeListener);
        }
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public synchronized void removeMOTableRowListener(MOTableRowListener<R> mOTableRowListener) {
        if (this.moTableRowListeners != null) {
            this.moTableRowListeners.remove(mOTableRowListener);
        }
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public R removeRow(OID oid) {
        MOTableRow row;
        M m = this.model;
        if (!(m instanceof MOMutableTableModel) || (row = m.getRow(oid)) == null) {
            return null;
        }
        MOTableRowEvent<R> mOTableRowEvent = new MOTableRowEvent<>((Object) this, (MOTable<MOTableRow, ? extends MOColumn, ? extends MOTableModel<MOTableRow>>) this, row, 3, true);
        fireRowChanged(mOTableRowEvent);
        if (mOTableRowEvent.getVetoStatus() == 0) {
            return (R) ((MOMutableTableModel) this.model).removeRow(oid);
        }
        return null;
    }

    @Override // org.snmp4j.agent.SerializableManagedObject
    public void save(MOOutput mOOutput) throws IOException {
        LinkedList linkedList = new LinkedList();
        synchronized (this.model) {
            for (R r : this.model) {
                boolean z = false;
                int i2 = 0;
                while (true) {
                    if (i2 >= this.columns.length) {
                        break;
                    }
                    if (this.columns[i2].isVolatile(r, i2)) {
                        z = true;
                        break;
                    }
                    i2++;
                }
                if (!z) {
                    linkedList.add(new IndexedVariables(r.getIndex(), getPersistentValues(r)));
                }
            }
        }
        mOOutput.writeSequence(new Sequence(linkedList.size()));
        Iterator it = linkedList.iterator();
        while (it.hasNext()) {
            mOOutput.writeIndexedVariables((IndexedVariables) it.next());
        }
    }

    public void setModel(M m) {
        this.model = m;
    }

    @Override // org.snmp4j.agent.ManagedObjectValueAccess
    public boolean setValue(VariableBinding variableBinding) {
        MOTableCellInfo cellInfo = getCellInfo(variableBinding.getOid());
        if (cellInfo == null) {
            return false;
        }
        MOColumn column = getColumn(cellInfo.getColumn());
        if (logger.isDebugEnabled()) {
            logger.debug("Setting value " + variableBinding + " for column: " + column);
        }
        synchronized (this.model) {
            MOTableRow row = this.model.getRow(cellInfo.getIndex());
            if (!(row instanceof MOMutableTableRow)) {
                return false;
            }
            ((MOMutableTableRow) row).setValue(cellInfo.getColumn(), variableBinding.getVariable());
            return true;
        }
    }

    public void setVolatile(boolean z) {
        this.isVolatile = z;
    }

    public String toString() {
        return "DefaultMOTable[id=" + getID() + ",index=" + getIndexDef() + ",columns=" + Arrays.asList(getColumns()) + "]";
    }

    @Override // org.snmp4j.agent.ManagedObject
    public void undo(SubRequest subRequest) {
        MOTableCellInfo cellInfo = getCellInfo(subRequest.getVariableBinding().getOid());
        MOMutableColumn mOMutableColumn = (MOMutableColumn) getColumn(cellInfo.getColumn());
        if (logger.isDebugEnabled()) {
            logger.debug("Undoing sub-request (" + subRequest.getVariableBinding() + ") for column: " + mOMutableColumn);
        }
        if (hasNewRows(subRequest.getRequest())) {
            ((MOMutableTableModel) this.model).removeRow(cellInfo.getIndex());
            return;
        }
        MOMutableTableRow mOMutableTableRow = (MOMutableTableRow) this.model.getRow(cellInfo.getIndex());
        if (mOMutableTableRow != null) {
            mOMutableColumn.undo(subRequest, mOMutableTableRow, cellInfo.getColumn());
        }
        if ((mOMutableTableRow instanceof MOMutableRow2PC) && isChangeSetComplete(subRequest, mOMutableTableRow.getIndex(), cellInfo.getColumn())) {
            ((MOMutableRow2PC) mOMutableTableRow).undoRow(subRequest, getPendingChangeSet(subRequest, mOMutableTableRow.getIndex()));
        }
    }

    public void update(MOScope mOScope) {
    }

    protected void update(MOScope mOScope, SubRequest subRequest) {
        if (((subRequest == null || subRequest.getRequest() == null) ? null : subRequest.getRequest().getProcessingUserObject(getOID())) == null) {
            if (subRequest != null && subRequest.getRequest() != null) {
                subRequest.getRequest().setProcessingUserObject(getOID(), new Object());
            }
            update(mOScope);
        }
    }

    public DefaultMOTable(OID oid, MOTableIndex mOTableIndex, C[] cArr, M m) {
        this.oid = oid;
        this.indexDef = mOTableIndex;
        this.columns = cArr;
        this.model = m;
        registerColumns();
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public Variable getValue(OID oid, int i2) {
        return getValue(this.model.getRow(oid), i2);
    }

    protected Variable getValue(MOTableRow mOTableRow, int i2) {
        if (mOTableRow == null || i2 < 0 || i2 >= mOTableRow.size()) {
            return null;
        }
        return this.columns[i2].getValue(mOTableRow, i2);
    }

    static class CellInfo implements MOTableCellInfo {
        private int col;
        private int id;
        private OID index;
        private MOTableRow row;
        private DefaultMOTable table;

        public CellInfo(DefaultMOTable defaultMOTable, OID oid) {
            this.id = 0;
            this.col = -1;
            this.table = defaultMOTable;
            this.index = defaultMOTable.getIndexPart(oid);
            if (oid.size() <= defaultMOTable.oid.size() || !oid.startsWith(defaultMOTable.oid)) {
                return;
            }
            this.id = oid.get(defaultMOTable.oid.size());
        }

        @Override // org.snmp4j.agent.mo.MOTableCellInfo
        public OID getCellOID() {
            return this.table.getCellOID(this.index, this.col);
        }

        @Override // org.snmp4j.agent.mo.MOTableCellInfo
        public int getColumn() {
            if (this.col < 0) {
                this.col = this.table.getColumnIndex(this.id);
            }
            return this.col;
        }

        @Override // org.snmp4j.agent.mo.MOTableCellInfo
        public int getColumnID() {
            return this.id;
        }

        @Override // org.snmp4j.agent.mo.MOTableCellInfo
        public OID getIndex() {
            return this.index;
        }

        public MOTableRow getRow() {
            return this.row;
        }

        public String toString() {
            return "CellInfo{index=" + this.index + ", id=" + this.id + ", col=" + this.col + ", row=" + this.row + ", table=" + this.table + '}';
        }

        public CellInfo(DefaultMOTable defaultMOTable, OID oid, int i2, int i3) {
            this.id = 0;
            this.col = -1;
            this.table = defaultMOTable;
            this.index = oid;
            this.col = i2;
            this.id = i3;
        }

        public CellInfo(DefaultMOTable defaultMOTable, OID oid, int i2, int i3, MOTableRow mOTableRow) {
            this(defaultMOTable, oid, i2, i3);
            this.row = mOTableRow;
        }
    }

    @Override // org.snmp4j.agent.mo.MOTable
    public R createRow(OID oid) {
        return (R) createRow(oid, getDefaultValues());
    }

    private R createRow(SubRequest subRequest, MOTableCellInfo mOTableCellInfo, MOMutableTableModel<R> mOMutableTableModel) throws UnsupportedOperationException {
        if (!getColumn(mOTableCellInfo.getColumn()).getAccess().isAccessibleForCreate()) {
            return null;
        }
        Variable[] variableArr = new Variable[getColumnCount()];
        getChangesFromRequest(mOTableCellInfo.getIndex(), null, subRequest, variableArr, true, true);
        R rCreateRow = mOMutableTableModel.createRow(mOTableCellInfo.getIndex(), variableArr);
        getNewRows(subRequest.getRequest()).put(rCreateRow.getIndex(), rCreateRow);
        return rCreateRow;
    }

    private void prepare(SubRequest subRequest, MOTableCellInfo mOTableCellInfo, MOMutableColumn mOMutableColumn, R r, boolean z) {
        if (this.moChangeListeners != null) {
            MOChangeEvent mOChangeEvent = new MOChangeEvent(this, new CellProxy(mOTableCellInfo), mOTableCellInfo.getCellOID(), z ? null : r.getValue(mOTableCellInfo.getColumn()), subRequest.getVariableBinding().getVariable(), true);
            fireBeforePrepareMOChange(mOChangeEvent);
            if (mOChangeEvent.getDenyReason() != 0) {
                subRequest.getStatus().setErrorStatus(mOChangeEvent.getDenyReason());
            }
        }
        ChangeSet pendingChangeSet = getPendingChangeSet(subRequest, mOTableCellInfo.getIndex());
        if (pendingChangeSet == null) {
            pendingChangeSet = addPendingChanges(subRequest, r, z);
        }
        if (this.moTableRowListeners != null && !subRequest.hasError()) {
            if (isChangeSetComplete(subRequest, r.getIndex(), mOTableCellInfo.getColumn())) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Change set complete column=" + mOTableCellInfo.getColumn() + ",rowIndex=" + r.getIndex() + ",request=" + subRequest);
                }
                MOTableRowEvent<R> mOTableRowEvent = new MOTableRowEvent<>(this, this, r, pendingChangeSet, z ? 1 : 0, true);
                fireRowChanged(mOTableRowEvent);
                if (mOTableRowEvent.getVetoStatus() != 0) {
                    if (mOTableRowEvent.getVetoColumn() >= 0) {
                        int columnID = this.columns[mOTableRowEvent.getVetoColumn()].getColumnID();
                        OID oid = new OID(getOID());
                        oid.append(columnID);
                        SubRequest subRequestFind = subRequest.getRequest().find(oid);
                        if (subRequestFind != null) {
                            subRequestFind.getStatus().setErrorStatus(mOTableRowEvent.getVetoStatus());
                        } else {
                            subRequest.getRequest().setErrorStatus(mOTableRowEvent.getVetoStatus());
                        }
                    } else {
                        subRequest.getRequest().setErrorStatus(mOTableRowEvent.getVetoStatus());
                    }
                }
            } else if (logger.isDebugEnabled()) {
                logger.debug("Change set not yet complete on column=" + mOTableCellInfo.getColumn() + ",rowIndex=" + r.getIndex() + ",request=" + subRequest);
            }
        }
        if (subRequest.getStatus().getErrorStatus() == 0) {
            mOMutableColumn.prepare(subRequest, r, pendingChangeSet, mOTableCellInfo.getColumn());
            MOChangeEvent mOChangeEvent2 = new MOChangeEvent(this, new CellProxy(mOTableCellInfo), mOTableCellInfo.getCellOID(), r.getValue(mOTableCellInfo.getColumn()), subRequest.getVariableBinding().getVariable(), true);
            fireAfterPrepareMOChange(mOChangeEvent2);
            if (mOChangeEvent2.getDenyReason() != 0) {
                subRequest.getStatus().setErrorStatus(mOChangeEvent2.getDenyReason());
            } else if ((r instanceof MOMutableRow2PC) && isChangeSetComplete(subRequest, r.getIndex(), mOTableCellInfo.getColumn())) {
                ((MOMutableRow2PC) r).prepareRow(subRequest, pendingChangeSet);
            }
        }
    }
}