LT Project: A convenience class for shared data

We are gradually working our way upwards towards a full LibraryBookRecord: we've reached the point where we can look at the core common data.

There are two implementations of the LibraryBookRecord interface, depending on whether they were read in directly from file (in which case they have to intern all the data in each record) or whether there is an in-memory database corresponding to the file, in which case the full set of fields can be held by reference.  In both cases, though, they use a core set of data for sorting and searching.

The LibraryBookRecordSecondaryData class handles that common data.

class LibraryBookRecordSecondaryData : public ISettableAuthorContainer,

                                       public IMinimalLibraryBookRecord

{

public:

  LibraryBookRecordSecondaryData(const int inId, const bool inIsBibliographic)

      : m_bookId(inId), m_secondaryAuthors(inIsBibliographic)

  { }

  ~LibraryBookRecordSecondaryData() override;

  Author getAuthor() const override

  {

    return m_authorKey;

  }

  void setAuthor(const std::string &inVal) override

  {

    m_authorKey.set(inVal);

  }

  bool matchesOnAuthor(std::string_view inName) const

  {

    return m_authorKey.containsName(inName);

  }

  bool matchesOnCollection(const std::string &inName) const

  {

    return m_collections.matches(inName);

  }

  bool matchesOnTag(const std::string &inName) const

  {

    return m_tags.matches(inName);

  }

  bool isDeaccessioned() const

  {

    return m_collections.matches("Deaccessioned");

  }

  bool lessThan(const IMinimalLibraryBookRecord &inFirstRec,

                const IMinimalLibraryBookRecord &inSecondRec) const;

  std::string_view getTitle() const override

  {

    return m_title;

  }

  void setTitle(const std::string &inTitle)

  {

    m_title = inTitle;

  }

  constexpr int getId() const

  {

    return m_bookId;

  }

  int getTitleSortOffset() const override

  {

    return m_titleSortOffset;

  }

  static void SetBibliographicSort()

  {

    m_sortStrategy = &s_BibliographicStrategy;

  }

  static void SetTitleSort()

  {

    m_sortStrategy = &s_TitleStrategy;

  }

  std::string_view getAuthorLastName() const

  {

    return m_authorKey.getLastName();

  }

  void setBookId(const int inID)

  {

    m_bookId = inID;

  }

  void setTitleSortOffset(const int inVal)

  {

    m_titleSortOffset = inVal;

  }

  void rationalizeTitleSortOffset()

  {

    if (m_titleSortOffset < 0)

      m_titleSortOffset = 0;

  }

  void setCollections(const std::string &inVal)

  {

    m_collections.addEncodedList(inVal);

  }

  void setTags(const std::string &inVal)

  {

    m_tags.addEncodedList(inVal);

  }

  const ISecondaryAuthorSet & getSecondaryAuthors() const

  {

    return m_secondaryAuthors;

  }

  void setSecondaryAuthors(const std::string &inVal);

  void setSecondaryAuthorRoles(const std::string &inVal);

  const std::string & getPostTitleContent() const

  {

    return m_postTitleContent;

  }

  void setPostTitleContent(const std::string &inVal) override

  {

    m_postTitleContent = inVal;

  }

  void expandEntry(const bool inBreakOutCollections, const bool inBreakoutTags,

                   const ELibraryRecord inType, const std::string &inVal);

private:

  int m_bookId;

  int m_titleSortOffset = 0;

  CollectionSearchableSet m_collections;

  TagSearchableSet m_tags;

  Author m_authorKey;

  std::string m_title;

  SecondaryAuthorSet m_secondaryAuthors;

  mutable std::string m_postTitleContent;

  inline constinit static Log::ThreadedLogger s_Logger;

  inline static TitleRecordSortStrategy s_TitleStrategy{ s_Logger };

  inline static BibliographicRecordSortStrategy s_BibliographicStrategy{

    s_Logger

  };

  inline static IRecordSortStrategy *m_sortStrategy = &s_TitleStrategy;

};

It tends fairly heavily towards being a data class, with lots of accessors, some setters (because of the incremental creation of record objects from the line records), and a few functions with more extensive logic:

bool LibraryBookRecordSecondaryData::lessThan(const IMinimalLibraryBookRecord &inFirstRec,

const IMinimalLibraryBookRecord &inSecondRec) const

{

  return m_sortStrategy->isLessThan(inFirstRec, inSecondRec);

}

void LibraryBookRecordSecondaryData::setSecondaryAuthors(const std::string &inVal)

{

 std::ranges::for_each(boost::tokenizer<boost::char_separator<char>>(inVal, pipeSeparator), [&](const auto &inSAVal) {

    m_secondaryAuthors.addAuthorName(inSAVal);

  });

}


void LibraryBookRecordSecondaryData::setSecondaryAuthorRoles(

    const std::string &inVal)

{

  int i = 0;

  std::ranges::for_each(boost::tokenizer<boost::char_separator<char>>(inVal, pipeSeparator), [&](const auto &inSARVal) {

    if (!inSARVal.empty())

      m_secondaryAuthors.addAuthorRole(inSARVal, i++);

    else

      ++i;

  });

}

void LibraryBookRecordSecondaryData::expandEntry(const bool inBreakOutCollections,

                                            const bool inBreakoutTags,

                                            const ELibraryRecord inType,

                                            const std::string &inVal)

{

  switch (inType)

    {

    case ELibraryRecord::Collections:

      if (inBreakOutCollections)

        setCollections(inVal);

      break;

    case ELibraryRecord::Tags:

      if (inBreakoutTags)

        setTags(inVal);

      break;

    case ELibraryRecord::Secondary_Author:

      {

        setSecondaryAuthors(inVal);

      }

      break;

    case ELibraryRecord::Secondary_Author_Roles:

      {

        setSecondaryAuthorRoles(inVal);

      }

      break;

    default:

      break;

    }

}

Except for the sorting function lessThan() these are invoked during the data initialization phase.

This is essentially a convenience grouping of other objects, principally to reduce duplication of data models.


Comments

Post a Comment

Popular posts from this blog

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 LtL...
Read more

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

Decent First Drafts

Let's say that you are implementing a Composite pattern for an interface with several interface functions. For functions which return void, it's straightforward to anticipate that the implementation will be a simple for_each. For functions which return a value, something has to be done to convert multiple return values into one. There are several obvious patterns: - For functions like size() you call accumulate/fold_left and return an accumulated value.  This can't be extended arbitrarily to functions returning a numeric type: you might want, for example, to return a maximum value. - For functions which return a boolean status, you return the results of applying std::none_of to a test for a false return, std::all_of to a test for a true return. - For functions generating a string representation you return a string concatenating outputs with interpolated delimiters and possibly a beginning and ending. The same applies as a special case of output functions which return void b...
Read more