test/dumps/jax/SerialConnectionEntryImpl.java

   1 /*
   2  * This Java file has been generated by smidump 0.4.5. It
   3  * is intended to be edited by the application programmer and
   4  * to be used within a Java AgentX sub-agent environment.
   5  *
   6  * $Id: SerialConnectionEntryImpl.java 4432 2006-05-29 16:21:11Z strauss $
   7  */
   8
   9 /**
  10     This class extends the Java AgentX (JAX) implementation of
  11     the table row serialConnectionEntry defined in RMON2-MIB.
  12  */
  13
  14 import jax.AgentXOID;
  15 import jax.AgentXSetPhase;
  16 import jax.AgentXResponsePDU;
  17 import jax.AgentXEntry;
  18
  19 public class SerialConnectionEntryImpl extends SerialConnectionEntry
  20 {
  21
  22     // constructor
  23     public SerialConnectionEntryImpl(int serialConnectIndex)
  24     {
  25         super(serialConnectIndex);
  26     }
  27
  28     public byte[] get_serialConnectDestIpAddress()
  29     {
  30         return serialConnectDestIpAddress;
  31     }
  32
  33     public int set_serialConnectDestIpAddress(AgentXSetPhase phase, byte[] value)
  34     {
  35         switch (phase.getPhase()) {
  36         case AgentXSetPhase.TEST_SET:
  37             break;
  38         case AgentXSetPhase.COMMIT:
  39             undo_serialConnectDestIpAddress = serialConnectDestIpAddress;
  40             serialConnectDestIpAddress = new byte[value.length];
  41             for(int i = 0; i < value.length; i++)
  42                 serialConnectDestIpAddress[i] = value[i];
  43             break;
  44         case AgentXSetPhase.UNDO:
  45             serialConnectDestIpAddress = undo_serialConnectDestIpAddress;
  46             break;
  47         case AgentXSetPhase.CLEANUP:
  48             undo_serialConnectDestIpAddress = null;
  49             break;
  50         default:
  51             return AgentXResponsePDU.PROCESSING_ERROR;
  52         }
  53         return AgentXResponsePDU.NO_ERROR;
  54     }
  55     public int get_serialConnectType()
  56     {
  57         return serialConnectType;
  58     }
  59
  60     public int set_serialConnectType(AgentXSetPhase phase, int value)
  61     {
  62         switch (phase.getPhase()) {
  63         case AgentXSetPhase.TEST_SET:
  64             break;
  65         case AgentXSetPhase.COMMIT:
  66             undo_serialConnectType = serialConnectType;
  67             serialConnectType = value;
  68             break;
  69         case AgentXSetPhase.UNDO:
  70             serialConnectType = undo_serialConnectType;
  71             break;
  72         case AgentXSetPhase.CLEANUP:
  73             break;
  74         default:
  75             return AgentXResponsePDU.PROCESSING_ERROR;
  76         }
  77         return AgentXResponsePDU.NO_ERROR;
  78     }
  79     public byte[] get_serialConnectDialString()
  80     {
  81         return serialConnectDialString;
  82     }
  83
  84     public int set_serialConnectDialString(AgentXSetPhase phase, byte[] value)
  85     {
  86         switch (phase.getPhase()) {
  87         case AgentXSetPhase.TEST_SET:
  88             break;
  89         case AgentXSetPhase.COMMIT:
  90             undo_serialConnectDialString = serialConnectDialString;
  91             serialConnectDialString = new byte[value.length];
  92             for(int i = 0; i < value.length; i++)
  93                 serialConnectDialString[i] = value[i];
  94             break;
  95         case AgentXSetPhase.UNDO:
  96             serialConnectDialString = undo_serialConnectDialString;
  97             break;
  98         case AgentXSetPhase.CLEANUP:
  99             undo_serialConnectDialString = null;
 100             break;
 101         default:
 102             return AgentXResponsePDU.PROCESSING_ERROR;
 103         }
 104         return AgentXResponsePDU.NO_ERROR;
 105     }
 106     public byte[] get_serialConnectSwitchConnectSeq()
 107     {
 108         return serialConnectSwitchConnectSeq;
 109     }
 110
 111     public int set_serialConnectSwitchConnectSeq(AgentXSetPhase phase, byte[] value)
 112     {
 113         switch (phase.getPhase()) {
 114         case AgentXSetPhase.TEST_SET:
 115             break;
 116         case AgentXSetPhase.COMMIT:
 117             undo_serialConnectSwitchConnectSeq = serialConnectSwitchConnectSeq;
 118             serialConnectSwitchConnectSeq = new byte[value.length];
 119             for(int i = 0; i < value.length; i++)
 120                 serialConnectSwitchConnectSeq[i] = value[i];
 121             break;
 122         case AgentXSetPhase.UNDO:
 123             serialConnectSwitchConnectSeq = undo_serialConnectSwitchConnectSeq;
 124             break;
 125         case AgentXSetPhase.CLEANUP:
 126             undo_serialConnectSwitchConnectSeq = null;
 127             break;
 128         default:
 129             return AgentXResponsePDU.PROCESSING_ERROR;
 130         }
 131         return AgentXResponsePDU.NO_ERROR;
 132     }
 133     public byte[] get_serialConnectSwitchDisconnectSeq()
 134     {
 135         return serialConnectSwitchDisconnectSeq;
 136     }
 137
 138     public int set_serialConnectSwitchDisconnectSeq(AgentXSetPhase phase, byte[] value)
 139     {
 140         switch (phase.getPhase()) {
 141         case AgentXSetPhase.TEST_SET:
 142             break;
 143         case AgentXSetPhase.COMMIT:
 144             undo_serialConnectSwitchDisconnectSeq = serialConnectSwitchDisconnectSeq;
 145             serialConnectSwitchDisconnectSeq = new byte[value.length];
 146             for(int i = 0; i < value.length; i++)
 147                 serialConnectSwitchDisconnectSeq[i] = value[i];
 148             break;
 149         case AgentXSetPhase.UNDO:
 150             serialConnectSwitchDisconnectSeq = undo_serialConnectSwitchDisconnectSeq;
 151             break;
 152         case AgentXSetPhase.CLEANUP:
 153             undo_serialConnectSwitchDisconnectSeq = null;
 154             break;
 155         default:
 156             return AgentXResponsePDU.PROCESSING_ERROR;
 157         }
 158         return AgentXResponsePDU.NO_ERROR;
 159     }
 160     public byte[] get_serialConnectSwitchResetSeq()
 161     {
 162         return serialConnectSwitchResetSeq;
 163     }
 164
 165     public int set_serialConnectSwitchResetSeq(AgentXSetPhase phase, byte[] value)
 166     {
 167         switch (phase.getPhase()) {
 168         case AgentXSetPhase.TEST_SET:
 169             break;
 170         case AgentXSetPhase.COMMIT:
 171             undo_serialConnectSwitchResetSeq = serialConnectSwitchResetSeq;
 172             serialConnectSwitchResetSeq = new byte[value.length];
 173             for(int i = 0; i < value.length; i++)
 174                 serialConnectSwitchResetSeq[i] = value[i];
 175             break;
 176         case AgentXSetPhase.UNDO:
 177             serialConnectSwitchResetSeq = undo_serialConnectSwitchResetSeq;
 178             break;
 179         case AgentXSetPhase.CLEANUP:
 180             undo_serialConnectSwitchResetSeq = null;
 181             break;
 182         default:
 183             return AgentXResponsePDU.PROCESSING_ERROR;
 184         }
 185         return AgentXResponsePDU.NO_ERROR;
 186     }
 187     public byte[] get_serialConnectOwner()
 188     {
 189         return serialConnectOwner;
 190     }
 191
 192     public int set_serialConnectOwner(AgentXSetPhase phase, byte[] value)
 193     {
 194         switch (phase.getPhase()) {
 195         case AgentXSetPhase.TEST_SET:
 196             break;
 197         case AgentXSetPhase.COMMIT:
 198             undo_serialConnectOwner = serialConnectOwner;
 199             serialConnectOwner = new byte[value.length];
 200             for(int i = 0; i < value.length; i++)
 201                 serialConnectOwner[i] = value[i];
 202             break;
 203         case AgentXSetPhase.UNDO:
 204             serialConnectOwner = undo_serialConnectOwner;
 205             break;
 206         case AgentXSetPhase.CLEANUP:
 207             undo_serialConnectOwner = null;
 208             break;
 209         default:
 210             return AgentXResponsePDU.PROCESSING_ERROR;
 211         }
 212         return AgentXResponsePDU.NO_ERROR;
 213     }
 214     public int get_serialConnectStatus()
 215     {
 216         return serialConnectStatus;
 217     }
 218
 219     public int set_serialConnectStatus(AgentXSetPhase phase, int value)
 220     {
 221         switch (phase.getPhase()) {
 222         case AgentXSetPhase.TEST_SET:
 223             break;
 224         case AgentXSetPhase.COMMIT:
 225             undo_serialConnectStatus = serialConnectStatus;
 226             serialConnectStatus = value;
 227             break;
 228         case AgentXSetPhase.UNDO:
 229             serialConnectStatus = undo_serialConnectStatus;
 230             break;
 231         case AgentXSetPhase.CLEANUP:
 232             break;
 233         default:
 234             return AgentXResponsePDU.PROCESSING_ERROR;
 235         }
 236         return AgentXResponsePDU.NO_ERROR;
 237     }
 238 }
 239