LT Project: Record Sources

RecordPopulatorSetFactory

Before jumping into the actual data source classes, there's one small bridge class we have to look at.

class IRecordSetPopulatorFactory

{

public:

  virtual ~IRecordSetPopulatorFactory();


  virtual std::unique_ptr<IRecordSetPopulator>

  create(const IFieldAdderSet &inAdders,

         const IRecordSetCriteria &inCriteria) const = 0;

};

This (and its implementation) is the class that provides the bridge between the criteria specified by the user (plus the general rules selected for by the type of display, represented by the field adder set) and the class that actually does the work of doing the matching, which we looked at a short time ago.

The implementation is simple:

class RecordSetPopulatorFactory : public IRecordSetPopulatorFactory

{

public:

  ~RecordSetPopulatorFactory() override;


  std::unique_ptr<IRecordSetPopulator>

  create(const IFieldAdderSet &inAdders,

         const IRecordSetCriteria &inCriteria) const override

  {

      if (!inCriteria.hasSingleId())

        {

          return std::make_unique<RecordSetPopulator>(inAdders, inCriteria);

        }

      else

        {

          return std::make_unique<SingleRecordSetPopulator>(inCriteria.getId());

        }

  }

};

(The SingleRecordSetPopulator has much simpler logic than the general case.  Implementations of its key functions are:

ILibraryBookRecord *

SingleRecordSetPopulator::createRecord(const std::string &inString) const

{

  if (std::atoi(inString.c_str()) == m_key)

    {

      LibraryBookRecord *rval

          = new LibraryBookRecord(inString, theAdder, true, true);

      rval->setIsOnHeap(true);

      return rval;

    }

  else

    {

      return &theNullrval;

    }

}

ILibraryBookRecord *SingleRecordSetPopulator::filterRecord(

    const BaseLibraryBookRecord &inRec) const

{

  if (inRec.getId() == m_key)

    {

      return inRec.createRecord(theAdder, true, true);

    }

  else

    {

      return &theNullrval;

    }

}

void SingleRecordSetPopulator::updateStats(

    LtStats &outStats, const BaseLibraryBookRecord &inRec) const

{

  if (inRec.getId() == m_key)

    {

      outStats.add(inRec);

    }

}

Note that we take advantage of the fact that the line records begin with the record ID by using std::atoi() to avoid the need for parsing the record except for the one which we want.  And we use atoi() rather than stoi() to avoid the effect of throwing an exception on a defective record.)

FileRecordSource

The simpler of the two sources is the FileRecordSource:

class FileRecordSource : public LtLibrary::IRecordSource

{

public:

  FileRecordSource(const JSBUtil::IFileLineSourceFactory &inSourceFactory,

                   const LtLibrary::IRecordSetPopulatorFactory &inFactory,

                   std::shared_ptr<Log::ILogger> inLogger);

  ~FileRecordSource() override;

  std::unique_ptr<LtLibrary::ILibraryRecordSet>

  getRecords(const LtLibrary::IFieldAdderSet &inAdders,

             const LtLibrary::IRecordSetCriteria &inCriteria) const override;

  void getStats(LtLibrary::LtStats &outStats,

           const LtLibrary::IFieldAdderSet &inAdders,

           const LtLibrary::IRecordSetCriteria &inCriteria) const override;


private:

  mutable std::unique_ptr<JSBUtil::IFileLineSource> m_source;

  const LtLibrary::IRecordSetPopulatorFactory &m_factory;

  std::shared_ptr<Log::ILogger> m_logger;

};

This is used only in the command-line application, which does a single pass over the records.

The constructor just captures parameters:

FileRecordSource::FileRecordSource(

    const JSBUtil::IFileLineSourceFactory &inSourceFactory,

    const LtLibrary::IRecordSetPopulatorFactory &inFactory,

    std::shared_ptr<Log::ILogger> inLogger):

    m_source(inSourceFactory.create()),

    m_factory(inFactory), m_logger(inLogger)

{ }

All the activity takes place during the single pass in getRecords() or getStats():

std::unique_ptr<LtLibrary::ILibraryRecordSet> FileRecordSource::getRecords(

    const LtLibrary::IFieldAdderSet &inAdders,

    const LtLibrary::IRecordSetCriteria &inCriteria) const

{

  m_source->openSource();

  std::vector<std::string> vec;

  while (true)

    {

      std::string s;

      if (!m_source->getNextLine(s))

        break;

      vec.push_back(std::move(s));

    }

  std::unique_ptr<LtLibrary::IRecordSetPopulator> populator

      = m_factory.create(inAdders, inCriteria);

  return std::make_unique<LtLibrary::LibraryRecordSet>(

      vec, *populator, inCriteria.isBibliographic(), m_logger);

}

void FileRecordSource::getStats(

    LtLibrary::LtStats &outStats, const LtLibrary::IFieldAdderSet &inAdders,

    const LtLibrary::IRecordSetCriteria &inCriteria) const

{

  m_source->openSource();

  std::unique_ptr<LtLibrary::IRecordSetPopulator> populator

      = m_factory.create(inAdders, inCriteria);

  while (true)

    {

      std::string s;

      if (!m_source->getNextLine(s))

        break;

      populator->updateStats(outStats, LtLibrary::BaseLibraryBookRecord(s));

    }

}

MemoryRecordSource

The MemoryRecordSource stores the contents of the text database as an in-memory vector:

class MemoryRecordSource : public IRecordSource

{

  using storage_type = std::vector<BaseLibraryBookRecord>;

public:

  MemoryRecordSource (const JSBUtil::IFileLineSourceFactory &inFileFactory,

                      const IRecordSetPopulatorFactory &inFactory,

                      std::shared_ptr<Log::ILogger> inLogger);

  ~MemoryRecordSource () override;

  std::unique_ptr<ILibraryRecordSet>

  getRecords (const IFieldAdderSet &inAdders,

              const IRecordSetCriteria &inCriteria) const override;


  void getStats (LtStats &outStats, const IFieldAdderSet &inAdders,

                 const IRecordSetCriteria &inCriteria) const override;

private:

  storage_type m_records;

  const IRecordSetPopulatorFactory &m_factory;

  std::shared_ptr<Log::ILogger> m_logger;

};

Unlike in the previous class, the constructor loads all the records into memory.  If there is a file-related failure there will be an exception and the whole application will fail fast.

MemoryRecordSource::MemoryRecordSource(

    const JSBUtil::IFileLineSourceFactory &inFileFactory,

    const IRecordSetPopulatorFactory &inFactory,

    std::shared_ptr<Log::ILogger> inLogger)

    : m_factory(inFactory), m_logger(inLogger)

{

  auto source = inFileFactory.create();

  source->openSource();

  std::string s;

  while (source->getNextLine(s))

    m_records.emplace_back(s);

}


std::unique_ptr<ILibraryRecordSet>

MemoryRecordSource::getRecords(const IFieldAdderSet &inAdders,

                               const IRecordSetCriteria &inCriteria) const

{

  std::unique_ptr<IRecordSetPopulator> populator

      = m_factory.create(inAdders, inCriteria);

  if (!inCriteria.hasSingleId())

    return std::make_unique<LibraryRecordSet>(

        m_records, *populator, inCriteria.isBibliographic(), m_logger);

  else

    {

      if (auto val

          = std::ranges::find_if(m_records, [&inCriteria](const auto &inVal) {

    return inCriteria.matchesId(inVal.getId());

  }); val != m_records.end()) [[likely]]

        return std::make_unique<SingleLibraryRecordSet>(*val, *populator,

                                                        m_logger);

      else

        return std::make_unique<EmptyLibraryRecordSet>();

    }

}

We optimize for the single id case with a faster find_if approach.  In practice, the id passed should come from an already retrieved record and the case where the lookup fails is a "can't happen" case, but we handle it in any case.

void

MemoryRecordSource::getStats(LtStats &outStats, const IFieldAdderSet &inAdders,

                             const IRecordSetCriteria &inCriteria) const

{

  std::unique_ptr<IRecordSetPopulator> populator

      = m_factory.create(inAdders, inCriteria);

  std::ranges::for_each(m_records, [&](const auto &inRec) {

    populator->updateStats(outStats, inRec);

  });

}

In practice, there shouldn't be a stats call on a single id query, so we just use general logic.

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

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

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