Package org.eclipse.swt.dnd

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

See Also:
  `Transfer`

### Constructor Summary

Constructors
`ByteArrayTransfer()`

### Method Summary

All Methods Instance Methods Concrete Methods
`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 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

    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(org.eclipse.swt.dnd.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(java.lang.Object, org.eclipse.swt.dnd.TransferData)`