Eclipse Rich Ajax Platform Release 1.3

## org.eclipse.swt.dnd
Class ByteArrayTransfer

    java.lang.Object
      org.eclipse.swt.dnd.Transfer
          org.eclipse.swt.dnd.ByteArrayTransfer

Direct Known Subclasses:
  FileTransfer, HTMLTransfer, ImageTransfer, RTFTransfer, TextTransfer, URLTransfer

public abstract class ByteArrayTransfer
extends Transfer

The class `ByteArrayTransfer` provides a platform specific mechanism for converting a java `byte[]` to a platform specific representation of the byte array and vice versa.

`ByteArrayTransfer` is never used directly but is sub-classed by transfer agents that convert between data in a java format such as a `String` and a platform specific byte array.

If the data you are converting does not map to a `byte[]`, you should sub-class `Transfer` directly and do your own mapping to a platform data type.

The following snippet shows a subclass of ByteArrayTransfer that transfers data defined by the class `MyType`.

     public class MyType {
    	public String fileName;
    	public long fileLength;
    	public long lastModified;
     }

     public class MyTypeTransfer extends ByteArrayTransfer {

    	private static final String MYTYPENAME = "my_type_name";
    	private static final int MYTYPEID = registerType(MYTYPENAME);
    	private static MyTypeTransfer _instance = new MyTypeTransfer();

     private MyTypeTransfer() {}

     public static MyTypeTransfer getInstance () {
     	return _instance;
     }
     public void javaToNative (Object object, TransferData transferData) {
     	if (object == null || !(object instanceof MyType[])) return;

     	if (isSupportedType(transferData)) {
     		MyType[] myTypes = (MyType[]) object;
     		try {
     			// write data to a byte array and then ask super to convert to pMedium
     			ByteArrayOutputStream out = new ByteArrayOutputStream();
     			DataOutputStream writeOut = new DataOutputStream(out);
     			for (int i = 0, length = myTypes.length; i < length;  i++){
     				byte[] buffer = myTypes[i].fileName.getBytes();
     				writeOut.writeInt(buffer.length);
     				writeOut.write(buffer);
     				writeOut.writeLong(myTypes[i].fileLength);
     				writeOut.writeLong(myTypes[i].lastModified);
     			}
     			byte[] buffer = out.toByteArray();
     			writeOut.close();

     			super.javaToNative(buffer, transferData);

     		} catch (IOException e) {
     		}
     	}
     }
     public Object nativeToJava(TransferData transferData){

     	if (isSupportedType(transferData)) {

     		byte[] buffer = (byte[])super.nativeToJava(transferData);
     		if (buffer == null) return null;

     		MyType[] myData = new MyType[0];
     		try {
     			ByteArrayInputStream in = new ByteArrayInputStream(buffer);
     			DataInputStream readIn = new DataInputStream(in);
     			while(readIn.available() > 20) {
     				MyType datum = new MyType();
     				int size = readIn.readInt();
     				byte[] name = new byte[size];
     				readIn.read(name);
     				datum.fileName = new String(name);
     				datum.fileLength = readIn.readLong();
     				datum.lastModified = readIn.readLong();
     				MyType[] newMyData = new MyType[myData.length + 1];
     				System.arraycopy(myData, 0, newMyData, 0, myData.length);
     				newMyData[myData.length] = datum;
     				myData = newMyData;
     			}
     			readIn.close();
     		} catch (IOException ex) {
     			return null;
     		}
     		return myData;
     	}

     	return null;
     }
     protected String[] getTypeNames(){
     	return new String[]{MYTYPENAME};
     }
     protected int[] getTypeIds(){
     	return new int[] {MYTYPEID};
     }
     }

Since:
  1.3
See Also:
  `Transfer`

Constructor Summary
`ByteArrayTransfer()`

Method Summary
`TransferData[]` `getSupportedTypes()` Returns a list of the platform specific data types that can be converted using this transfer agent.
`boolean` `isSupportedType(TransferData transferData)` Returns true if the `TransferData` data type can be converted using this transfer agent, or false otherwise (including if transferData is `null`).
`void` `javaToNative(Object object, TransferData transferData)` This implementation of `javaToNative` converts a java `byte[]` to a platform specific representation.
`Object` `nativeToJava(TransferData transferData)` This implementation of `nativeToJava` converts a platform specific representation of a byte array to a java `byte[]`.

Methods inherited from class org.eclipse.swt.dnd.Transfer
`getTypeIds, getTypeNames, registerType, validate`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### ByteArrayTransfer

    public ByteArrayTransfer()

Method Detail

### getSupportedTypes

    public TransferData[] getSupportedTypes()

  Description copied from class: `Transfer`
  Returns a list of the platform specific data types that can be converted using this transfer agent.

  Only the data type fields of the `TransferData` objects are filled in.

  Specified by:
    `getSupportedTypes` in class `Transfer`
  Returns:
    a list of the data types that can be converted using this transfer agent

### isSupportedType

    public boolean isSupportedType(TransferData transferData)

  Description copied from class: `Transfer`
  Returns true if the `TransferData` data type can be converted using this transfer agent, or false otherwise (including if transferData is `null`).

  Specified by:
    `isSupportedType` in class `Transfer`
  Parameters:
    `transferData` - a platform specific description of a data type; only the data type fields of the `TransferData` object need to be filled in
  Returns:
    true if the transferData data type can be converted using this transfer agent

### javaToNative

    public void javaToNative(Object object,
                             TransferData transferData)

  This implementation of `javaToNative` converts a java `byte[]` to a platform specific representation.

  Specified by:
    `javaToNative` in class `Transfer`
  Parameters:
    `object` - a java `byte[]` containing the data to be converted
    `transferData` - an empty `TransferData` object that will be filled in on return with the platform specific format of the data
  See Also:
    `Transfer.nativeToJava(org.eclipse.swt.dnd.TransferData)`

### nativeToJava

    public Object nativeToJava(TransferData transferData)

  This implementation of `nativeToJava` converts a platform specific representation of a byte array to a java `byte[]`.

  Specified by:
    `nativeToJava` in class `Transfer`
  Parameters:
    `transferData` - the platform specific representation of the data to be converted
  Returns:
    a java `byte[]` containing the converted data if the conversion was successful; otherwise null
  See Also:
    `Transfer.javaToNative(java.lang.Object, org.eclipse.swt.dnd.TransferData)`

Eclipse Rich Ajax Platform Release 1.3

Copyright (c) Innoopract Informationssysteme GmbH and others 2002, 2011. All rights reserved.