diff --git a/src/register/hei_hardware_register.cpp b/src/register/hei_hardware_register.cpp
index 7629a06..74df35f 100644
--- a/src/register/hei_hardware_register.cpp
+++ b/src/register/hei_hardware_register.cpp
@@ -12,16 +12,6 @@
 
 //------------------------------------------------------------------------------
 
-#if 0
-void HardwareRegister::setBitString(const BitString *bs)
-{
-    BitString& l_string  = accessBitString();
-    l_string.setString(*bs);
-}
-#endif
-
-//------------------------------------------------------------------------------
-
 const BitString* HardwareRegister::getBitString(const Chip& i_chip) const
 {
     // Verify this register belongs on i_chip.
diff --git a/src/register/hei_hardware_register.hpp b/src/register/hei_hardware_register.hpp
index f79191d..ee57b2a 100644
--- a/src/register/hei_hardware_register.hpp
+++ b/src/register/hei_hardware_register.hpp
@@ -145,15 +145,6 @@
     /** Function overloaded from parent Register class. */
     const BitString* getBitString(const Chip& i_chip) const;
 
-#if 0
-    /**
-     * @brief     Updates bit string contents associated with register
-     * @param     i_bs               poiner to bit string
-     * @return    Nil
-     */
-    virtual void setBitString(const BitString * i_bs) ;
-#endif
-
     /**
      * @brief  Reads a register from hardware via the user interface APIs.
      * @param  i_chip  The target chip in which this register belongs.
diff --git a/src/register/hei_operator_register.hpp b/src/register/hei_operator_register.hpp
index 02c9b1d..ce9a869 100644
--- a/src/register/hei_operator_register.hpp
+++ b/src/register/hei_operator_register.hpp
@@ -2,6 +2,23 @@
 
 #include <register/hei_register.hpp>
 
+/**
+ * @file hei_operator_register.hpp
+ *
+ * A library of useful classes used to perform logical or bitwise math on or
+ * between other registers. The classes implemented here include NotRegister,
+ * LeftShiftRegister, RightShiftRegister, AndRegister, OrRegister, and
+ * ConstantRegister.
+ *
+ * Accompanied with other Register classes and the getBitString() function, it
+ * is possible to perform operations like:
+ *
+ *      AndRegister reg{<register1>,<register2>};
+ *      result = reg.getBitString(<someChip>);
+ *
+ * This example will return a BitString containing the result of the bitwise
+ * AND operation applied to register1 and register2.
+ */
 namespace libhei
 {
 
@@ -44,6 +61,13 @@
 // Pure virtual destructor must be defined.
 inline OperatorRegister::~OperatorRegister() {}
 
+/**
+ * @brief Using getBitString(), performs a bitwise NOT operation on a register.
+ *
+ * Example:
+ *      NotRegister reg{someRegister};
+ *      result = reg.getBitString(someChip);
+ */
 class NotRegister : public OperatorRegister
 {
   public:
@@ -90,6 +114,13 @@
     Register* iv_child;
 };
 
+/**
+ * @brief Using getBitString(), performs a left shift operation on a register.
+ *
+ * Example:
+ *      LeftShiftRegister reg{someRegister1, shiftValue};
+ *      result = reg.getBitString(someChip);
+ */
 class LeftShiftRegister : public OperatorRegister
 {
   public:
@@ -140,6 +171,13 @@
     uint16_t iv_amount;
 };
 
+/**
+ * @brief Using getBitString(), performs a right shift operation on a register.
+ *
+ * Example:
+ *      RightShiftRegister reg{someRegister1, shiftValue};
+ *      result = reg.getBitString(someChip);
+ */
 class RightShiftRegister : public OperatorRegister
 {
   public:
@@ -190,6 +228,14 @@
     uint16_t iv_amount;
 };
 
+/**
+ * @brief Using getBitString(), performs a bitwise AND operation on a pair
+ *        of registers.
+ *
+ * Example:
+ *      AndRegister reg{someRegister1, someRegister2};
+ *      result = reg.getBitString(someChip);
+ */
 class AndRegister : public OperatorRegister
 {
   public:
@@ -242,6 +288,14 @@
     Register* iv_right;
 };
 
+/**
+ * @brief Using getBitString(), performs a bitwise OR operation on a pair
+ *        of registers.
+ *
+ * Example:
+ *      OrRegister reg{someRegister1, someRegister2};
+ *      result = reg.getBitString(someChip);
+ */
 class OrRegister : public OperatorRegister
 {
   public:
@@ -294,6 +348,11 @@
     Register* iv_right;
 };
 
+/**
+ * @brief Contains a constant value that can be used within any of the other
+ *        register operators. The value can be retrieved using the
+ *        getBitString() function.
+ **/
 class ConstantRegister : public OperatorRegister
 {
   public:
diff --git a/src/register/hei_register.hpp b/src/register/hei_register.hpp
index d3435a3..ff8999c 100644
--- a/src/register/hei_register.hpp
+++ b/src/register/hei_register.hpp
@@ -15,15 +15,14 @@
 creates a place where these registers can be put together like logical
 building blocks.  For example, Register makes this possible:
 
-Register * fir = new HardwareRegister(REG_ADDRESS, REG_WIDTH,
-                                      CHIP_TYPE, ACCESS_RO);
-Register * mask = new ConstantRegister(0xffffffff00000000);
-Register * fir_mask = new AndRegister(fir, mask);
+Register * mask1 = new ConstantRegister(0xffff000000000000);
+Register * mask2 = new ConstantRegister(0xffffffff00000000);
+Register * fir_mask = new AndRegister(mask1, mask2);
 const BitString * bs = fir_mask->getBitString(chip);
 
 The getBitString function (defined by each register) provides access to
 the BitString that manages each register's data.  In this example bs will
-contain the result of fir & mask.
+contain the result of mask1 & mask2.
 */
 class Register
 {