Refs #15058 New updates from David

Framework/DataHandling/src/LoadANSTOHelper.cpp

@@ -17,12 +17,17 @@ namespace ANSTO {
 // ProgressTracker
 ProgressTracker::ProgressTracker(API::Progress &progBar, const char *msg,
                                  int64_t target, size_t count)
-    : m_msg(msg), m_count(count), m_step(target / count), m_next(m_step),
-      m_progBar(progBar) {
+  : m_msg(msg),
+    m_count(count),
+    m_step(target / count),
+    m_next(m_step),
+    m_progBar(progBar) {
 
   m_progBar.doReport(m_msg);
 }
-ProgressTracker::~ProgressTracker() { complete(); }
+ProgressTracker::~ProgressTracker() {
+  complete();
+}
 void ProgressTracker::update(int64_t position) {
   while (m_next <= position) {
     m_progBar.report(m_msg);
@@ -50,17 +55,23 @@ void ProgressTracker::complete() {
 }
 
 // EventProcessor
-EventProcessor::EventProcessor(const std::vector<bool> &roi,
-                               const size_t stride, const double period,
-                               const double phase, const double tofMinBoundary,
+EventProcessor::EventProcessor(const std::vector<bool> &roi, const size_t stride,
+                               const double period, const double phase,
+                               const double tofMinBoundary,
                                const double tofMaxBoundary,
                                const double timeMinBoundary,
                                const double timeMaxBoundary)
-    : m_roi(roi), m_stride(stride), m_frames(0), m_period(period),
-      m_phase(phase), m_tofMinBoundary(tofMinBoundary),
-      m_tofMaxBoundary(tofMaxBoundary), m_timeMinBoundary(timeMinBoundary),
-      m_timeMaxBoundary(timeMaxBoundary) {}
-void EventProcessor::newFrame() { m_frames++; }
+  : m_roi(roi), m_stride(stride),
+    m_frames(0),
+    m_period(period), m_phase(phase),
+    m_tofMinBoundary(tofMinBoundary),
+    m_tofMaxBoundary(tofMaxBoundary),
+    m_timeMinBoundary(timeMinBoundary),
+    m_timeMaxBoundary(timeMaxBoundary) {
+}
+void EventProcessor::newFrame() {
+  m_frames++;
+}
 void EventProcessor::addEvent(size_t x, size_t y, double tof) {
   // tof correction
   if (m_period > 0.0) {
@@ -75,7 +86,7 @@ void EventProcessor::addEvent(size_t x, size_t y, double tof) {
 
   // frame boundary
   double frameTime = (m_frames * m_period) * 1e-6; // in seconds
-  if ((frameTime <= m_timeMinBoundary) || (frameTime > m_timeMaxBoundary))
+  if ((frameTime < m_timeMinBoundary) || (frameTime > m_timeMaxBoundary))
     return;
 
   // ToF boundary
@@ -97,16 +108,17 @@ void EventProcessor::addEvent(size_t x, size_t y, double tof) {
 // EventCounter
 EventCounter::EventCounter(const std::vector<bool> &roi, const size_t stride,
                            const double period, const double phase,
-                           const double tofMinBoundary,
-                           const double tofMaxBoundary,
-                           const double timeMinBoundary,
-                           const double timeMaxBoundary,
+                           const double tofMinBoundary, const double tofMaxBoundary,
+                           const double timeMinBoundary, const double timeMaxBoundary,
                            std::vector<size_t> &eventCounts)
-    : EventProcessor(roi, stride, period, phase, tofMinBoundary, tofMaxBoundary,
-                     timeMinBoundary, timeMaxBoundary),
-      m_eventCounts(eventCounts), m_tofMin(std::numeric_limits<double>::max()),
-      m_tofMax(std::numeric_limits<double>::min()) {}
-size_t EventCounter::numFrames() const { return m_frames; }
+  : EventProcessor(roi, stride, period, phase, tofMinBoundary, tofMaxBoundary, timeMinBoundary, timeMaxBoundary),
+    m_eventCounts(eventCounts),
+    m_tofMin(std::numeric_limits<double>::max()),
+    m_tofMax(std::numeric_limits<double>::min()) {
+}
+size_t EventCounter::numFrames() const {
+  return m_frames;
+}
 double EventCounter::tofMin() const {
   return m_tofMin <= m_tofMax ? m_tofMin : 0.0;
 }
@@ -125,14 +137,12 @@ void EventCounter::addEventImpl(size_t id, double tof) {
 // EventAssigner
 EventAssigner::EventAssigner(const std::vector<bool> &roi, const size_t stride,
                              const double period, const double phase,
-                             const double tofMinBoundary,
-                             const double tofMaxBoundary,
-                             const double timeMinBoundary,
-                             const double timeMaxBoundary,
+                             const double tofMinBoundary, const double tofMaxBoundary,
+                             const double timeMinBoundary, const double timeMaxBoundary,
                              std::vector<EventVector_pt> &eventVectors)
-    : EventProcessor(roi, stride, period, phase, tofMinBoundary, tofMaxBoundary,
-                     timeMinBoundary, timeMaxBoundary),
-      m_eventVectors(eventVectors) {}
+  : EventProcessor(roi, stride, period, phase, tofMinBoundary, tofMaxBoundary, timeMinBoundary, timeMaxBoundary),
+    m_eventVectors(eventVectors) {
+}
 void EventAssigner::addEventImpl(size_t id, double tof) {
   m_eventVectors[id]->push_back(tof);
 }
@@ -143,8 +153,12 @@ FastReadOnlyFile::FastReadOnlyFile(const char *filename) {
   m_handle = CreateFileA(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
                          OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 }
-FastReadOnlyFile::~FastReadOnlyFile() { close(); }
-void *FastReadOnlyFile::handle() const { return m_handle; }
+FastReadOnlyFile::~FastReadOnlyFile() {
+  close();
+}
+void *FastReadOnlyFile::handle() const {
+  return m_handle;
+}
 void FastReadOnlyFile::close() {
   CloseHandle(m_handle);
   m_handle = NULL;
@@ -162,8 +176,12 @@ bool FastReadOnlyFile::seek(int64_t offset, int whence, int64_t *newPosition) {
 FastReadOnlyFile::FastReadOnlyFile(const char *filename) {
   m_handle = fopen(filename, "rb");
 }
-FastReadOnlyFile::~FastReadOnlyFile() { close(); }
-void *FastReadOnlyFile::handle() const { return m_handle; }
+FastReadOnlyFile::~FastReadOnlyFile() {
+  close();
+}
+void *FastReadOnlyFile::handle() const {
+  return m_handle;
+}
 void FastReadOnlyFile::close() {
   fclose(m_handle);
   m_handle = NULL;
@@ -179,16 +197,17 @@ bool FastReadOnlyFile::seek(int64_t offset, int whence, int64_t *newPosition) {
 #endif
 
 namespace Tar {
-
+  
 void EntryHeader::writeChecksum() {
   memset(Checksum, ' ', sizeof(Checksum));
   size_t value = std::accumulate(
-      (const char *)this, (const char *)this + sizeof(EntryHeader), (size_t)0);
-
+    (const char*)this,
+    (const char*)this + sizeof(EntryHeader),
+    (size_t)0);
+  
   std::ostringstream buffer;
 
-  buffer << std::oct << std::setfill('0') << std::setw(sizeof(Checksum) - 1)
-         << value;
+  buffer << std::oct << std::setfill('0') << std::setw(sizeof(Checksum) - 1) << value;
   std::string string = buffer.str();
 
   std::copy(string.cbegin(), string.cend(), Checksum);
@@ -197,8 +216,7 @@ void EntryHeader::writeChecksum() {
 void EntryHeader::writeFileSize(int64_t value) {
   std::ostringstream buffer;
 
-  buffer << std::oct << std::setfill('0') << std::setw(sizeof(FileSize) - 1)
-         << value;
+  buffer << std::oct << std::setfill('0') << std::setw(sizeof(FileSize) - 1) << value;
   std::string string = buffer.str();
 
   std::copy(string.cbegin(), string.cend(), FileSize);
@@ -217,8 +235,8 @@ int64_t EntryHeader::readFileSize() {
 
 // construction
 File::File(const std::string &path)
-    : m_good(true), m_file(path.c_str()), m_selected(static_cast<size_t>(-1)),
-      m_position(0), m_size(0), m_bufferPosition(0), m_bufferAvailable(0) {
+  : m_good(true), m_file(path.c_str()), m_selected(static_cast<size_t>(-1)), m_position(0),
+    m_size(0), m_bufferPosition(0), m_bufferAvailable(0) {
 
   m_good = m_file.handle() != NULL;
   while (m_good) {
@@ -263,13 +281,21 @@ void File::close() {
 }
 
 // properties
-bool File::good() const { return m_good; }
-const std::vector<std::string> &File::files() const { return m_fileNames; }
+bool File::good() const {
+  return m_good;
+}
+const std::vector<std::string> &File::files() const {
+  return m_fileNames;
+}
 const std::string &File::selected_name() const {
   return m_fileNames[m_selected];
 }
-int64_t File::selected_position() const { return m_position; }
-int64_t File::selected_size() const { return m_size; }
+int64_t File::selected_position() const {
+  return m_position;
+}
+int64_t File::selected_size() const {
+  return m_size;
+}
 
 // methods
 bool File::select(const char *file) {
@@ -382,11 +408,11 @@ int File::read_byte() {
   m_position++;
   return m_buffer[m_bufferPosition++];
 }
-bool File::append(const std::string &path, const std::string &name,
-                  const void *buffer, size_t size) {
-  std::unique_ptr<FILE, decltype(&fclose)> handle(fopen(path.c_str(), "rb+"),
-                                                  fclose);
-
+bool File::append(const std::string &path, const std::string &name, const void *buffer, size_t size) {
+  std::unique_ptr<FILE, decltype(&fclose)> handle(
+    fopen(path.c_str(), "rb+"),
+    fclose);
+  
   bool good = handle != NULL;
   int64_t lastHeaderPosition = 0;
   int64_t targetPosition = -1;
@@ -396,7 +422,7 @@ bool File::append(const std::string &path, const std::string &name,
     int64_t position;
 
     lastHeaderPosition = static_cast<int64_t>(ftell(handle.get()));
-
+    
     good &= 1 == fread(&header, sizeof(EntryHeader), 1, handle.get());
     good &= 0 == fseek(handle.get(), 512 - sizeof(EntryHeader), SEEK_CUR);
     good &= 0 <= (position = static_cast<int64_t>(ftell(handle.get())));
@@ -407,12 +433,11 @@ bool File::append(const std::string &path, const std::string &name,
     std::string fileName(header.FileName);
     if (fileName.length() == 0)
       break;
-
+    
     if (fileName.compare(name) == 0)
       targetPosition = lastHeaderPosition;
     else if (targetPosition != -1)
-      throw std::exception(
-          "format exception"); // it has to be the last file in the archive
+      throw std::exception("format exception"); // it has to be the last file in the archive
 
     FileInfo fileInfo;
     fileInfo.Offset = position;
@@ -422,8 +447,7 @@ bool File::append(const std::string &path, const std::string &name,
     if (offset != 0)
       offset = 512 - offset;
 
-    good &= 0 == fseek(handle.get(), static_cast<long>(fileInfo.Size + offset),
-                       SEEK_CUR);
+    good &= 0 == fseek(handle.get(), static_cast<long>(fileInfo.Size + offset), SEEK_CUR);
   }
 
   if (!good)
@@ -431,7 +455,7 @@ bool File::append(const std::string &path, const std::string &name,
 
   if (targetPosition == -1)
     targetPosition = lastHeaderPosition;
-
+  
   // empty buffer
   char padding[512];
   memset(padding, 0, 512);
@@ -444,7 +468,7 @@ bool File::append(const std::string &path, const std::string &name,
   memset(header.OwnerUserID, '0', sizeof(header.OwnerUserID) - 1);
   memset(header.OwnerGroupID, '0', sizeof(header.OwnerGroupID) - 1);
   memset(header.LastModification, '0', sizeof(header.LastModification) - 1);
-
+    
   header.TypeFlag = TarTypeFlag_NormalFile;
   header.writeFileSize(size);
   header.writeChecksum();
@@ -456,7 +480,7 @@ bool File::append(const std::string &path, const std::string &name,
 
   // write content
   good &= 1 == fwrite(buffer, size, 1, handle.get());
-
+    
   // write padding
   size_t offset = static_cast<size_t>(size % 512);
   if (offset != 0) {