Changeset 3823


Ignore:
Timestamp:
03/14/08 16:59:03 (12 years ago)
Author:
curtis
Message:

Arrays work now, including arrays of strings.

Location:
trunk/loci/jvmlink
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/jvmlink/ConnThread.java

    r3758 r3823  
    6666  public static final int LONG_TYPE = 8; 
    6767  public static final int SHORT_TYPE = 9; 
     68  public static final int NULL_TYPE = -1; 
    6869 
    6970  public static final int BYTE_ORDER = 0; 
     
    138139   *  size - number of bytes (per item) 
    139140   *   In case of strings, length of string 
     141   *   For array of strings, 0 
    140142   */ 
    141143 
     
    230232      int insideType = readInt(); 
    231233      int arrayLength = readInt(); 
    232       int size = readInt(); 
    233       debug("in array type for variable " + name + 
    234         " insidetype, length, size: " + insideType + ", " + arrayLength + 
    235         ", " + size); 
     234      int size = getSize(insideType); 
    236235      Object theArray = null; 
    237236      if (insideType == INT_TYPE) { 
    238237        int[] intArray = new int[arrayLength]; 
    239           int readBytes = 0, totalBytes = size*arrayLength; 
    240           while (readBytes < totalBytes) { 
    241             int packetSize = MAX_PACKET_SIZE; 
    242             if (readBytes + MAX_PACKET_SIZE > totalBytes) { 
    243               packetSize = totalBytes - readBytes; 
    244             } 
    245             byte[] b = new byte[packetSize]; 
    246             in.readFully(b, 0, packetSize); 
    247             for (int i=0; i<packetSize/4; i++) { 
    248               intArray[i + (readBytes/4)] = 
    249                 DataTools.bytesToInt(b, 4*i, little); 
    250             } 
    251             readBytes += packetSize; 
    252           } 
    253           theArray = intArray; 
    254         } 
     238        int readBytes = 0, totalBytes = size*arrayLength; 
     239        while (readBytes < totalBytes) { 
     240          int packetSize = MAX_PACKET_SIZE; 
     241          if (readBytes + MAX_PACKET_SIZE > totalBytes) { 
     242            packetSize = totalBytes - readBytes; 
     243          } 
     244          byte[] b = new byte[packetSize]; 
     245          in.readFully(b, 0, packetSize); 
     246          for (int i=0; i<packetSize/4; i++) { 
     247            intArray[i + (readBytes/4)] = 
     248              DataTools.bytesToInt(b, 4*i, little); 
     249          } 
     250          readBytes += packetSize; 
     251        } 
     252        theArray = intArray; 
     253      } 
    255254      else if (insideType == STRING_TYPE) { 
    256255        String[] stringArray = new String[arrayLength]; 
    257           for (int i=0; i<arrayLength; i++) { 
    258             stringArray[i] = readString(); 
    259           } 
    260           theArray = stringArray; 
    261         } 
     256        for (int i=0; i<arrayLength; i++) { 
     257          stringArray[i] = readString(); 
     258        } 
     259        theArray = stringArray; 
     260      } 
    262261      else if (insideType == BYTE_TYPE) { 
    263262        byte[] byteArray = new byte[arrayLength]; 
    264           int readBytes = 0, totalBytes = size*arrayLength; 
    265           while (readBytes < totalBytes) { 
    266             int packetSize = MAX_PACKET_SIZE; 
    267             if (readBytes + MAX_PACKET_SIZE > totalBytes) { 
    268               packetSize = totalBytes - readBytes; 
    269             } 
    270             in.readFully(byteArray, readBytes, packetSize); 
    271             readBytes += packetSize; 
    272           } 
    273           theArray = byteArray; 
    274         } 
     263        int readBytes = 0, totalBytes = size*arrayLength; 
     264        while (readBytes < totalBytes) { 
     265          int packetSize = MAX_PACKET_SIZE; 
     266          if (readBytes + MAX_PACKET_SIZE > totalBytes) { 
     267            packetSize = totalBytes - readBytes; 
     268          } 
     269          in.readFully(byteArray, readBytes, packetSize); 
     270          readBytes += packetSize; 
     271        } 
     272        theArray = byteArray; 
     273      } 
    275274      else if (insideType == CHAR_TYPE) { 
    276275        char[] charArray = new char[arrayLength]; 
    277           int readBytes = 0, totalBytes = size*arrayLength; 
    278           while (readBytes < totalBytes) { 
    279             int packetSize = MAX_PACKET_SIZE; 
    280             if (readBytes + MAX_PACKET_SIZE > totalBytes) { 
    281               packetSize = totalBytes - readBytes; 
    282             } 
    283             byte[] b = new byte[packetSize]; 
    284             in.readFully(b, 0, packetSize); 
    285             for (int i=0; i<packetSize; i++) { 
    286               charArray[i + readBytes] = (char) 
    287                 ((0x00 << 8) | (b[i] & 0xff)); 
    288             } 
    289             readBytes += packetSize; 
    290           } 
    291           theArray = charArray; 
    292           //debug("recvd char array is " + new String(charArray)); 
    293         } 
     276        int readBytes = 0, totalBytes = size*arrayLength; 
     277        while (readBytes < totalBytes) { 
     278          int packetSize = MAX_PACKET_SIZE; 
     279          if (readBytes + MAX_PACKET_SIZE > totalBytes) { 
     280            packetSize = totalBytes - readBytes; 
     281          } 
     282          byte[] b = new byte[packetSize]; 
     283          in.readFully(b, 0, packetSize); 
     284          for (int i=0; i<packetSize; i++) { 
     285            charArray[i + readBytes] = (char) 
     286              ((0x00 << 8) | (b[i] & 0xff)); 
     287          } 
     288          readBytes += packetSize; 
     289        } 
     290        theArray = charArray; 
     291      } 
    294292      else if (insideType == FLOAT_TYPE) { 
    295293        float[] floatArray = new float[arrayLength]; 
     
    704702  } 
    705703 
     704  public static int getSize(int type) { 
     705    switch (type) { 
     706      case BYTE_TYPE: 
     707      case CHAR_TYPE: 
     708      case BOOLEAN_TYPE: 
     709      case NULL_TYPE: 
     710        return 1; 
     711      case SHORT_TYPE: 
     712        return 2; 
     713      case INT_TYPE: 
     714      case FLOAT_TYPE: 
     715        return 4; 
     716      case DOUBLE_TYPE: 
     717      case LONG_TYPE: 
     718        return 8; 
     719      case STRING_TYPE: // string size is variable 
     720      default: 
     721        return 0; 
     722    } 
     723  } 
     724 
    706725  public static String getValue(Object value) { 
    707726    if (value == null) return null; 
    708     String val = value.toString(); 
     727    String val; 
    709728    try { 
    710       val += " (length " + Array.getLength(value) + ")"; 
    711     } 
    712     catch (IllegalArgumentException exc) { } 
     729      int len = Array.getLength(value); 
     730      StringBuffer sb = new StringBuffer(); 
     731      sb.append("["); 
     732      boolean str = false; 
     733      for (int i=0; i<len; i++) { 
     734        Object o = Array.get(value, i); 
     735        str = o instanceof String; 
     736        sb.append(str ? "\n\t" : " "); 
     737        sb.append(o); 
     738      } 
     739      sb.append(str ? "\n" : " "); 
     740      sb.append("]"); 
     741      val = sb.toString(); 
     742    } 
     743    catch (IllegalArgumentException exc) { 
     744      val = value.toString(); 
     745    } 
    713746    return val; 
    714747  } 
  • trunk/loci/jvmlink/cpp/JVMLinkClient.cpp

    r3766 r3823  
    159159 
    160160void JVMLinkClient::setVar(JVMLinkObject* obj) { 
    161         debug("setVar: " << obj->name << " = " << obj); 
    162161        sendInt(SETVAR_CMD); 
    163162        sendMessage(obj->name); 
     
    166165                sendInt((int) obj->insideType); 
    167166                sendInt(obj->length); 
    168                 sendInt(obj->size); 
    169  
    170                 int sentBytes = 0; 
    171                 int totalBytes = (obj->size)*(obj->length); 
    172                 char* dataPointer = (char*) obj->data; 
    173                 while (sentBytes < totalBytes) { 
    174                         char* buff = (char*) (dataPointer + sentBytes); 
    175                         int packetSize = MAX_PACKET_SIZE; 
    176                         if (sentBytes + MAX_PACKET_SIZE > totalBytes) { 
    177                                 packetSize = totalBytes - sentBytes; 
     167                if (obj->insideType == STRING_TYPE) { 
     168                        CString* s = (CString*) obj->data; 
     169                        for (int i=0; i<obj->length; i++) sendMessage(s[i]); 
     170                } 
     171                else { 
     172                        int sentBytes = 0; 
     173                        int totalBytes = obj->size * obj->length; 
     174                        char* dataPointer = (char*) obj->data; 
     175                        while (sentBytes < totalBytes) { 
     176                                char* buff = (char*) (dataPointer + sentBytes); 
     177                                int packetSize = MAX_PACKET_SIZE; 
     178                                if (sentBytes + MAX_PACKET_SIZE > totalBytes) { 
     179                                        packetSize = totalBytes - sentBytes; 
     180                                } 
     181                                send(conn, dataPointer, packetSize, 0); 
     182                                sentBytes += packetSize; 
    178183                        } 
    179                         send(conn,buff,packetSize,0); 
    180                         sentBytes += packetSize; 
    181184                } 
    182185        } 
    183186        else { 
    184187                if (obj->type == STRING_TYPE) sendMessage(*(CString*) obj->data); 
    185                 else send(conn, (char*) obj->data, obj->size,0); 
     188                else send(conn, (char*) obj->data, obj->size, 0); 
    186189        } 
    187190} 
     
    196199void JVMLinkClient::setVar(CString argname, int* obj, int length) { 
    197200        debug("setVar: " << argname << " (int array)"); 
    198         JVMLinkObject* jvmObj = new JVMLinkObject(argname, INT_TYPE, length, &obj); 
     201        JVMLinkObject* jvmObj = new JVMLinkObject(argname, INT_TYPE, length, obj); 
    199202        setVar(jvmObj); 
    200203        delete jvmObj; 
     
    210213void JVMLinkClient::setVar(CString argname, CString* obj, int length) { 
    211214        debug("setVar: " << argname << " (string array)"); 
    212         JVMLinkObject* jvmObj = new JVMLinkObject(argname, STRING_TYPE, length, &obj); 
     215        JVMLinkObject* jvmObj = new JVMLinkObject(argname, STRING_TYPE, length, obj); 
    213216        setVar(jvmObj); 
    214217        delete jvmObj; 
     
    224227void JVMLinkClient::setVar(CString argname, char* obj, int length) { 
    225228        debug("setVar: " << argname << " (char array)"); 
    226         JVMLinkObject* jvmObj = new JVMLinkObject(argname, CHAR_TYPE, length, &obj); 
     229        JVMLinkObject* jvmObj = new JVMLinkObject(argname, CHAR_TYPE, length, obj); 
    227230        setVar(jvmObj); 
    228231        delete jvmObj; 
     
    238241void JVMLinkClient::setVar(CString argname, Byte* obj, int length) { 
    239242        debug("setVar: " << argname << " (byte array)"); 
    240         JVMLinkObject* jvmObj = new JVMLinkObject(argname, BYTE_TYPE, length, &obj); 
     243        JVMLinkObject* jvmObj = new JVMLinkObject(argname, BYTE_TYPE, length, obj); 
    241244        setVar(jvmObj); 
    242245        delete jvmObj; 
     
    252255void JVMLinkClient::setVar(CString argname, float* obj, int length) { 
    253256        debug("setVar: " << argname << " (float array)"); 
    254         JVMLinkObject* jvmObj = new JVMLinkObject(argname, FLOAT_TYPE, length, &obj); 
     257        JVMLinkObject* jvmObj = new JVMLinkObject(argname, FLOAT_TYPE, length, obj); 
    255258        setVar(jvmObj); 
    256259        delete jvmObj; 
     
    266269void JVMLinkClient::setVar(CString argname, bool* obj, int length) { 
    267270        debug("setVar: " << argname << " (bool array)"); 
    268         JVMLinkObject* jvmObj = new JVMLinkObject(argname, BOOL_TYPE, length, &obj); 
     271        JVMLinkObject* jvmObj = new JVMLinkObject(argname, BOOL_TYPE, length, obj); 
    269272        setVar(jvmObj); 
    270273        delete jvmObj; 
     
    280283void JVMLinkClient::setVar(CString argname, double* obj, int length) { 
    281284        debug("setVar: " << argname << " (double array)"); 
    282         JVMLinkObject* jvmObj = new JVMLinkObject(argname, DOUBLE_TYPE, length, &obj); 
     285        JVMLinkObject* jvmObj = new JVMLinkObject(argname, DOUBLE_TYPE, length, obj); 
    283286        setVar(jvmObj); 
    284287        delete jvmObj; 
     
    294297void JVMLinkClient::setVar(CString argname, long long* obj, int length) { 
    295298        debug("setVar: " << argname << " (long array)"); 
    296         JVMLinkObject* jvmObj = new JVMLinkObject(argname, LONG_TYPE, length, &obj); 
     299        JVMLinkObject* jvmObj = new JVMLinkObject(argname, LONG_TYPE, length, obj); 
    297300        setVar(jvmObj); 
    298301        delete jvmObj; 
     
    308311void JVMLinkClient::setVar(CString argname, short* obj, int length) { 
    309312        debug("setVar: " << argname << " (short array)"); 
    310         JVMLinkObject* jvmObj = new JVMLinkObject(argname, SHORT_TYPE, length, &obj); 
     313        JVMLinkObject* jvmObj = new JVMLinkObject(argname, SHORT_TYPE, length, obj); 
    311314        setVar(jvmObj); 
    312315        delete jvmObj; 
     
    317320int JVMLinkClient::sendMessage(CString message) { 
    318321    sendInt(message.GetLength()); 
    319         send(conn,(LPCTSTR)message,message.GetLength(),0); 
    320         return 0; 
     322        return send(conn,(LPCTSTR)message,message.GetLength(),0); 
    321323} 
    322324 
    323325int JVMLinkClient::sendInt(int value) { 
    324326        char* buff = (char*) (&value); 
    325         send(conn,buff,4,0); 
    326         return 0; 
     327        return send(conn,buff,4,0); 
    327328} 
    328329 
    329330void* JVMLinkClient::readMessage(int size) { 
    330331        char* buff = (char*) malloc(size); 
    331         recv(conn,buff,size,0); //TODO: check if everything is received. 
     332        recv(conn, buff, size, 0); //TODO: check if everything is received. 
    332333        return (void*) buff; 
    333334} 
  • trunk/loci/jvmlink/cpp/JVMLinkObject.cpp

    r3758 r3823  
    4141JVMLinkObject::JVMLinkObject(CString name, Type type, void* data) { 
    4242        this->name = name; 
    43         this->size = getSize(type, data); 
     43        this->size = getSize(type); 
    4444        this->length = 1; 
    4545        this->type = type; 
     
    5050JVMLinkObject::JVMLinkObject(CString name, Type type, int length, void* data) { 
    5151        this->name = name; 
    52         this->size = getSize(type, data); 
     52        this->size = getSize(type); 
    5353        this->length = length; 
    5454        this->type = ARRAY_TYPE; 
     
    153153} 
    154154 
    155 int JVMLinkObject::getSize(Type type, void* data) { 
     155int JVMLinkObject::getSize(Type type) { 
    156156        switch (type) { 
    157157                case BYTE_TYPE: 
     
    168168                case LONG_TYPE: 
    169169                        return 8; 
    170                 case STRING_TYPE: 
    171                         return ((CString*) data)->GetLength(); 
     170                case STRING_TYPE: // string size is variable 
    172171                default: 
    173172                        return 0; 
  • trunk/loci/jvmlink/cpp/JVMLinkObject.h

    r3758 r3823  
    6363class JVMLinkObject { 
    6464private: 
    65         int getSize(Type, void*); 
     65        int getSize(Type); 
    6666 
    6767public: 
  • trunk/loci/jvmlink/cpp/TestC2.cpp

    r3787 r3823  
    145145        JVMLinkObject* jvmInt = p->getVar("myInt"); 
    146146        std::cout << "TestC2: getVar: myInt = " << jvmInt->getDataAsInt() << std::endl; 
    147         //for (int i=0; i<first->length; i++) std::cout << a[i] << ", "; 
    148         //std::cout << "Last two elements are " << data[first->length - 2] << " and " << data[first->length - 1] << std::endl; 
    149147 
    150148        // long variables 
     
    280278 
    281279        // CString arrays 
    282 //      p->setVar("myStrings", myStrings, num); 
    283 //      std::cout << "TestC2: setVar: myStrings = [" << std::endl; 
    284 //      for (i=0; i<num; i++) { 
    285 //              std::cout << "\t" << myStrings[i] << std::endl; 
    286 //      } 
    287 //      std::cout << "]" << std::endl; 
    288 //      JVMLinkObject* jvmStrings = p->getVar("myStrings"); 
    289 //      std::cout << "TestC2: getVar: myStrings = [" << std::endl; 
    290 //      for (i=0; i<num; i++) { 
    291 //              std::cout << "\t" << myStrings[i] << std::endl; 
    292 //      } 
    293 //      std::cout << "]" << std::endl; 
     280        p->setVar("myStrings", myStrings, num); 
     281        std::cout << "TestC2: setVar: myStrings = [" << std::endl; 
     282        for (int i=0; i<num; i++) { 
     283                std::cout << "\t" << myStrings[i] << std::endl; 
     284        } 
     285        std::cout << "]" << std::endl; 
     286        JVMLinkObject* jvmStrings = p->getVar("myStrings"); 
     287        std::cout << "TestC2: getVar: myStrings = [" << std::endl; 
     288        for (int i=0; i<num; i++) { 
     289                std::cout << "\t" << myStrings[i] << std::endl; 
     290        } 
     291        std::cout << "]" << std::endl; 
    294292 
    295293        delete myBools; 
Note: See TracChangeset for help on using the changeset viewer.