/**
* Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior
* University
*
* 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.openflow.protocol.statistics;
import org.codehaus.jackson.annotate.JsonIgnore;
import org.jboss.netty.buffer.ChannelBuffer;
/**
* Represents an ofp_port_stats structure
* @author David Erickson (daviderickson@cs.stanford.edu)
*/
public class OFPortStatisticsReply implements OFStatistics {
protected short portNumber;
protected long receivePackets;
protected long transmitPackets;
protected long receiveBytes;
protected long transmitBytes;
protected long receiveDropped;
protected long transmitDropped;
protected long receiveErrors;
protected long transmitErrors;
protected long receiveFrameErrors;
protected long receiveOverrunErrors;
protected long receiveCRCErrors;
protected long collisions;
/**
* @return the portNumber
*/
public short getPortNumber() {
return portNumber;
}
/**
* @param portNumber the portNumber to set
*/
public void setPortNumber(short portNumber) {
this.portNumber = portNumber;
}
/**
* @return the receivePackets
*/
public long getreceivePackets() {
return receivePackets;
}
/**
* @param receivePackets the receivePackets to set
*/
public void setreceivePackets(long receivePackets) {
this.receivePackets = receivePackets;
}
/**
* @return the transmitPackets
*/
public long getTransmitPackets() {
return transmitPackets;
}
/**
* @param transmitPackets the transmitPackets to set
*/
public void setTransmitPackets(long transmitPackets) {
this.transmitPackets = transmitPackets;
}
/**
* @return the receiveBytes
*/
public long getReceiveBytes() {
return receiveBytes;
}
/**
* @param receiveBytes the receiveBytes to set
*/
public void setReceiveBytes(long receiveBytes) {
this.receiveBytes = receiveBytes;
}
/**
* @return the transmitBytes
*/
public long getTransmitBytes() {
return transmitBytes;
}
/**
* @param transmitBytes the transmitBytes to set
*/
public void setTransmitBytes(long transmitBytes) {
this.transmitBytes = transmitBytes;
}
/**
* @return the receiveDropped
*/
public long getReceiveDropped() {
return receiveDropped;
}
/**
* @param receiveDropped the receiveDropped to set
*/
public void setReceiveDropped(long receiveDropped) {
this.receiveDropped = receiveDropped;
}
/**
* @return the transmitDropped
*/
public long getTransmitDropped() {
return transmitDropped;
}
/**
* @param transmitDropped the transmitDropped to set
*/
public void setTransmitDropped(long transmitDropped) {
this.transmitDropped = transmitDropped;
}
/**
* @return the receiveErrors
*/
public long getreceiveErrors() {
return receiveErrors;
}
/**
* @param receiveErrors the receiveErrors to set
*/
public void setreceiveErrors(long receiveErrors) {
this.receiveErrors = receiveErrors;
}
/**
* @return the transmitErrors
*/
public long getTransmitErrors() {
return transmitErrors;
}
/**
* @param transmitErrors the transmitErrors to set
*/
public void setTransmitErrors(long transmitErrors) {
this.transmitErrors = transmitErrors;
}
/**
* @return the receiveFrameErrors
*/
public long getReceiveFrameErrors() {
return receiveFrameErrors;
}
/**
* @param receiveFrameErrors the receiveFrameErrors to set
*/
public void setReceiveFrameErrors(long receiveFrameErrors) {
this.receiveFrameErrors = receiveFrameErrors;
}
/**
* @return the receiveOverrunErrors
*/
public long getReceiveOverrunErrors() {
return receiveOverrunErrors;
}
/**
* @param receiveOverrunErrors the receiveOverrunErrors to set
*/
public void setReceiveOverrunErrors(long receiveOverrunErrors) {
this.receiveOverrunErrors = receiveOverrunErrors;
}
/**
* @return the receiveCRCErrors
*/
public long getReceiveCRCErrors() {
return receiveCRCErrors;
}
/**
* @param receiveCRCErrors the receiveCRCErrors to set
*/
public void setReceiveCRCErrors(long receiveCRCErrors) {
this.receiveCRCErrors = receiveCRCErrors;
}
/**
* @return the collisions
*/
public long getCollisions() {
return collisions;
}
/**
* @param collisions the collisions to set
*/
public void setCollisions(long collisions) {
this.collisions = collisions;
}
@Override
@JsonIgnore
public int getLength() {
return 104;
}
@Override
public void readFrom(ChannelBuffer data) {
this.portNumber = data.readShort();
data.readShort(); // pad
data.readInt(); // pad
this.receivePackets = data.readLong();
this.transmitPackets = data.readLong();
this.receiveBytes = data.readLong();
this.transmitBytes = data.readLong();
this.receiveDropped = data.readLong();
this.transmitDropped = data.readLong();
this.receiveErrors = data.readLong();
this.transmitErrors = data.readLong();
this.receiveFrameErrors = data.readLong();
this.receiveOverrunErrors = data.readLong();
this.receiveCRCErrors = data.readLong();
this.collisions = data.readLong();
}
@Override
public void writeTo(ChannelBuffer data) {
data.writeShort(this.portNumber);
data.writeShort((short) 0); // pad
data.writeInt(0); // pad
data.writeLong(this.receivePackets);
data.writeLong(this.transmitPackets);
data.writeLong(this.receiveBytes);
data.writeLong(this.transmitBytes);
data.writeLong(this.receiveDropped);
data.writeLong(this.transmitDropped);
data.writeLong(this.receiveErrors);
data.writeLong(this.transmitErrors);
data.writeLong(this.receiveFrameErrors);
data.writeLong(this.receiveOverrunErrors);
data.writeLong(this.receiveCRCErrors);
data.writeLong(this.collisions);
}
@Override
public int hashCode() {
final int prime = 431;
int result = 1;
result = prime * result + (int) (collisions ^ (collisions >>> 32));
result = prime * result + portNumber;
result = prime * result
+ (int) (receivePackets ^ (receivePackets >>> 32));
result = prime * result + (int) (receiveBytes ^ (receiveBytes >>> 32));
result = prime * result
+ (int) (receiveCRCErrors ^ (receiveCRCErrors >>> 32));
result = prime * result
+ (int) (receiveDropped ^ (receiveDropped >>> 32));
result = prime * result
+ (int) (receiveFrameErrors ^ (receiveFrameErrors >>> 32));
result = prime * result
+ (int) (receiveOverrunErrors ^ (receiveOverrunErrors >>> 32));
result = prime * result
+ (int) (receiveErrors ^ (receiveErrors >>> 32));
result = prime * result
+ (int) (transmitBytes ^ (transmitBytes >>> 32));
result = prime * result
+ (int) (transmitDropped ^ (transmitDropped >>> 32));
result = prime * result
+ (int) (transmitErrors ^ (transmitErrors >>> 32));
result = prime * result
+ (int) (transmitPackets ^ (transmitPackets >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof OFPortStatisticsReply)) {
return false;
}
OFPortStatisticsReply other = (OFPortStatisticsReply) obj;
if (collisions != other.collisions) {
return false;
}
if (portNumber != other.portNumber) {
return false;
}
if (receivePackets != other.receivePackets) {
return false;
}
if (receiveBytes != other.receiveBytes) {
return false;
}
if (receiveCRCErrors != other.receiveCRCErrors) {
return false;
}
if (receiveDropped != other.receiveDropped) {
return false;
}
if (receiveFrameErrors != other.receiveFrameErrors) {
return false;
}
if (receiveOverrunErrors != other.receiveOverrunErrors) {
return false;
}
if (receiveErrors != other.receiveErrors) {
return false;
}
if (transmitBytes != other.transmitBytes) {
return false;
}
if (transmitDropped != other.transmitDropped) {
return false;
}
if (transmitErrors != other.transmitErrors) {
return false;
}
if (transmitPackets != other.transmitPackets) {
return false;
}
return true;
}
}