Class 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();
                            byte[] buffer = out.toByteArray();
                            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];
                                    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;
                    } 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:
    • 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
        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
        transferData - a platform specific description of a data type; only the data type fields of the TransferData object need to be filled in
        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
        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: