Assignment 1: Data-Oriented C++ Programming

(Due Date: Thursday 9/15/94)

Introduction

What You Have to Do

Step 1:

A (partial) class definition of RecSpec follows:

enum BOOL { FALSE, TRUE};

class RecSpec {
public:

    enum field_type { INT, STR };

    RecSpec(unsigned int maxstrlen, field_type sortfield);

    BOOL operator==(const RecSpec &rs) const;
    int compare(const void *rec1, const void *rec2) const;

    BOOL print_rec(const void *rec) const;
    BOOL get_from_file(ifstream &is, void *buf) const;

    unsigned int rec_size() const;

private:

    const unsigned int  max_str_len;
    const field_type    sort_field;
};

Step 2:

A (partial) class definition for Seq is shown below:

class Seq {
public:

    Seq(const RecSpec *recinfo);
    ~Seq();

    virtual BOOL get_next_rec(void *&recptr) = 0;

    inline const RecSpec *get_rec_spec() const { return rec_info; }


protected:

    const RecSpec   *rec_info;
};

A (partial) class definition for FileSeq is shown below:

class FileSeq   : public Seq {
public:
    
    FileSeq(const char *name, const RecSpec *recinfo);
    ~FileSeq();

    virtual BOOL get_next_rec(void *&recptr);

private:
    
    ifstream        in_file;
    char            *buffer;
};

The destructor will close the file and free the buffer.

get_next_rec should read the next record into the buffer and return it as was discussed for Seq.

A (partial) class definition for MergeSeq is shown below:

class MergeSeq  : public Seq {
public:
    MergeSeq(Seq *s1, Seq *s2);
    ~MergeSeq();

    virtual BOOL get_next_rec(void *&recptr);

private:

    Seq     *seq1;
    Seq     *seq2;
};

The destructor should recursively delete its children. This way, a Seq tree can be deleted simply by calling delete on its root.

get_next_rec should compare the two current records, using the RecSpec::compare method, and return the lesser. Some sort of a flag will be needed to remember which input's current record has not yet been used (the greater record from the last call).

Empty sequences and end-of-sequence should be handled along the lines indicated in FileSeq.

Points to Note

Use the fstream classes for I/O operations. (To do so, you must #include both iostream.h and fstream.h in your header file.)

Both FileSeq and MergeSeq objects should operate in ``lazy manner'', e.g., the input file should be read one record at a time in response to successive calls to get_next_rec on a FileSeq object.

If you want to modify any of the class definitions shown above by adding/removing/modifying private and/or protected members, feel free to do so. But you must keep the public interfaces as they have been described above,

You should use C++'s memory management (new and delete). Do not use malloc and free! Be sure to study how to use new and delete for arrays.

A Word on Documentation, Error Checking and Style

You are expected to check for error conditions, and ensure that your code including all the public methods above terminates gracefully on all inputs, with meaningful error msgs. While some error conditions have been explicitly discussed, e.g., get_next_rec on an empty file, others have not, e.g., what happens when RecSpec::get_from_file is called on an empty file. So think carefully about potential errors, and write defensive code.

Program Grading Criteria

• Works as specified: 65%
• Good documentation: 15%
• Good coding style: 10%
• Good error checking: 10%

What to Turn In

Finding the Files

Due Date