ngageoint
diff --git a/‎externals/coda-oss/modules/c++/config/include/config/coda_oss_config.h.in‎
Lines changed: 6 additions & 3 deletions b/‎externals/coda-oss/modules/c++/config/include/config/coda_oss_config.h.in‎
Lines changed: 6 additions & 3 deletions
diff --git a/‎externals/coda-oss/modules/c++/config/include/config/compiler_extensions.h‎
Lines changed: 26 additions & 13 deletions b/‎externals/coda-oss/modules/c++/config/include/config/compiler_extensions.h‎
Lines changed: 26 additions & 13 deletions
diff --git a/‎externals/coda-oss/modules/c++/io/include/io/PipeStream.h‎
Lines changed: 5 additions & 11 deletions b/‎externals/coda-oss/modules/c++/io/include/io/PipeStream.h‎
Lines changed: 5 additions & 11 deletions
diff --git a/‎externals/coda-oss/modules/c++/io/include/io/TempFile.h‎
Lines changed: 5 additions & 5 deletions b/‎externals/coda-oss/modules/c++/io/include/io/TempFile.h‎
Lines changed: 5 additions & 5 deletions
diff --git a/‎externals/coda-oss/modules/c++/logging/include/logging/Logger.h‎
Lines changed: 3 additions & 7 deletions b/‎externals/coda-oss/modules/c++/logging/include/logging/Logger.h‎
Lines changed: 3 additions & 7 deletions
diff --git a/‎externals/coda-oss/modules/c++/mem/include/mem/ScopedAlignedArray.h‎
Lines changed: 4 additions & 6 deletions b/‎externals/coda-oss/modules/c++/mem/include/mem/ScopedAlignedArray.h‎
Lines changed: 4 additions & 6 deletions
diff --git a/‎externals/coda-oss/modules/c++/mem/include/mem/ScopedArray.h‎
Lines changed: 4 additions & 7 deletions b/‎externals/coda-oss/modules/c++/mem/include/mem/ScopedArray.h‎
Lines changed: 4 additions & 7 deletions
diff --git a/‎externals/coda-oss/modules/c++/mem/include/mem/ScratchMemory.h‎
Lines changed: 3 additions & 3 deletions b/‎externals/coda-oss/modules/c++/mem/include/mem/ScratchMemory.h‎
Lines changed: 3 additions & 3 deletions
diff --git a/‎externals/coda-oss/modules/c++/mem/include/mem/VectorOfPointers.h‎
Lines changed: 4 additions & 8 deletions b/‎externals/coda-oss/modules/c++/mem/include/mem/VectorOfPointers.h‎
Lines changed: 4 additions & 8 deletions
diff --git a/‎externals/coda-oss/modules/c++/mem/unittests/test_scoped_copyable_ptr.cpp‎
Lines changed: 56 additions & 18 deletions b/‎externals/coda-oss/modules/c++/mem/unittests/test_scoped_copyable_ptr.cpp‎
Lines changed: 56 additions & 18 deletions
@@ -3,6 +3,7 @@
 #ifndef _CODA_OSS_CONFIG_H_
 #define _CODA_OSS_CONFIG_H_
 
+/* these should no longer be needed */
 #cmakedefine HAVE_PTHREAD_H @HAVE_PTHREAD_H@
 #cmakedefine HAVE_EXECINFO_H @HAVE_EXECINFO_H@
 #cmakedefine HAVE_CLOCK_GETTIME @HAVE_CLOCK_GETTIME@
@@ -11,12 +12,14 @@
 #cmakedefine HAVE_LOCALTIME_R @HAVE_LOCALTIME_R@
 #cmakedefine HAVE_GMTIME_R @HAVE_GMTIME_R@
 #cmakedefine HAVE_SETENV @HAVE_SETENV@
-#cmakedefine HAVE_POSIX_MEMALIGN @HAVE_POSIX_MEMALIGN@
-#cmakedefine HAVE_MEMALIGN @HAVE_MEMALIGN@
 #cmakedefine01 BIGENDIAN
 #cmakedefine SIZEOF_SIZE_T @SIZEOF_SIZE_T@
-#cmakedefine HAVE_ATTRIBUTE_NOINLINE @HAVE_ATTRIBUTE_NOINLINE@
+#cmakedefine HAVE_POSIX_MEMALIGN @HAVE_POSIX_MEMALIGN@
+#cmakedefine HAVE_MEMALIGN @HAVE_MEMALIGN@
 #cmakedefine HAVE_ATTRIBUTE_ALIGNED @HAVE_ATTRIBUTE_ALIGNED@
+#cmakedefine HAVE_ATTRIBUTE_NOINLINE @HAVE_ATTRIBUTE_NOINLINE@
+
+/* still might need these ... for now */
 #cmakedefine CODA_EXPORT @CODA_EXPORT@
 
 #endif /* _CODA_OSS_CONFIG_H_ */
@@ -19,21 +19,34 @@
  * see <http://www.gnu.org/licenses/>.
  *
  */
-#ifndef CONFIG_COMPILER_EXTENSIONS
-#define CONFIG_COMPILER_EXTENSIONS
+#ifndef CODA_OSS_config_compiler_extentions_h_INCLUDED_
+#define CODA_OSS_config_compiler_extentions_h_INCLUDED_
+#pragma once
 
 #include <config/coda_oss_config.h>
 
-#ifdef HAVE_ATTRIBUTE_NOINLINE
-#define ATTRIBUTE_NOINLINE __attribute__((noinline))
-#else
-#define ATTRIBUTE_NOINLINE
-#endif
+#ifndef CODA_OSS_attribute_noinline_DEFINED_
+	#define CODA_OSS_attribute_noinline_DEFINED_ 1
 
-#ifdef HAVE_ATTRIBUTE_ALIGNED
-#define ATTRIBUTE_ALIGNED(x) __attribute__((aligned (x)))
-#else
-#define ATTRIBUTE_ALIGNED(X)
-#endif
+	// https://stackoverflow.com/a/49468469/8877
+	#if defined(__GNUC__)
+	#define ATTRIBUTE_NOINLINE __attribute__((noinline))
+	#elif defined(_MSC_VER)
+	#define ATTRIBUTE_NOINLINE __declspec(noinline)
+	#else
+	#define ATTRIBUTE_NOINLINE
+	#endif
+#endif // CODA_OSS_attribute_noinline_DEFINED_
 
-#endif
+#ifndef CODA_OSS_attribute_aligned_DEFINED_
+	#define CODA_OSS_attribute_aligned_DEFINED_ 1
+
+	#if defined(__GNUC__)
+	// https://gcc.gnu.org/onlinedocs/gcc-3.2/gcc/Variable-Attributes.html
+	#define ATTRIBUTE_ALIGNED(x) __attribute__((aligned(x)))
+	#else
+	#define ATTRIBUTE_ALIGNED(X)
+	#endif
+#endif // CODA_OSS_attribute_aligned_DEFINED_
+
+#endif // CODA_OSS_config_compiler_extentions_h_INCLUDED_
@@ -39,11 +39,8 @@ namespace io
  *  \brief captures the standard output from a pipe
  *         and streams it to the specified location
  */
-class PipeStream : InputStream
+struct PipeStream : InputStream
 {
-
-public:
-
     /*!
     *  Constructor --
     *  Streams data from a pipe when available
@@ -95,6 +92,9 @@ class PipeStream : InputStream
     virtual sys::SSize_T streamTo(OutputStream& soi,
                                   sys::SSize_T numBytes = IS_END);
 
+    PipeStream(const PipeStream&) = delete;
+    PipeStream& operator=(const PipeStream&) = delete;
+
 protected:
     /*!
      *  \brief returns the requested size in bytes from the stream
@@ -104,13 +104,7 @@ class PipeStream : InputStream
 
     sys::ExecPipe mExecPipe;
     mem::ScopedArray<char> mCharString;
-    size_t mBufferSize;
-
-private:
-
-    //! Noncopyable
-    PipeStream(const PipeStream& );
-    const PipeStream& operator=(const PipeStream& );
+    size_t mBufferSize = DEFAULT_CHUNK_SIZE;
 };
 
 }
 
@@ -32,9 +32,8 @@ namespace io
  * RAII object for a temporary file that gets deleted
  * upon object destruction
  */
-class TempFile
+struct TempFile
 {
-public:
     /*!
      * Constructor for TempFile object. Provided a directory,
      * this will find a random, unused filename, and create a file
@@ -53,10 +52,11 @@ class TempFile
     {
         return mPathname;
     }
+
+    TempFile(const TempFile&) = delete;
+    TempFile& operator=(const TempFile&) = delete;
+
 private:
-    // Noncopyable
-    TempFile(const TempFile& );
-    const TempFile& operator=(const TempFile& );
     const sys::OS mOS;
     const std::string mPathname;
 };
 
@@ -43,10 +43,8 @@ namespace logging
  * Instances of the Logger class represent a single logging channel.
  * A Logger instance can log to several Handlers.
  */
-class Logger : public Filterer
+struct Logger : public Filterer
 {
-
-public:
     /*!
      * Constructs a Logger with an optional name
      * \param name  (optional) Name of the logger
@@ -130,15 +128,13 @@ class Logger : public Filterer
     //! Removes all handlers
     void reset();
 
-private:
-    // Noncopyable
     // NOTE: It isn't currently safe to copy a logger because mHandlers isn't
     //       a deep copy and you end up with a double delete (it's not using
     //       smart pointers :o( ).  If we really wanted to support a copy,
     //       would need to decide if mHandlers should be deeply or shallowly
     //       copied.
-    Logger(const Logger& );
-    Logger& operator=(const Logger& );
+    Logger(const Logger&) = delete;
+    Logger& operator=(const Logger&) = delete;
 
 protected:
     void handle(const LogRecord* record);
 
@@ -34,9 +34,8 @@ namespace mem
      *  \brief This class provides RAII for alignedAlloc() and alignedFree()
      */
     template <class T>
-    class ScopedAlignedArray
+    struct ScopedAlignedArray
     {
-    public:
         typedef T ElementType;
 
         explicit ScopedAlignedArray(
@@ -91,11 +90,10 @@ namespace mem
             return array;
         }
 
-    private:
-        // Noncopyable
-        ScopedAlignedArray(const ScopedAlignedArray& );
-        const ScopedAlignedArray& operator=(const ScopedAlignedArray& );
+        ScopedAlignedArray(const ScopedAlignedArray&) = delete;
+        ScopedAlignedArray& operator=(const ScopedAlignedArray&) = delete;
 
+    private:
         static
         T* allocate(size_t numElements, size_t alignment)
         {
 
@@ -33,9 +33,8 @@ namespace mem
      *         It is based on boost::scoped_array.
      */
     template <class T>
-    class ScopedArray
-    {
-    public:
+    struct ScopedArray
+    { 
         typedef T ElementType;
 
         explicit ScopedArray(T* array = NULL) :
@@ -71,10 +70,8 @@ namespace mem
             return array;
         }
 
-    private:
-        // Noncopyable
-        ScopedArray(const ScopedArray& );
-        const ScopedArray& operator=(const ScopedArray& );
+        ScopedArray(const ScopedArray&) = delete;
+        ScopedArray& operator=(const ScopedArray&) = delete;
 
     private:
         T* mArray;
 
@@ -157,10 +157,10 @@ class ScratchMemory
         return mNumBytesNeeded;
     }
 
-private:
-    ScratchMemory(const ScratchMemory&);
-    ScratchMemory& operator=(const ScratchMemory&);
+    ScratchMemory(const ScratchMemory&) = delete;
+    ScratchMemory& operator=(const ScratchMemory&) = delete;
 
+private:
     struct Segment
     {
         Segment(size_t numBytes, size_t numBuffers, size_t alignment, size_t offset);
 
@@ -37,9 +37,8 @@ namespace mem
  *  \brief This class provides safe cleanup for vectors of pointers
  */
 template <typename T>
-class VectorOfPointers
+struct VectorOfPointers
 {
-public:
     VectorOfPointers()
     {
     }
@@ -149,19 +148,16 @@ class VectorOfPointers
         return mValues.erase(first, last);
     }
 
-private:
-    // Noncopyable
-    VectorOfPointers(const VectorOfPointers& );
-    const VectorOfPointers& operator=(const VectorOfPointers& );
+    VectorOfPointers(const VectorOfPointers&) = delete;
+    VectorOfPointers& operator=(const VectorOfPointers&) = delete;
 
 private:
     std::vector<T*> mValues;
 };
 
 template <typename T>
-    class VectorOfSharedPointers
+    struct VectorOfSharedPointers
 {
-public:
     VectorOfSharedPointers()
     {
     }
 
@@ -20,38 +20,34 @@
  *
  */
 
+#include <memory>
+
 #include <mem/ScopedCopyablePtr.h>
 
 #include "TestCase.h"
 
 namespace
 {
-struct Foo
+struct Foo final
 {
-    Foo()
-    : val1(0),
-      val2(0)
-    {
-    }
-
-    size_t val1;
-    size_t val2;
+    size_t val1 = 0;
+    size_t val2 = 0;
 };
 
-struct Bar
+struct Bar final
 {
-    Bar()
-    : val3(0)
-    {
-    }
-
     mem::ScopedCopyablePtr<Foo> foo;
-    size_t                      val3;
+    size_t val3 = 0;
+};
+
+struct Baz final
+{
+    std::shared_ptr<Foo> pFoo;
+    size_t val3 = 0;
 };
 
-class AssignOnDestruct
+struct AssignOnDestruct final
 {
-public:
     AssignOnDestruct(size_t &ref, size_t finalVal) :
         mRef(ref),
         mFinalVal(finalVal)
@@ -92,6 +88,25 @@ TEST_CASE(testCopyConstructor)
     TEST_ASSERT_EQ(bar1.val3, 30);
 }
 
+TEST_CASE(testSharedCopyConstructor)
+{
+    // Initialize the values
+    Baz b1;
+    b1.pFoo.reset(new Foo());
+    b1.pFoo->val1 = 10;
+    b1.pFoo->val2 = 20;
+    b1.val3 = 30;
+
+    // Show that memory is shared, not copied as with mem::ScopedCopyablePtr
+    auto b2 = b1;
+    b2.pFoo->val1 = 40;
+    b2.pFoo->val2 = 50;
+    b2.val3 = 60;
+    TEST_ASSERT_EQ(b1.pFoo->val1, 40);
+    TEST_ASSERT_EQ(b1.pFoo->val2, 50);
+    TEST_ASSERT_EQ(b1.val3, 30);
+}
+
 TEST_CASE(testAssignmentOperator)
 {
     // Initialize the values
@@ -117,6 +132,27 @@ TEST_CASE(testAssignmentOperator)
     TEST_ASSERT_EQ(bar1.val3, 30);
 }
 
+TEST_CASE(testSharedAssignmentOperator)
+{
+    // Initialize the values
+    Baz b1;
+    b1.pFoo.reset(new Foo());
+    b1.pFoo->val1 = 10;
+    b1.pFoo->val2 = 20;
+    b1.val3 = 30;
+
+    Baz b2;
+    b2 = b1;
+
+    // Show that memory is shared, not copied as with mem::ScopedCopyablePtr
+    b2.pFoo->val1 = 40;
+    b2.pFoo->val2 = 50;
+    b2.val3 = 60;
+    TEST_ASSERT_EQ(b1.pFoo->val1, 40);
+    TEST_ASSERT_EQ(b1.pFoo->val2, 50);
+    TEST_ASSERT_EQ(b1.val3, 30);
+}
+
 TEST_CASE(testDestructor)
 {
     // When the ScopedCopyablePtr goes out of scope, it should delete the
@@ -167,7 +203,9 @@ TEST_CASE(testEqualityOperator)
 int main(int, char**)
 {
     TEST_CHECK(testCopyConstructor);
+    TEST_CHECK(testSharedCopyConstructor);
     TEST_CHECK(testAssignmentOperator);
+    TEST_CHECK(testSharedAssignmentOperator);    
     TEST_CHECK(testDestructor);
     TEST_CHECK(testSyntax);
     TEST_CHECK(testEqualityOperator);
Original file line number	Diff line number	Diff line change
`@@ -157,10 +157,10 @@ class ScratchMemory`
`157`	`157`	`return mNumBytesNeeded;`
`158`	`158`	`}`
`159`	`159`
`160`		`-private:`
`161`		`- ScratchMemory(const ScratchMemory&);`
`162`		`- ScratchMemory& operator=(const ScratchMemory&);`
	`160`	`+ ScratchMemory(const ScratchMemory&) = delete;`
	`161`	`+ ScratchMemory& operator=(const ScratchMemory&) = delete;`
`163`	`162`
	`163`	`+private:`
`164`	`164`	`struct Segment`
`165`	`165`	`{`
`166`	`166`	`Segment(size_t numBytes, size_t numBuffers, size_t alignment, size_t offset);`
Original file line number	Diff line number	Diff line change
`@@ -37,9 +37,8 @@ namespace mem`
`37`	`37`	`* \brief This class provides safe cleanup for vectors of pointers`
`38`	`38`	`*/`
`39`	`39`	`template <typename T>`
`40`		`-class VectorOfPointers`
	`40`	`+struct VectorOfPointers`
`41`	`41`	`{`
`42`		`-public:`
`43`	`42`	`VectorOfPointers()`
`44`	`43`	`{`
`45`	`44`	`}`
`@@ -149,19 +148,16 @@ class VectorOfPointers`
`149`	`148`	`return mValues.erase(first, last);`
`150`	`149`	`}`
`151`	`150`
`152`		`-private:`
`153`		`- // Noncopyable`
`154`		`- VectorOfPointers(const VectorOfPointers& );`
`155`		`- const VectorOfPointers& operator=(const VectorOfPointers& );`
	`151`	`+ VectorOfPointers(const VectorOfPointers&) = delete;`
	`152`	`+ VectorOfPointers& operator=(const VectorOfPointers&) = delete;`
`156`	`153`
`157`	`154`	`private:`
`158`	`155`	`std::vector<T*> mValues;`
`159`	`156`	`};`
`160`	`157`
`161`	`158`	`template <typename T>`
`162`		`- class VectorOfSharedPointers`
	`159`	`+ struct VectorOfSharedPointers`
`163`	`160`	`{`
`164`		`-public:`
`165`	`161`	`VectorOfSharedPointers()`
`166`	`162`	`{`
`167`	`163`	`}`