4 octets in address string : String « Date Type « Android

1. Android
2. Date Type
3. String

4 octets in address string

    
/*
 * This file is part of JSTUN. 
 * 
 * Copyright (c) 2005 Thomas King <king@t-king.de> - All rights
 * reserved.
 * 
 * This software is licensed under either the GNU Public License (GPL),
 * or the Apache 2.0 license. Copies of both license agreements are
 * included in this distribution.
 */

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.StringTokenizer;

public class Address {
  int firstOctet;
  int secondOctet;
  int thirdOctet;
  int fourthOctet;

  public Address(int firstOctet, int secondOctet, int thirdOctet,
      int fourthOctet) throws UtilityException {
    if ((firstOctet < 0) || (firstOctet > 255) || (secondOctet < 0)
        || (secondOctet > 255) || (thirdOctet < 0)
        || (thirdOctet > 255) || (fourthOctet < 0)
        || (fourthOctet > 255)) {
      throw new UtilityException("Address is malformed.");
    }
    this.firstOctet = firstOctet;
    this.secondOctet = secondOctet;
    this.thirdOctet = thirdOctet;
    this.fourthOctet = fourthOctet;
  }

  public Address(String address) throws UtilityException {
    StringTokenizer st = new StringTokenizer(address, ".");
    if (st.countTokens() != 4) {
      throw new UtilityException(
          "4 octets in address string are required.");
    }
    int i = 0;
    while (st.hasMoreTokens()) {
      int temp = Integer.parseInt(st.nextToken());
      if ((temp < 0) || (temp > 255)) {
        throw new UtilityException("Address is in incorrect format.");
      }
      switch (i) {
      case 0:
        firstOctet = temp;
        ++i;
        break;
      case 1:
        secondOctet = temp;
        ++i;
        break;
      case 2:
        thirdOctet = temp;
        ++i;
        break;
      case 3:
        fourthOctet = temp;
        ++i;
        break;
      }
    }
  }

  public Address(byte[] address) throws UtilityException {
    if (address.length < 4) {
      throw new UtilityException("4 bytes are required.");
    }
    firstOctet = Utility.oneByteToInteger(address[0]);
    secondOctet = Utility.oneByteToInteger(address[1]);
    thirdOctet = Utility.oneByteToInteger(address[2]);
    fourthOctet = Utility.oneByteToInteger(address[3]);
  }

  public String toString() {
    return firstOctet + "." + secondOctet + "." + thirdOctet + "."
        + fourthOctet;
  }

  public byte[] getBytes() throws UtilityException {
    byte[] result = new byte[4];
    result[0] = Utility.integerToOneByte(firstOctet);
    result[1] = Utility.integerToOneByte(secondOctet);
    result[2] = Utility.integerToOneByte(thirdOctet);
    result[3] = Utility.integerToOneByte(fourthOctet);
    return result;
  }

  public InetAddress getInetAddress() throws UtilityException,
      UnknownHostException {
    byte[] address = new byte[4];
    address[0] = Utility.integerToOneByte(firstOctet);
    address[1] = Utility.integerToOneByte(secondOctet);
    address[2] = Utility.integerToOneByte(thirdOctet);
    address[3] = Utility.integerToOneByte(fourthOctet);
    return InetAddress.getByAddress(address);
  }

  public boolean equals(Object obj) {
    if (obj == null)
      return false;
    try {
      byte[] data1 = this.getBytes();
      byte[] data2 = ((Address) obj).getBytes();
      if ((data1[0] == data2[0]) && (data1[1] == data2[1])
          && (data1[2] == data2[2]) && (data1[3] == data2[3]))
        return true;
      return false;
    } catch (UtilityException ue) {
      return false;
    }
  }

  public int hashCode() {
    return (firstOctet << 24) + (secondOctet << 16) + (thirdOctet << 8)
        + fourthOctet;
  }

}

class UtilityException extends Exception {
  private static final long serialVersionUID = 3545800974716581680L;

  UtilityException(String mesg) {
    super(mesg);
  }

}

class Utility {

  public static final byte integerToOneByte(int value) throws UtilityException {
    if ((value > Math.pow(2,15)) || (value < 0)) {
      throw new UtilityException("Integer value " + value + " is larger than 2^15");
    }
    return (byte)(value & 0xFF);
  }
  
  public static final byte[] integerToTwoBytes(int value) throws UtilityException {
    byte[] result = new byte[2];
    if ((value > Math.pow(2,31)) || (value < 0)) {
      throw new UtilityException("Integer value " + value + " is larger than 2^31");
    }
        result[0] = (byte)((value >>> 8) & 0xFF);
        result[1] = (byte)(value & 0xFF);
    return result; 
  }
  
  public static final byte[] integerToFourBytes(int value) throws UtilityException {
    byte[] result = new byte[4];
    if ((value > Math.pow(2,63)) || (value < 0)) {
      throw new UtilityException("Integer value " + value + " is larger than 2^63");
    }
        result[0] = (byte)((value >>> 24) & 0xFF);
    result[1] = (byte)((value >>> 16) & 0xFF);
    result[2] = (byte)((value >>> 8) & 0xFF);
        result[3] = (byte)(value & 0xFF);
    return result; 
  }
  
  public static final int oneByteToInteger(byte value) throws UtilityException {
    return (int)value & 0xFF;
  }
  
  public static final int twoBytesToInteger(byte[] value) throws UtilityException {
    if (value.length < 2) {
      throw new UtilityException("Byte array too short!");
    }
        int temp0 = value[0] & 0xFF;
        int temp1 = value[1] & 0xFF;
        return ((temp0 << 8) + temp1);
  }
  
  public static final long fourBytesToLong(byte[] value) throws UtilityException {
    if (value.length < 4) {
      throw new UtilityException("Byte array too short!");
    }
        int temp0 = value[0] & 0xFF;
        int temp1 = value[1] & 0xFF;
    int temp2 = value[2] & 0xFF;
    int temp3 = value[3] & 0xFF;
        return (((long)temp0 << 24) + (temp1 << 16) + (temp2 << 8) + temp3);
  }                                        
}

   
    
    
    
  

Related examples in the same category