MacHack 1998/MacHack 1998.toast/Programming Contest/Secret Solutions Folder/Problem 05 - Database/Solution.p

Text File | 1998-06-12 | 6.3 KB | 200 lines | [TEXT/CWIE]

(*
Problem 05 - Database

type
    StringsHandle = Handle; // Sequence of Pascal Strings packed together
    DatabaseHandle = Handle; // Must be a real handle

procedure DatabaseInit( var database: Handle; field_count: UInt32 );
procedure DatabaseAddEntry( database: Handle; entry: StringsHandle );
procedure DatabaseFindEntry( database: Handle; field: UInt32; const match: Str255; var entry: StringsHandle );
procedure DatabaseDeleteEntry( database: Handle; field: UInt32; const match: Str255 );
function DatabaseCount( database: Handle ): UInt32;
procedure DatabaseGetIndEntry( database: Handle; index: UInt32; var entry: StringsHandle );

All strings are case sensitive (ie, treated as eight bit binary data).

DatabaseInit creates a new, empty database ready to accept records with field_count string fields.  All the database information must be stored in the real Mac memory manager handle - it will be disposed with DisposeHandle and that must release all memory, so dont store any extra information outside the handle.  Also, you must be able to deal with having multiple databases instantiated simultaneously.

DatabaseAddEntry adds an entry (which is a Handle to field_count pascal strings packed together conceptually numbered 1 to field_count)

DatabaseFindEntry finds an entry whose field (between 1 and field_count) string is exactly equal to match.  The entry is returned in a newly created handle (which will be disposed of using DisposeHandle).  Return nil if no match is found.  If more than one entry matches, you must return the earliest added entry.

DatabaseDeleteEntry finds the entry that DatabaseFindEntry would find, and if found removes it from the database.

DatabaseCount returns the number fo entries in the database.

DatabaseGetIndEntry returns the entries in the Database in the order they were entered, 1 for the earliest entered, DatabaseCount the last entered.

You will not be given invalid parameters so you don't need to handle error checking, and there will be plenty of memory.
*)

unit Solution;

interface

// Do not modify the interface

    uses
        Types, Files, TextUtils;

    type
        StringsHandle = Handle; // Sequence of Pascal Strings packed together
        DatabaseHandle = Handle; // Must be a real handle

    procedure DatabaseInit( var database: Handle; field_count: UInt32 );
    procedure DatabaseAddEntry( database: Handle; entry: StringsHandle );
    procedure DatabaseFindEntry( database: Handle; field: UInt32; const match: Str255; var entry: StringsHandle );
    procedure DatabaseDeleteEntry( database: Handle; field: UInt32; const match: Str255 );
    function DatabaseCount( database: Handle ): UInt32;
    procedure DatabaseGetIndEntry( database: Handle; index: UInt32; var entry: StringsHandle );

implementation

// Fill in your solution and then submit this folder

// Team Name: Example Solution
// 18 minutes

    const
        first_entry_pos = SizeOf(UInt32);
    type
        UInt32Ptr = ^UInt32;
        UInt32Handle = ^UInt32Ptr;

    function GetCount( database: Handle ): UInt32;
    begin
        GetCount := UInt32Handle(database)^^;
    end;

    function GetHandleOffset( data: Handle; offset: UInt32 ): Ptr;
    begin
        GetHandleOffset := Ptr(longint(data^)+offset);
    end;

    function GetByteAtPtr( p: Ptr ): integer;
    begin
        GetByteAtPtr := band( p^, $00FF );
    end;

    function GetNextEntry( database: Handle; var offset: UInt32; entry: StringsHandle ): boolean;
        var
            i, count, orgoffset: UInt32;
    begin
        if offset >= GetHandleSize( database ) then begin
            GetNextEntry := false;
        end else begin
            GetNextEntry := true;
            count := getCount( database );
            orgoffset := offset;
            for i := 1 to count do begin
                offset := offset + GetByteAtPtr( GetHandleOffset( database, offset ) ) + 1;
            end;
            SetHandleSize( entry, offset - orgoffset );
            BlockMoveData( GetHandleOffset( database, orgoffset ), entry^, offset - orgoffset );
        end;
    end;

    procedure GetNthString( entry: StringsHandle; index: UInt32; var s: Str255 );
        var
            offset: UInt32;
            len: integer;
            i: UInt32;
    begin
        offset := 0;
        for i := 1 to index-1 do begin
            offset := offset + GetByteAtPtr( GetHandleOffset( entry, offset ) ) + 1;
        end;
        len := GetByteAtPtr( GetHandleOffset( entry, offset ) );
        BlockMoveData( GetHandleOffset( entry, offset ), @s, len + 1 );
    end;

    procedure DatabaseInit( var database: Handle; field_count: UInt32 );
    begin
        database := NewHandle( SizeOf(field_count) );
        if database <> nil then begin
            UInt32Handle(database)^^ := field_count;
        end;
    end;

    procedure DatabaseAddEntry( database: Handle; entry: StringsHandle );
        var
            junk: OSErr;
    begin
        junk := HandAndHand( entry, database );
    end;

    procedure FindEntry( database: Handle; field: UInt32; const match: Str255; var entryoffset: UInt32; var entry: StringsHandle );
        var
            offset: UInt32;
            found: boolean;
            s: Str255;
    begin
        offset := first_entry_pos;
        entry := NewHandle( 0 );
        found := false;
        entryoffset := offset;
        while not found & GetNextEntry( database, offset, entry ) do begin
            GetNthString( entry, field, s );
            found := s = match;
            if not found then begin
                entryoffset := offset;
            end;
        end;
        if not found then begin
            DisposeHandle( entry );
            entry := nil;
        end;
    end;

    procedure DatabaseFindEntry( database: Handle; field: UInt32; const match: Str255; var entry: StringsHandle );
        var
            entryoffset: UInt32;
    begin
        FindEntry( database, field, match, entryoffset, entry );
    end;

    procedure DatabaseDeleteEntry( database: Handle; field: UInt32; const match: Str255 );
        var
            entryoffset: UInt32;
            junkl: longint;
            entry: Handle;
    begin
        FindEntry( database, field, match, entryoffset, entry );
        if entry <> nil then begin
            junkl := Munger( database, entryoffset, nil, GetHandleSize(entry),@junkl, 0);
            DisposeHandle(entry);
        end;
    end;

    function DatabaseCount( database: Handle ): UInt32;
        var
            offset, count: UInt32;
            entry: Handle;
    begin
        offset := first_entry_pos;
        count := 0;
        entry := NewHandle( 0 );
        while GetNextEntry( database, offset, entry ) do begin
            Inc(count);
        end;
        DisposeHandle( entry );
        DatabaseCount := count;
    end;

    procedure DatabaseGetIndEntry( database: Handle; index: UInt32; var entry: StringsHandle );
        var
            offset: UInt32;
    begin
        offset := first_entry_pos;
        entry := NewHandle( 0 );
        while GetNextEntry( database, offset, entry ) do begin
            Dec(index);
            if index = 0 then begin
                leave;
            end;
        end;
    end;

end.