def returnString(self, limit=False, omitBrackets=False, executable=False, honorMissing=False):
        '''Return a string containing the list of dictionaries in easy
        human-readable read format.

        Each entry is on one line. Key/value pairs are 'spaced' in such a way
        as to have them all line up vertically if using a monospace font. The
        fields are normalized to alphabetical order. Missing keys in a
        dictionary are inserted with a value of 'None' unless *honorMissing* is
        set to True.

        Example of use:

        >>> test = [
        ...    {"name": "Jim",   "age": 18, "income": 93000, "order": 2},
        ...    {"name": "Larry", "age": 18,                  "order": 3},
        ...    {"name": "Joe",   "age": 20, "income": 15000, "order": 1},
        ...    {"name": "Bill",  "age": 19, "income": 29000, "order": 4},
        ... ]
        >>> print PLOD(test).returnString()
        [
            {age: 18, income: 93000, name: 'Jim'  , order: 2},
            {age: 18, income: None , name: 'Larry', order: 3},
            {age: 20, income: 15000, name: 'Joe'  , order: 1},
            {age: 19, income: 29000, name: 'Bill' , order: 4}
        ]
        >>> print PLOD(test).returnString(limit=3, omitBrackets=True, executable=True)
        {'age': 18, 'income': 93000, 'name': 'Jim'  , 'order': 2},
        {'age': 18, 'income': None , 'name': 'Larry', 'order': 3},
        {'age': 20, 'income': 15000, 'name': 'Joe'  , 'order': 1}
        >>> print PLOD(test).returnString(honorMissing=True)
        [
            {age: 18, income: 93000, name: 'Jim'  , order: 2},
            {age: 18,                name: 'Larry', order: 3},
            {age: 20, income: 15000, name: 'Joe'  , order: 1},
            {age: 19, income: 29000, name: 'Bill' , order: 4}
        ]
        
        :param limit:
           A number limiting the quantity of entries to return. Defaults to
           False, which means that the full list is returned.
        :param omitBrackets:
           If set to True, the outer square brackets representing the entire
           list are omitted. Defaults to False.
        :param executable:
           If set to True, the string is formatted in such a way that it
           conforms to Python syntax. Defaults to False.
        :param honorMissing:
           If set to True, keys that are missing in a dictionary are simply
           skipped with spaces. If False, then the key is display and given
           a value of None. Defaults to False.
        :return:
           A string containing a formatted textual representation of the list
           of dictionaries.
        '''
        result = ""
        # we limit the table if needed
        if not limit:
            limit = len(self.table)
        used_table = []
        for i in range(limit):
            if len(self.table)>i:
                used_table.append(internal.convert_to_dict(self.table[i]))
        # we locate all of the attributes and their lengths
        attr_width = {}
        # first pass to get the keys themselves
        for row in used_table:
            for key in row:
                if not key in attr_width:
                    attr_width[key] = 0
        # get a sorted list of keys
        attr_order = attr_width.keys()
        attr_order.sort()
        # not get minimum widths
        #  (this is done as a seperate step to account for 'None' and other conditions.
        for row in used_table:
            for key in attr_width:
                if not key in row:
                    if not honorMissing:
                        if attr_width[key] < len("None"):
                            attr_width[key] = len("None")
                else:
                    if len(repr(row[key])) > attr_width[key]:
                        attr_width[key] = len(repr(row[key]))
        # now we do the pretty print
        if not omitBrackets:
            result += "[\n"
        body = []
        for row in used_table:
            row_string = ""
            if not omitBrackets:
                row_string += "    "
            row_string += "{"
            middle = []
            for key in attr_order:
                if key in row:
                    # build the key
                    if executable:
                        item = "'"+str(key) + "': "
                    else:
                        item = str(key) + ": "
                    # build the value
                    s = repr(row[key])
                    if type(row[key]) is typemod.IntType:
                        s = s.rjust(attr_width[key])
                else:
                    if honorMissing:
                        # build the key
                        item = " "*len(str(key))
                        if executable:
                            item += "  "
                        item +=  "  "
                        # build the value
                        s=""
                    else:
                        # build the key
                        if executable:
                            item = "'"+str(key) + "': "
                        else:
                            item = str(key) + ": "
                        # build the value
                        s = "None"
                item += s.ljust(attr_width[key])
                middle.append(item)
            # row_string += ", ".join(middle)
            row_string += internal.special_join(middle)
            row_string += "}"
            body.append(row_string)
        result += ",\n".join(body)
        if len(body) and not omitBrackets:
            result += "\n"
        if not omitBrackets:
            result += "]"
        return result
Return a string containing the list of dictionaries in easy
        human-readable read format.

        Each entry is on one line. Key/value pairs are 'spaced' in such a way
        as to have them all line up vertically if using a monospace font. The
        fields are normalized to alphabetical order. Missing keys in a
        dictionary are inserted with a value of 'None' unless *honorMissing* is
        set to True.

        Example of use:

        >>> test = [
        ...    {"name": "Jim",   "age": 18, "income": 93000, "order": 2},
        ...    {"name": "Larry", "age": 18,                  "order": 3},
        ...    {"name": "Joe",   "age": 20, "income": 15000, "order": 1},
        ...    {"name": "Bill",  "age": 19, "income": 29000, "order": 4},
        ... ]
        >>> print PLOD(test).returnString()
        [
            {age: 18, income: 93000, name: 'Jim'  , order: 2},
            {age: 18, income: None , name: 'Larry', order: 3},
            {age: 20, income: 15000, name: 'Joe'  , order: 1},
            {age: 19, income: 29000, name: 'Bill' , order: 4}
        ]
        >>> print PLOD(test).returnString(limit=3, omitBrackets=True, executable=True)
        {'age': 18, 'income': 93000, 'name': 'Jim'  , 'order': 2},
        {'age': 18, 'income': None , 'name': 'Larry', 'order': 3},
        {'age': 20, 'income': 15000, 'name': 'Joe'  , 'order': 1}
        >>> print PLOD(test).returnString(honorMissing=True)
        [
            {age: 18, income: 93000, name: 'Jim'  , order: 2},
            {age: 18,                name: 'Larry', order: 3},
            {age: 20, income: 15000, name: 'Joe'  , order: 1},
            {age: 19, income: 29000, name: 'Bill' , order: 4}
        ]
        
        :param limit:
           A number limiting the quantity of entries to return. Defaults to
           False, which means that the full list is returned.
        :param omitBrackets:
           If set to True, the outer square brackets representing the entire
           list are omitted. Defaults to False.
        :param executable:
           If set to True, the string is formatted in such a way that it
           conforms to Python syntax. Defaults to False.
        :param honorMissing:
           If set to True, keys that are missing in a dictionary are simply
           skipped with spaces. If False, then the key is display and given
           a value of None. Defaults to False.
        :return:
           A string containing a formatted textual representation of the list
           of dictionaries.