LT Project: Author

The LTLibrary Author class is designed to do two things: provide access to the author's last name, and to provide a lexicographic sort key based on the author's full name.  The expected format of the author name is "Smith, John", or "Aristotle".  For sorting, punctuation and spaces are removed and the string is converted to lower case.

namespace LtLibrary

{

class Author {

public:

  void set(const std::string &inName);

  void set(const std::string &inName, const std::string &inCompName);

  auto empty() const { return m_name.empty(); }

  auto

  compare(const Author &inOther) const

  {

    return m_compName.compare(inOther.m_compName);

  }

  auto containsName(std::string_view inName) const { return m_name.contains(inName); }

  std::string_view getLastName() const;

private:

  std::string m_name;

  std::string m_compName;

};

}

inline bool operator==(const LtLibrary::Author& inFirst, const LtLibrary::Author&  inSecond)

{

  return inFirst.compare(inSecond) == 0;

}

Note two things about this in particular:

1) It is possible for two different author names to compare equal, although it would be rare: "Smith, Ed" would show as equivalent to "Smith, E.D.".  This is an edge case which is probably wrong by true bibliographic conventions but is acceptable here. (The aim is to ensure that e.g. "Smith, E.D.", "Smith, E. D.", "Smith, E D" all compare equivalently; all might appear in Library Thing records.)

2) The only constructor is, deliberately, one which leaves the object in a consistent but incomplete state.  This reflects the fact that the object will be declared before the record to set it has been parsed.

The two variants of set() use boost to get a lower-case copy and then uses C++20 erase_if to get rid of unwanted characters.

void Author::set(const std::string &inName) {   set(inName, inName); }

void Author::set(const std::string &inName, const std::string &inCompName)

{

  m_name = inName;

  m_compName = boost::algorithm::to_lower_copy(inCompName);

  std::erase_if(m_compName, [](const char x) -> bool { return std::ispunct(x) || std::isspace(x); });

}

Returning a string_view for the last name simplifies the logic for returning the value by allowing remove_suffix to be applied cheaply.

std::string_view Author::getLastName() const

{

  std::string_view rval(m_name);

  if (auto sz = m_name.find(','); sz != std::string::npos)

    rval.remove_suffix(m_name.length() - sz);

  return rval;

}

Overall, this is a fairly short concrete class which nevertheless shows, in net, the overall effect of having available the newer language calls to simplify the code and to express intent. set() would be significantly longer and messier without erase_if. A version of getLastName() which returned a std::string would be more expensive (though no wordier --

std::string Author::getLastName() const

{

  std::size_t sz = m_name.find(',');

  if (sz != std::string::npos)

     return m_name.substr(0, sz);

  return m_name;

}

 -- the operation on the string_view is cheaper than the need to generate a substring.) Using C++23 contains is clearer and slightly neater than "m_name.find(inName) != std::string::npos" and very possibly slightly cheaper.

Comments

Post a Comment

Popular posts from this blog

Boundaries

Imagine that you have a well-designed application, possibly using dependency injection. It will almost always have a very thin layer visible in main() - capturing command-line parameters and environment variables, mainly[1], and then a call to an Application class which manages the rest of the initial logic - setting up resources such as logging, doing substantive validation of parameters, and creating and running the objects on the next level down which actually carry out the work of the application. This is simply following the SRP at a high level.
Read more

State Machines

Almost any program can be modelled as a state machine. I say "almost any" because it is, just, possible to think of a program which cannot easily be resolved into anything more than a one-state state machine. Consider a command interpreter with no support for loops or function definitions (like the old DOS command.com) and with no internal commands, only the ability to execute external commands. It loops forever and does only one thing for every line it reads.    If it does no error handling, the execution is a single line, a call to execve or one of its relatives. There are internal stages inside the C library call, but they are effectively invisible to the program.  However, it's not a very useful program. Neither is any version of HelloWorld. The echo application does have its uses. Once one gets beyond this, even simple programs have at least two states: setup and execute. A simple version of cp has to open two files for input and output before beginning to copy data....
Read more

Considerations on an Optimization

An application – actually, successive pair of applications – is meant to process (in the end) about three hundred or so entries to convert a simple markup into complex LaTeX markup. It also enhances the data with information drawn from a flat-file text database (i.e. literally a set of .txt files in a single directory). This application was originally written in rust, which is not my favourite language, but one worth exercising to a degree. The rust application covered a limited subdomain, and generally avoided unsafe rust code, although in some cases it had to use cell mechanisms which converted compile-time to runtime safety. The initial iteration had the text database as one large file, with some logic allowing for extended seeking through chapters. It soon became apparent, after extending my dataset to about twenty or so items, that this was going to result in an unacceptable runtime — it was taking longer to process than the later TeX processing took, and although in theory this w...
Read more