ifmib.java

关于 RFID 读写器的相关内容

      return (Counter32) getValue(idxIfOutErrors);
    }  
    
    public void setIfOutErrors(Counter32 newValue) {
      setValue(idxIfOutErrors, newValue);
    }
    
    public Gauge32 getIfOutQLen() {
      return (Gauge32) getValue(idxIfOutQLen);
    }  
    
    public void setIfOutQLen(Gauge32 newValue) {
      setValue(idxIfOutQLen, newValue);
    }
    
    public OID getIfSpecific() {
      return (OID) getValue(idxIfSpecific);
    }  
    
    public void setIfSpecific(OID newValue) {
      setValue(idxIfSpecific, newValue);
    }
    

     //--AgentGen BEGIN=ifEntry::Row
     //--AgentGen END
  }
  
  class IfEntryRowFactory 
        extends DefaultMOMutableRow2PCFactory 
  {
    public synchronized MOTableRow createRow(OID index, Variable[] values) 
        throws UnsupportedOperationException 
    {
      IfEntryRow row = new IfEntryRow(index, values);
     //--AgentGen BEGIN=ifEntry::createRow
     //--AgentGen END
      return row;
    }
    
    public synchronized void freeRow(MOTableRow row) {
     //--AgentGen BEGIN=ifEntry::freeRow
     //--AgentGen END
    }

     //--AgentGen BEGIN=ifEntry::RowFactory
     //--AgentGen END
  }
  public class IfXEntryRow extends DefaultMOMutableRow2PC {
    public IfXEntryRow(OID index, Variable[] values) {
      super(index, values);
    }
    
    public OctetString getIfName() {
      return (OctetString) getValue(idxIfName);
    }  
    
    public void setIfName(OctetString newValue) {
      setValue(idxIfName, newValue);
    }
    
    public Counter32 getIfInMulticastPkts() {
      return (Counter32) getValue(idxIfInMulticastPkts);
    }  
    
    public void setIfInMulticastPkts(Counter32 newValue) {
      setValue(idxIfInMulticastPkts, newValue);
    }
    
    public Counter32 getIfInBroadcastPkts() {
      return (Counter32) getValue(idxIfInBroadcastPkts);
    }  
    
    public void setIfInBroadcastPkts(Counter32 newValue) {
      setValue(idxIfInBroadcastPkts, newValue);
    }
    
    public Counter32 getIfOutMulticastPkts() {
      return (Counter32) getValue(idxIfOutMulticastPkts);
    }  
    
    public void setIfOutMulticastPkts(Counter32 newValue) {
      setValue(idxIfOutMulticastPkts, newValue);
    }
    
    public Counter32 getIfOutBroadcastPkts() {
      return (Counter32) getValue(idxIfOutBroadcastPkts);
    }  
    
    public void setIfOutBroadcastPkts(Counter32 newValue) {
      setValue(idxIfOutBroadcastPkts, newValue);
    }
    
    public Counter64 getIfHCInOctets() {
      return (Counter64) getValue(idxIfHCInOctets);
    }  
    
    public void setIfHCInOctets(Counter64 newValue) {
      setValue(idxIfHCInOctets, newValue);
    }
    
    public Counter64 getIfHCInUcastPkts() {
      return (Counter64) getValue(idxIfHCInUcastPkts);
    }  
    
    public void setIfHCInUcastPkts(Counter64 newValue) {
      setValue(idxIfHCInUcastPkts, newValue);
    }
    
    public Counter64 getIfHCInMulticastPkts() {
      return (Counter64) getValue(idxIfHCInMulticastPkts);
    }  
    
    public void setIfHCInMulticastPkts(Counter64 newValue) {
      setValue(idxIfHCInMulticastPkts, newValue);
    }
    
    public Counter64 getIfHCInBroadcastPkts() {
      return (Counter64) getValue(idxIfHCInBroadcastPkts);
    }  
    
    public void setIfHCInBroadcastPkts(Counter64 newValue) {
      setValue(idxIfHCInBroadcastPkts, newValue);
    }
    
    public Counter64 getIfHCOutOctets() {
      return (Counter64) getValue(idxIfHCOutOctets);
    }  
    
    public void setIfHCOutOctets(Counter64 newValue) {
      setValue(idxIfHCOutOctets, newValue);
    }
    
    public Counter64 getIfHCOutUcastPkts() {
      return (Counter64) getValue(idxIfHCOutUcastPkts);
    }  
    
    public void setIfHCOutUcastPkts(Counter64 newValue) {
      setValue(idxIfHCOutUcastPkts, newValue);
    }
    
    public Counter64 getIfHCOutMulticastPkts() {
      return (Counter64) getValue(idxIfHCOutMulticastPkts);
    }  
    
    public void setIfHCOutMulticastPkts(Counter64 newValue) {
      setValue(idxIfHCOutMulticastPkts, newValue);
    }
    
    public Counter64 getIfHCOutBroadcastPkts() {
      return (Counter64) getValue(idxIfHCOutBroadcastPkts);
    }  
    
    public void setIfHCOutBroadcastPkts(Counter64 newValue) {
      setValue(idxIfHCOutBroadcastPkts, newValue);
    }
    
    public Integer32 getIfLinkUpDownTrapEnable() {
      return (Integer32) getValue(idxIfLinkUpDownTrapEnable);
    }  
    
    public void setIfLinkUpDownTrapEnable(Integer32 newValue) {
      setValue(idxIfLinkUpDownTrapEnable, newValue);
    }
    
    public Gauge32 getIfHighSpeed() {
      return (Gauge32) getValue(idxIfHighSpeed);
    }  
    
    public void setIfHighSpeed(Gauge32 newValue) {
      setValue(idxIfHighSpeed, newValue);
    }
    
    public Integer32 getIfPromiscuousMode() {
      return (Integer32) getValue(idxIfPromiscuousMode);
    }  
    
    public void setIfPromiscuousMode(Integer32 newValue) {
      setValue(idxIfPromiscuousMode, newValue);
    }
    
    public Integer32 getIfConnectorPresent() {
      return (Integer32) getValue(idxIfConnectorPresent);
    }  
    
    public void setIfConnectorPresent(Integer32 newValue) {
      setValue(idxIfConnectorPresent, newValue);
    }
    
    public OctetString getIfAlias() {
      return (OctetString) getValue(idxIfAlias);
    }  
    
    public void setIfAlias(OctetString newValue) {
      setValue(idxIfAlias, newValue);
    }
    
    public TimeTicks getIfCounterDiscontinuityTime() {
      return (TimeTicks) getValue(idxIfCounterDiscontinuityTime);
    }  
    
    public void setIfCounterDiscontinuityTime(TimeTicks newValue) {
      setValue(idxIfCounterDiscontinuityTime, newValue);
    }
    

     //--AgentGen BEGIN=ifXEntry::Row
     //--AgentGen END
  }
  
  class IfXEntryRowFactory 
        extends DefaultMOMutableRow2PCFactory 
  {
    public synchronized MOTableRow createRow(OID index, Variable[] values) 
        throws UnsupportedOperationException 
    {
      IfXEntryRow row = new IfXEntryRow(index, values);
     //--AgentGen BEGIN=ifXEntry::createRow
     //--AgentGen END
      return row;
    }
    
    public synchronized void freeRow(MOTableRow row) {
     //--AgentGen BEGIN=ifXEntry::freeRow
     //--AgentGen END
    }

     //--AgentGen BEGIN=ifXEntry::RowFactory
     //--AgentGen END
  }
  public class IfStackEntryRow extends DefaultMOMutableRow2PC {
    public IfStackEntryRow(OID index, Variable[] values) {
      super(index, values);
    }
    
    public Integer32 getIfStackStatus() {
      return (Integer32) getValue(idxIfStackStatus);
    }  
    
    public void setIfStackStatus(Integer32 newValue) {
      setValue(idxIfStackStatus, newValue);
    }
    

     //--AgentGen BEGIN=ifStackEntry::Row
     //--AgentGen END
  }
  
  class IfStackEntryRowFactory 
        extends DefaultMOMutableRow2PCFactory 
  {
    public synchronized MOTableRow createRow(OID index, Variable[] values) 
        throws UnsupportedOperationException 
    {
      IfStackEntryRow row = new IfStackEntryRow(index, values);
     //--AgentGen BEGIN=ifStackEntry::createRow
     //--AgentGen END
      return row;
    }
    
    public synchronized void freeRow(MOTableRow row) {
     //--AgentGen BEGIN=ifStackEntry::freeRow
     //--AgentGen END
    }

     //--AgentGen BEGIN=ifStackEntry::RowFactory
     //--AgentGen END
  }
  public class IfTestEntryRow extends DefaultMOMutableRow2PC {
    public IfTestEntryRow(OID index, Variable[] values) {
      super(index, values);
    }
    
    public Integer32 getIfTestId() {
      return (Integer32) getValue(idxIfTestId);
    }  
    
    public void setIfTestId(Integer32 newValue) {
      setValue(idxIfTestId, newValue);
    }
    
    public Integer32 getIfTestStatus() {
      return (Integer32) getValue(idxIfTestStatus);
    }  
    
    public void setIfTestStatus(Integer32 newValue) {
      setValue(idxIfTestStatus, newValue);
    }
    
    public OID getIfTestType() {
      return (OID) getValue(idxIfTestType);
    }  
    
    public void setIfTestType(OID newValue) {
      setValue(idxIfTestType, newValue);
    }
    
    public Integer32 getIfTestResult() {
      return (Integer32) getValue(idxIfTestResult);
    }  
    
    public void setIfTestResult(Integer32 newValue) {
      setValue(idxIfTestResult, newValue);
    }
    
    public OID getIfTestCode() {
      return (OID) getValue(idxIfTestCode);
    }  
    
    public void setIfTestCode(OID newValue) {
      setValue(idxIfTestCode, newValue);
    }
    
    public OctetString getIfTestOwner() {
      return (OctetString) getValue(idxIfTestOwner);
    }  
    
    public void setIfTestOwner(OctetString newValue) {
      setValue(idxIfTestOwner, newValue);
    }
    

     //--AgentGen BEGIN=ifTestEntry::Row
     //--AgentGen END
  }
  
  class IfTestEntryRowFactory 
        extends DefaultMOMutableRow2PCFactory 
  {
    public synchronized MOTableRow createRow(OID index, Variable[] values) 
        throws UnsupportedOperationException 
    {
      IfTestEntryRow row = new IfTestEntryRow(index, values);
     //--AgentGen BEGIN=ifTestEntry::createRow
     //--AgentGen END
      return row;
    }
    
    public synchronized void freeRow(MOTableRow row) {
     //--AgentGen BEGIN=ifTestEntry::freeRow
     //--AgentGen END
    }

     //--AgentGen BEGIN=ifTestEntry::RowFactory
     //--AgentGen END
  }
  public class IfRcvAddressEntryRow extends DefaultMOMutableRow2PC {
    public IfRcvAddressEntryRow(OID index, Variable[] values) {
      super(index, values);
    }
    
    public Integer32 getIfRcvAddressStatus() {
      return (Integer32) getValue(idxIfRcvAddressStatus);
    }  
    
    public void setIfRcvAddressStatus(Integer32 newValue) {
      setValue(idxIfRcvAddressStatus, newValue);
    }
    
    public Integer32 getIfRcvAddressType() {
      return (Integer32) getValue(idxIfRcvAddressType);
    }  
    
    public void setIfRcvAddressType(Integer32 newValue) {
      setValue(idxIfRcvAddressType, newValue);
    }
    

     //--AgentGen BEGIN=ifRcvAddressEntry::Row
     //--AgentGen END
  }
  
  class IfRcvAddressEntryRowFactory 
        extends DefaultMOMutableRow2PCFactory 
  {
    public synchronized MOTableRow createRow(OID index, Variable[] values) 
        throws UnsupportedOperationException 
    {
      IfRcvAddressEntryRow row = new IfRcvAddressEntryRow(index, values);
     //--AgentGen BEGIN=ifRcvAddressEntry::createRow
     //--AgentGen END
      return row;
    }
    
    public synchronized void freeRow(MOTableRow row) {
     //--AgentGen BEGIN=ifRcvAddressEntry::freeRow
     //--AgentGen END
    }

     //--AgentGen BEGIN=ifRcvAddressEntry::RowFactory
     //--AgentGen END
  }


//--AgentGen BEGIN=_METHODS
//--AgentGen END

//--AgentGen BEGIN=_CLASSES
//--AgentGen END

//--AgentGen BEGIN=_END
//--AgentGen END
}