javax.microedition.rms.RecordStoreException Java Examples

@Override
public void closeRecordStore()
		throws RecordStoreNotOpenException, RecordStoreException {
	if (!open) {
		throw new RecordStoreNotOpenException();
	}

	if (recordListeners != null) {
		recordListeners.removeAllElements();
	}

	records.clear();

	open = false;
	Log.d(TAG, "RecordStore " + recordStoreName + " closed");
}
 

@Override
public byte[] nextRecord()
		throws InvalidRecordIDException, RecordStoreNotOpenException, RecordStoreException {
	if (!recordStoreImpl.isOpen()) {
		throw new RecordStoreNotOpenException();
	}

	if (currentRecord >= numRecords()) {
		throw new InvalidRecordIDException();
	}

	byte[] result = enumerationRecords.elementAt(currentRecord).value;
	currentRecord++;

	return result;
}
 

public void flush() throws IOException {
    if (cache != null) {
        byte[] data = cache.toByteArray();
        if (data.length > 0) {
            RecordStore r = null;
            try {
                r = RecordStore.openRecordStore("" + letter + key, true);
                r.addRecord(data, 0, data.length);
                r.closeRecordStore();
                if (letter == 'Z') {
                    letter = 'a';
                } else {
                    letter++;
                }
                cache.reset();
            } catch (RecordStoreException ex) {
                ex.printStackTrace();
                cleanup(r);
                throw new IOException(ex.toString());
            }
        }
    }
}
 

@Override
public void deleteRecord(int recordId)
		throws RecordStoreNotOpenException, InvalidRecordIDException, RecordStoreException {
	if (!open) {
		throw new RecordStoreNotOpenException();
	}

	synchronized (this) {
		// throws InvalidRecordIDException when no record found
		getRecord(recordId);
		records.remove(new Integer(recordId));
		version++;
		lastModified = System.currentTimeMillis();
		size--;
	}

	recordStoreManager.deleteRecord(this, recordId);

	fireRecordListener(ExtendedRecordListener.RECORD_DELETE, recordId);
	Log.d(TAG, "Record " + recordStoreName + "." + recordId + " deleted");
}
 

@Override
public int getRecordSize(int recordId)
		throws RecordStoreNotOpenException, InvalidRecordIDException, RecordStoreException {
	if (!open) {
		throw new RecordStoreNotOpenException();
	}

	synchronized (this) {
		byte[] data = records.get(new Integer(recordId));
		if (data == null) {
			recordStoreManager.loadRecord(this, recordId);
			data = records.get(new Integer(recordId));
			if (data == null) {
				throw new InvalidRecordIDException();
			}
		}

		return data.length;
	}
}
 

public void writeRecord(DataOutputStream dos, int recordId)
		throws IOException {
	dos.writeInt(recordId);
	dos.writeInt(0); // TODO Tag
	try {
		byte[] data = getRecord(recordId);
		if (data == null) {
			dos.writeInt(0);
		} else {
			dos.writeInt(data.length);
			dos.write(data);
		}
	} catch (RecordStoreException e) {
		throw new IOException();
	}
}
 

@Override
public byte[] getRecord(int recordId)
		throws RecordStoreNotOpenException, InvalidRecordIDException, RecordStoreException {
	if (!open) {
		throw new RecordStoreNotOpenException();
	}

	byte[] data;

	synchronized (this) {
		data = new byte[getRecordSize(recordId)];
		getRecord(recordId, data, 0);
	}

	return data.length < 1 ? null : data;
}
 

public void flush() throws IOException {
    if(cache != null) {
        byte[] data = cache.toByteArray();
        if(data.length > 0) {
            RecordStore r = null;
            try {
                r = RecordStore.openRecordStore("" + letter + key, true);
                r.addRecord(data, 0, data.length);
                r.closeRecordStore();
                if(letter == 'Z') {
                    letter = 'a';
                } else {
                    letter++;
                }
                cache = new ByteArrayOutputStream();
            } catch (RecordStoreException ex) {
                ex.printStackTrace();
                cleanup(r);
                throw new IOException(ex.toString());
            }
        }
    }
}
 

private synchronized void deleteFromDisk(RecordStoreImpl recordStore, int recordId)
		throws RecordStoreException {
	try {
		DataOutputStream dos = new DataOutputStream(
				ContextHolder.openFileOutput(getHeaderFileName(recordStore.getName())));
		recordStore.writeHeader(dos);
		dos.close();
	} catch (IOException e) {
		Log.e(TAG, "RecordStore.saveToDisk: ERROR writting object to " + getHeaderFileName(recordStore.getName()), e);
		throw new RecordStoreException(e.getMessage());
	}

	ContextHolder.deleteFile(getRecordFileName(recordStore.getName(), recordId));
}
 

@Override
public byte[] previousRecord()
		throws InvalidRecordIDException, RecordStoreNotOpenException, RecordStoreException {
	if (!recordStoreImpl.isOpen()) {
		throw new RecordStoreNotOpenException();
	}
	if (currentRecord < 0) {
		throw new InvalidRecordIDException();
	}

	currentRecord--;

	return enumerationRecords.elementAt(currentRecord).value;
}
 

/**
 * @inheritDoc
 */
public void deleteStorageFile(String name) {
    Short key = (Short)fat.get(name);
    fat.remove(name);
    resaveFat();
    if(key != null) {
        try {
            for(char c = 'A' ; c < 'Z' ; c++) {
                RecordStore.deleteRecordStore("" + c + key);
            }
        } catch(RecordStoreException e) {}
    }
}
 

public RMSOutputStream(short key) {
    this.key =  key;

    // first we need to cleanup existing files
    try {
        for(char c = 'A' ; c < 'Z' ; c++) {
            RecordStore.deleteRecordStore("" + c + key);
        }
    } catch(RecordStoreException e) {}

    cache = new ByteArrayOutputStream();
}
 

public RMSInputStream(short key) throws IOException {
            this.key = key;
            RecordStore r = null;
            RecordEnumeration e = null;
            char letter = 'A';
            try {
                ByteArrayOutputStream os = new ByteArrayOutputStream();
                r = open("" + letter + key);
                while(r != null) {
                    e = r.enumerateRecords(null, null, false);
                    while(e.hasNextElement()) {
                        byte[] data = e.nextRecord();
                        os.write(data);
                    }
                    e.destroy();
                    r.closeRecordStore();
                    letter++;
                    r = open("" + letter + key);
                    if(letter == 'Z') {
                        letter = 'a' - ((char)1);
                    }
                }
                os.close();
                current = new ByteArrayInputStream(os.toByteArray());
            } catch (RecordStoreException ex) {
                //#ifndef RIM
                ex.printStackTrace();
                //#else
//#                 System.out.println("Exception in object store input stream constructor: " + ex);
                //#endif
                cleanup(r);
                cleanup(e);
                throw new IOException(ex.toString());
            }
        }
 

private RecordStore open(String s) {
    try {
        return RecordStore.openRecordStore(s, false);
    } catch (RecordStoreException ex) {
        return null;
    }
}
 

/**
 * @inheritDoc
 */
public void deleteStorageFile(String name) {
    Short key = (Short) fat.get(name);
    fat.remove(name);
    resaveFat();
    if (key != null) {
        try {
            for (char c = 'A'; c < 'Z'; c++) {
                RecordStore.deleteRecordStore("" + c + key);
            }
        } catch (RecordStoreException e) {
        }
    }
}
 

public RMSOutputStream(short key) {
    this.key = key;

    // first we need to cleanup existing files
    try {
        for (char c = 'A'; c < 'Z'; c++) {
            RecordStore.deleteRecordStore("" + c + key);
        }
    } catch (RecordStoreException e) {
    }

    cache = new ByteArrayOutputStream();
}
 

public RMSInputStream(short key) throws IOException {
    this.key = key;
    RecordStore r = null;
    RecordEnumeration e = null;
    char letter = 'A';
    try {
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        r = open("" + letter + key);
        while (r != null) {
            e = r.enumerateRecords(null, null, false);
            while (e.hasNextElement()) {
                byte[] data = e.nextRecord();
                os.write(data);
            }
            e.destroy();
            r.closeRecordStore();
            letter++;
            r = open("" + letter + key);
            if (letter == 'Z') {
                letter = 'a' - ((char) 1);
            }
        }
        os.close();
        current = new ByteArrayInputStream(os.toByteArray());
    } catch (RecordStoreException ex) {
        ex.printStackTrace();
        cleanup(r);
        cleanup(e);
        throw new IOException(ex.toString());
    }
}
 

private RecordStore open(String s) {
    try {
        return RecordStore.openRecordStore(s, false);
    } catch (RecordStoreException ex) {
        return null;
    }
}
 

@Override
public int getSize()
		throws RecordStoreNotOpenException {
	if (!open) {
		throw new RecordStoreNotOpenException();
	}

	// TODO include size overhead such as the data structures used to hold the state of the record store

	// Preload all records
	enumerateRecords(null, null, false);

	int result = 0;
	Enumeration keys = records.keys();
	while (keys.hasMoreElements()) {
		int key = (Integer) keys.nextElement();
		try {
			byte[] data = getRecord(key);
			if (data != null) {
				result += data.length;
			}
		} catch (RecordStoreException e) {
			e.printStackTrace();
		}
	}
	return result;
}
 

@Override
public void deleteRecordStore(final String recordStoreName)
		throws RecordStoreNotFoundException, RecordStoreException {
	initializeIfNecessary();

	Object value = recordStores.get(recordStoreName);
	if (value == null) {
		throw new RecordStoreNotFoundException(recordStoreName);
	}
	if (value instanceof RecordStoreImpl && ((RecordStoreImpl) value).isOpen()) {
		throw new RecordStoreException();
	}

	RecordStoreImpl recordStoreImpl;
	try {
		DataInputStream dis = new DataInputStream(ContextHolder.openFileInput(getHeaderFileName(recordStoreName)));
		recordStoreImpl = new RecordStoreImpl(this);
		recordStoreImpl.readHeader(dis);
		dis.close();
	} catch (IOException e) {
		Log.e(TAG, "RecordStore.deleteRecordStore: ERROR reading " + getHeaderFileName(recordStoreName), e);
		throw new RecordStoreException();
	}

	recordStoreImpl.setOpen(true);
	RecordEnumeration re = recordStoreImpl.enumerateRecords(null, null, false);
	while (re.hasNextElement()) {
		ContextHolder.deleteFile(getRecordFileName(recordStoreName, re.nextRecordId()));
	}
	recordStoreImpl.setOpen(false);
	ContextHolder.deleteFile(getHeaderFileName(recordStoreName));

	recordStores.remove(recordStoreName);
	Log.d(TAG, "RecordStore " + recordStoreName + " deleted");
}
 

@Override
public int getNextRecordID()
		throws RecordStoreNotOpenException, RecordStoreException {
	if (!open) {
		throw new RecordStoreNotOpenException();
	}

	// lastRecordId needs to hold correct number, all records have to be preloaded
	enumerateRecords(null, null, false);

	synchronized (this) {
		return lastRecordId + 1;
	}
}
 

@Override
public int addRecord(byte[] data, int offset, int numBytes)
		throws RecordStoreNotOpenException, RecordStoreException, RecordStoreFullException {
	if (!open) {
		throw new RecordStoreNotOpenException();
	}
	if (data == null && numBytes > 0) {
		throw new NullPointerException();
	}
	if (numBytes > recordStoreManager.getSizeAvailable(this)) {
		throw new RecordStoreFullException();
	}

	// lastRecordId needs to hold correct number, all records have to be preloaded
	enumerateRecords(null, null, false);

	byte[] recordData = new byte[numBytes];
	if (data != null) {
		System.arraycopy(data, offset, recordData, 0, numBytes);
	}

	int nextRecordID = getNextRecordID();
	synchronized (this) {
		records.put(new Integer(nextRecordID), recordData);
		version++;
		lastModified = System.currentTimeMillis();
		lastRecordId++;
		size++;
	}

	recordStoreManager.saveRecord(this, nextRecordID);

	fireRecordListener(ExtendedRecordListener.RECORD_ADD, nextRecordID);

	Log.d(TAG, "Record " + recordStoreName + "." + nextRecordID + " added");
	return nextRecordID;
}
 

@Override
public int getRecord(int recordId, byte[] buffer, int offset)
		throws RecordStoreNotOpenException, InvalidRecordIDException, RecordStoreException {
	int recordSize;
	synchronized (this) {
		recordSize = getRecordSize(recordId);
		System.arraycopy(records.get(new Integer(recordId)), 0, buffer, offset, recordSize);
	}

	fireRecordListener(ExtendedRecordListener.RECORD_READ, recordId);

	return recordSize;
}
 

@Override
public void setRecord(int recordId, byte[] newData, int offset, int numBytes)
		throws RecordStoreNotOpenException, InvalidRecordIDException, RecordStoreException, RecordStoreFullException {
	if (!open) {
		throw new RecordStoreNotOpenException();
	}

	// FIXME fixit
	if (numBytes > recordStoreManager.getSizeAvailable(this)) {
		throw new RecordStoreFullException();
	}

	byte[] recordData = new byte[numBytes];
	System.arraycopy(newData, offset, recordData, 0, numBytes);

	synchronized (this) {
		// throws InvalidRecordIDException when no record found
		getRecord(recordId);
		records.put(new Integer(recordId), recordData);
		version++;
		lastModified = System.currentTimeMillis();
	}

	recordStoreManager.saveRecord(this, recordId);

	fireRecordListener(ExtendedRecordListener.RECORD_CHANGE, recordId);
	Log.d(TAG, "Record " + recordStoreName + "." + recordId + " set");
}
 

@Override
public void deleteRecord(RecordStoreImpl recordStoreImpl, int recordId)
		throws RecordStoreNotOpenException, RecordStoreException {
	deleteFromDisk(recordStoreImpl, recordId);
}
 

void deleteRecordStore(String recordStoreName)
throws RecordStoreNotFoundException, RecordStoreException;
 

RecordStore openRecordStore(String recordStoreName, boolean createIfNecessary)
throws RecordStoreException;
 

void loadRecord(RecordStoreImpl recordStoreImpl, int recordId)
throws RecordStoreNotOpenException, InvalidRecordIDException, RecordStoreException;
 

void deleteRecord(RecordStoreImpl recordStoreImpl, int recordId)
throws RecordStoreNotOpenException, RecordStoreException;
 

void saveRecord(RecordStoreImpl recordStoreImpl, int recordId)
throws RecordStoreNotOpenException, RecordStoreException;