Educational Objectives: On successful completion of this assignment, the student should be able to
===================================================
rubric to be used in assessment
---------------------------------------------------
builds [0..10]: xx
foaa.x foaa.com1 (operator[]) [0..10]: xx
foaa.x foaa.com2 (Insert, RBLL) [0..5]: x
foaa.x foaa.com3 (Erase, Rehash) [0..5]: x XC
ws2.x on english.txt [0..5]: x
moaa.x 5 [0..5]: x
log & report [0..5]: x
requirements and specs [0..5]: x
software engineering [-20..+5]: x
dated submissions deduction [2 pts each]: ( x)
--
total: [0..50]: xx
===================================================
Background Knowledge Required: Be sure that you have mastered the
material in these chapters before beginning the assignment:
Introduction to Sets,
Introduction to Maps,
Binary Search Trees, and
Balanced BSTs.
Operational Objectives: Create an implementation of the Ordered Associative Array API using left-leaning red-black trees. Illustrate the use of the API by refactoring your WordSmith as a client of Ordered Associative Array API.
Deliverables:
oaa.h # the ordered associative array class template wordsmith2.h # defines wordsmith refactored to use the OAA API wordsmith2.cpp # implements wordsmith2.h cleanup.cpp # from WordSmith project log.txt # your standard work log
The official development/testing/assessment environment is specified in the Course Organizer.
Keep a text file log of your development and testing activities in log.txt.
Begin by copying LIB/scripts/submit.sh and all of the files from the assignment distribution directory LIB/proj4. Your directory should now include:
main2.cpp # driver program for wordsmith2 foaa.cpp # functionality test for OAA moaa.cpp # random hammer test for OAA oaa.start # starter kit for OAA<K,D,P> rantable.cpp # random table file generator makefile # makefile for project - builds ws2.x, foaa.x, and moaa.x submit.sh # generic submit script deliverables.sh # submit script configuration file
Define and implement the class template OAA<K,D,P>, placing the code in the file oaa.h.
Use the default value P = fsu::LessThan<K> for the third template parameter, so that OAA<K,D> is also automatically defined.
Thoroughly test your OAA<> with the distributed test client programs foaa.cpp and moaa.cpp. Be sure to log all test activity.
Define the application WordSmith, refactored as a client of OAA<fsu::String, size_t>, in the header file wordsmith2.h, and implement the refactored WordSmith in the file wordsmith2.cpp
Test your refactored WordSmith thouroughly to be certain that it is a true refactoring of the original. (Refactoring is defined to be re-coding without changing the program behavior.) Again, log all test activity.
Be sure to fully cite all references used for code and ideas, including URLs for web-based resources. These citations should be in two places: (1) the code file documentation and if appropriate detailed in relevant code locations; and (2) in your log.
Submit the assignment by entering the command submit.sh.
Warning: Submit scripts do not work on the program and
linprog servers. Use shell.cs.fsu.edu to submit assignments. If you do
not receive the second confirmation with the contents of your assignment, there has
been a malfunction.
Implement the Ordered Associative Array API using the following class template:
template < typename K , typename D , class P = LessThan<K> >
class OAA
{
public:
typedef K KeyType;
typedef D DataType;
typedef P PredicateType;
OAA ();
explicit OAA (P p);
OAA (const OAA& a);
~OAA ();
OAA& operator=(const OAA& a);
DataType& operator [] (const KeyType& k) { return Get(k); }
void Put (const KeyType& k , const DataType& d) { Get(k) = d; }
D& Get (const KeyType& k);
void Erase(const KeyType& k);
void Clear();
void Rehash();
bool Empty () const { return root_ == 0; }
size_t Size () const { return RSize(root_); } // counts alive nodes
size_t NumNodes () const { return RNumNodes(root_); } // counts nodes
int Height () const { return RHeight(root_); }
template <class F>
void Traverse(F f) const { RTraverse(root_,f); }
void Display (std::ostream& os, int kw, int dw, // key, data widths
std::ios_base::fmtflags kf = std::ios_base::right, // key flag
std::ios_base::fmtflags df = std::ios_base::right // data flag
) const;
void Dump (std::ostream& os) const;
void Dump (std::ostream& os, int dw) const;
void Dump (std::ostream& os, int dw, char fill) const;
private: // definitions and relationships
enum Flags { ZERO = 0x00 , DEAD = 0x01, RED = 0x02 , DEFAULT = RED }; // DEFAULT = alive,red
static const char* ColorMap (uint8_t flags)
{
flags &= 0x03; // last 2 bits only
switch(flags)
{
case 0x00: return ANSI_BOLD_BLUE; // bits 00
case 0x01: return ANSI_BOLD_BLUE_SHADED; // bits 01
case 0x02: return ANSI_BOLD_RED; // bits 10
case 0x03: return ANSI_BOLD_RED_SHADED; // bits 11
default: return "unknown color"; // unknown flags
}
}
class Node
{
const KeyType key_;
DataType data_;
Node * lchild_, * rchild_;
uint8_t flags_;
Node (const KeyType& k, const DataType& d, Flags flags = DEFAULT)
: key_(k), data_(d), lchild_(0), rchild_(0), flags_(flags)
{}
friend class OAA<K,D,P>;
bool IsRed () const { return 0 != (RED & flags_); }
bool IsBlack () const { return !IsRed(); }
bool IsDead () const { return 0 != (DEAD & flags_); }
bool IsAlive () const { return !IsDead(); }
void SetRed () { flags_ |= RED; }
void SetBlack () { flags_ &= ~RED; }
void SetDead () { flags_ |= DEAD; }
void SetAlive () { flags_ &= ~DEAD; }
};
class PrintNode
{
public:
PrintNode (std::ostream& os, int kw, int dw, std::ios_base::fmtflags kf, std::ios_base::fmtflags df)
: os_(os), kw_(kw), dw_(dw), kf_(kf), df_(df) {}
void operator() (const Node * n) const
{
if (n->IsAlive())
{
os_.setf(kf_,std::ios_base::adjustfield);
os_ << std::setw(kw_) << n->key_;
os_.setf(df_,std::ios_base::adjustfield);
os_ << std::setw(dw_) << n->data_;
os_ << '\n';
}
}
private:
std::ostream& os_;
int kw_, dw_; // key and data column widths
std::ios_base::fmtflags kf_, df_; // column adjustment flags for output stream
};
class CopyNode
{
public:
CopyNode (Node*& newroot, OAA<K,D>* oaa) : newroot_(newroot), oldtree_(oaa) {}
void operator() (const Node * n) const
{
if (n->IsAlive())
{
newroot_ = oldtree_->RInsert(newroot_,n->key_, n->data_);
newroot_->SetBlack();
}
}
private:
Node *& newroot_;
OAA<K,D> * oldtree_;
};
private: // data
Node * root_;
PredicateType pred_;
private: // methods
static Node * NewNode (const K& k, const D& d, Flags flags);
static void RRelease (Node* n); // deletes all descendants of n
static Node * RClone (const Node* n); // returns deep copy of n
static size_t RSize (Node * n);
static size_t RNumNodes (Node * n);
static int RHeight (Node * n);
// rotations
static Node * RotateLeft (Node * n);
static Node * RotateRight (Node * n);
template < class F >
static void RTraverse (Node * n, F f);
// recursive left-leaning get
Node * RGet(Node* nptr, const K& kval, Node*& location);
// recursive left-leaning insert
Node * RInsert(Node* nptr, const K& key, const D& data);
}; // class OAA<>
Note that the implementations of all OAA methods are discussed in the lecture notes in one form or another.
Many of the required implementations are already available in the file LIB/proj4/oaa.start.
It is worth pointing out what is NOT in these requirements that would be in a "full" OAA API:
The remaining "mutator" portion of the OAA API consists of Get, Put, Clear, Erase and Rehash -- arguably the minimal necessary for a useful general purpose container.
Note that the AA bracket operator is in the interface and is implemented in-line above with a single call to Get. Also note that Put is implemented with a single call to Get, which leaves Get as the principal functionality requiring implementation in order to have the AA bracket operator. The AA bracket operator, in turn, is required for the refactoring of WordSmith.
The various const methods measure useful characteristics of the underlying BST and provide output useful in the development process as well as offering client programs insight into the AA structure.
The color system is outlined here just as in the lecture notes. The ColorMap is used by the Dump methods to color nodes at output. Color is manipulated by the four Node methods for detecting and changing node color. (This particular map colors red nodes red, black nodes blue, and shades the background of tombstones.)
There are four privately declared in-class types:
The various "private" statements are redundant, but they emphasize the various reasons for using that designation: (1) to have private in-class definitions, such as Node or typedef statements, and to record any friend relationships that might be needed; (2) private data in the form of variables; (3) private methods; and (4) things that are privatized to prevent their use.
The Erase method is not used by WordSmith and may be implemented non-functionally. However, there is 10% extra credit available for correctly implementing Erase.
Here is a working header file for the refactored WordSmith:
/*
wordsmith2.h
*/
#include <xstring.h>
#include <list.h>
#include <oaa.h>
class WordSmith
{
public:
WordSmith ();
virtual ~WordSmith ();
bool ReadText (const fsu::String& infile);
bool WriteReport (const fsu::String& outfile,
unsigned short kw = 15, // key col width
unsigned short dw = 15, // data col width
std::ios_base::fmtflags kf = std::ios_base::left, // key justify
std::ios_base::fmtflags df = std::ios_base::right // data justify
) const;
void ShowSummary () const;
void ClearData ();
private:
typedef fsu::String KeyType;
typedef size_t DataType;
size_t count_;
fsu::OAA < KeyType , DataType > frequency_;
fsu::List < fsu::String > infiles_;
static void Cleanup (fsu::String& s); // optional
} ;
The set "wordset_" from the original design is replaced with the ordered associative array "frequency_".
Note the private terminology is changed slightly. (Of course, the API is not changed.) The main storage OAA is called frequency_ which makes very readable code of this form:
...
Cleanup(str);
if (str.Length() != 0)
{
++frequency_[str];
++numwords;
} // end if
...
This snippet is the inner core of the processing loop implementing ReadText. The main loop implementing ReadText is now only 5 lines of code. (You should be certain you understand how this works, for both a new word and another encounter of an existing word. Note that the default constructor for size_t sets the initial value to 0).
Another small change is that it is no longer possible to loop through the data to count the words, because we are not defining an Iterator class. We could work out a way to make this count using a traversal with a special function object that retrieves the specific frequencies, but it is simpler just to have a class variable count_ that maintains the total number of words read (and is reset to 0 by ClearData()).
Hints