Re: Reading tab-delimited files with STL

In article <rOOdnd1KceY95d_WnZ2dnUVZ8rednZ2d@eclipse.net.uk>,
no.way@nospam.invalid says...


That data doesn't look like it parses into sets of three items very
well. Trying to divide it that way, I get the key for the second item
as being "23.456", which may be possible, but sounds a bit unlikely.
To eliminate any uncertainty, I put together a small test file:

George Washington\tFirst President\tArmy General
Abraham Lincoln\tSixteenth President\tMilitia Captain
John Fitzgerald Kennedy\tThirty Fifth President\tNavy Lieutenant

The part you seem to be having trouble with is creating the ctype
facet that treats only the characters you want to as spaces. There
are several ways to do that. I did it like this:

struct my_ctype: std::ctype<char> {
    my_ctype(): std::ctype<char>(get_table()) {}

    static std::ctype_base::mask const* get_table()
    {
        static std::vector<std::ctype_base::mask>
            rc(std::ctype<char>::table_size, mask());
        rc['\t'] = (mask)space;
        rc['\n'] = (mask)space;
        return &rc[0];
    }
};

Note that you don't really have to play with any of the is* functions
or anything like that -- you just provide a table with the right
classifications for the characters, and the library code handles the
rest. As-is, this table has limitations -- for it doesn't classify
_anything_ as a digit or letter, so it's probably only useful for the
purpose at hand.

To work with the data, I created a simple "record" type that stores
the data and supports insertion, extraction and comparison:

struct record {
    std::string name, value1, value2;

    bool operator<(record const &other) const {
        return name < other.name;
    }

    friend std::istream &operator>>(std::istream &is,
                                    record &r)
    {
        return is >> r.name >> r.value1 >> r.value2;
    }

    friend std::ostream &operator<<(std::ostream &os,
                                    record const &r)
    {
        return os << r.name <<
            ":(" << r.value1 << ", " << r.value2 << ")";
    }
};

To exercise those, I wrote a bit of code like:

int main() {
    // Create a locale object, and imbue a stream with that locale
    // (i.e. tell the stream to use that locale).
    //
    std::locale tsv(std::locale(), new my_ctype);
    std::cin.imbue(tsv);

    std::set<record> records;

    // read the data from the file, eliminating dupes and sorting:
    //
    std::copy(std::istream_iterator<record>(std::cin),
              std::istream_iterator<record>(),
              std::inserter(records, records.end()));

    // Show the result:
    //
    std::copy(records.begin(),
              records.end(),
              std::ostream_iterator<record>(std::cout, "\n"));
    return 0;
}

--
    Later,
    Jerry.