Moved the statistics calculation into a separate file.

Author: peterfpeterson

CMakeLists.txt

@@ -7,9 +7,9 @@ project ( morebin )
 include ( CheckIncludeFiles )
 # stdint
 check_include_files ( stdint.h stdint )
-if ( stdint )
-  add_definitions ( -DHAVE_STDINT_H )
-endif ( stdint )
+if ( NOT stdint )
+  MESSAGE ( FATAL_ERROR "stdint.h required to build" )
+endif ( NOT stdint )
 # tclap - needs to go
 #find_path ( TCLAP_INCLUDE_DIR tclap/CmdLine.h )
 #include_directories ( ${TCLAP_INCLUDE_DIR} )
@@ -25,7 +25,9 @@ set ( SRC_FILES
       byte_swap.h
       more_bin.cpp
       renderer.cpp
-      renderer.hpp )
+      renderer.hpp
+      statistics.cpp
+      statistics.hpp )
 
 add_executable( morebin ${SRC_FILES} )
 target_link_libraries ( morebin ${Boost_LIBRARIES} )

bin_file.hpp

@@ -4,22 +4,10 @@
 #include <boost/shared_ptr.hpp>
 #include <fstream>
 #include <sstream>
+#include <stdint.h>
 #include <string>
 #include <vector>
 
-#ifdef HAVE_STDINT_H
-#include <stdint.h>
-#else
-typedef signed char             int8_t;
-typedef short int               int16_t;
-typedef int                     int32_t;
-typedef long int                int64_t;
-typedef unsigned char           uint8_t;
-typedef unsigned short int      uint16_t;
-typedef unsigned int            uint32_t;
-typedef unsigned long int       uint64_t;
-#endif
-
 class BinFile
 {
 public:

renderer.cpp

@@ -1,9 +1,9 @@
 #include <algorithm>
-#include <limits>
 #include <iostream>
 #include <sstream>
 #include <stdexcept>
 #include "renderer.hpp"
+#include "statistics.hpp"
 
 using std::cout;
 using std::endl;
@@ -93,47 +93,6 @@ void Renderer::showLines(const bool showLines)
   this->m_showLines = showLines;
 }
 
-template <typename NumT>
-void getMinMax(NumT &min, NumT &max)
-{
-  min = std::numeric_limits<NumT>::max();
-  max = std::numeric_limits<NumT>::min();
-}
-
-template <>
-void getMinMax<double>(double &min, double &max)
-{
-  min = std::numeric_limits<double>::max();
-  max = -1. * std::numeric_limits<double>::max();
-}
-
-template <>
-void getMinMax<float>(float &min, float &max)
-{
-  min = std::numeric_limits<float>::max();
-  max = -1. * std::numeric_limits<float>::max();
-}
-
-// TODO put this in a separate class
-// TODO add in mean value
-template <typename NumT>
-void Renderer::showStatistics(vector<NumT> &data)
-{
-  NumT min;
-  NumT max;
-  getMinMax(min, max);
-
-  size_t size = data.size();
-  for (size_t i = 0; i < size; i++) {
-    if (data[i] < min)
-      min = data[i];
-    if (data[i] > max)
-      max = data[i];
-  }
-
-  cout << "MIN " << min << " MAX: " << max << " TOTAL ELEMENTS: " << size << endl;
-}
-
 template <typename NumT>
 void Renderer::innerShowData(BinFile &file, size_t offset, size_t length)
 {
@@ -142,17 +101,19 @@ void Renderer::innerShowData(BinFile &file, size_t offset, size_t length)
   if ((offset % sizeof(NumT)) == 0)
     myOffset = offset / sizeof(NumT);
 
+  Statistics<NumT> stats; // object for generating statistics
   vector<NumT> data;
   file.read(data, length);
   if (!(data.empty())) {
+    stats.parseData(data);
     for (size_t i = 0; i < data.size(); i++) {
       if (this->m_showLines)
 	cout << (myOffset + i + 1) << " "; // start counting with one
       cout << data[i] << EOL;
     }
 
-    this->showStatistics(data);
   }
+  cout << stats << endl;
 }
 
 /// Special version for strings

renderer.hpp

@@ -20,8 +20,6 @@ class Renderer
 private:
   template <typename NumT>
   void innerShowData(BinFile &file, size_t offset, size_t length);
-  template <typename NumT>
-  void showStatistics(std::vector<NumT> &data);
 
   std::vector<std::string> * m_dataDescr;
   bool m_showLines;

statistics.cpp

@@ -0,0 +1,94 @@
+#include <limits>
+#include <stdint.h>
+#include "statistics.hpp"
+
+namespace { // anonymous namespace to hide from others
+
+template <typename NumT>
+void getMinMax(NumT &min, NumT &max)
+{
+  min = std::numeric_limits<NumT>::max();
+  max = std::numeric_limits<NumT>::min();
+}
+
+template <>
+void getMinMax<double>(double &min, double &max)
+{
+  min = std::numeric_limits<double>::max();
+  max = -1. * std::numeric_limits<double>::max();
+}
+
+template <>
+void getMinMax<float>(float &min, float &max)
+{
+  min = std::numeric_limits<float>::max();
+  max = -1. * std::numeric_limits<float>::max();
+}
+
+}
+
+template <typename NumT>
+Statistics<NumT>::Statistics()
+{
+  this->total = static_cast<NumT>(0.);
+  this->number = static_cast<std::size_t>(0);
+  getMinMax(this->min, this->max);
+}
+
+template <typename NumT>
+Statistics<NumT>::~Statistics()
+{
+}
+
+template <typename NumT>
+void Statistics<NumT>::parseData(std::vector<NumT> & data)
+{
+  size_t size = data.size();
+  this->number += size;
+
+  NumT item;
+  for (size_t i = 0; i < size; i++) {
+    item = data[i];
+    if (item < this->min)
+      this->min = item;
+    if (item > this->max)
+      this->max = item;
+    this->total += item;
+  }
+}
+
+template <typename NumT>
+std::ostream& operator<<(std::ostream &os, const Statistics<NumT> & thing) {
+  if (thing.number > 0) {
+    double mean = static_cast<double>(thing.total);
+    mean = mean / static_cast<double>(thing.number);
+    os << "MEAN " << mean << " ";
+  }
+
+  os << "MIN " << thing.min << " MAX: " << thing.max
+     << " TOTAL ELEMENTS: " << thing.number;
+  return os;
+}
+
+// concrete instantiations to make the compiler happy
+template class Statistics<uint8_t>;
+template class Statistics<int8_t>;
+template class Statistics<uint16_t>;
+template class Statistics<int16_t>;
+template class Statistics<uint32_t>;
+template class Statistics<int32_t>;
+template class Statistics<uint64_t>;
+template class Statistics<int64_t>;
+template class Statistics<float>;
+template class Statistics<double>;
+
+template std::ostream& operator<<(std::ostream &, const Statistics<uint8_t> &);
+template std::ostream& operator<<(std::ostream &, const Statistics<int8_t> &);
+template std::ostream& operator<<(std::ostream &, const Statistics<uint16_t> &);
+template std::ostream& operator<<(std::ostream &, const Statistics<int16_t> &);
+template std::ostream& operator<<(std::ostream &, const Statistics<uint32_t> &);
+template std::ostream& operator<<(std::ostream &, const Statistics<int32_t> &);
+template std::ostream& operator<<(std::ostream &, const Statistics<uint64_t> &);
+template std::ostream& operator<<(std::ostream &, const Statistics<int64_t> &);
+template std::ostream& operator<<(std::ostream &, const Statistics<float> &);
+template std::ostream& operator<<(std::ostream &, const Statistics<double> &);

statistics.hpp

@@ -0,0 +1,27 @@
+#ifndef _STATISTICS_HPP
+#define _STATISTICS_HPP 1
+
+#include <iostream>
+#include <vector>
+
+template <typename NumT>
+class Statistics
+{
+template <typename TYPE>
+friend std::ostream& operator<<(std::ostream &os,
+				const Statistics<TYPE> & thing);
+
+public:
+  Statistics();
+  virtual ~Statistics();
+
+  void parseData(std::vector<NumT> & data);
+
+private:
+  NumT total;
+  NumT min;
+  NumT max;
+  std::size_t number;
+};
+
+#endif