org.snmp4j.agent.mo.MOMutableColumn Maven / Gradle / Ivy

Go to download
/*_############################################################################
  _##
  _##  SNMP4J-Agent - MOMutableColumn.java
  _##
  _##  Copyright (C) 2005-2009  Frank Fock (SNMP4J.org)
  _##
  _##  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 org.snmp4j.agent.mo;

import java.util.*;

import org.snmp4j.*;
import org.snmp4j.agent.*;
import org.snmp4j.agent.request.*;
import org.snmp4j.mp.*;
import org.snmp4j.smi.*;

/**
 * The MOMutableColumn class represents mutable columnar SMI
 * objects. It represents all instances of a table's column not only a
 * single instance (cell).
 * 
 * Objects represented by MOMutableColumn can be modified via SNMP,
 * thus MOColumn supports read-only, read-write, and read-create
 * maximum access.
 *
 * @see MOColumn
 * @author Frank Fock
 * @version 1.0
 */
public class MOMutableColumn extends MOColumn {

  private Vector validators;
  private Variable defaultValue;
  private boolean mutableInService = true;
  private boolean mandatory = true;

  public MOMutableColumn(int columnID, int syntax) {
    super(columnID, syntax);
  }

  public MOMutableColumn(int columnID, int syntax, MOAccess access) {
    super(columnID, syntax, access);
  }

  public MOMutableColumn(int columnID, int syntax, MOAccess access,
                         Variable defaultValue) {
    super(columnID, syntax, access);
    this.defaultValue = defaultValue;
  }

  public MOMutableColumn(int columnID, int syntax, MOAccess access,
                         Variable defaultValue, boolean mutableInService) {
    super(columnID, syntax, access);
    this.defaultValue = defaultValue;
    this.mutableInService = mutableInService;
  }

  public synchronized void
      addMOValueValidationListener(MOValueValidationListener validator) {
    if (validators == null) {
      validators = new Vector(2);
    }
    validators.add(validator);
  }

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

  public synchronized int validate(Variable newValue, Variable oldValue) {
    int status = SnmpConstants.SNMP_ERROR_SUCCESS;
    if (validators != null) {
      for (Iterator it = validators.iterator(); it.hasNext();) {
        MOValueValidationListener v = (MOValueValidationListener) it.next();
        MOValueValidationEvent event =
            new MOValueValidationEvent(this, oldValue, newValue);
        v.validate(event);
        if (event.getValidationStatus() != SnmpConstants.SNMP_ERROR_SUCCESS) {
          status = event.getValidationStatus();
          break;
        }
      }
    }
    return status;
  }

  protected boolean validateSetRequest(SubRequest subRequest,
                                       MOTableRow row, int column) {
    Variable value = subRequest.getVariableBinding().getVariable();
    if (value.getSyntax() != getSyntax()) {
      subRequest.getStatus().setErrorStatus(PDU.wrongType);
    }
    int status =
        validate(value, (row.size() > column) ? row.getValue(column) : null);
    if (status != SnmpConstants.SNMP_ERROR_SUCCESS) {
      subRequest.getStatus().setErrorStatus(status);
      return false;
    }
    return true;
  }

  public void prepare(SubRequest subRequest, MOTableRow row,
                      MOTableRow changeSet, int column) {
    if (row instanceof MOMutableRow2PC) {
      if (validateSetRequest(subRequest, row, column)) {
        ((MOMutableRow2PC) row).prepare(subRequest, changeSet, column);
      }
    }
    else if (row instanceof MOMutableTableRow) {
      if (validateSetRequest(subRequest, row, column)) {
        subRequest.completed();
      }
    }
    else {
      // not writable
      subRequest.getStatus().setErrorStatus(PDU.notWritable);
    }
  }

  public void commit(SubRequest subRequest, MOTableRow row,
                     MOTableRow changeSet, int column) {
    if (row instanceof MOMutableRow2PC) {
      ((MOMutableRow2PC)row).commit(subRequest, changeSet, column);
    }
    else if (row instanceof MOMutableTableRow) {
      if (subRequest.getUndoValue() == null) {
        subRequest.setUndoValue(row.getValue(column));
      }
      ((MOMutableTableRow)row).setValue(column,
          (Variable)subRequest.getVariableBinding().getVariable().clone());
      subRequest.completed();
    }
    else {
      // should never be reached!
      subRequest.getStatus().setErrorStatus(PDU.commitFailed);
    }
  }

  public void undo(SubRequest subRequest, MOTableRow row, int column) {
    if (row instanceof MOMutableRow2PC) {
      ((MOMutableRow2PC)row).undo(subRequest, column);
    }
    if ((row instanceof MOMutableTableRow) &&
        (subRequest.getUndoValue() instanceof Variable)) {
      ((MOMutableTableRow)row).setValue(column, (Variable)
                                        subRequest.getUndoValue());
      subRequest.completed();
    }
    else {
      // should never be reached!
      subRequest.getStatus().setErrorStatus(PDU.undoFailed);
    }
  }

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

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

  public void setMutableInService(boolean mutableInService) {

    this.mutableInService = mutableInService;
  }

  public Variable getDefaultValue() {
    return defaultValue;
  }

  public boolean isMutableInService() {
    return mutableInService;
  }

  /**
   * Returns true if this column must be specified in a SET
   * request which creates a row.
   * @return
   *    true if this row has a maximum access of READ-CREATE and
   *    has a null default value, false otherwise.
   */
  public boolean isMandatory() {
    return (mandatory) &&
        (defaultValue == null) && (getAccess().isAccessibleForCreate());
  }

  /**
   * Sets a flag that determines if this column must be specified in a SET
   * request which creates a row. The default is true.
   * @param mandatory
   *    if true and a row has a maximum access of READ-CREATE and
   *    has a null default value, then it must be provided in
   *    order to activate the row.
   * @since 1.3.2
   */
  public void setMandatory(boolean mandatory) {
    this.mandatory = mandatory;
  }

  public String toString() {
    return this.getClass().getName()+"[columnID="+getColumnID()+",syntax="+
        getSyntax()+",default="+getDefaultValue()+",mutableInService="+
        mutableInService+",mandatory="+mandatory+"]";
  }
}