public static boolean ParseObjectKey()

in yoko-core/src/main/java/org/apache/yoko/orb/OB/ObjectKey.java [137:266]
82 lines of code
20 McCabe index (conditional complexity)

    public static boolean ParseObjectKey(byte[] key, ObjectKeyData keyData) {
        //
        // Parse out the POA's. This should be a sequence of strings
        // terminated by two null values.
        //
        int data = 0;
        int end = key.length;
        
        if (logger.isLoggable(Level.FINE)) {
            logger.fine("Parsing object key\n" + IORUtil.dump_octets(key)); 
        }

        //
        // First try to figure out whether the object-key is OB 4.x
        // format. Must be at least 4 bytes - magic + 1|0.
        //
        // OB 4.x magic number: abacab
        //
        if (key.length > 4 && key[0] == (byte) 0xab && key[1] == (byte) 0xac
                && key[2] == (byte) 0xab) {
            data += 3;
            if (key[data] == '0') // persistent
            {
                logger.fine("Parsing persistent object key"); 
                keyData.persistent = true;
                keyData.createTime = 0;
                ++data;
            } else {
                if (key[data] != '1') {
                    logger.fine("Characters '1' expected at position " + data); 
                    return false;
                }
                keyData.persistent = false;
                ++data;
                //
                // Remember the start of the time stamp
                //
                int start = data;
                while (data < end && key[data] != '\0') {
                    data++;
                }
                if (data >= end) {
                    logger.fine("Missing '\0' in key data"); 
                    return false;
                }

                String t = new String(key, start, data - start);
                try {
                    keyData.createTime = Integer.valueOf(t).intValue();
                } catch (NumberFormatException ex) {
                    logger.log(Level.FINE, "Invalid timestamp in key data", ex); 
                    return false;
                }
                //
                // skip the null byte
                //
                ++data;
            }

            boolean first = true;
            java.util.Vector poaId = new java.util.Vector();
            while (data < end) {
                //
                // Remember the start of the POA name
                //
                int start = data;
                while (data < end && key[data] != '\0') {
                    data++;
                }

                //
                // Ensure that we haven't gone too far...
                //
                if (data >= end) {
                    logger.fine("Missing '\0' in key data"); 
                    return false;
                }

                //
                // Append this to the sequence of POA's.
                //
                if (first) {
                    keyData.serverId = new String(key, start, data - start);
                    logger.fine("Parsed serverId=" + keyData.serverId); 
                    first = false;
                } else {
                    String element = new String(key, start, data - start); 
                    logger.fine("Parsed POA name=" + element); 
                    poaId.addElement(element);
                }

                //
                // Skip this byte, check to see if we have another '\0'
                //
                if (key[++data] == '\0') {
                    //
                    // Skip this byte
                    //
                    ++data;
                    break;
                }
            }
            keyData.poaId = new String[poaId.size()];
            poaId.copyInto(keyData.poaId);

            //
            // Verify that we haven't gone too far.
            //
            if (data >= end) {
                logger.fine("Missing object id in key data"); 
                return false;
            }

            //
            // Remaining portion is the ObjectId.
            //
            int len = end - data;
            keyData.oid = new byte[len];
            System.arraycopy(key, data, keyData.oid, 0, len);

            if (logger.isLoggable(Level.FINEST)) {
                logger.finest("Parsed object id is\n" + IORUtil.dump_octets(keyData.oid)); 
            }

            return true;
        } else {
            logger.fine("Invalid magic number in object key"); 
            return false;
        }
    }