Thread: [Openlcb-svn-commits] SF.net SVN: openlcb:[4003] trunk/prototypes/java (Page 8)

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Revision: 4003
          http://sourceforge.net/p/openlcb/svn/4003
Author:   dpharris
Date:     2016-01-19 22:28:40 +0000 (Tue, 19 Jan 2016)
Log Message:
-----------
Loader trial code

Modified Paths:
--------------
    trunk/prototypes/java/src/org/openlcb/DatagramMessage.java
    trunk/prototypes/java/src/org/openlcb/StreamDataSendMessage.java
    trunk/prototypes/java/src/org/openlcb/implementations/MemoryConfigurationService.java
    trunk/prototypes/java/src/org/openlcb/implementations/StreamTransmitter.java
    trunk/prototypes/java/test/org/openlcb/PackageTest.java

Added Paths:
-----------
    trunk/prototypes/java/src/org/openlcb/LoaderClient.java
    trunk/prototypes/java/test/org/openlcb/LoaderClientTest.java
    trunk/prototypes/java/test/org/openlcb/README

Removed Paths:
-------------
    trunk/prototypes/java/src/org/openlcb/LoaderClient.txt

Modified: trunk/prototypes/java/src/org/openlcb/DatagramMessage.java
===================================================================

--- trunk/prototypes/java/src/org/openlcb/DatagramMessage.java	2016-01-19 17:20:42 UTC (rev 4002)
+++ trunk/prototypes/java/src/org/openlcb/DatagramMessage.java	2016-01-19 22:28:40 UTC (rev 4003)
@@ -85,7 +85,7 @@
     @Override
     public String toString() {
         StringBuilder value = new StringBuilder(super.toString());
-        value.append(" Datagram: ");  
+        value.append(" Datagram: ");
         
         int n = getData().length;
         boolean first = true;

Copied: trunk/prototypes/java/src/org/openlcb/LoaderClient.java (from rev 3979, trunk/prototypes/java/src/org/openlcb/LoaderClient.txt)
===================================================================
--- trunk/prototypes/java/src/org/openlcb/LoaderClient.java	                        (rev 0)
+++ trunk/prototypes/java/src/org/openlcb/LoaderClient.java	2016-01-19 22:28:40 UTC (rev 4003)
@@ -0,0 +1,262 @@
+package org.openlcb;
+
+import org.openlcb.*;
+import org.openlcb.implementations.*;
+import org.openlcb.implementations.DatagramService.*;
+import org.openlcb.implementations.MemoryConfigurationService.*;
+import org.openlcb.implementations.StreamTransmitter.*;
+import org.openlcb.implementations.DatagramTransmitter.*;
+import org.openlcb.ProtocolIdentificationReplyMessage;
+import org.openlcb.StreamInitiateReplyMessage;
+
+//import org.slf4j.Logger;
+//import org.slf4j.LoggerFactory;
+
+//
+//  LoaderClient.java
+//
+//
+//  Created by David on 2015-12-29.
+//
+//
+
+//#include "LoaderClient.hpp"
+
+public class LoaderClient extends MessageDecoder {
+    enum State { IDLE, ABORT, FREEZE, INITCOMPL, PIP, SETUPSTREAM, STREAM, STREAMDATA, DG, UNFREEEZE, SUCCESS, FAIL };
+    Connection connection;
+    MemoryConfigurationService mcs;
+    DatagramService dcs;
+    MimicNodeStore store;
+
+    State state;
+    NodeID src;
+    NodeID dest;
+    int space;
+    long address;
+    byte[] content;
+    LoaderStatusReporter feedback;
+    
+    public abstract class LoaderStatusReporter {
+        public abstract void onProgress(float percent);
+        public abstract void onDone(int errorCode, String errorString);
+    }
+    
+    public LoaderClient(NodeID _src, NodeID _dest, int _space, long _address, byte[] _content, LoaderStatusReporter _feedback, Connection _connection, MemoryConfigurationService _mcs, DatagramService _dcs ) {
+        src = _src;
+        dest = _dest;
+        space = _space;
+        address = _address;
+        content = _content.clone();
+                                      // System.out.println("LoaderClient: content="+content);
+        feedback = _feedback;
+        connection = _connection;
+        //dcs = new DatagramService(src, connection);
+        //mcs = new MemoryConfigurationService(src, dcs);
+        dcs = _dcs;
+        mcs = _mcs;
+    }
+    
+    /* Protocol:
+      ---> memconfig Freeze (DG)
+     (<--- DG ok)    -- node may reboot, and not be able to garantee this
+      <--- InitComplete
+      ---> PIPRequest
+      <--- PIPReply
+     IF streams implemented then use one:
+      ---> memconfig write stream request (DG)
+      <--- DG ok
+      <--- memconfig write stream reply (DG)
+      ---> DG ok
+      ---> StreamInitRequest
+      <--- StreamInitReply
+      ---> StreamDataSend
+      ...
+      ---> StreamDataComplete
+     ELSE use datagrams: 
+      ---> DatagramMessage
+      <--- DatagramAcknowledged
+      ...
+      ---> [stop sending data when run out of buffer]
+      <--- stream data proceed
+      ...
+      <--- DatagramAcknowledged
+     THEN:
+      ---> UnFreeze
+     
+     */
+    
+    
+    public void doLoad() {
+        state = State.FREEZE;
+        sendFreeze();  // allow restarts
+    }
+    
+    final int DG_OK = 0x0000;     // double check these
+    final int DG_FAIL = 0x0100;   // note that this value is used in DGMeteringBuffer to denote time-out
+    final int DG_RESEND = 0x0200;
+    void sendFreeze() {
+                                      // System.out.println("lSendFreeze ");
+        //DatagramTransmitter d0 = new DatagramTransmitter(src, dest, new int[]{0x20, 0xA1, space}, connection);
+        
+        dcs.sendData(
+            new DatagramService.DatagramServiceTransmitMemo(dest, new int[]{0x20, 0xA1, space}) {
+                @Override
+                public void handleReply(int code) {
+                                                  // System.out.println("Freeze handleReply: ");
+                  if((state==State.FREEZE)) {
+                      if(code==DG_OK)      { state = State.INITCOMPL; } // DG ok
+                      else if(code==DG_FAIL) { state = State.INITCOMPL; } // DG timed out, but ok timeouts
+                      //else if((code&DG_RESEND)!=0) { state = State.FREEZE; } // resend ok, so start again
+                      else state = State.FAIL;    // Apparently this node doesn't handle DGs
+                  } else state = State.FAIL;
+                }
+            });
+    }
+    @Override
+    public void handleInitializationComplete(InitializationCompleteMessage msg, Connection sender){
+                                      // System.out.println("lhandleInitializationComplete");
+        if (state == State.FREEZE && msg.getSourceNodeID().equals(dest)) { state = State.PIP; sendPipRequest(); }
+        if (state == State.INITCOMPL && msg.getSourceNodeID().equals(dest)) { state = State.PIP; sendPipRequest(); }
+    }
+    void sendPipRequest() {
+                                      // System.out.println("lSendPipRequest ");
+        Message msg = new ProtocolIdentificationRequestMessage(src, dest);
+        connection.put(msg, this);
+        //state = PIPREPLY;
+    }
+    @Override
+    public void handleProtocolIdentificationReply(ProtocolIdentificationReplyMessage msg, Connection sender){
+                                      // System.out.println("lhandleProtocolIdentificationReply");
+        int retries = 0;
+        if (state == State.PIP && msg.getSourceNodeID().equals(dest)) {
+            if((msg.getValue()&0x00200000)!=0) {
+                state=State.FAIL;
+                feedback.onDone(0, "Loader: Target node should not be in Operating state.");
+            }
+            else if((msg.getValue()&0x00100000)==0) {
+                state=State.FAIL; // not in FirmwareUpgrade Operating state
+                feedback.onDone(0, "Loader: Target node is not in Firmware Upgrade state.");
+            }
+            else if((msg.getValue()&0x20000000)!=0) {
+                state = State.SETUPSTREAM;
+                setupStream();
+            } else if((msg.getValue()&0x40000000)!=0) {
+                state = State.DG;
+                //feedback.onDone(0, "BollicksDG!?");
+               sendDGs();
+            } else {
+                state = State.FAIL;
+                feedback.onDone(0, "Loader: Target node does not support Streams nor Datagram!?");
+            }
+        }
+    }
+
+    int bufferSize;      // chunk size
+    int startaddr;
+    int endaddr;
+    int totalmsgs;
+    int sentmsgs;
+    int location;
+    int nextIndex;
+    float progress;
+    
+    byte destStreamID;
+    byte sourceStreamID = 4;  // notional value
+    
+    void setupStream() {
+                                      // System.out.println("lSetup Stream ");
+        bufferSize = 64;
+        state = State.STREAM;
+        
+        mcs.request(new McsWriteStreamMemo(dest, space, address) {
+            @Override
+            public void handleWriteReply(int code) {
+                                      // System.out.println("Reply mcs.request McsWriteStreamMemo handleWriteReply: ");
+                sendStream();
+            }
+        });
+    }
+        
+    void sendStream() {
+                                      // System.out.println("lSend Stream ");
+        StreamInitiateRequestMessage m = new StreamInitiateRequestMessage(src, dest, bufferSize, sourceStreamID, destStreamID);
+        connection.put(m, this);
+    }
+    
+    void handleStreamDataCompleteMessage() {
+                                      // System.out.println("l>>>handleStreamDataCompleteMessage");
+    }
+
+    public void handleStreamInitiateReply(StreamInitiateReplyMessage msg, Connection sender){
+                                      // System.out.println("handleStreamInitiateReply ");
+        // pick up buffer size to use
+        if(state==State.STREAM && sourceStreamID==msg.getSourceStreamID()) {
+            this.bufferSize = msg.getBufferSize();
+            this.destStreamID = msg.getDestinationStreamID();
+            // init transfer
+            nextIndex = 0;
+            // send data
+            state=State.STREAMDATA;
+                                          // System.out.println("Stream proceed ");
+            sendStreamNext();
+        }
+    }
+    public void sendStreamNext() {
+        int size = Math.min(bufferSize, content.length-nextIndex);
+        byte[] data = new byte[size];
+        // copy the needed data
+        for (int i=0; i<size; i++) data[i] = content[nextIndex+i];
+        nextIndex = nextIndex+size;
+                                         // System.out.println("\nsendStreamNext: "+data);
+        Message m = new StreamDataSendMessage(src, dest, data, destStreamID);
+        connection.put(m, this);
+        // are we done?
+        if (nextIndex < content.length) return; // wait for Data Proceed message
+        // yes, say we're done
+        m = new StreamDataCompleteMessage(src, dest, sourceStreamID, destStreamID);
+        connection.put(m, this);
+        sendUnfreeze();
+        state = State.SUCCESS;
+    }
+    public void handleStreamDataProceed(StreamDataProceedMessage msg, Connection sender){
+                                      // System.out.println("handleStreamDataProceed");
+        sendStreamNext();
+    }
+    
+    void sendDGs() {
+                                      // System.out.println("\nlsendDGs: ");
+        nextIndex = 0;
+        bufferSize = 8;
+        sendDGNext();
+    }
+    void sendDGNext() {
+        int size = Math.min(bufferSize, content.length-nextIndex);
+                                      // System.out.println("lbufferSize: "+bufferSize);
+                                      // System.out.println("lsize: "+size);
+            int[] data = new int[size];
+            // copy the needed data
+            for (int i=0; i<size; i++) data[i] = content[nextIndex+i];
+            nextIndex = nextIndex+size;
+        dcs.sendData(new DatagramService.DatagramServiceTransmitMemo(dest, data) {
+            @Override
+            public void handleReply(int code) {
+                                              // System.out.println("lDG handleReply");
+                sendDGNext();
+            }
+        });
+            // are we done?
+        if( nextIndex < content.length ) return;
+        sendUnfreeze();
+        state = State.SUCCESS;
+
+    }
+    
+    void sendUnfreeze() {
+                                      // System.out.println("lsendUnfreeze");
+        dcs.sendData(new DatagramService.DatagramServiceTransmitMemo(dest, new int[]{0x20, 0xA0, space}) {
+            public void handleReply(int code) {
+            }
+        });
+    }
+}
\ No newline at end of file

Deleted: trunk/prototypes/java/src/org/openlcb/LoaderClient.txt
===================================================================
--- trunk/prototypes/java/src/org/openlcb/LoaderClient.txt	2016-01-19 17:20:42 UTC (rev 4002)
+++ trunk/prototypes/java/src/org/openlcb/LoaderClient.txt	2016-01-19 22:28:40 UTC (rev 4003)
@@ -1,275 +0,0 @@
-//
-//  LoaderClient.java
-//
-//
-//  Created by David on 2015-12-29.
-//
-//
-
-#include "LoaderClient.hpp"
-
-public class LoaderClient extends MessageDecoder {
-    enum state = { IDLE, ABORT, FREEZE, INITCOMPL, PIP, SETUPSTREAM, STREAM, STREAMDATA, DG, UNFREEEZE, SUCCESS, FAIL };
-    NodeID dest;
-    int space;
-    long address;
-    byte[] content
-    public abstract class LoaderStatusReporter {
-        public abstract void onProgress(float percent);
-        public abstract void onDone(int errorCode, String errorString);
-    }
-    
-    public LoaderClient(NodeID _dest, int _space, long _address, MemoryContents inputContent, LoaderStatusReporter _feedback) {
-        dest = _dest;
-        space = _space;
-        address = _address;
-        feedback = _feedback;
-    }
-    
-    /* Protocol:
-      ---> memconfig Freeze (DG)
-     (<--- DG ok)    -- node may reboot, and not be able to garantee this
-      <--- InitComplete
-      ---> PIPRequest
-      <--- PIPReply
-     IF streams implemented then use one:
-      ---> memconfig write stream request (DG)
-      <--- DG ok
-      <--- memconfig write stream reply (DG)
-      ---> DG ok
-      ---> StreamInitRequest
-      <--- StreamInitReply
-      ---> StreamDataSend
-      ...
-      ---> StreamDataComplete
-     ELSE use datagrams: 
-      ---> DatagramMessage
-      <--- DatagramAcknowledged
-      ...
-      ---> [stop sending data when run out of buffer]
-      <--- stream data proceed
-      ...
-      <--- DatagramAcknowledged
-     THEN:
-      ---> UnFreeze
-     
-     */
-    
-    
-    public boolean doLoad() {
-        log.info("LoaderClient: Freeze reply");
-        state = FREEZE;
-        sendFreeze();  // allow restarts
-    }
-    
-    final int DG_OK 0x000;     // double check these
-    final int DG_FAIL 0x100;   // note that this value is used in DGMeteringBuffer to denote time-out
-    final int DG_RESEND 0x200;
-    void sendFreeze() {
-        dcs.sendData(new DatagramService.DatagramServiceTransmitMemo(destNodeID(),{0x20, 0xA1, space}) {
-            public void handleReply(int code) {
-                // super handleReply(code);  // is this needed?
-                log.info("LoaderClient: Freeze reply");
-                log.debug("LoaderClient: Start of handleFreezeReply "+code);
-                if((state==FREEZE)) {
-                    if(code==DG_OK)      { state = INITCOMPL; } // DG ok
-                    else if(code==DG_FAIL) { state = INITCOMPL; } // DG timed out, but ok timeouts
-                    else if(code&&DG_RESEND) { state = FREEZE; } // resend ok, so start again
-                    else state = FAIL;    // Apparently this node doesn't handle DGs
-                } else state = FAIL;
-            }
-        });
-    }
-    @Override
-    public void handleInitializationComplete(InitializationCompleteMessage msg, Connection sender){
-        log.debug("LoaderClient: handleInitializationComplete");
-        if (state == INITCOMPL && msg.source().equals(destNodeID())) { state = PIP; sendPipRequest(); }
-    }
-    void sendPipRequest() {
-        log.debug("LoaderClient: PIPRequestMessage");
-        Message msg = new PIPRequestMessage(destNodeID());
-        connection.put(msg, this);
-        //state = PIPREPLY;
-    }
-    @Override
-    public void handlePipReply(PipReplyMessage msg, Connection sender){
-        log.debug("LoaderClient: handlePipReply");
-        int retries = 0;
-        if (state == PIP && msg.source().equals(destNodeID())) {
-            if(msg.data[2]&0x20) {
-                state=FAIL;
-                onDone(FAIL, "Target node should not be in Operating state.");
-            }
-            else if(!(msg.data[2]&0x10)) {
-                state=FAIL; // not in FirmwareUpgrade Operating state
-                onDone(FAIL, "Target node is not in Firmware Upgrade state.");
-            }
-            else if(msg.data[0]&0x20) {
-                state = SETUPSTREAM;
-                setupStream();
-            } else if(msg.data[0]&0x40) {
-                state = DG;
-                sendDG();
-            } else {
-                state = FAIL;
-                onDone(FAIL, "Target node does not support Streams nor Datagram!?");
-            }
-        }
-    }
-    void setupStream() {
-        log.debug("LoaderClient: MemConfigWriteStreamRequest");
-        mcs.Write
-        
-        
-        /*
-        byte[] cmd = { 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, space }; // write stream altspace start(4) space
-        dcs.sendData(new DatagramService.DatagramServiceTransmitMemo(destNodeID(), cmd) {
-            public void handleReply(int code) {
-                log.debug("LoaderClient: MemConfigWriteStreamRequest "+code);
-                log.info("LoaderClient: MemConfigWriteStreamRequest reply");
-                if((state==SETUPSTREAM)) {
-                    if(code==DG_OK)      { state = INITCOMPL; } // DG ok
-                    else {
-                        state = FAIL;
-                        onDone(FAIL, "MemConfigWriteStreamRequest failed.");
-                    }
-                } else {
-                    state = FAIL;
-                    onDone(FAIL, "We got lost 1.");
-                }
-            }
-        });
-         */
-    }
-
-    int bufferSize;      // chunk size
-    int startaddr;
-    int endaddr;
-    int totalmsgs;
-    int sentmsgs;
-    int location;
-    float progress;
-    
-    int destStreamID;
-    int sourceStreamID = 4;  // notional value
-    void sendStream() {
-        log.debug("LoaderClient: sendStream");
-        // not implemented yet
-        state = FAIL;
-        StreamInitRequestMessage m = new StreamInitRequestMessage(here, destNodeID(), bufferSize, sourceStreamID);
-        connection.put(m, this);
-    }
-    public void handleStreamInitReply(StreamInitReplyMessage msg, Connection sender){
-        log.debug("LoaderClient: handleStreamInitReply");
-        // pick up buffer size to use
-        if(state==STREAM && sourceStreamID==msg.getSourceStreamID) {
-            this.bufferSize = msg.getBufferSize();
-            this.destStreamID = msg.getDestStreamID();
-            // init transfer
-            nextIndex = 0;
-            // send data
-            state=STREAMDATA;
-            sendStreamNext();
-        }
-    }
-    public void sendStreamNext() {
-        log.debug("LoaderClient: sendStreamNext");
-        int size = Math.min(bufferSize, bytes.length-nextIndex);
-        int[] data = new int[size];
-        // copy the needed data
-        for (int i=0; i<size; i++) data[i] = bytes[nextIndex+i];
-        nextIndex = nextIndex+size;
-        // send data
-        log.debug("LoaderClient: StreamDataSendMessage");
-        Message m = new StreamDataSendMessage(here, destNodeID(), data, destStreamID);
-        connection.put(m, this);
-        // are we done?
-        if (nextIndex < bytes.length) return; // wait for Data Proceed message
-        // yes, say we're done
-        log.debug("LoaderClient: StreamDataCompleteMessage");
-        m = new StreamDataCompleteMessage(here, far, sourceStreamID, destStreamID);
-        connection.put(m, this);
-        log.info("   LoaderClient: Streaming Download completed normally");
-        state = SUCCESS;
-    }
-    public void handleStreamDataProceed(StreamDataProceedMessage msg, Connection sender){
-        sendStreamNext();
-    }
-
-    void sendDGSequence() {
-        log.debug("LoaderClient: sendDGSequence");
-        bufferSize = 64;
-        startaddr = 0x000000;
-        endaddr = 0xFFFFFF;
-        // fast scan to count messages to send for progress bar
-        location = inputContent.nextContent(startaddr);
-        totalmsgs = 0;
-        sentmsgs = 0;
-        do {
-            // we're assuming that data is pretty dense,
-            // so we can jump through in bufferSize-sized chunks
-            location = location + bufferSize;
-            totalmsgs++;
-            // update to the next location for data
-            int next = inputContent.nextContent(location);
-            if (next < 0) { break; }   // no data left
-            location = next;
-        } while (location <= endaddr);
-        log.info("LoaderClient: Expect downloading to send {} write messages", totalmsgs);
-        
-        // Start write sequence:
-        // find the initial location with data
-        location = inputContent.nextContent(startaddr);
-        sendDGNext();
-    }
-    
-    sendDGNext() {
-        log.debug("LoaderClient: sendDGNext");
-        SwingUtilities.invokeLater(() -> {
-            byte[] temp = new byte[bufferSize];
-            int count;
-            for (count = 0; count < bufferSize; count++) {
-                if (!inputContent.locationInUse(location+count)) {
-                    break;
-                }
-                temp[count] = (byte)inputContent.getLocation(location+count);
-            }
-            byte[] data = new byte[count];
-            System.arraycopy(temp, 0, data, 0, count);
-            int addr = location; // next call back might be instantaneous
-            location = location + count;
-            log.debug("LoaderClient: DG Data");
-            dcs.sendData(new DatagramService.DatagramServiceTransmitMemo(destNodeID(),new int[]{data}) {
-                public void handleWriteReply(int code) {
-                    log.debug("LoaderClient: Start of DGNextReply "+code);
-                    progress = sentmsgs/totalmsgs*100;
-                    if ((++sentmsgs % 20) == 0) ; //updateGUI(state, progress); // callback for GUI
-                    if(state==DG && code==0x000) {
-                        location = inputContent.nextContent(location);
-                        if (location < 0) {
-                            log.info("   LoaderClient: Download completed normally");
-                            sendUnfreeze();
-                            state = SUCCESS;
-                        } else {
-                            log.debug("   LoaderClient: Continue to 0x{}", Integer.toHexString(location).toUpperCase());
-                            sendDGNext();
-                        }
-                    } else {
-                        // non-normal reply
-                        log.info("   LoaderClient: Done abnormal code:{}", code);
-                        state = FAIL;
-                        sendUnfreeze();
-                    }
-                });
-            }
-        });
-    }
-    void sendUnfreeze() {
-        log.debug("LoaderClient: sendUnfreeze");
-        dcs.sendData(new DatagramService.DatagramServiceTransmitMemo(destNodeID(), {0x20, 0xA0, space}) {
-            public void handleReply(int code) {
-                log.info("LoaderClient: unfreeze reply");
-            }
-        });
-    }
-}
\ No newline at end of file

Modified: trunk/prototypes/java/src/org/openlcb/StreamDataSendMessage.java
===================================================================
--- trunk/prototypes/java/src/org/openlcb/StreamDataSendMessage.java	2016-01-19 17:20:42 UTC (rev 4002)
+++ trunk/prototypes/java/src/org/openlcb/StreamDataSendMessage.java	2016-01-19 22:28:40 UTC (rev 4003)
@@ -47,8 +47,19 @@
     } 
 
     public String toString() {
-        return super.toString()
-                +" StreamDataSend "+data;     
+        StringBuilder value = new StringBuilder(super.toString());
+        value.append(" Stream: ");
+        
+        int n = data.length;
+        if(n>16) n=16;
+        boolean first = true;
+        for (int i = 0; i<n; i++) {
+            if (!first) value.append(".");
+            value.append(Integer.toHexString((int)(data[i]&0xFF)).toUpperCase());
+            first = false;
+        }
+        if(data.length>16) value.append(" ...");
+        return new String(value);
     }
 
     public int getMTI() { return MTI_STREAM_DATA_SEND; }

Modified: trunk/prototypes/java/src/org/openlcb/implementations/MemoryConfigurationService.java
===================================================================
--- trunk/prototypes/java/src/org/openlcb/implementations/MemoryConfigurationService.java	2016-01-19 17:20:42 UTC (rev 4002)
+++ trunk/prototypes/java/src/org/openlcb/implementations/MemoryConfigurationService.java	2016-01-19 22:28:40 UTC (rev 4003)
@@ -86,6 +86,7 @@
                     //memo.handleConfigData(dest, commands, options, highSpace, lowSpace,"");
                 }
                 // dph
+                
                 if (writeStreamMemo != null) {
                     // receive destinationStreamID
                     // figure out address space uses byte?
@@ -101,8 +102,9 @@
                     }
                     McsWriteStreamMemo memo = writeStreamMemo;
                     writeStreamMemo = null;
-                    memo.handleWriteStreamData(dest, memo.space, memo.address, content);
+                    //memo.handleWriteStreamData(dest, memo.space, memo.address, content);
                 }
+                
             }
         });
     }
@@ -134,9 +136,11 @@
     // dph
     McsWriteStreamMemo writeStreamMemo;
     public void request(McsWriteStreamMemo memo) {
-        // forward as read Datagram
+        // forward as write Datagram
+                                      //System.out.println("writeStreamMemo: "+memo.dest+","+memo.space+","+memo.address);
+                                      // System.out.println("writeStreamMemo: "+memo.dest);
         writeStreamMemo = memo;
-        WriteDatagramMemo dg = new WriteDatagramMemo(memo.dest, memo.space, memo.address, memo.data, memo);
+        WriteStreamMemo dg = new WriteStreamMemo(memo.dest, memo.space, memo.address, memo);
         downstream.sendData(dg);
     }
 
@@ -206,6 +210,53 @@
     }
 
     @Immutable
+    @ThreadSafe
+    static public class McsWriteStreamMemo {
+        public McsWriteStreamMemo(NodeID dest, int space, long address) {
+            //super(dest, space, address);
+            this.address = address;
+            this.space = space;
+            this.dest = dest;
+            this.data = null;
+        }
+        
+        //final int count;
+        final long address;
+        final int space;
+        final NodeID dest;
+        final byte[] data;
+        
+        @Override
+        public boolean equals(Object o) {
+            if (o == null) return false;
+            if (! (o instanceof McsWriteMemo)) return false;
+            McsWriteMemo m = (McsWriteMemo) o;
+            if (this.dest != m.dest) return false;
+            if (this.space != m.space) return false;
+            if (this.address != m.address) return false;
+            return this.data.length == m.data.length;
+        }
+        
+        @Override
+        public String toString() {
+            return "McsWriteStreamMemo: "+address;
+        }
+        
+        @Override
+        public int hashCode() { return dest.hashCode()+space+((int)address)+data.length; }
+        
+        /**
+         * Overload this for notification of failure reply
+         * @param code non-zero for error reply
+         */
+
+        public void handleReply(int code){}
+        public void handleWriteReply(int code){}
+        public void handleWriteStreamReply(int code) {}
+    }
+    
+    
+    @Immutable
     @ThreadSafe    
     static public class ReadDatagramMemo extends DatagramService.DatagramServiceTransmitMemo {
         ReadDatagramMemo(NodeID dest, int space, long address, int count, McsReadMemo memo) {
@@ -319,52 +370,45 @@
     // need sourceStreamID
     @Immutable
     @ThreadSafe
-    static public class McsWriteStreamMemo extends McsWriteMemo {
-        public McsWriteStreamMemo(NodeID dest, int space, long address, byte[] data) {
-            super( dest, space, address, data);
-            this.address = address;
-            this.space = space;
-            this.dest = dest;
-            this.data = data;
+    static public class WriteStreamMemo extends DatagramService.DatagramServiceTransmitMemo  {
+//        public WriteStreamMemo(NodeID dest, int space, long address, byte[] content, McsWriteMemo memo) {
+      public WriteStreamMemo(NodeID dest, int space, long address, McsWriteStreamMemo memo) {
+          super(dest);
+          this.space=space;
+          this.address = address;
+          boolean spaceByte = false;
+          if (space<0xFD) spaceByte = true;
+          this.data = new int[6+(spaceByte ? 1 : 0)+1];
+          this.data[0] = DATAGRAM_TYPE;
+          this.data[1] = 0x20;
+          if (space >= 0xFD) this.data[1] |= space&0x3;
+          
+          this.data[2] = (int)(address>>24)&0xFF;
+          this.data[3] = (int)(address>>16)&0xFF;
+          this.data[4] = (int)(address>>8 )&0xFF;
+          this.data[5] = (int)(address    )&0xFF;
+          
+          if (spaceByte) {
+              this.data[6] = space;
+              this.data[7] = 0x04;
+          } else this.data[6] = 0x04;   // srcStreamID???? why do we need this?
+          
+          
+          //for (int i = 0; i < content.length; i++)
+          //    this.data[6+(spaceByte ? 1 : 0)+i] = content[i];
+          
+          this.memo = memo;
         }
-
-        byte[] data;
-        final long address;
-        final int space;
-        final NodeID dest;
-        
-        @Override
-        public boolean equals(Object o) {
-            if (o == null) return false;
-            if (! (o instanceof McsWriteStreamMemo)) return false;
-            McsWriteStreamMemo m = (McsWriteStreamMemo) o;
-            if (this.dest != m.dest) return false;
-            if (this.space != m.space) return false;
-            if (this.address != m.address) return false;
-            return this...
 
[truncated message content]

Thread: [Openlcb-svn-commits] SF.net SVN: openlcb:[4003] trunk/prototypes/java (Page 8)

openlcb-svn-commits