reduce use of explicit "new"

six/modules/c++/cphd/include/cphd/CPHDReader.h

@@ -41,9 +41,8 @@ namespace cphd
  *  Requires a valid CPHD file,and optional schemas
  *  for XML format verification
  */
-class CPHDReader
+struct CPHDReader final
 {
-public:
     /*
      *  \func CPHDReader constructor
      *  \brief Construct CPHDReader from an input stream
@@ -81,22 +80,22 @@ class CPHDReader
     //! Get parameter functions
     size_t getNumChannels() const
     {
-        return mMetadata->data.getNumChannels();
+        return mMetadata.data.getNumChannels();
     }
     //! 0-based channel number
     size_t getNumVectors(size_t channel) const
     {
-        return mMetadata->data.getNumVectors(channel);
+        return mMetadata.data.getNumVectors(channel);
     }
     //! 0-based channel number
     size_t getNumSamples(size_t channel) const
     {
-        return mMetadata->data.getNumSamples(channel);
+        return mMetadata.data.getNumSamples(channel);
     }
     //! returns total per complex sample (2, 4, or 8)
     size_t getNumBytesPerSample() const
     {
-        return mMetadata->data.getNumBytesPerSample();
+        return mMetadata.data.getNumBytesPerSample();
     }
 
     /*
@@ -122,12 +121,12 @@ class CPHDReader
     //! Get metadata object
     const Metadata& getMetadata() const
     {
-        return *mMetadata;
+        return mMetadata;
     }
     //! Get per vector parameters
     const PVPBlock& getPVPBlock() const
     {
-        return *mPVPBlock;
+        return mPVPBlock;
     }
     //! Get signal data
     const Wideband& getWideband() const
@@ -145,11 +144,11 @@ class CPHDReader
     //! New cphd file header
     FileHeader mFileHeader;
     //! Metadata read in from CPHD file
-    std::unique_ptr<Metadata> mMetadata;
+    Metadata mMetadata;
     //! Support Block book-keeping info read in from CPHD file
     std::unique_ptr<SupportBlock> mSupportBlock;
     //! Per Vector Parameter info read in from CPHD file
-    std::unique_ptr<PVPBlock> mPVPBlock;
+    PVPBlock mPVPBlock;
     //! Signal block book-keeping info read in from CPHD file
     std::unique_ptr<Wideband> mWideband;
 

six/modules/c++/cphd/include/cphd/CPHDWriter.h

@@ -127,10 +127,8 @@ struct DataWriterLittleEndian final : public DataWriter
 
 
 private:
-    // Size of scratch space
-    const size_t mScratchSize;
     // Scratch space buffer
-    const std::unique_ptr<std::byte[]> mScratch;
+    std::vector<std::byte> mScratch;
 };
 
 /*
@@ -389,6 +387,7 @@ struct CPHDWriter
 
     //! DataWriter object
     std::unique_ptr<DataWriter> mDataWriter;
+    void initializeDataWriter();
 
     // Book-keeping element
     //! metadata information

six/modules/c++/cphd/include/cphd/CPHDXMLControl.h

@@ -22,16 +22,19 @@
 
 #ifndef __CPHD_CPHD_XML_CONTROL_H__
 #define __CPHD_CPHD_XML_CONTROL_H__
+#pragma once
 
 #include <memory>
 #include <unordered_map>
+#include <std/filesystem>
+#include <vector>
 
 #include <scene/sys_Conf.h>
-#include <logging/Logger.h>
 #include <xml/lite/Element.h>
 #include <xml/lite/Document.h>
 #include <cphd/CPHDXMLParser.h>
 #include <cphd/Types.h>
+#include <six/Logger.h>
 
 namespace cphd
 {
@@ -54,7 +57,7 @@ class CPHDXMLControl
     CPHDXMLControl(logging::Logger* log = nullptr, bool ownLog = false);
 
     //! Destructor
-    virtual ~CPHDXMLControl();
+    virtual ~CPHDXMLControl() = default;
 
     /*
      *  \func setLogger
@@ -63,7 +66,15 @@ class CPHDXMLControl
      *  \param log provide logger object
      *  \param ownLog flag indicates if log should be deleted
      */
-    void setLogger(logging::Logger* log, bool ownLog = false);
+    template<typename TLogger>
+    void setLogger(TLogger&& logger)
+    {
+        mLogger.setLogger(std::forward<TLogger>(logger));
+    }
+    void setLogger(logging::Logger* logger, bool ownLog)
+    {
+        mLogger.setLogger(logger, ownLog);
+    }
 
     /*!
      *  \func toXMLString
@@ -117,10 +128,14 @@ class CPHDXMLControl
     virtual std::unique_ptr<Metadata> fromXML(
             const xml::lite::Document* doc,
             const std::vector<std::string>& schemaPaths = std::vector<std::string>());
+    virtual Metadata fromXML(const xml::lite::Document& doc,
+        const std::vector<std::filesystem::path>& schemaPaths = std::vector<std::filesystem::path>());
+
 
 protected:
-    logging::Logger *mLog;
-    bool mOwnLog;
+    logging::Logger *mLog = nullptr;
+    bool mOwnLog = false;
+    six::Logger mLogger;
 
 private:
     //! \return Hardcoded version to uri mapping

six/modules/c++/cphd/include/cphd/Metadata.h

@@ -55,7 +55,7 @@ namespace cphd
  *  This object contains all of the sub-blocks for CPHD.
  *
  */
-struct Metadata : MetadataBase
+struct Metadata final : MetadataBase
 {
     //! Default constructor
     //! Initializes CPHD version to default version specified in FileHeader

six/modules/c++/cphd/include/cphd/PVPBlock.h

@@ -41,6 +41,7 @@
 
 namespace cphd
 {
+    class FileHeader;
 /*
  *  \struct AddedPVP
  *  \brief Template Specialization to get additional pvp
@@ -98,6 +99,7 @@ struct PVPBlock
      *  if provided number of bytes is not sufficient
     */
     PVPBlock(const Pvp& pvp, const Data& data);
+    PVPBlock(const Metadata&);
 
     /*!
      *  \func PVPBlock
@@ -323,6 +325,7 @@ struct PVPBlock
                     int64_t startPVP,
                     int64_t sizePVP,
                     size_t numThreads);
+    int64_t load(io::SeekableInputStream& inStream, const FileHeader&, size_t numThreads);
 
     //! Equality operators
     bool operator==(const PVPBlock& other) const

six/modules/c++/cphd/include/cphd/SupportBlock.h

@@ -41,16 +41,17 @@
 
 namespace cphd
 {
+    class FileHeader;
+
 
 /*
  *  \struct SupportBlock
  *
  *  \brief This class contains information about the SupportBlock CPHD data.
  */
 //  Provides methods to read support block data from CPHD file/stream
-class SupportBlock
+struct SupportBlock final
 {
-public:
     /*
      *  \func SupportBlock
      *
@@ -80,6 +81,8 @@ class SupportBlock
                  const cphd::Data& data,
                  int64_t startSupport,
                  int64_t sizeSupport);
+    SupportBlock(std::shared_ptr<io::SeekableInputStream> inStream,
+        const cphd::Data& data, const FileHeader&);
 
     // Noncopyable
     SupportBlock(const SupportBlock&) = delete;
@@ -138,12 +141,12 @@ class SupportBlock
     // Same as above but allocates the memory
     void read(const std::string& id,
               size_t numThreads,
-              mem::ScopedArray<sys::ubyte>& data) const;
+              std::unique_ptr<sys::ubyte[]>& data) const;
     void read(const std::string& id,
               size_t numThreads,
               std::unique_ptr<std::byte[]>& data) const
     {
-        mem::ScopedArray<sys::ubyte> data_;
+        std::unique_ptr<sys::ubyte[]> data_;
         read(id, numThreads, data_);
         data.reset(reinterpret_cast<std::byte*>(data_.release()));
     }
@@ -161,11 +164,11 @@ class SupportBlock
      *
      */
     void readAll(size_t numThreads,
-                 mem::ScopedArray<sys::ubyte>& data) const;
+                std::unique_ptr<sys::ubyte[]>& data) const;
     void readAll(size_t numThreads,
                  std::unique_ptr<std::byte[]>& data) const
     {
-        mem::ScopedArray<sys::ubyte> data_;
+        std::unique_ptr<sys::ubyte[]> data_;
         readAll(numThreads, data_);
         data.reset(reinterpret_cast<std::byte*>(data_.release()));
     }

six/modules/c++/cphd/include/cphd/Wideband.h

@@ -40,15 +40,16 @@
 
 namespace cphd
 {
+    class FileHeader;
+
 /*
  * \class Wideband
  * \brief Information about the wideband CPHD data
  */
 //  It contains the cphd::Data structure (for channel and vector sizes).
 //  Provides methods read wideband data from CPHD file/stream
-class Wideband
+struct Wideband final
 {
-public:
     static const size_t ALL;
 
     /*!
@@ -211,15 +212,15 @@ class Wideband
               size_t firstSample,
               size_t lastSample,
               size_t numThreads,
-              mem::ScopedArray<sys::ubyte>& data) const;
+              std::unique_ptr<sys::ubyte[]>& data) const;
     std::unique_ptr<std::byte[]>read(size_t channel,
               size_t firstVector,
               size_t lastVector,
               size_t firstSample,
               size_t lastSample,
               size_t numThreads) const
     {
-        mem::ScopedArray<sys::ubyte> data;
+        std::unique_ptr<sys::ubyte[]> data;
         read(channel, firstVector, lastVector, firstSample, lastSample, numThreads, data);
 
         return std::unique_ptr<std::byte[]>(reinterpret_cast<std::byte*>(data.release()));
@@ -238,10 +239,10 @@ class Wideband
      *  \throw except::Exception If BufferView memory allocated is insufficient
      */
     // Same as above for compressed Signal Array
-    void read(size_t channel, mem::ScopedArray<sys::ubyte>& data) const;
+    void read(size_t channel, std::unique_ptr<sys::ubyte[]>& data) const;
     void read(size_t channel, std::unique_ptr<std::byte[]>& data) const
     {
-        mem::ScopedArray<sys::ubyte> data_;
+        std::unique_ptr<sys::ubyte[]> data_;
         read(channel, data_);
         data.reset(reinterpret_cast<std::byte*>(data_.release()));
     }

six/modules/c++/cphd/source/ByteSwap.cpp

@@ -22,6 +22,7 @@
 #include <cphd/ByteSwap.h>
 
 #include <string>
+#include <std/memory>
 
 #include <sys/Conf.h>
 #include <mt/ThreadPlanner.h>
@@ -195,13 +196,12 @@ void byteSwapAndPromote(const void* input,
                                      startRow,
                                      numRowsThisThread))
         {
-            std::unique_ptr<sys::Runnable> scaler(
-                new ByteSwapAndPromoteRunnable<InT>(
+            auto scaler = std::make_unique<ByteSwapAndPromoteRunnable<InT>>(
                     input,
                     startRow,
                     numRowsThisThread,
                     dims.col,
-                    output));
+                    output);
             threads.createThread(std::move(scaler));
         }
 
@@ -233,13 +233,13 @@ void byteSwapAndScale(const void* input,
                                      startRow,
                                      numRowsThisThread))
         {
-            std::unique_ptr<sys::Runnable> scaler(new ByteSwapAndScaleRunnable<InT>(
+            auto scaler = std::make_unique<ByteSwapAndScaleRunnable<InT>>(
                     input,
                     startRow,
                     numRowsThisThread,
                     dims.col,
                     scaleFactors,
-                    output));
+                    output);
             threads.createThread(std::move(scaler));
         }
 
@@ -273,12 +273,11 @@ void byteSwap(void* buffer,
                                      startElement,
                                      numElementsThisThread))
         {
-            std::unique_ptr<sys::Runnable> thread(new ByteSwapRunnable(
+            auto thread = std::make_unique<ByteSwapRunnable>(
                     buffer,
                     elemSize,
                     startElement,
-                    numElementsThisThread));
-
+                    numElementsThisThread);
             threads.createThread(std::move(thread));
         }
         threads.joinAll();