indexfilehelper.java

Disk simulation program. Simulates file-system with direct access.

import java.util.List;
import java.util.ArrayList;

public class IndexFileHelper
{
    private List<IndexRecord> idxRecords;
    private IndexedFile file;

    public IndexFileHelper(IndexedFile file)
    {
        System.out.println("Building index tree...");
        this.file = file;
        this.idxRecords = new ArrayList<IndexRecord>();
        fillRecords();
    }

    private void fillRecords()
    {
        int idxStart = file.getIndexStart();
        int idxSectors = file.getIndexSectors();
        int idxRecordSize = file.getKeySize()+IndexRecord.SECTOR_NUMBER_LENGTH;
        int idxRecordsInSector = file.getDisk().getSectorSize() / idxRecordSize;

        for(int i=idxStart; i<(idxStart+idxSectors); i++)
        {
            char[] buffer = new char[file.getDisk().getSectorSize()];
            file.getDisk().readSector(i, buffer);

            for(int k=0; k<idxRecordsInSector; k++)
            {
                int offset = k * idxRecordSize;
                char[] record = new char[idxRecordSize];
                System.arraycopy(buffer, offset, record, 0, idxRecordSize);
                IndexRecord ir = new IndexRecord(file.getKeySize(), record);
                if(ir.getKey()[0]!='\0' && ir.getSectorNumber()[0]!='\0')
                    idxRecords.add(ir);
            }
        }

        System.out.println("Read "+idxSectors+" index sectors, "+idxRecords.size()+" index records");
    }

    public Record findRecordInSector(int sector, char[] key)
    {
        char[] buffer = new char[file.getDisk().getSectorSize()];
        file.getDisk().readSector(sector, buffer);
        int recordsNum = file.getDisk().getSectorSize() / file.getRecordSize();
        String keyStr = String.valueOf(key).trim();

        for (int i = 0; i < recordsNum; i++)
        {
            Record r = getRecordFromBuffer(buffer, i);
            String nameStr = String.valueOf(r.getName()).trim();

            if(nameStr.equals(keyStr))
                return r;
        }
        return null;
    }

    private Record getRecordFromBuffer(char[] buffer, int recordNumber)
    {
        char[] recordBuffer = new char[file.getRecordSize()];
        int offset = recordNumber * file.getRecordSize();
        System.arraycopy(buffer, offset, recordBuffer, 0, file.getRecordSize());
        Record r = new Record();
        r.parseFromData(recordBuffer);
        return r;
    }

    /**
     * Searches for empty place for one record in sector
     *
     * @param sectorNum - sector to search in
     * @return offset in sector
     */
    public int getFirstEmptyDataRecordOffset(int sectorNum)
    {
        int res = -1;
        int recordsNum = file.getDisk().getSectorSize() / file.getRecordSize();
        char[] secBuffer = new char[file.getDisk().getSectorSize()];
        file.getDisk().readSector(sectorNum, secBuffer);

        for (int i = 0; i < recordsNum; i++)
        {
            Record r = getRecordFromBuffer(secBuffer, i);
            if (r.getAltitude()[0] == '\0' && r.getCountry()[0] == '\0' && r.getName()[0] == '\0')
            {
                res = i * file.getRecordSize();
                break;
            }
        }
        return res;
    }

    public int findSector(char[] key)
    {
        IndexRecord r = null;
        int sector = -1;
        String keyStr = String.valueOf(key).trim();

        // Search by key
        for (IndexRecord idxRecord : idxRecords)
        {
            if(r==null) r=idxRecord;
            int sectorNumber = Integer.parseInt(String.valueOf(idxRecord.getSectorNumber()).trim());

            //Some index found
            String recKeyStr = String.valueOf(idxRecord.getKey()).trim();
            if(recKeyStr.equals(key))
            {
                //If index is pointing to another index
                if(sectorNumber >= file.getIndexStart())
                    continue;
                else
                {
                    //If index is pointing to data area
                    sector = sectorNumber;
                    break;
                }
            }

            //If current sector points to data area
            if(sectorNumber < file.getIndexStart())
            {
                String minKeyStr = new String(r.getKey());

                //If keyStr > recKeyStr and recKeyStr > minKeyStr - then idxRecord key is closest to key than previous save idxRecord
                if((recKeyStr.compareTo(keyStr) < 0) && (minKeyStr.compareTo(recKeyStr) < 0))
                    r = idxRecord;
            }
        }

        //Return sector found by key (if so exists)
        if(sector>-1)
            return sector;

        //Return sector found by closest key
        return Integer.parseInt(String.valueOf(r.getSectorNumber()).trim());
    }
}