CONVENTIONS FOR NAMING METHODS, MEMBERS, ETC.

In order to make the code easier to follow, certain conventions have
been followed.

* NSR Scoping

    All of the code has been defined inside of an NSR class, whose
    constructor has been made private. This means that it may never be
    instantiated. In order to reference a class or enum or type, the
    scoping resolution operator must be used. For example:

    NSR::LogExtentList

    Note that if desired, typedefs may be used to make the using code
    less cluttered with "NSR::". For example:

    typedef NSR::LogExtentList LogExtList;

    LogExtList lel;

* Multiple-Word Names

    Rather than using underscores ("_") to separate words in a name,
    Capital letters are used at the start of each new word. Acronyms
    are typically all capitals.

    Examples:

    class LogExtentList { ... };
    PrimaryVolumeDesc::verifyISO();

* Type Names

    All classes and enumeration types are capitalized, for example:

    class LogExtent
    class LogExtentList
    class SingleSurfaceVolume
    enum  ExtType

    Where built-in types have been typedef'ed, the symbols are all
    capitals. For Example:

    UINT32 i;
    INT16  j;

* Enumerators

    Enumerators, or the elements of an enumeration, are NOT
    capitalized. Rather, they consist of an all-lower-case prefix,
    intended to indicate the Enumeration to which they belong, an
    underbar, and then a capitalized name which indicates their
    meaning. The simpler enumerations, e.g., Boolean (False,True), do
    not follow this convention.

    Examples:

    enum ExtType {
        ext_Recorded,
        ext_Erased,
        ...
    };

    enum TagType {
        tag_Unknown =   0,
        tag_PVD     =   1,
        tag_AVD     =   2,
        ...
    };

    enum ErrorCodeType {
        error_This_error_is_bad,
        ...
    };

* Variables

    Variables all start with lower case, but otherwise follow the
    convention for multiple words and acronyms. The notion here is
    that if their value can change, they are NOT capitalized, while
    Type and class definitions do NOT change, and ARE therefore
    capitalized.

    Examples:

    TagType tagType;
    ExtType extType;

* Data Members

    Data members of structs or classes follow the convention of
    variables, but also end in an underscore ("_"). This serves two
    purposes. First, it is important for simple consistency between
    data member names and names of methods which provide access to
    data members. Secondly, inside method calls, the difference
    between data members and passed-in or temporary variables is more
    obvious.

    Examples:

    class MyClass {
        UINT32  field1_;
        Boolean field1Valid_;
    ...
    };

* Field-accessing Methods

    When a class provides methods which simply allow access to data
    members, these methods are named identically to the data members
    they reference, except they contain no underbar. This aids in
    using the debugger, where methods are not easily called, but data
    members are easily displayed.

    Examples:

    class MyClass {
        UINT32  field1_;
        Boolean field1Valid_;
    public:
        UINT32  field1() const ;        // getter
        Boolean field1Valid() const ;   // getter
    };

    When the value of the field is easily returned as a return value,
    or passed in by value, the "getter" and "setter" methods have the
    same name, but different signatures, as shown below:

    class MyClass {
        ...
        UINT32 field1_;
    public:
        UINT32 field1() const ;        // getter
        UINT32 field1(UINT32 newVal) ; // setter
        ...
    };

    However, when the size of the value being returned is large enough
    to incur a significant overhead, the get/set nomenclature is used,
    with references being passed. For example

    class MyClass {
        ...
        LogExtent firstExt_;
    public:
        void getFirstExt(LogExtent & le) const;
        void setFirstExt(const LogExtent & le);
        ...
    };

* Pointer Fields and Methods

    When a struct or class contains a pointer, the convention is that
    the pointer's field name ends in a "p_". Since the method
    accessing it is named according to the usual method-naming
    conventions, this means that it ends in a p.

    Examples:

    class MyClass {
        ...
        MyClass * myParentp_;
    public:
        MyClass * myParentp() ;              // getter
        MyClass * myParentp(MyClass * mcp) ; // setter
    };

    
