ifmib.java

你个snmp的源码

                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
                             new TimeTicks());
    ifStackLastChange =
      moFactory.createScalar(oidIfStackLastChange,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
                             new TimeTicks());
    createIfEntry();
    createIfXEntry();
    createIfStackEntry();
    createIfTestEntry();
    createIfRcvAddressEntry();
//--AgentGen BEGIN=_DEFAULTCONSTRUCTOR
//--AgentGen END
  }

//--AgentGen BEGIN=_CONSTRUCTORS
//--AgentGen END


  public MOTable getIfEntry() {
    return ifEntry;
  }


  private void createIfEntry() {
    MOColumn[] ifEntryColumns = new MOColumn[22];
    ifEntryColumns[idxIfIndex] =
      moFactory.createColumn(colIfIndex,
                             SMIConstants.SYNTAX_INTEGER32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfDescr] =
      moFactory.createColumn(colIfDescr,
                             SMIConstants.SYNTAX_OCTET_STRING,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfType] =
      moFactory.createColumn(colIfType,
                             SMIConstants.SYNTAX_INTEGER,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfMtu] =
      moFactory.createColumn(colIfMtu,
                             SMIConstants.SYNTAX_INTEGER32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfSpeed] =
      moFactory.createColumn(colIfSpeed,
                             SMIConstants.SYNTAX_GAUGE32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfPhysAddress] =
      moFactory.createColumn(colIfPhysAddress,
                             SMIConstants.SYNTAX_OCTET_STRING,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfAdminStatus] =
      new Enumerated(colIfAdminStatus,
                     moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_WRITE),
                     null);
    ValueConstraint ifAdminStatusVC = new EnumerationConstraint(
      new int[] { IfAdminStatusEnum.up,
                  IfAdminStatusEnum.down,
                  IfAdminStatusEnum.testing });
    ((MOMutableColumn)ifEntryColumns[idxIfAdminStatus]).
      addMOValueValidationListener(new ValueConstraintValidator(ifAdminStatusVC));
    ifEntryColumns[idxIfOperStatus] =
      moFactory.createColumn(colIfOperStatus,
                             SMIConstants.SYNTAX_INTEGER,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfLastChange] =
      moFactory.createColumn(colIfLastChange,
                             SMIConstants.SYNTAX_TIMETICKS,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfInOctets] =
      moFactory.createColumn(colIfInOctets,
                             SMIConstants.SYNTAX_COUNTER32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfInUcastPkts] =
      moFactory.createColumn(colIfInUcastPkts,
                             SMIConstants.SYNTAX_COUNTER32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfInNUcastPkts] =
      moFactory.createColumn(colIfInNUcastPkts,
                             SMIConstants.SYNTAX_COUNTER32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfInDiscards] =
      moFactory.createColumn(colIfInDiscards,
                             SMIConstants.SYNTAX_COUNTER32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfInErrors] =
      moFactory.createColumn(colIfInErrors,
                             SMIConstants.SYNTAX_COUNTER32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfInUnknownProtos] =
      moFactory.createColumn(colIfInUnknownProtos,
                             SMIConstants.SYNTAX_COUNTER32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfOutOctets] =
      moFactory.createColumn(colIfOutOctets,
                             SMIConstants.SYNTAX_COUNTER32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfOutUcastPkts] =
      moFactory.createColumn(colIfOutUcastPkts,
                             SMIConstants.SYNTAX_COUNTER32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfOutNUcastPkts] =
      moFactory.createColumn(colIfOutNUcastPkts,
                             SMIConstants.SYNTAX_COUNTER32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfOutDiscards] =
      moFactory.createColumn(colIfOutDiscards,
                             SMIConstants.SYNTAX_COUNTER32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfOutErrors] =
      moFactory.createColumn(colIfOutErrors,
                             SMIConstants.SYNTAX_COUNTER32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfOutQLen] =
      moFactory.createColumn(colIfOutQLen,
                             SMIConstants.SYNTAX_GAUGE32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifEntryColumns[idxIfSpecific] =
      moFactory.createColumn(colIfSpecific,
                             SMIConstants.SYNTAX_OBJECT_IDENTIFIER,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));

    ifEntryModel = new DefaultMOMutableTableModel();
    ifEntryModel.setRowFactory(new IfEntryRowFactory());
    ifEntry =
      moFactory.createTable(oidIfEntry,
                            ifEntryIndex,
                            ifEntryColumns,
                            ifEntryModel);
  }

  public MOTable getIfXEntry() {
    return ifXEntry;
  }


  private void createIfXEntry() {
    MOColumn[] ifXEntryColumns = new MOColumn[19];
    ifXEntryColumns[idxIfName] =
      moFactory.createColumn(colIfName,
                             SMIConstants.SYNTAX_OCTET_STRING,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifXEntryColumns[idxIfInMulticastPkts] =
      moFactory.createColumn(colIfInMulticastPkts,
                             SMIConstants.SYNTAX_COUNTER32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifXEntryColumns[idxIfInBroadcastPkts] =
      moFactory.createColumn(colIfInBroadcastPkts,
                             SMIConstants.SYNTAX_COUNTER32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifXEntryColumns[idxIfOutMulticastPkts] =
      moFactory.createColumn(colIfOutMulticastPkts,
                             SMIConstants.SYNTAX_COUNTER32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifXEntryColumns[idxIfOutBroadcastPkts] =
      moFactory.createColumn(colIfOutBroadcastPkts,
                             SMIConstants.SYNTAX_COUNTER32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifXEntryColumns[idxIfHCInOctets] =
      moFactory.createColumn(colIfHCInOctets,
                             SMIConstants.SYNTAX_COUNTER64,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifXEntryColumns[idxIfHCInUcastPkts] =
      moFactory.createColumn(colIfHCInUcastPkts,
                             SMIConstants.SYNTAX_COUNTER64,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifXEntryColumns[idxIfHCInMulticastPkts] =
      moFactory.createColumn(colIfHCInMulticastPkts,
                             SMIConstants.SYNTAX_COUNTER64,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifXEntryColumns[idxIfHCInBroadcastPkts] =
      moFactory.createColumn(colIfHCInBroadcastPkts,
                             SMIConstants.SYNTAX_COUNTER64,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifXEntryColumns[idxIfHCOutOctets] =
      moFactory.createColumn(colIfHCOutOctets,
                             SMIConstants.SYNTAX_COUNTER64,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifXEntryColumns[idxIfHCOutUcastPkts] =
      moFactory.createColumn(colIfHCOutUcastPkts,
                             SMIConstants.SYNTAX_COUNTER64,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifXEntryColumns[idxIfHCOutMulticastPkts] =
      moFactory.createColumn(colIfHCOutMulticastPkts,
                             SMIConstants.SYNTAX_COUNTER64,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifXEntryColumns[idxIfHCOutBroadcastPkts] =
      moFactory.createColumn(colIfHCOutBroadcastPkts,
                             SMIConstants.SYNTAX_COUNTER64,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifXEntryColumns[idxIfLinkUpDownTrapEnable] =
      new Enumerated(colIfLinkUpDownTrapEnable,
                     moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_WRITE),
                     null);
    ValueConstraint ifLinkUpDownTrapEnableVC = new EnumerationConstraint(
      new int[] { IfLinkUpDownTrapEnableEnum.enabled,
                  IfLinkUpDownTrapEnableEnum.disabled });
    ((MOMutableColumn)ifXEntryColumns[idxIfLinkUpDownTrapEnable]).
      addMOValueValidationListener(new ValueConstraintValidator(ifLinkUpDownTrapEnableVC));
    ifXEntryColumns[idxIfHighSpeed] =
      moFactory.createColumn(colIfHighSpeed,
                             SMIConstants.SYNTAX_GAUGE32,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifXEntryColumns[idxIfPromiscuousMode] =
      new MOMutableColumn(colIfPromiscuousMode,
                          SMIConstants.SYNTAX_INTEGER,
                          moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_WRITE),
                          null);
    ValueConstraint ifPromiscuousModeVC = new EnumerationConstraint(
      new int[] { IfPromiscuousModeEnum._true,
                  IfPromiscuousModeEnum._false });
    ((MOMutableColumn)ifXEntryColumns[idxIfPromiscuousMode]).
      addMOValueValidationListener(new ValueConstraintValidator(ifPromiscuousModeVC));
    ifXEntryColumns[idxIfConnectorPresent] =
      moFactory.createColumn(colIfConnectorPresent,
                             SMIConstants.SYNTAX_INTEGER,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifXEntryColumns[idxIfAlias] =
      new DisplayString(colIfAlias,
                        moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_WRITE),
                        null);
    ValueConstraint ifAliasVC = new ConstraintsImpl();
    ((ConstraintsImpl)ifAliasVC).add(new Constraint(0, 64));
    ((MOMutableColumn)ifXEntryColumns[idxIfAlias]).
      addMOValueValidationListener(new ValueConstraintValidator(ifAliasVC));
    ifXEntryColumns[idxIfCounterDiscontinuityTime] =
      moFactory.createColumn(colIfCounterDiscontinuityTime,
                             SMIConstants.SYNTAX_TIMETICKS,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));

    ifXEntryModel = new DefaultMOMutableTableModel();
    ifXEntryModel.setRowFactory(new IfXEntryRowFactory());
    ifXEntry =
      moFactory.createTable(oidIfXEntry,
                            ifXEntryIndex,
                            ifXEntryColumns,
                            ifXEntryModel);
  }

  public MOTable getIfStackEntry() {
    return ifStackEntry;
  }


  private void createIfStackEntry() {
    MOColumn[] ifStackEntryColumns = new MOColumn[1];
    ifStackEntryColumns[idxIfStackStatus] =
      new RowStatus(colIfStackStatus);
    ValueConstraint ifStackStatusVC = new EnumerationConstraint(
      new int[] { IfStackStatusEnum.active,
                  IfStackStatusEnum.notInService,
                  IfStackStatusEnum.notReady,
                  IfStackStatusEnum.createAndGo,
                  IfStackStatusEnum.createAndWait,
                  IfStackStatusEnum.destroy });
    ((MOMutableColumn)ifStackEntryColumns[idxIfStackStatus]).
      addMOValueValidationListener(new ValueConstraintValidator(ifStackStatusVC));

    ifStackEntryModel = new DefaultMOMutableTableModel();
    ifStackEntryModel.setRowFactory(new IfStackEntryRowFactory());
    ifStackEntry =
      moFactory.createTable(oidIfStackEntry,
                            ifStackEntryIndex,
                            ifStackEntryColumns,
                            ifStackEntryModel);
  }

  public MOTable getIfTestEntry() {
    return ifTestEntry;
  }


  private void createIfTestEntry() {
    MOColumn[] ifTestEntryColumns = new MOColumn[6];
    ifTestEntryColumns[idxIfTestId] =
      new MOMutableColumn(colIfTestId,
                          SMIConstants.SYNTAX_INTEGER,
                          moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_WRITE),
                          null);
    ValueConstraint ifTestIdVC = new ConstraintsImpl();
    ((ConstraintsImpl)ifTestIdVC).add(new Constraint(0, 2147483647));
    ((MOMutableColumn)ifTestEntryColumns[idxIfTestId]).
      addMOValueValidationListener(new ValueConstraintValidator(ifTestIdVC));
    ifTestEntryColumns[idxIfTestStatus] =
      new Enumerated(colIfTestStatus,
                     moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_WRITE),
                     null);
    ValueConstraint ifTestStatusVC = new EnumerationConstraint(
      new int[] { IfTestStatusEnum.notInUse,
                  IfTestStatusEnum.inUse });
    ((MOMutableColumn)ifTestEntryColumns[idxIfTestStatus]).
      addMOValueValidationListener(new ValueConstraintValidator(ifTestStatusVC));
    ifTestEntryColumns[idxIfTestType] =
      new MOMutableColumn(colIfTestType,
                          SMIConstants.SYNTAX_OBJECT_IDENTIFIER,
                          moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_WRITE),
                          null);
    ifTestEntryColumns[idxIfTestResult] =
      moFactory.createColumn(colIfTestResult,
                             SMIConstants.SYNTAX_INTEGER,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifTestEntryColumns[idxIfTestCode] =
      moFactory.createColumn(colIfTestCode,
                             SMIConstants.SYNTAX_OBJECT_IDENTIFIER,
                             moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
    ifTestEntryColumns[idxIfTestOwner] =
      new MOMutableColumn(colIfTestOwner,
                          SMIConstants.SYNTAX_OCTET_STRING,
                          moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_WRITE),
                          null);
    ValueConstraint ifTestOwnerVC = new ConstraintsImpl();
    ((ConstraintsImpl)ifTestOwnerVC).add(new Constraint(0, 255));
    ((MOMutableColumn)ifTestEntryColumns[idxIfTestOwner]).
      addMOValueValidationListener(new ValueConstraintValidator(ifTestOwnerVC));

    ifTestEntryModel = new DefaultMOMutableTableModel();
    ifTestEntryModel.setRowFactory(new IfTestEntryRowFactory());
    ifTestEntry =
      moFactory.createTable(oidIfTestEntry,
                            ifTestEntryIndex,
                            ifTestEntryColumns,
                            ifTestEntryModel);
  }

  public MOTable getIfRcvAddressEntry() {
    return ifRcvAddressEntry;
  }


  private void createIfRcvAddressEntry() {
    MOColumn[] ifRcvAddressEntryColumns = new MOColumn[2];
    ifRcvAddressEntryColumns[idxIfRcvAddressStatus] =
      new RowStatus(colIfRcvAddressStatus);
    ValueConstraint ifRcvAddressStatusVC = new EnumerationConstraint(
      new int[] { IfRcvAddressStatusEnum.active,
                  IfRcvAddressStatusEnum.notInService,
                  IfRcvAddressStatusEnum.notReady,
                  IfRcvAddressStatusEnum.createAndGo,
                  IfRcvAddressStatusEnum.createAndWait,
                  IfRcvAddressStatusEnum.destroy });
    ((MOMutableColumn)ifRcvAddressEntryColumns[idxIfRcvAddressStatus]).
      addMOValueValidationListener(new ValueConstraintValidator(ifRcvAddressStatusVC));