Create method: impossible to call from lock/unlock.

[Anton Golovin]

Hi, guys. I have another question, this time related to the create method. This method can not require that a record it is about to create be locked, since it cannot know the record number. My create method reuses deleted records. Here is what I came up with:

 
 public synchronized int create(String[] data) throws DuplicateKeyException {
 
        // checks that a valid reference was passed in for the record data
        if (data == null) {
            return -1;
        }
 
        boolean NOT_OK = false; // false indicates record is ok to overwrite
        int newRecordNumber = 0; // holds record number to create record at
        boolean reused = true; // indicates if the record is to be reused
 
        // finds a deleted record to reuse or creates a new one
        // makes sure that the record it wishes to reuse is reusable, i.e.,
        // deleted, at the point of creating a new record
 
        do {
 
            // checks if a deleted record exists in the cache,
            // and if so, gets the first instance of such occurence
            newRecordNumber = cached.indexOf(null);
 
            // if there are no deleted records to be reused in the cache,
            // a new one must be created at the end of the records
            if (newRecordNumber == -1) {
                newRecordNumber = cached.size();
                DataUtilities.log("Data.CREATE: Found record number " +
                                   newRecordNumber + " suitable for writing.");
                reused = false; // record is to be appended
                NOT_OK = false; // no need to continue looking for reusable records
            }
 
            // there is a possibility, in reuse, that the method finds a record
            // after it is deleted but before it is unlocked. it would not be
            // prudent to modify even a deleted record before it has been un-
            // locked, and so the method waits until the lock is off the record.
            if (reused) { // but only if reusing a record
                waitForUnlock(new Integer(newRecordNumber));
                // but because of the uncertainties of multi-threading, the record
                // is subject to additional modification before it is unlocked.
                // (for instance, when delete and update are both called from
                // within the same lock/unlock block.)
                // therefore, when the create method gets to it, it may no longer
                // be deleted. therefore, it needs to recheck if this record is
                // ok to overwrite.
                if (isRecord(newRecordNumber)) {
                    // and if the record has been updated, it needs to look
                    // for another deleted record to overwrite (or, if no more
                    // are left) for a brand-new record number to append the new
                    // record
                    NOT_OK = true;
                    // however, if the record is still deleted and reusable,
                    // it is ok to overwrite it, and looping must stop
                } else {
                    NOT_OK = false;
                }
                DataUtilities.log("NOT_OK: " + NOT_OK);
            }
 
        } while (NOT_OK);
 
        // checks if the record number to put the record at already has a
        // valid record at it. this should never be thrown in well-written code.
        // here it is used due to method requirements and as a defense of last
        // resort should something like that somehow occur
        if (isRecord(newRecordNumber)) {
            throw new DuplicateKeyException("Record " + newRecordNumber +
                                            " already exists and cannot be overwritten.");
        }
 
        // validates the record
           if (!header.validateRecord(newRecordNumber, data)) {
               return -1;
           }
 
        // writes the record data to data file at the specified number
        try {
            this.writeRecord(newRecordNumber, data);
        } catch (SecurityException secEx) {
            return -1;
        } catch (IOException ioEx) {
            return -1;
        }
 
        // adds the record to cache
        if (reused) { // inserts the record, replacing a deleted one
            cached.set(newRecordNumber, data);
 
        } else { // appends a record, creating a new entry
            cached.add(newRecordNumber, data);
        }
 
        DataUtilities.log("Data.CREATE: created record " + newRecordNumber +
                           ". Created by thread " +
                           Thread.currentThread().getName());
 
        // returns number of newly created record
        return newRecordNumber;
    }
 

Any opinions are welcome, including those which think I overcomplicated things.

[Michael Couck]

Hi Anton,

Looks pretty good to me.

I will say that it was not specifically mentioned in the spec that the create method was to be implemented. As it turns out I did, as well as the delete if I remember correctly, but I didn't expose these functions to the client, i.e. the gui, so just a book and search function. But the specs are slightly different.

Anyway, looks fine.

See ya

Michael