# Class ByteArrayTransfer

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

Direct Known Subclasses:
  `EditorInputTransfer, FileTransfer, HTMLTransfer, ImageTransfer, LocalSelectionTransfer, MarkerTransfer, PluginTransfer, ResourceTransfer, 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;
    }

    @Override
    public void javaToNative(Object object, TransferData transferData) {
            if (!checkMyType(object) || !isSupportedType(transferData)) {
                    DND.error(DND.ERROR_INVALID_DATA);
            }

            MyType myType = (MyType) object;
            // write data to a byte array and then ask super to convert to native
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            try (DataOutputStream writeOut = new DataOutputStream(out)) {
                    byte[] fileNameBytes = myType.fileName.getBytes(StandardCharsets.UTF_8);
                    writeOut.writeInt(fileNameBytes.length);
                    writeOut.write(fileNameBytes);
                    writeOut.writeLong(myType.fileLength);
                    writeOut.writeLong(myType.lastModified);
                    super.javaToNative(out.toByteArray(), transferData);
            } catch (IOException e) {
            }
    }

    @Override
    public Object nativeToJava(TransferData transferData) {
            if (!isSupportedType(transferData)) {
                    return null;
            }

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

            ByteArrayInputStream in = new ByteArrayInputStream(buffer);
            try (DataInputStream readIn = new DataInputStream(in)) {
                    MyType myType = new MyType();
                    int size = readIn.readInt();
                    byte[] name = new byte[size];
                    readIn.read(name);
                    myType.fileName = new String(name);
                    myType.fileLength = readIn.readLong();
                    myType.lastModified = readIn.readLong();
                    return myType;
            } catch (IOException ex) {
            }
            return null;
    }

    @Override
    protected String[] getTypeNames() {
            return new String[] { MYTYPENAME };
    }

    @Override
    protected int[] getTypeIds() {
            return new int[] { MYTYPEID };
    }

    private boolean checkMyType(Object object) {
            return (object instanceof MyType);
    }

    @Override
    protected boolean validate(Object object) {
            return checkMyType(object);
    }
    }

See Also:
  - `Transfer`

## Constructor Summary

Constructors
Constructor
Description
`ByteArrayTransfer()`

## Method Summary

Modifier and Type
Method
Description
`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`).
`protected void`
`javaToNative(Object object, TransferData transferData)`
This implementation of `javaToNative` converts a java `byte[]` to a platform specific representation.
`protected 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 Transfer

`getTypeIds, getTypeNames, registerType, validate`

### Methods inherited from class Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Constructor Details

### ByteArrayTransfer

public ByteArrayTransfer()

## Method Details

### 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

protected 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(TransferData)`

### nativeToJava

protected 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(Object, TransferData)`