package org.snmp4j.agent.mo;

import java.util.Vector;
import org.snmp4j.agent.MOAccess;
import org.snmp4j.agent.request.SubRequest;
import org.snmp4j.smi.Variable;

/* JADX INFO: loaded from: classes.dex */
public class MOMutableColumn<V extends Variable> extends MOColumn<V> {
    private Variable defaultValue;
    private boolean mandatory;
    private boolean mutableInService;
    private Vector<MOValueValidationListener> validators;

    public MOMutableColumn(int i2, int i3) {
        super(i2, i3);
        this.mutableInService = true;
        this.mandatory = true;
    }

    public synchronized void addMOValueValidationListener(MOValueValidationListener mOValueValidationListener) {
        if (this.validators == null) {
            this.validators = new Vector<>(2);
        }
        this.validators.add(mOValueValidationListener);
    }

    public void cleanup(SubRequest subRequest, MOTableRow mOTableRow, int i2) {
        if (mOTableRow instanceof MOMutableRow2PC) {
            ((MOMutableRow2PC) mOTableRow).cleanup(subRequest, i2);
        }
        subRequest.completed();
    }

    public void commit(SubRequest subRequest, MOTableRow mOTableRow, MOTableRow mOTableRow2, int i2) {
        if (mOTableRow instanceof MOMutableRow2PC) {
            ((MOMutableRow2PC) mOTableRow).commit(subRequest, mOTableRow2, i2);
            return;
        }
        if (!(mOTableRow instanceof MOMutableTableRow)) {
            subRequest.getStatus().setErrorStatus(14);
            return;
        }
        if (subRequest.getUndoValue() == null) {
            subRequest.setUndoValue(mOTableRow.getValue(i2));
        }
        ((MOMutableTableRow) mOTableRow).setValue(i2, (Variable) subRequest.getVariableBinding().getVariable().clone());
        subRequest.completed();
    }

    public Variable getDefaultValue() {
        return this.defaultValue;
    }

    public boolean isMandatory() {
        return this.mandatory && this.defaultValue == null && getAccess().isAccessibleForCreate();
    }

    public boolean isMutableInService() {
        return this.mutableInService;
    }

    public void prepare(SubRequest subRequest, MOTableRow mOTableRow, MOTableRow mOTableRow2, int i2) {
        if (mOTableRow instanceof MOMutableRow2PC) {
            if (validateSetRequest(subRequest, mOTableRow, i2)) {
                ((MOMutableRow2PC) mOTableRow).prepare(subRequest, mOTableRow2, i2);
            }
        } else if (!(mOTableRow instanceof MOMutableTableRow)) {
            subRequest.getStatus().setErrorStatus(17);
        } else if (validateSetRequest(subRequest, mOTableRow, i2)) {
            subRequest.completed();
        }
    }

    public synchronized void removeMOValueValidationListener(MOValueValidationListener mOValueValidationListener) {
        if (this.validators != null) {
            this.validators.remove(mOValueValidationListener);
        }
    }

    public void setDefaultValue(Variable variable) {
        this.defaultValue = variable;
    }

    public void setMandatory(boolean z) {
        this.mandatory = z;
    }

    public void setMutableInService(boolean z) {
        this.mutableInService = z;
    }

    @Override // org.snmp4j.agent.mo.MOColumn
    public String toString() {
        return getClass().getName() + "[columnID=" + getColumnID() + ",syntax=" + getSyntax() + ",default=" + getDefaultValue() + ",mutableInService=" + this.mutableInService + ",mandatory=" + this.mandatory + "]";
    }

    public void undo(SubRequest subRequest, MOTableRow mOTableRow, int i2) {
        if (mOTableRow instanceof MOMutableRow2PC) {
            ((MOMutableRow2PC) mOTableRow).undo(subRequest, i2);
        }
        if (!(mOTableRow instanceof MOMutableTableRow) || !(subRequest.getUndoValue() instanceof Variable)) {
            subRequest.getStatus().setErrorStatus(15);
        } else {
            ((MOMutableTableRow) mOTableRow).setValue(i2, (Variable) subRequest.getUndoValue());
            subRequest.completed();
        }
    }

    /* JADX WARN: Code restructure failed: missing block: B:11:0x0026, code lost:
    
        r0 = r3.getValidationStatus();
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public synchronized int validate(org.snmp4j.smi.Variable r5, org.snmp4j.smi.Variable r6) {
        /*
            r4 = this;
            monitor-enter(r4)
            r0 = 0
            java.util.Vector<org.snmp4j.agent.mo.MOValueValidationListener> r1 = r4.validators     // Catch: java.lang.Throwable -> L2c
            if (r1 == 0) goto L2a
            java.util.Vector<org.snmp4j.agent.mo.MOValueValidationListener> r1 = r4.validators     // Catch: java.lang.Throwable -> L2c
            java.util.Iterator r1 = r1.iterator()     // Catch: java.lang.Throwable -> L2c
        Lc:
            boolean r2 = r1.hasNext()     // Catch: java.lang.Throwable -> L2c
            if (r2 == 0) goto L2a
            java.lang.Object r2 = r1.next()     // Catch: java.lang.Throwable -> L2c
            org.snmp4j.agent.mo.MOValueValidationListener r2 = (org.snmp4j.agent.mo.MOValueValidationListener) r2     // Catch: java.lang.Throwable -> L2c
            org.snmp4j.agent.mo.MOValueValidationEvent r3 = new org.snmp4j.agent.mo.MOValueValidationEvent     // Catch: java.lang.Throwable -> L2c
            r3.<init>(r4, r6, r5)     // Catch: java.lang.Throwable -> L2c
            r2.validate(r3)     // Catch: java.lang.Throwable -> L2c
            int r2 = r3.getValidationStatus()     // Catch: java.lang.Throwable -> L2c
            if (r2 == 0) goto Lc
            int r0 = r3.getValidationStatus()     // Catch: java.lang.Throwable -> L2c
        L2a:
            monitor-exit(r4)
            return r0
        L2c:
            r5 = move-exception
            monitor-exit(r4)
            goto L30
        L2f:
            throw r5
        L30:
            goto L2f
        */
        throw new UnsupportedOperationException("Method not decompiled: org.snmp4j.agent.mo.MOMutableColumn.validate(org.snmp4j.smi.Variable, org.snmp4j.smi.Variable):int");
    }

    protected boolean validateSetRequest(SubRequest subRequest, MOTableRow mOTableRow, int i2) {
        Variable variable = subRequest.getVariableBinding().getVariable();
        if (variable.getSyntax() != getSyntax()) {
            subRequest.getStatus().setErrorStatus(7);
        }
        int iValidate = validate(variable, mOTableRow.size() > i2 ? mOTableRow.getValue(i2) : null);
        if (iValidate == 0) {
            return true;
        }
        subRequest.getStatus().setErrorStatus(iValidate);
        return false;
    }

    public MOMutableColumn(int i2, int i3, MOAccess mOAccess) {
        super(i2, i3, mOAccess);
        this.mutableInService = true;
        this.mandatory = true;
    }

    public MOMutableColumn(int i2, int i3, MOAccess mOAccess, Variable variable) {
        super(i2, i3, mOAccess);
        this.mutableInService = true;
        this.mandatory = true;
        this.defaultValue = variable;
    }

    public MOMutableColumn(int i2, int i3, MOAccess mOAccess, Variable variable, boolean z) {
        super(i2, i3, mOAccess);
        this.mutableInService = true;
        this.mandatory = true;
        this.defaultValue = variable;
        this.mutableInService = z;
    }
}