From f3924b062b9e1cea30fe6055d93a89dfd03f17b9 Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Sat, 22 Jun 2019 22:23:10 -0400
Subject: [PATCH 01/17] Add datatype ids for long and unsigned long

---
 asdf_datatype.hpp | 15 +++++++++++++++
 datatype.cpp      |  2 ++
 2 files changed, 17 insertions(+)

diff --git a/asdf_datatype.hpp b/asdf_datatype.hpp
index 1621d51..7be4da9 100644
--- a/asdf_datatype.hpp
+++ b/asdf_datatype.hpp
@@ -67,6 +67,13 @@ template <> struct get_scalar_type_id<int32_t> {
 template <> struct get_scalar_type_id<int64_t> {
   constexpr static scalar_type_id_t value = id_int64;
 };
+template <> struct get_scalar_type_id<long> {
+  constexpr static scalar_type_id_t value =
+      sizeof(long) == sizeof(int32_t)
+          ? get_scalar_type_id<int32_t>::value
+          : sizeof(long) == sizeof(int64_t) ? get_scalar_type_id<int64_t>::value
+                                            : scalar_type_id_t(-1);
+};
 template <> struct get_scalar_type_id<uint8_t> {
   constexpr static scalar_type_id_t value = id_uint8;
 };
@@ -79,6 +86,14 @@ template <> struct get_scalar_type_id<uint32_t> {
 template <> struct get_scalar_type_id<uint64_t> {
   constexpr static scalar_type_id_t value = id_uint64;
 };
+template <> struct get_scalar_type_id<unsigned long> {
+  constexpr static scalar_type_id_t value =
+      sizeof(unsigned long) == sizeof(uint32_t)
+          ? get_scalar_type_id<uint32_t>::value
+          : sizeof(unsigned long) == sizeof(uint64_t)
+                ? get_scalar_type_id<uint64_t>::value
+                : scalar_type_id_t(-1);
+};
 template <> struct get_scalar_type_id<float32_t> {
   constexpr static scalar_type_id_t value = id_float32;
 };
diff --git a/datatype.cpp b/datatype.cpp
index 1323302..1a87e3c 100644
--- a/datatype.cpp
+++ b/datatype.cpp
@@ -11,10 +11,12 @@ constexpr scalar_type_id_t get_scalar_type_id<int8_t>::value;
 constexpr scalar_type_id_t get_scalar_type_id<int16_t>::value;
 constexpr scalar_type_id_t get_scalar_type_id<int32_t>::value;
 constexpr scalar_type_id_t get_scalar_type_id<int64_t>::value;
+constexpr scalar_type_id_t get_scalar_type_id<long>::value;
 constexpr scalar_type_id_t get_scalar_type_id<uint8_t>::value;
 constexpr scalar_type_id_t get_scalar_type_id<uint16_t>::value;
 constexpr scalar_type_id_t get_scalar_type_id<uint32_t>::value;
 constexpr scalar_type_id_t get_scalar_type_id<uint64_t>::value;
+constexpr scalar_type_id_t get_scalar_type_id<unsigned long>::value;
 constexpr scalar_type_id_t get_scalar_type_id<float32_t>::value;
 constexpr scalar_type_id_t get_scalar_type_id<float64_t>::value;
 constexpr scalar_type_id_t get_scalar_type_id<complex64_t>::value;

From aaae2f83fd053785f4ac89184289814f177f0a07 Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Sat, 22 Jun 2019 22:23:28 -0400
Subject: [PATCH 02/17] Reorder functions for groups

---
 asdf_group.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/asdf_group.hpp b/asdf_group.hpp
index 5d76395..933386f 100644
--- a/asdf_group.hpp
+++ b/asdf_group.hpp
@@ -46,18 +46,18 @@ class entry {
     assert(ref);
   }
 
-  entry(string name1, shared_ptr<group> grp1, string description1)
-      : name(move(name1)), grp(move(grp1)), description(move(description1)) {
-    assert(!name.empty());
-    assert(grp);
-  }
-
   entry(string name1, shared_ptr<sequence> seq1, string description1)
       : name(move(name1)), seq(move(seq1)), description(move(description1)) {
     assert(!name.empty());
     assert(seq);
   }
 
+  entry(string name1, shared_ptr<group> grp1, string description1)
+      : name(move(name1)), grp(move(grp1)), description(move(description1)) {
+    assert(!name.empty());
+    assert(grp);
+  }
+
   entry(const shared_ptr<reader_state> &rs, const YAML::Node &node);
   entry(const copy_state &cs, const entry &ent);
   writer &to_yaml(writer &w) const;

From 8cef24cbccc0a25048ca17b9a0952c1219a1f156 Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Sat, 22 Jun 2019 22:23:44 -0400
Subject: [PATCH 03/17] New function get_data_vector for ndarray

---
 asdf_ndarray.hpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/asdf_ndarray.hpp b/asdf_ndarray.hpp
index a4c97b4..abdb01e 100644
--- a/asdf_ndarray.hpp
+++ b/asdf_ndarray.hpp
@@ -187,6 +187,21 @@ class ndarray {
     return mdata;
   }
 
+  template <typename T> vector<T> get_data_vector() const {
+    assert(datatype->is_scalar);
+    assert(datatype->scalar_type_id == get_scalar_type_id<T>::value);
+    int64_t npoints = 1;
+    for (size_t d = 0; d < shape.size(); ++d)
+      npoints *= shape.at(d);
+    const T *ptr = static_cast<const T *>(mdata->ptr());
+    size_t nbytes = mdata->nbytes();
+    assert(nbytes == npoints * sizeof(T));
+    vector<T> data(npoints);
+    for (size_t i = 0; i < npoints; ++i)
+      data[i] = ptr[i];
+    return data;
+  }
+
   shared_ptr<datatype_t> get_datatype() const { return datatype; }
   vector<int64_t> get_shape() const { return shape; }
   int64_t get_offset() const { return offset; }

From e6a765a46b601a3ad701a0933d4ada8a75da3153 Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Sat, 22 Jun 2019 22:24:08 -0400
Subject: [PATCH 04/17] Add notes for calling cmake

---
 BUILD.txt | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 BUILD.txt

diff --git a/BUILD.txt b/BUILD.txt
new file mode 100644
index 0000000..21067c1
--- /dev/null
+++ b/BUILD.txt
@@ -0,0 +1,15 @@
+Redshift:
+
+mkdir build && cd build
+env "PATH=$HOME/src/spack-view/bin:$PATH" cmake -DCMAKE_INSTALL_PREFIX=$HOME/asdf-cxx -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -G Ninja ..
+
+env "PATH=$HOME/src/spack-view/bin:$PATH" cmake --build .
+for lib in *.so; do install_name_tool -change '@rpath/libyaml-cpp.0.6.dylib' "$HOME/src/spack-view/lib/libyaml-cpp.0.6.2.dylib" $lib; done
+for exe in ./asdf-*; do install_name_tool -change '@rpath/libyaml-cpp.0.6.dylib' "$HOME/src/spack-view/lib/libyaml-cpp.0.6.2.dylib" $exe; done
+
+env "PATH=$HOME/src/spack-view/bin:$PATH" "DYLD_LIBRARY_PATH=$HOME/src/spack-view/lib:$DYLD_LIBRARY_PATH" ./test_RegionCalculus
+env "PATH=$HOME/src/spack-view/bin:$PATH" "DYLD_LIBRARY_PATH=$HOME/src/spack-view/lib:$DYLD_LIBRARY_PATH" ./test_SimulationIO
+
+env "PATH=$HOME/src/spack-view/bin:$PATH" "DYLD_LIBRARY_PATH=$HOME/src/spack-view/lib:$DYLD_LIBRARY_PATH" "PYTHONHOME=$HOME/src/spack-view" "PYTHONPATH=$(pwd)" $HOME/src/spack-view/bin/python ../demo-python.py
+
+env "PATH=$HOME/src/spack-view/bin:$PATH" cmake --build . --target install

From 50e439b35a2e76e29f8a6bb2bde6dc8ac39417c4 Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Sat, 22 Jun 2019 22:24:29 -0400
Subject: [PATCH 05/17] Add SWIG Python bindings

---
 CMakeLists.txt |  47 ++++++-
 asdf.i         | 352 +++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 398 insertions(+), 1 deletion(-)
 create mode 100644 asdf.i

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f6e7e20..6b72b84 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -57,6 +57,22 @@ else()
   set(HAVE_ZLIB 0)
 endif()
 
+set(Python_ADDITIONAL_VERSIONS 3.0)
+# This sets PYTHONINTERP_FOUND
+find_package(PythonInterp)
+# This sets PYTHONLIBS_FOUND
+find_package(PythonLibs)
+if(PYTHONINTERP_FOUND AND PYTHONLIBS_FOUND)
+  include_directories(${PYTHON_INCLUDE_DIRS})
+endif()
+
+if(PYTHONINTERP_FOUND AND PYTHONLIBS_FOUND)
+  find_package(SWIG)
+endif()
+if(SWIG_FOUND)
+  include(${SWIG_USE_FILE})
+endif()
+
 # Main project
 
 set(CMAKE_CXX_STANDARD 11)
@@ -115,6 +131,14 @@ target_link_libraries(asdf-demo-large asdf-cxx ${LIBS})
 add_executable(asdf-ls ls.cpp)
 target_link_libraries(asdf-ls asdf-cxx ${LIBS})
 
+# SWIG bindings
+
+if(PYTHONINTERP_FOUND AND PYTHONLIBS_FOUND AND SWIG_FOUND)
+  set_source_files_properties(asdf.i PROPERTIES CPLUSPLUS ON)
+  swig_add_library(asdf LANGUAGE python SOURCES asdf.i)
+  swig_link_libraries(asdf asdf-cxx ${LIBS} ${PYTHON_LIBRARIES})
+endif()
+
 # Tests
 
 enable_testing()
@@ -124,9 +148,26 @@ add_test(NAME copy COMMAND ./asdf-copy demo.asdf demo2.asdf)
 add_test(NAME ls2 COMMAND ./asdf-ls demo2.asdf)
 add_test(NAME compare
   COMMAND ${CMAKE_SOURCE_DIR}/diff-commands.sh
-            "./asdf-ls demo.asdf" "./asdf-ls demo2.asdf")
+  "./asdf-ls demo.asdf" "./asdf-ls demo2.asdf")
 add_test(NAME external COMMAND ./asdf-demo-external)
 
+if(PYTHONINTERP_FOUND AND PYTHONLIBS_FOUND AND SWIG_FOUND)
+  add_test(NAME demo-python
+    COMMAND
+    env "PYTHONPATH=${PROJECT_BINARY_DIR}:$ENV{PYTHONPATH}"
+    ${PYTHON_EXECUTABLE} "${PROJECT_SOURCE_DIR}/asdf-demo-python.py")
+  add_test(NAME compare
+    COMMAND ${CMAKE_SOURCE_DIR}/diff-commands.sh
+    "./asdf-ls demo.asdf" "./asdf-ls demo-python.asdf")
+  add_test(NAME demo-external-python
+    COMMAND
+    env "PYTHONPATH=${PROJECT_BINARY_DIR}:$ENV{PYTHONPATH}"
+    ${PYTHON_EXECUTABLE} "${PROJECT_SOURCE_DIR}/asdf-demo-external-python.py")
+  add_test(NAME compare
+    COMMAND ${CMAKE_SOURCE_DIR}/diff-commands.sh
+    "./asdf-ls demo-external.asdf" "./asdf-ls demo-external-python.asdf")
+endif()
+
 # Coverage
 
 # We don't want this to run on every build
@@ -145,6 +186,10 @@ install(FILES "${PROJECT_BINARY_DIR}/asdf_config.hpp" DESTINATION include)
 install(TARGETS asdf-cxx DESTINATION lib)
 install(TARGETS asdf-copy asdf-demo asdf-demo-external asdf-demo-large asdf-ls
   DESTINATION bin)
+if(PYTHONINTERP_FOUND AND PYTHONLIBS_FOUND AND SWIG_FOUND)
+  install(PROGRAMS asdf-demo-python.py asdf-demo-external-python.py
+    DESTINATION bin)
+endif()
 
 set(PKG_CONFIG_REQUIRES "yaml-cpp")
 set(PKG_CONFIG_INCLUDEDIR "\${prefix}/include")
diff --git a/asdf.i b/asdf.i
new file mode 100644
index 0000000..e188cc3
--- /dev/null
+++ b/asdf.i
@@ -0,0 +1,352 @@
+// SWIG interface file
+
+%module asdf
+
+%{
+  #include "asdf.hpp"
+  using namespace ASDF;
+%}
+
+%include <std_complex.i>
+%include <std_map.i>
+%include <std_shared_ptr.i>
+%include <std_string.i>
+%include <std_vector.i>
+
+using std::string;
+
+%shared_ptr(asdf);
+%shared_ptr(datatype_t);
+%shared_ptr(entry);
+%shared_ptr(field_t);
+%shared_ptr(group);
+%shared_ptr(ndarray);
+%shared_ptr(reference);
+%shared_ptr(sequence);
+%shared_ptr(std::vector<long long>);
+
+%template(map_string_string)
+  std::map<string, string>;
+%template(map_string_shared_ptr_entry)
+  std::map<string, std::shared_ptr<entry>>;
+%template(map_string_shared_ptr_ndarray)
+  std::map<string, std::shared_ptr<ndarray>>;
+
+%template(vector_bool) std::vector<bool>;
+%template(vector_complex_float) std::vector<std::complex<float>>;
+%template(vector_complex_double) std::vector<std::complex<double>>;
+%template(vector_double) std::vector<double>;
+%template(vector_float) std::vector<float>;
+// %template(vector_int32_t) std::vector<int32_t>;
+// %template(vector_int64_t) std::vector<int64_t>;
+%template(vector_int) std::vector<int>;
+%template(vector_long_long) std::vector<long long>;
+%template(vector_shared_ptr_entry) std::vector<std::shared_ptr<entry>>;
+%template(vector_string) std::vector<string>;
+
+%nodefaultctor;
+
+
+
+enum class block_format_t { undefined, block, inline_array };
+enum class compression_t { undefined, none, bzip2, zlib };
+
+
+
+%{
+struct reader_state_node {
+  std::shared_ptr<reader_state> rs;
+  YAML::Node node;
+};
+%}
+struct reader_state_node {
+};
+
+
+
+enum scalar_type_id_t {
+  id_bool8,
+  id_int8,
+  id_int16,
+  id_int32,
+  id_int64,
+  id_uint8,
+  id_uint16,
+  id_uint32,
+  id_uint64,
+  id_float32,
+  id_float64,
+  id_complex64,
+  id_complex128,
+  id_ascii,
+  id_ucs4,
+};
+
+%{
+  constexpr scalar_type_id_t scalar_type_id_int32() { return get_scalar_type_id<int32_t>::value; }
+  constexpr scalar_type_id_t scalar_type_id_int64() { return get_scalar_type_id<int64_t>::value; }
+  constexpr scalar_type_id_t scalar_type_id_float32() { return get_scalar_type_id<float32_t>::value; }
+  constexpr scalar_type_id_t scalar_type_id_float64() { return get_scalar_type_id<float64_t>::value; }
+  constexpr scalar_type_id_t scalar_type_id_complex64() { return get_scalar_type_id<complex64_t>::value; }
+  constexpr scalar_type_id_t scalar_type_id_complex128() { return get_scalar_type_id<complex128_t>::value; }
+%}
+constexpr scalar_type_id_t scalar_type_id_int32();
+constexpr scalar_type_id_t scalar_type_id_int64();
+constexpr scalar_type_id_t scalar_type_id_float32();
+constexpr scalar_type_id_t scalar_type_id_float64();
+constexpr scalar_type_id_t scalar_type_id_complex64();
+constexpr scalar_type_id_t scalar_type_id_complex128();
+
+class datatype_t;
+
+class field_t {
+ public:
+};
+
+class datatype_t {
+ public:
+  bool is_scalar;
+  scalar_type_id_t scalar_type_id;
+  // std::vector<std::shared_ptr<field_t>> fields;
+};
+
+
+
+class ndarray {
+ public:
+
+  %extend {
+    // TODO: accept bool
+    static std::shared_ptr<ndarray>
+      create_bool(const std::vector<long long>& data1,
+                  block_format_t block_format,
+                  compression_t compression,
+                  int compression_level,
+                  std::vector<bool> mask,
+                  std::vector<long long> shape)
+    {
+      // TODO: Avoid this copy
+      std::vector<bool> data(data1.size());
+      for (size_t i=0; i<data.size(); ++i)
+        data[i] = data1[i];
+      return std::make_shared<ndarray>
+        (std::move(data), block_format, compression, compression_level,
+         std::move(mask), std::move(shape));
+    }
+    static std::shared_ptr<ndarray>
+      create_int64(std::vector<long long> data,
+                   block_format_t block_format,
+                   compression_t compression,
+                   int compression_level,
+                   std::vector<bool> mask,
+                   std::vector<long long> shape)
+    {
+      return std::make_shared<ndarray>
+        (std::move(data), block_format, compression, compression_level,
+         std::move(mask), std::move(shape));
+    }
+    static std::shared_ptr<ndarray>
+      create_float64(std::vector<double> data,
+                     block_format_t block_format,
+                     compression_t compression,
+                     int compression_level,
+                     std::vector<bool> mask,
+                     std::vector<long long> shape)
+    {
+      return std::make_shared<ndarray>
+        (std::move(data), block_format, compression, compression_level,
+         std::move(mask), std::move(shape));
+    }
+    static std::shared_ptr<ndarray>
+      create_complex128(std::vector<std::complex<double>> data,
+                        block_format_t block_format,
+                        compression_t compression,
+                        int compression_level,
+                        std::vector<bool> mask,
+                        std::vector<long long> shape)
+    {
+      return std::make_shared<ndarray>
+        (std::move(data), block_format, compression, compression_level,
+         std::move(mask), std::move(shape));
+    }
+
+    static std::shared_ptr<ndarray>
+      read(const reader_state_node &&rs_node)
+    {
+      return std::make_shared<ndarray>(rs_node.rs, rs_node.node);
+    }
+  }
+
+  %extend {
+    std::vector<int> get_data_vector_int32() const
+    {
+      return self->get_data_vector<int32_t>();
+    }
+    std::vector<long long> get_data_vector_int64() const
+    {
+      return self->get_data_vector<int64_t>();
+    }
+    std::vector<float> get_data_vector_float32() const
+    {
+      return self->get_data_vector<float32_t>();
+    }
+    std::vector<double> get_data_vector_float64() const
+    {
+      return self->get_data_vector<float64_t>();
+    }
+    std::vector<std::complex<float>> get_data_vector_complex64() const
+    {
+      return self->get_data_vector<complex64_t>();
+    }
+    std::vector<std::complex<double>> get_data_vector_complex128() const
+    {
+      return self->get_data_vector<complex128_t>();
+    }
+  }
+
+  std::shared_ptr<datatype_t> get_datatype() const;
+  std::vector<long long> get_shape() const;
+  int64_t get_offset() const;
+  std::vector<long long> get_strides() const;
+};
+
+
+
+class reference {
+ public:
+
+  %extend {
+    static std::shared_ptr<reference>
+      create_from_target(string target)
+    {
+      return std::make_shared<reference>(std::move(target));
+    }
+    static std::shared_ptr<reference>
+      create_from_path(const string &base_target,
+                       const std::vector<string> &doc_path)
+    {
+      return std::make_shared<reference>(base_target, doc_path);
+    }
+    static std::shared_ptr<reference>
+      create_from_reader_state_node(const reader_state_node &rs_node)
+    {
+      return std::make_shared<reference>(rs_node.rs, rs_node.node);
+    }
+  }
+
+  string get_target() const;
+  std::pair<string, std::vector<string>> get_split_target() const;
+
+  %extend {
+    reader_state_node resolve() const
+    {
+      auto rs_node = self->resolve();
+      return reader_state_node{std::get<0>(rs_node), std::get<1>(rs_node)};
+    }
+  }
+};
+
+
+
+class sequence;
+class group;
+
+class entry {
+ public:
+
+  %extend {
+    static std::shared_ptr<entry>
+      create_from_ndarray(const string& name,
+                          const std::shared_ptr<ndarray>& arr,
+                          const string& description)
+    {
+      return std::make_shared<entry>(name, arr, description);
+    }
+    static std::shared_ptr<entry>
+      create_from_reference(const string& name,
+                            const std::shared_ptr<reference>& ref,
+                            const string& description)
+    {
+      return std::make_shared<entry>(name, ref, description);
+    }
+    static std::shared_ptr<entry>
+      create_from_sequence(const string& name,
+                           const std::shared_ptr<sequence>& seq,
+                           const string& description)
+    {
+      return std::make_shared<entry>(name, seq, description);
+    }
+    static std::shared_ptr<entry>
+      create_from_group(const string& name,
+                        const std::shared_ptr<group>& grp,
+                        const string& description)
+    {
+      return std::make_shared<entry>(name, grp, description);
+    }
+  }
+
+  string get_name() const;
+  std::shared_ptr<ndarray> get_array() const;
+  std::shared_ptr<reference> get_reference() const;
+  std::shared_ptr<sequence> get_sequence() const;
+  std::shared_ptr<group> get_group() const;
+  string get_description() const;
+};
+
+class sequence {
+ public:
+
+  %extend {
+    static std::shared_ptr<sequence>
+      create(std::vector<std::shared_ptr<entry>> entries)
+    {
+      return std::make_shared<sequence>(std::move(entries));
+    }
+  }
+
+  const vector<shared_ptr<entry>> &get_entries() const;
+};
+
+class group {
+ public:
+
+  %extend {
+    static std::shared_ptr<group>
+      create(std::map<string, std::shared_ptr<entry>> entries)
+    {
+      return std::make_shared<group>(std::move(entries));
+    }
+  }
+
+  const std::map<string, std::shared_ptr<entry>> &get_entries() const;
+};
+
+
+
+class asdf {
+ public:
+
+  %extend {
+    static std::shared_ptr<asdf>
+      create_from_ndarrays(std::map<string, string> tags,
+                           std::map<string, std::shared_ptr<ndarray>> data)
+    {
+      return std::make_shared<asdf>(std::move(tags), std::move(data));
+    }
+    static std::shared_ptr<asdf>
+      create_from_group(std::map<string, string> tags,
+                        std::shared_ptr<group> grp)
+    {
+      return std::make_shared<asdf>(std::move(tags), std::move(grp));
+    }
+    static std::shared_ptr<asdf>
+      read(const string &filename)
+    {
+      return std::make_shared<asdf>(filename);
+    }
+  }
+
+  void write(const string &filename) const;
+
+  std::shared_ptr<group> get_group() const;
+};

From 7892a7b36d8f8131541edf5c83c5c840dc8d64a7 Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Sat, 22 Jun 2019 22:24:38 -0400
Subject: [PATCH 06/17] Add Python tests

---
 demo-external-python.py | 90 +++++++++++++++++++++++++++++++++++++++++
 demo-python.py          | 68 +++++++++++++++++++++++++++++++
 2 files changed, 158 insertions(+)
 create mode 100755 demo-external-python.py
 create mode 100755 demo-python.py

diff --git a/demo-external-python.py b/demo-external-python.py
new file mode 100755
index 0000000..1c4ead0
--- /dev/null
+++ b/demo-external-python.py
@@ -0,0 +1,90 @@
+#! /usr/bin/env python
+
+from __future__ import print_function
+import numpy as np
+
+from asdf import *
+
+
+
+def write_external():
+    print("Writing external file...")
+
+    # The actual dataset
+    alpha = ndarray.create_int64(
+        np.array([1, 2, 3], np.int64), block_format_t_inline_array,
+        compression_t_none, 0, np.array([]), [3])
+    # A local reference
+    beta = reference.create_from_path("", ["group", "alpha", "data"])
+
+    grp = group.create(
+        {"alpha": entry.create_from_ndarray("alpha", alpha, ""),
+         "beta": entry.create_from_reference("beta", beta, "")})
+
+    project = asdf.create_from_group({}, grp)
+    project.write("external.asdf")
+
+
+
+def write_metadata():
+    print("Writing metadata file...")
+
+    # A remote reference
+    gamma = reference.create_from_path("external.asdf",
+                                       ["group", "alpha", "data"])
+    # A local reference
+    delta = reference.create_from_path("", ["group", "gamma", "reference"])
+    # A remote reference to a local reference
+    epsilon = reference.create_from_path("external.asdf",
+                                         ["group", "beta", "reference"])
+
+    grp = group.create(
+        {"gamma": entry.create_from_reference("gamma", gamma, ""),
+         "delta": entry.create_from_reference("delta", delta, ""),
+         "epsilon": entry.create_from_reference("epsilon", epsilon, "")})
+
+    project = asdf.create_from_group({}, grp)
+    project.write("metadata.asdf")
+
+
+
+def read_metadata():
+    print("Reading metadata file...")
+
+    project = asdf.read("metadata.asdf")
+    grp = project.get_group()
+
+    gamma = grp.get_entries()["gamma"].get_reference()
+    print("gamma: <" + gamma.get_target() + ">")
+    rs_node = gamma.resolve()
+    arr = ndarray.read(rs_node)
+    print("gamma': [ndarray] " + str(arr.get_data_vector_int64()))
+
+    delta = grp.get_entries()["delta"].get_reference()
+    print("delta: <" + delta.get_target() + ">")
+    rs_node = delta.resolve()
+    ref = reference.create_from_reader_state_node(rs_node)
+    print("delta': [reference] " + ref.get_target())
+    rs_node1 = ref.resolve()
+    arr = ndarray.read(rs_node1)
+    print("delta'': [ndarray] " + str(arr.get_data_vector_int64()))
+  
+    epsilon = grp.get_entries()["epsilon"].get_reference()
+    print("epsilon: <" + epsilon.get_target() + ">")
+    rs_node = epsilon.resolve()
+    ref = reference.create_from_reader_state_node(rs_node)
+    print("epsilon': [reference] " + ref.get_target())
+    rs_node1 = ref.resolve()
+    arr = ndarray.read(rs_node1)
+    print("epsilon'': [ndarray] " + str(arr.get_data_vector_int64()))
+
+
+
+print("asdf-demo-external-python:")
+print("    Create a simple ASDF file with external references from Python")
+
+write_external()
+write_metadata()
+read_metadata()
+
+print("Done.")
diff --git a/demo-python.py b/demo-python.py
new file mode 100755
index 0000000..95e657a
--- /dev/null
+++ b/demo-python.py
@@ -0,0 +1,68 @@
+#! /usr/bin/env python
+
+from __future__ import print_function
+import numpy as np
+
+from asdf import *
+
+print("asdf-demo-python: Create a simple ASDF file from Python")
+
+array0d = ndarray.create_int64(np.array([42], np.int64),
+                               block_format_t_inline_array,
+                               compression_t_none,
+                               0,
+                               np.array([]),
+                               np.array([]))
+ent0 = entry.create_from_ndarray("alpha", array0d, "")
+
+array1d = ndarray.create_int64(np.array([1, 2, 3], np.int64),
+                               block_format_t_block,
+                               compression_t_none,
+                               0,
+                               np.array([]),
+                               np.array([3]))
+ent1 = entry.create_from_ndarray("beta", array1d, "")
+
+array2d = ndarray.create_float64(np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0],
+                                          np.float64),
+                                 block_format_t_inline_array,
+                                 compression_t_none, 0,
+                                 np.array([]),
+                                 np.array([2, 3]))
+ent2 = entry.create_from_ndarray("gamma", array2d, "")
+
+array3d = ndarray.create_complex128(np.array([1, -2, 3j, -4j, 5 + 1j, 6 - 1j],
+                                             np.complex128),
+                                    block_format_t_block,
+                                    compression_t_bzip2,
+                                    9,
+                                    np.array([]),
+                                    np.array([1, 2, 3]))
+ent3 = entry.create_from_ndarray("delta", array3d, "")
+
+array8d = ndarray.create_bool(np.array([True], np.int),
+                              block_format_t_block,
+                              compression_t_zlib,
+                              9,
+                              np.array([]),
+                              np.array([1, 1, 1, 1, 1, 1, 1, 1]))
+ent8 = entry.create_from_ndarray("epsilon", array8d, "")
+
+seq = sequence.create([ent0, ent1, ent2])
+ents = entry.create_from_sequence("zeta", seq, "")
+
+ref = reference.create_from_path("", ["group", "1"])
+entr = entry.create_from_reference("eta", ref, "")
+
+grp = group.create({"alpha": ent0,
+                    "beta": ent1,
+                    "gamma": ent2,
+                    "delta": ent3,
+                    "epsilon": ent8,
+                    "zeta": ents,
+                    "eta": entr})
+
+project = asdf.create_from_group({}, grp)
+project.write("demo-python.asdf")
+
+print("Done.")

From dc799395b7393e46be660be0d054a67d67801ae5 Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Sat, 22 Jun 2019 23:58:09 -0400
Subject: [PATCH 07/17] Rewrite type traits

---
 BUILD.txt         |   4 +-
 CMakeLists.txt    |   8 ++--
 asdf.i            |  24 +++++-----
 asdf_datatype.hpp | 114 +++++++++++++++++++++-------------------------
 asdf_ndarray.hpp  |   4 +-
 datatype.cpp      |  79 ++++++++++++--------------------
 demo-external.cpp |   2 +-
 demo.cpp          |   8 ++--
 ndarray.cpp       |   4 +-
 9 files changed, 110 insertions(+), 137 deletions(-)

diff --git a/BUILD.txt b/BUILD.txt
index 21067c1..3fa6aa6 100644
--- a/BUILD.txt
+++ b/BUILD.txt
@@ -7,8 +7,8 @@ env "PATH=$HOME/src/spack-view/bin:$PATH" cmake --build .
 for lib in *.so; do install_name_tool -change '@rpath/libyaml-cpp.0.6.dylib' "$HOME/src/spack-view/lib/libyaml-cpp.0.6.2.dylib" $lib; done
 for exe in ./asdf-*; do install_name_tool -change '@rpath/libyaml-cpp.0.6.dylib' "$HOME/src/spack-view/lib/libyaml-cpp.0.6.2.dylib" $exe; done
 
-env "PATH=$HOME/src/spack-view/bin:$PATH" "DYLD_LIBRARY_PATH=$HOME/src/spack-view/lib:$DYLD_LIBRARY_PATH" ./test_RegionCalculus
-env "PATH=$HOME/src/spack-view/bin:$PATH" "DYLD_LIBRARY_PATH=$HOME/src/spack-view/lib:$DYLD_LIBRARY_PATH" ./test_SimulationIO
+env "PATH=$HOME/src/spack-view/bin:$PATH" "DYLD_LIBRARY_PATH=$HOME/src/spack-view/lib:$DYLD_LIBRARY_PATH" ./asdf-demo
+env "PATH=$HOME/src/spack-view/bin:$PATH" "DYLD_LIBRARY_PATH=$HOME/src/spack-view/lib:$DYLD_LIBRARY_PATH" ./asdf-demo-external
 
 env "PATH=$HOME/src/spack-view/bin:$PATH" "DYLD_LIBRARY_PATH=$HOME/src/spack-view/lib:$DYLD_LIBRARY_PATH" "PYTHONHOME=$HOME/src/spack-view" "PYTHONPATH=$(pwd)" $HOME/src/spack-view/bin/python ../demo-python.py
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6b72b84..afe3201 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -75,7 +75,7 @@ endif()
 
 # Main project
 
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 string(REPLACE "-DNDEBUG" ""
@@ -146,7 +146,7 @@ add_test(NAME demo COMMAND ./asdf-demo)
 add_test(NAME ls COMMAND ./asdf-ls demo.asdf)
 add_test(NAME copy COMMAND ./asdf-copy demo.asdf demo2.asdf)
 add_test(NAME ls2 COMMAND ./asdf-ls demo2.asdf)
-add_test(NAME compare
+add_test(NAME compare-demo
   COMMAND ${CMAKE_SOURCE_DIR}/diff-commands.sh
   "./asdf-ls demo.asdf" "./asdf-ls demo2.asdf")
 add_test(NAME external COMMAND ./asdf-demo-external)
@@ -156,14 +156,14 @@ if(PYTHONINTERP_FOUND AND PYTHONLIBS_FOUND AND SWIG_FOUND)
     COMMAND
     env "PYTHONPATH=${PROJECT_BINARY_DIR}:$ENV{PYTHONPATH}"
     ${PYTHON_EXECUTABLE} "${PROJECT_SOURCE_DIR}/asdf-demo-python.py")
-  add_test(NAME compare
+  add_test(NAME compare-demo-python
     COMMAND ${CMAKE_SOURCE_DIR}/diff-commands.sh
     "./asdf-ls demo.asdf" "./asdf-ls demo-python.asdf")
   add_test(NAME demo-external-python
     COMMAND
     env "PYTHONPATH=${PROJECT_BINARY_DIR}:$ENV{PYTHONPATH}"
     ${PYTHON_EXECUTABLE} "${PROJECT_SOURCE_DIR}/asdf-demo-external-python.py")
-  add_test(NAME compare
+  add_test(NAME compare-demo-external-python
     COMMAND ${CMAKE_SOURCE_DIR}/diff-commands.sh
     "./asdf-ls demo-external.asdf" "./asdf-ls demo-external-python.asdf")
 endif()
diff --git a/asdf.i b/asdf.i
index e188cc3..c756db1 100644
--- a/asdf.i
+++ b/asdf.i
@@ -83,19 +83,19 @@ enum scalar_type_id_t {
 };
 
 %{
-  constexpr scalar_type_id_t scalar_type_id_int32() { return get_scalar_type_id<int32_t>::value; }
-  constexpr scalar_type_id_t scalar_type_id_int64() { return get_scalar_type_id<int64_t>::value; }
-  constexpr scalar_type_id_t scalar_type_id_float32() { return get_scalar_type_id<float32_t>::value; }
-  constexpr scalar_type_id_t scalar_type_id_float64() { return get_scalar_type_id<float64_t>::value; }
-  constexpr scalar_type_id_t scalar_type_id_complex64() { return get_scalar_type_id<complex64_t>::value; }
-  constexpr scalar_type_id_t scalar_type_id_complex128() { return get_scalar_type_id<complex128_t>::value; }
+  constexpr scalar_type_id_t get_scalar_type_id_int32() { return get_scalar_type_id<int32_t>(); }
+  constexpr scalar_type_id_t get_scalar_type_id_int64() { return get_scalar_type_id<int64_t>(); }
+  constexpr scalar_type_id_t get_scalar_type_id_float32() { return get_scalar_type_id<float32_t>(); }
+  constexpr scalar_type_id_t get_scalar_type_id_float64() { return get_scalar_type_id<float64_t>(); }
+  constexpr scalar_type_id_t get_scalar_type_id_complex64() { return get_scalar_type_id<complex64_t>(); }
+  constexpr scalar_type_id_t get_scalar_type_id_complex128() { return get_scalar_type_id<complex128_t>(); }
 %}
-constexpr scalar_type_id_t scalar_type_id_int32();
-constexpr scalar_type_id_t scalar_type_id_int64();
-constexpr scalar_type_id_t scalar_type_id_float32();
-constexpr scalar_type_id_t scalar_type_id_float64();
-constexpr scalar_type_id_t scalar_type_id_complex64();
-constexpr scalar_type_id_t scalar_type_id_complex128();
+constexpr scalar_type_id_t get_scalar_type_id_int32();
+constexpr scalar_type_id_t get_scalar_type_id_int64();
+constexpr scalar_type_id_t get_scalar_type_id_float32();
+constexpr scalar_type_id_t get_scalar_type_id_float64();
+constexpr scalar_type_id_t get_scalar_type_id_complex64();
+constexpr scalar_type_id_t get_scalar_type_id_complex128();
 
 class datatype_t;
 
diff --git a/asdf_datatype.hpp b/asdf_datatype.hpp
index 7be4da9..44ab61b 100644
--- a/asdf_datatype.hpp
+++ b/asdf_datatype.hpp
@@ -7,6 +7,7 @@
 #include <yaml-cpp/yaml.h>
 
 #include <complex>
+#include <type_traits>
 #include <vector>
 
 namespace ASDF {
@@ -16,6 +17,7 @@ using namespace std;
 
 // Define an id for every type
 enum scalar_type_id_t {
+  id_error = -1,
   id_bool8,
   id_int8,
   id_int16,
@@ -51,67 +53,57 @@ typedef vector<unsigned char> ascii_t;
 typedef vector<char32_t> ucs4_t;
 
 // Convert a type to its id enum
-template <typename> struct get_scalar_type_id;
-template <> struct get_scalar_type_id<bool8_t> {
-  constexpr static scalar_type_id_t value = id_bool8;
-};
-template <> struct get_scalar_type_id<int8_t> {
-  constexpr static scalar_type_id_t value = id_int8;
-};
-template <> struct get_scalar_type_id<int16_t> {
-  constexpr static scalar_type_id_t value = id_int16;
-};
-template <> struct get_scalar_type_id<int32_t> {
-  constexpr static scalar_type_id_t value = id_int32;
-};
-template <> struct get_scalar_type_id<int64_t> {
-  constexpr static scalar_type_id_t value = id_int64;
-};
-template <> struct get_scalar_type_id<long> {
-  constexpr static scalar_type_id_t value =
-      sizeof(long) == sizeof(int32_t)
-          ? get_scalar_type_id<int32_t>::value
-          : sizeof(long) == sizeof(int64_t) ? get_scalar_type_id<int64_t>::value
-                                            : scalar_type_id_t(-1);
-};
-template <> struct get_scalar_type_id<uint8_t> {
-  constexpr static scalar_type_id_t value = id_uint8;
-};
-template <> struct get_scalar_type_id<uint16_t> {
-  constexpr static scalar_type_id_t value = id_uint16;
-};
-template <> struct get_scalar_type_id<uint32_t> {
-  constexpr static scalar_type_id_t value = id_uint32;
-};
-template <> struct get_scalar_type_id<uint64_t> {
-  constexpr static scalar_type_id_t value = id_uint64;
-};
-template <> struct get_scalar_type_id<unsigned long> {
-  constexpr static scalar_type_id_t value =
-      sizeof(unsigned long) == sizeof(uint32_t)
-          ? get_scalar_type_id<uint32_t>::value
-          : sizeof(unsigned long) == sizeof(uint64_t)
-                ? get_scalar_type_id<uint64_t>::value
-                : scalar_type_id_t(-1);
-};
-template <> struct get_scalar_type_id<float32_t> {
-  constexpr static scalar_type_id_t value = id_float32;
-};
-template <> struct get_scalar_type_id<float64_t> {
-  constexpr static scalar_type_id_t value = id_float64;
-};
-template <> struct get_scalar_type_id<complex64_t> {
-  constexpr static scalar_type_id_t value = id_complex64;
-};
-template <> struct get_scalar_type_id<complex128_t> {
-  constexpr static scalar_type_id_t value = id_complex128;
-};
-template <> struct get_scalar_type_id<ascii_t> {
-  constexpr static scalar_type_id_t value = id_ascii;
-};
-template <> struct get_scalar_type_id<ucs4_t> {
-  constexpr static scalar_type_id_t value = id_ucs4;
-};
+namespace {
+template <typename T> struct is_complex : false_type {};
+template <typename T> struct is_complex<complex<T>> : is_floating_point<T> {};
+template <typename T> inline constexpr bool is_complex_v = is_complex<T>::value;
+} // namespace
+
+template <typename T> inline constexpr scalar_type_id_t get_scalar_type_id() {
+  if (is_same_v<T, bool8_t>)
+    return id_bool8;
+  if (is_integral_v<T> && is_signed_v<T>) {
+    if (sizeof(T) == 1)
+      return id_int8;
+    if (sizeof(T) == 2)
+      return id_int16;
+    if (sizeof(T) == 4)
+      return id_int32;
+    if (sizeof(T) == 8)
+      return id_int64;
+    return id_error;
+  }
+  if (is_integral_v<T> && is_unsigned_v<T>) {
+    if (sizeof(T) == 1)
+      return id_uint8;
+    if (sizeof(T) == 2)
+      return id_uint16;
+    if (sizeof(T) == 4)
+      return id_uint32;
+    if (sizeof(T) == 8)
+      return id_uint64;
+    return id_error;
+  }
+  if (is_floating_point_v<T>) {
+    if (sizeof(T) == 4)
+      return id_float32;
+    if (sizeof(T) == 8)
+      return id_float64;
+    return id_error;
+  }
+  if (is_complex_v<T>) {
+    if (sizeof(T) == 8)
+      return id_complex64;
+    if (sizeof(T) == 16)
+      return id_complex128;
+    return id_error;
+  }
+  if (is_same_v<T, ascii_t>)
+    return id_ascii;
+  if (is_same_v<T, ucs4_t>)
+    return id_ucs4;
+  return id_error;
+}
 
 // Convert an enum id to its type
 template <size_t> struct get_scalar_type;
diff --git a/asdf_ndarray.hpp b/asdf_ndarray.hpp
index abdb01e..9d41128 100644
--- a/asdf_ndarray.hpp
+++ b/asdf_ndarray.hpp
@@ -164,7 +164,7 @@ class ndarray {
       : ndarray(make_constant_memoized(shared_ptr<block_t>(
                     make_shared<typed_block_t<T>>(move(data1)))),
                 block_format, compression, compression_level, move(mask1),
-                make_shared<datatype_t>(get_scalar_type_id<T>::value),
+                make_shared<datatype_t>(get_scalar_type_id<T>()),
                 host_byteorder(), move(shape1), offset, move(strides1)) {}
 
   ndarray(const shared_ptr<reader_state> &rs, const YAML::Node &node);
@@ -189,7 +189,7 @@ class ndarray {
 
   template <typename T> vector<T> get_data_vector() const {
     assert(datatype->is_scalar);
-    assert(datatype->scalar_type_id == get_scalar_type_id<T>::value);
+    assert(datatype->scalar_type_id == get_scalar_type_id<T>());
     int64_t npoints = 1;
     for (size_t d = 0; d < shape.size(); ++d)
       npoints *= shape.at(d);
diff --git a/datatype.cpp b/datatype.cpp
index 1a87e3c..a54abfc 100644
--- a/datatype.cpp
+++ b/datatype.cpp
@@ -6,57 +6,38 @@ namespace ASDF {
 
 // Scalar types
 
-constexpr scalar_type_id_t get_scalar_type_id<bool8_t>::value;
-constexpr scalar_type_id_t get_scalar_type_id<int8_t>::value;
-constexpr scalar_type_id_t get_scalar_type_id<int16_t>::value;
-constexpr scalar_type_id_t get_scalar_type_id<int32_t>::value;
-constexpr scalar_type_id_t get_scalar_type_id<int64_t>::value;
-constexpr scalar_type_id_t get_scalar_type_id<long>::value;
-constexpr scalar_type_id_t get_scalar_type_id<uint8_t>::value;
-constexpr scalar_type_id_t get_scalar_type_id<uint16_t>::value;
-constexpr scalar_type_id_t get_scalar_type_id<uint32_t>::value;
-constexpr scalar_type_id_t get_scalar_type_id<uint64_t>::value;
-constexpr scalar_type_id_t get_scalar_type_id<unsigned long>::value;
-constexpr scalar_type_id_t get_scalar_type_id<float32_t>::value;
-constexpr scalar_type_id_t get_scalar_type_id<float64_t>::value;
-constexpr scalar_type_id_t get_scalar_type_id<complex64_t>::value;
-constexpr scalar_type_id_t get_scalar_type_id<complex128_t>::value;
-constexpr scalar_type_id_t get_scalar_type_id<ascii_t>::value;
-constexpr scalar_type_id_t get_scalar_type_id<ucs4_t>::value;
-
 // Check consistency between id enum and tuple element
-static_assert(is_same<get_scalar_type_t<id_bool8>, bool8_t>::value, "");
-static_assert(is_same<get_scalar_type_t<id_int8>, int8_t>::value, "");
-static_assert(is_same<get_scalar_type_t<id_int16>, int16_t>::value, "");
-static_assert(is_same<get_scalar_type_t<id_int32>, int32_t>::value, "");
-static_assert(is_same<get_scalar_type_t<id_int64>, int64_t>::value, "");
-static_assert(is_same<get_scalar_type_t<id_uint8>, uint8_t>::value, "");
-static_assert(is_same<get_scalar_type_t<id_uint16>, uint16_t>::value, "");
-static_assert(is_same<get_scalar_type_t<id_uint32>, uint32_t>::value, "");
-static_assert(is_same<get_scalar_type_t<id_uint64>, uint64_t>::value, "");
-static_assert(is_same<get_scalar_type_t<id_float32>, float32_t>::value, "");
-static_assert(is_same<get_scalar_type_t<id_float64>, float64_t>::value, "");
-static_assert(is_same<get_scalar_type_t<id_complex64>, complex64_t>::value, "");
-static_assert(is_same<get_scalar_type_t<id_complex128>, complex128_t>::value,
-              "");
-static_assert(is_same<get_scalar_type_t<id_ascii>, ascii_t>::value, "");
-static_assert(is_same<get_scalar_type_t<id_ucs4>, ucs4_t>::value, "");
+static_assert(is_same_v<get_scalar_type_t<id_bool8>, bool8_t>);
+static_assert(is_same_v<get_scalar_type_t<id_int8>, int8_t>);
+static_assert(is_same_v<get_scalar_type_t<id_int16>, int16_t>);
+static_assert(is_same_v<get_scalar_type_t<id_int32>, int32_t>);
+static_assert(is_same_v<get_scalar_type_t<id_int64>, int64_t>);
+static_assert(is_same_v<get_scalar_type_t<id_uint8>, uint8_t>);
+static_assert(is_same_v<get_scalar_type_t<id_uint16>, uint16_t>);
+static_assert(is_same_v<get_scalar_type_t<id_uint32>, uint32_t>);
+static_assert(is_same_v<get_scalar_type_t<id_uint64>, uint64_t>);
+static_assert(is_same_v<get_scalar_type_t<id_float32>, float32_t>);
+static_assert(is_same_v<get_scalar_type_t<id_float64>, float64_t>);
+static_assert(is_same_v<get_scalar_type_t<id_complex64>, complex64_t>);
+static_assert(is_same_v<get_scalar_type_t<id_complex128>, complex128_t>);
+static_assert(is_same_v<get_scalar_type_t<id_ascii>, ascii_t>);
+static_assert(is_same_v<get_scalar_type_t<id_ucs4>, ucs4_t>);
 
-static_assert(get_scalar_type_id<bool8_t>::value == id_bool8, "");
-static_assert(get_scalar_type_id<int8_t>::value == id_int8, "");
-static_assert(get_scalar_type_id<int16_t>::value == id_int16, "");
-static_assert(get_scalar_type_id<int32_t>::value == id_int32, "");
-static_assert(get_scalar_type_id<int64_t>::value == id_int64, "");
-static_assert(get_scalar_type_id<uint8_t>::value == id_uint8, "");
-static_assert(get_scalar_type_id<uint16_t>::value == id_uint16, "");
-static_assert(get_scalar_type_id<uint32_t>::value == id_uint32, "");
-static_assert(get_scalar_type_id<uint64_t>::value == id_uint64, "");
-static_assert(get_scalar_type_id<float32_t>::value == id_float32, "");
-static_assert(get_scalar_type_id<float64_t>::value == id_float64, "");
-static_assert(get_scalar_type_id<complex64_t>::value == id_complex64, "");
-static_assert(get_scalar_type_id<complex128_t>::value == id_complex128, "");
-static_assert(get_scalar_type_id<ascii_t>::value == id_ascii, "");
-static_assert(get_scalar_type_id<ucs4_t>::value == id_ucs4, "");
+static_assert(get_scalar_type_id<bool8_t>() == id_bool8);
+static_assert(get_scalar_type_id<int8_t>() == id_int8);
+static_assert(get_scalar_type_id<int16_t>() == id_int16);
+static_assert(get_scalar_type_id<int32_t>() == id_int32);
+static_assert(get_scalar_type_id<int64_t>() == id_int64);
+static_assert(get_scalar_type_id<uint8_t>() == id_uint8);
+static_assert(get_scalar_type_id<uint16_t>() == id_uint16);
+static_assert(get_scalar_type_id<uint32_t>() == id_uint32);
+static_assert(get_scalar_type_id<uint64_t>() == id_uint64);
+static_assert(get_scalar_type_id<float32_t>() == id_float32);
+static_assert(get_scalar_type_id<float64_t>() == id_float64);
+static_assert(get_scalar_type_id<complex64_t>() == id_complex64);
+static_assert(get_scalar_type_id<complex128_t>() == id_complex128);
+static_assert(get_scalar_type_id<ascii_t>() == id_ascii);
+static_assert(get_scalar_type_id<ucs4_t>() == id_ucs4);
 
 size_t get_scalar_type_size(scalar_type_id_t scalar_type_id) {
   switch (scalar_type_id) {
diff --git a/demo-external.cpp b/demo-external.cpp
index 29c571d..6608ded 100644
--- a/demo-external.cpp
+++ b/demo-external.cpp
@@ -57,7 +57,7 @@ void write_metadata() {
 template <typename T> vector<T> read_array(const shared_ptr<ndarray> &arr) {
   auto datatype = arr->get_datatype();
   assert(datatype->is_scalar);
-  assert(datatype->scalar_type_id == get_scalar_type_id<T>::value);
+  assert(datatype->scalar_type_id == get_scalar_type_id<T>());
   auto shape = arr->get_shape();
   assert(shape.size() == 1);
   auto npoints = shape.at(0);
diff --git a/demo.cpp b/demo.cpp
index 2d5b7cd..5718b42 100644
--- a/demo.cpp
+++ b/demo.cpp
@@ -28,10 +28,10 @@ int main(int argc, char **argv) {
                            block_format_t::inline_array, compression_t::none, 0,
                            vector<bool>(), vector<int64_t>{2, 3});
   auto ent2 = make_shared<entry>("gamma", array2d, string());
-  auto array3d =
-      make_shared<ndarray>(vector<complex128_t>{1, -2, 3i, -4i, 5 + 1i, 6 - 1i},
-                           block_format_t::block, compression_t::bzip2, 9,
-                           vector<bool>(), vector<int64_t>{1, 2, 3});
+  auto array3d = make_shared<ndarray>(
+      vector<complex128_t>{1, -2, 3i, -4i, 5.0 + 1i, 6.0 - 1i},
+      block_format_t::block, compression_t::bzip2, 9, vector<bool>(),
+      vector<int64_t>{1, 2, 3});
   auto ent3 = make_shared<entry>("delta", array3d, string());
   auto array8d = make_shared<ndarray>(
       vector<bool8_t>{true}, block_format_t::block, compression_t::zlib, 9,
diff --git a/ndarray.cpp b/ndarray.cpp
index 367ce9e..f95d3ec 100644
--- a/ndarray.cpp
+++ b/ndarray.cpp
@@ -149,7 +149,7 @@ template <typename T> void input(istream &is, T &data) {
 }
 
 shared_ptr<block_t>
-read_block_data(const shared_ptr<istream> &pis, ios::streamoff block_begin,
+read_block_data(const shared_ptr<istream> &pis, streamoff block_begin,
                 uint64_t allocated_space, uint64_t data_space,
                 compression_t compression,
                 const array<unsigned char, 16> &want_checksum) {
@@ -319,7 +319,7 @@ memoized<block_t> ndarray::read_block(const shared_ptr<istream> &pis) {
   // fdata.fill_cache();
 
   // skip padding
-  is.seekg(block_begin + ios::streamoff(used_space));
+  is.seekg(block_begin + streamoff(used_space));
   return move(fdata);
 }
 

From 1c4d43943f13648b8c36460ebb5760fcdc57a2a5 Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Sun, 23 Jun 2019 00:30:54 -0400
Subject: [PATCH 08/17] Revert back to C++14

---
 CMakeLists.txt    |  2 +-
 asdf_datatype.hpp | 17 ++++++-------
 datatype.cpp      | 61 ++++++++++++++++++++++++-----------------------
 3 files changed, 41 insertions(+), 39 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index afe3201..8a850e8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -75,7 +75,7 @@ endif()
 
 # Main project
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 string(REPLACE "-DNDEBUG" ""
diff --git a/asdf_datatype.hpp b/asdf_datatype.hpp
index 44ab61b..b252122 100644
--- a/asdf_datatype.hpp
+++ b/asdf_datatype.hpp
@@ -56,13 +56,14 @@ typedef vector<char32_t> ucs4_t;
 namespace {
 template <typename T> struct is_complex : false_type {};
 template <typename T> struct is_complex<complex<T>> : is_floating_point<T> {};
-template <typename T> inline constexpr bool is_complex_v = is_complex<T>::value;
+// template <typename T> inline constexpr bool is_complex_v =
+// is_complex<T>::value;
 } // namespace
 
 template <typename T> inline constexpr scalar_type_id_t get_scalar_type_id() {
-  if (is_same_v<T, bool8_t>)
+  if (is_same<T, bool8_t>::value)
     return id_bool8;
-  if (is_integral_v<T> && is_signed_v<T>) {
+  if (is_integral<T>::value && is_signed<T>::value) {
     if (sizeof(T) == 1)
       return id_int8;
     if (sizeof(T) == 2)
@@ -73,7 +74,7 @@ template <typename T> inline constexpr scalar_type_id_t get_scalar_type_id() {
       return id_int64;
     return id_error;
   }
-  if (is_integral_v<T> && is_unsigned_v<T>) {
+  if (is_integral<T>::value && is_unsigned<T>::value) {
     if (sizeof(T) == 1)
       return id_uint8;
     if (sizeof(T) == 2)
@@ -84,23 +85,23 @@ template <typename T> inline constexpr scalar_type_id_t get_scalar_type_id() {
       return id_uint64;
     return id_error;
   }
-  if (is_floating_point_v<T>) {
+  if (is_floating_point<T>::value) {
     if (sizeof(T) == 4)
       return id_float32;
     if (sizeof(T) == 8)
       return id_float64;
     return id_error;
   }
-  if (is_complex_v<T>) {
+  if (is_complex<T>::value) {
     if (sizeof(T) == 8)
       return id_complex64;
     if (sizeof(T) == 16)
       return id_complex128;
     return id_error;
   }
-  if (is_same_v<T, ascii_t>)
+  if (is_same<T, ascii_t>::value)
     return id_ascii;
-  if (is_same_v<T, ucs4_t>)
+  if (is_same<T, ucs4_t>::value)
     return id_ucs4;
   return id_error;
 }
diff --git a/datatype.cpp b/datatype.cpp
index a54abfc..8c9df0e 100644
--- a/datatype.cpp
+++ b/datatype.cpp
@@ -7,37 +7,38 @@ namespace ASDF {
 // Scalar types
 
 // Check consistency between id enum and tuple element
-static_assert(is_same_v<get_scalar_type_t<id_bool8>, bool8_t>);
-static_assert(is_same_v<get_scalar_type_t<id_int8>, int8_t>);
-static_assert(is_same_v<get_scalar_type_t<id_int16>, int16_t>);
-static_assert(is_same_v<get_scalar_type_t<id_int32>, int32_t>);
-static_assert(is_same_v<get_scalar_type_t<id_int64>, int64_t>);
-static_assert(is_same_v<get_scalar_type_t<id_uint8>, uint8_t>);
-static_assert(is_same_v<get_scalar_type_t<id_uint16>, uint16_t>);
-static_assert(is_same_v<get_scalar_type_t<id_uint32>, uint32_t>);
-static_assert(is_same_v<get_scalar_type_t<id_uint64>, uint64_t>);
-static_assert(is_same_v<get_scalar_type_t<id_float32>, float32_t>);
-static_assert(is_same_v<get_scalar_type_t<id_float64>, float64_t>);
-static_assert(is_same_v<get_scalar_type_t<id_complex64>, complex64_t>);
-static_assert(is_same_v<get_scalar_type_t<id_complex128>, complex128_t>);
-static_assert(is_same_v<get_scalar_type_t<id_ascii>, ascii_t>);
-static_assert(is_same_v<get_scalar_type_t<id_ucs4>, ucs4_t>);
+static_assert(is_same<get_scalar_type_t<id_bool8>, bool8_t>::value, "");
+static_assert(is_same<get_scalar_type_t<id_int8>, int8_t>::value, "");
+static_assert(is_same<get_scalar_type_t<id_int16>, int16_t>::value, "");
+static_assert(is_same<get_scalar_type_t<id_int32>, int32_t>::value, "");
+static_assert(is_same<get_scalar_type_t<id_int64>, int64_t>::value, "");
+static_assert(is_same<get_scalar_type_t<id_uint8>, uint8_t>::value, "");
+static_assert(is_same<get_scalar_type_t<id_uint16>, uint16_t>::value, "");
+static_assert(is_same<get_scalar_type_t<id_uint32>, uint32_t>::value, "");
+static_assert(is_same<get_scalar_type_t<id_uint64>, uint64_t>::value, "");
+static_assert(is_same<get_scalar_type_t<id_float32>, float32_t>::value, "");
+static_assert(is_same<get_scalar_type_t<id_float64>, float64_t>::value, "");
+static_assert(is_same<get_scalar_type_t<id_complex64>, complex64_t>::value, "");
+static_assert(is_same<get_scalar_type_t<id_complex128>, complex128_t>::value,
+              "");
+static_assert(is_same<get_scalar_type_t<id_ascii>, ascii_t>::value, "");
+static_assert(is_same<get_scalar_type_t<id_ucs4>, ucs4_t>::value, "");
 
-static_assert(get_scalar_type_id<bool8_t>() == id_bool8);
-static_assert(get_scalar_type_id<int8_t>() == id_int8);
-static_assert(get_scalar_type_id<int16_t>() == id_int16);
-static_assert(get_scalar_type_id<int32_t>() == id_int32);
-static_assert(get_scalar_type_id<int64_t>() == id_int64);
-static_assert(get_scalar_type_id<uint8_t>() == id_uint8);
-static_assert(get_scalar_type_id<uint16_t>() == id_uint16);
-static_assert(get_scalar_type_id<uint32_t>() == id_uint32);
-static_assert(get_scalar_type_id<uint64_t>() == id_uint64);
-static_assert(get_scalar_type_id<float32_t>() == id_float32);
-static_assert(get_scalar_type_id<float64_t>() == id_float64);
-static_assert(get_scalar_type_id<complex64_t>() == id_complex64);
-static_assert(get_scalar_type_id<complex128_t>() == id_complex128);
-static_assert(get_scalar_type_id<ascii_t>() == id_ascii);
-static_assert(get_scalar_type_id<ucs4_t>() == id_ucs4);
+static_assert(get_scalar_type_id<bool8_t>() == id_bool8, "");
+static_assert(get_scalar_type_id<int8_t>() == id_int8, "");
+static_assert(get_scalar_type_id<int16_t>() == id_int16, "");
+static_assert(get_scalar_type_id<int32_t>() == id_int32, "");
+static_assert(get_scalar_type_id<int64_t>() == id_int64, "");
+static_assert(get_scalar_type_id<uint8_t>() == id_uint8, "");
+static_assert(get_scalar_type_id<uint16_t>() == id_uint16, "");
+static_assert(get_scalar_type_id<uint32_t>() == id_uint32, "");
+static_assert(get_scalar_type_id<uint64_t>() == id_uint64, "");
+static_assert(get_scalar_type_id<float32_t>() == id_float32, "");
+static_assert(get_scalar_type_id<float64_t>() == id_float64, "");
+static_assert(get_scalar_type_id<complex64_t>() == id_complex64, "");
+static_assert(get_scalar_type_id<complex128_t>() == id_complex128, "");
+static_assert(get_scalar_type_id<ascii_t>() == id_ascii, "");
+static_assert(get_scalar_type_id<ucs4_t>() == id_ucs4, "");
 
 size_t get_scalar_type_size(scalar_type_id_t scalar_type_id) {
   switch (scalar_type_id) {

From 428a0617768451dffe6104a6f5400f319992867a Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Sun, 23 Jun 2019 12:32:34 -0400
Subject: [PATCH 09/17] Rename Python scripts

---
 demo-external-python.py => asdf-demo-external-python.py | 0
 demo-python.py => asdf-demo-python.py                   | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename demo-external-python.py => asdf-demo-external-python.py (100%)
 rename demo-python.py => asdf-demo-python.py (100%)

diff --git a/demo-external-python.py b/asdf-demo-external-python.py
similarity index 100%
rename from demo-external-python.py
rename to asdf-demo-external-python.py
diff --git a/demo-python.py b/asdf-demo-python.py
similarity index 100%
rename from demo-python.py
rename to asdf-demo-python.py

From 26b898b3789bda05b3f1e3c83ddf246137266a6d Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Sun, 23 Jun 2019 12:32:44 -0400
Subject: [PATCH 10/17] Update build instructions

---
 BUILD.txt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/BUILD.txt b/BUILD.txt
index 3fa6aa6..75414ad 100644
--- a/BUILD.txt
+++ b/BUILD.txt
@@ -10,6 +10,7 @@ for exe in ./asdf-*; do install_name_tool -change '@rpath/libyaml-cpp.0.6.dylib'
 env "PATH=$HOME/src/spack-view/bin:$PATH" "DYLD_LIBRARY_PATH=$HOME/src/spack-view/lib:$DYLD_LIBRARY_PATH" ./asdf-demo
 env "PATH=$HOME/src/spack-view/bin:$PATH" "DYLD_LIBRARY_PATH=$HOME/src/spack-view/lib:$DYLD_LIBRARY_PATH" ./asdf-demo-external
 
-env "PATH=$HOME/src/spack-view/bin:$PATH" "DYLD_LIBRARY_PATH=$HOME/src/spack-view/lib:$DYLD_LIBRARY_PATH" "PYTHONHOME=$HOME/src/spack-view" "PYTHONPATH=$(pwd)" $HOME/src/spack-view/bin/python ../demo-python.py
+env "PATH=$HOME/src/spack-view/bin:$PATH" "DYLD_LIBRARY_PATH=$HOME/src/spack-view/lib:$DYLD_LIBRARY_PATH" "PYTHONHOME=$HOME/src/spack-view" "PYTHONPATH=$(pwd)" $HOME/src/spack-view/bin/python ../asdf-demo-python.py
+env "PATH=$HOME/src/spack-view/bin:$PATH" "DYLD_LIBRARY_PATH=$HOME/src/spack-view/lib:$DYLD_LIBRARY_PATH" "PYTHONHOME=$HOME/src/spack-view" "PYTHONPATH=$(pwd)" $HOME/src/spack-view/bin/python ../asdf-demo-external-python.py
 
 env "PATH=$HOME/src/spack-view/bin:$PATH" cmake --build . --target install

From ad6a0bbab01d9636b6b945a12b8df838e0d64fc4 Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Sun, 23 Jun 2019 12:33:18 -0400
Subject: [PATCH 11/17] Use integral_constant instead of constexpr function

---
 asdf_datatype.hpp | 82 +++++++++++++++++++++--------------------------
 1 file changed, 37 insertions(+), 45 deletions(-)

diff --git a/asdf_datatype.hpp b/asdf_datatype.hpp
index b252122..5446e64 100644
--- a/asdf_datatype.hpp
+++ b/asdf_datatype.hpp
@@ -60,51 +60,43 @@ template <typename T> struct is_complex<complex<T>> : is_floating_point<T> {};
 // is_complex<T>::value;
 } // namespace
 
-template <typename T> inline constexpr scalar_type_id_t get_scalar_type_id() {
-  if (is_same<T, bool8_t>::value)
-    return id_bool8;
-  if (is_integral<T>::value && is_signed<T>::value) {
-    if (sizeof(T) == 1)
-      return id_int8;
-    if (sizeof(T) == 2)
-      return id_int16;
-    if (sizeof(T) == 4)
-      return id_int32;
-    if (sizeof(T) == 8)
-      return id_int64;
-    return id_error;
-  }
-  if (is_integral<T>::value && is_unsigned<T>::value) {
-    if (sizeof(T) == 1)
-      return id_uint8;
-    if (sizeof(T) == 2)
-      return id_uint16;
-    if (sizeof(T) == 4)
-      return id_uint32;
-    if (sizeof(T) == 8)
-      return id_uint64;
-    return id_error;
-  }
-  if (is_floating_point<T>::value) {
-    if (sizeof(T) == 4)
-      return id_float32;
-    if (sizeof(T) == 8)
-      return id_float64;
-    return id_error;
-  }
-  if (is_complex<T>::value) {
-    if (sizeof(T) == 8)
-      return id_complex64;
-    if (sizeof(T) == 16)
-      return id_complex128;
-    return id_error;
-  }
-  if (is_same<T, ascii_t>::value)
-    return id_ascii;
-  if (is_same<T, ucs4_t>::value)
-    return id_ucs4;
-  return id_error;
-}
+template <typename T>
+struct get_scalar_type_id
+    : integral_constant<
+          scalar_type_id_t,
+          is_same<T, bool8_t>::value
+              ? id_bool8
+              : is_integral<T>::value && is_signed<T>::value
+                    ? (sizeof(T) == 1
+                           ? id_int8
+                           : sizeof(T) == 2
+                                 ? id_int16
+                                 : sizeof(T) == 4
+                                       ? id_int32
+                                       : sizeof(T) == 8 ? id_int64 : id_error)
+                    : is_integral<T>::value && is_unsigned<T>::value
+                          ? (sizeof(T) == 1
+                                 ? id_uint8
+                                 : sizeof(T) == 2
+                                       ? id_uint16
+                                       : sizeof(T) == 4
+                                             ? id_uint32
+                                             : sizeof(T) == 8 ? id_uint64
+                                                              : id_error)
+                          : is_floating_point<T>::value
+                                ? (sizeof(T) == 4
+                                       ? id_float32
+                                       : sizeof(T) == 8 ? id_float64 : id_error)
+                                : is_complex<T>::value
+                                      ? (sizeof(T) == 8
+                                             ? id_complex64
+                                             : sizeof(T) == 16 ? id_complex128
+                                                               : id_error)
+                                      : is_same<T, ascii_t>::value
+                                            ? id_ascii
+                                            : is_same<T, ucs4_t>::value
+                                                  ? id_ucs4
+                                                  : id_error> {};
 
 // Convert an enum id to its type
 template <size_t> struct get_scalar_type;

From 7484f575336214ac3b3078cdfd89434b7c5061a8 Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Sun, 23 Jun 2019 12:48:52 -0400
Subject: [PATCH 12/17] Work around complex number bug in GCC 4.8

---
 datatype.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/datatype.cpp b/datatype.cpp
index 8c9df0e..1b15a0f 100644
--- a/datatype.cpp
+++ b/datatype.cpp
@@ -272,9 +272,11 @@ YAML::Node yaml_encode(float64_t val) {
 }
 template <typename T> YAML::Node yaml_encode(const complex<T> &val) {
   YAML::Emitter re;
-  re << val.real();
+  // re << val.real();
+  re << real(val);
   YAML::Emitter im;
-  im << val.imag();
+  // im << val.imag();
+  im << imag(val);
   ostringstream buf;
   buf << re.c_str();
   if (im.c_str()[0] != '-')

From e93bf5a7060003e22c5f86ad331f47bcdeb6af5c Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Sun, 23 Jun 2019 13:03:05 -0400
Subject: [PATCH 13/17] Work around GCC 4.8 complex number bug

---
 datatype.cpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/datatype.cpp b/datatype.cpp
index 1b15a0f..890cd20 100644
--- a/datatype.cpp
+++ b/datatype.cpp
@@ -271,12 +271,11 @@ YAML::Node yaml_encode(float64_t val) {
   return node;
 }
 template <typename T> YAML::Node yaml_encode(const complex<T> &val) {
+  auto val1(val);
   YAML::Emitter re;
-  // re << val.real();
-  re << real(val);
+  re << val1.real();
   YAML::Emitter im;
-  // im << val.imag();
-  im << imag(val);
+  im << val1.imag();
   ostringstream buf;
   buf << re.c_str();
   if (im.c_str()[0] != '-')

From e42a62cc9a4598441dd6c8202a0a96722c403552 Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Sun, 23 Jun 2019 13:06:31 -0400
Subject: [PATCH 14/17] More work-arounds for GCC 4.8 and complex numbers

---
 datatype.cpp | 1 +
 demo.cpp     | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/datatype.cpp b/datatype.cpp
index 890cd20..6ff9cd9 100644
--- a/datatype.cpp
+++ b/datatype.cpp
@@ -271,6 +271,7 @@ YAML::Node yaml_encode(float64_t val) {
   return node;
 }
 template <typename T> YAML::Node yaml_encode(const complex<T> &val) {
+  // Work around libstdc++ const-handling bug in gcc 4.8
   auto val1(val);
   YAML::Emitter re;
   re << val1.real();
diff --git a/demo.cpp b/demo.cpp
index 5718b42..7bc4c14 100644
--- a/demo.cpp
+++ b/demo.cpp
@@ -29,7 +29,7 @@ int main(int argc, char **argv) {
                            vector<bool>(), vector<int64_t>{2, 3});
   auto ent2 = make_shared<entry>("gamma", array2d, string());
   auto array3d = make_shared<ndarray>(
-      vector<complex128_t>{1, -2, 3i, -4i, 5.0 + 1i, 6.0 - 1i},
+      vector<complex128_t>{1.0, -2.0, 3.0i, -4.0i, 5.0 + 1.0i, 6.0 - 1.0i},
       block_format_t::block, compression_t::bzip2, 9, vector<bool>(),
       vector<int64_t>{1, 2, 3});
   auto ent3 = make_shared<entry>("delta", array3d, string());

From 4687f9470e856a61a820b44aa21b61a3e6883662 Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Sun, 23 Jun 2019 13:16:15 -0400
Subject: [PATCH 15/17] More GCC 4.8 complex work-arounds

---
 demo.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/demo.cpp b/demo.cpp
index 7bc4c14..1f6e896 100644
--- a/demo.cpp
+++ b/demo.cpp
@@ -12,6 +12,9 @@
 using namespace std;
 using namespace ASDF;
 
+// Work around shortcomings in GCC 4.8
+template <typename T> constexpr complex<T> C(T re, T im) { return {re, im}; }
+
 int main(int argc, char **argv) {
   cout << "asdf-demo: Create a simple ASDF file\n";
 
@@ -29,7 +32,7 @@ int main(int argc, char **argv) {
                            vector<bool>(), vector<int64_t>{2, 3});
   auto ent2 = make_shared<entry>("gamma", array2d, string());
   auto array3d = make_shared<ndarray>(
-      vector<complex128_t>{1.0, -2.0, 3.0i, -4.0i, 5.0 + 1.0i, 6.0 - 1.0i},
+      vector<complex128_t>{{1, 0}, {-2, 0}, {0, 3}, {-4, 0}, {5, 1}, {6, -1}},
       block_format_t::block, compression_t::bzip2, 9, vector<bool>(),
       vector<int64_t>{1, 2, 3});
   auto ent3 = make_shared<entry>("delta", array3d, string());

From 0081f5775986ff3a60a5fd92f64e066b9e96231c Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Sun, 23 Jun 2019 13:21:29 -0400
Subject: [PATCH 16/17] Remove workaround

---
 demo.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/demo.cpp b/demo.cpp
index 1f6e896..b5bae88 100644
--- a/demo.cpp
+++ b/demo.cpp
@@ -12,9 +12,6 @@
 using namespace std;
 using namespace ASDF;
 
-// Work around shortcomings in GCC 4.8
-template <typename T> constexpr complex<T> C(T re, T im) { return {re, im}; }
-
 int main(int argc, char **argv) {
   cout << "asdf-demo: Create a simple ASDF file\n";
 

From b138a7d57abbcac3771eab50ee2f5a05fa2f0f1d Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Sun, 23 Jun 2019 13:25:04 -0400
Subject: [PATCH 17/17] Increase version number to 7.1.0

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8a850e8..f5fc569 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -6,7 +6,7 @@ cmake_policy(SET CMP0048 NEW)
 set(CMAKE_DISABLE_IN_SOURCE_BUILD ON)
 set(CMAKE_DISABLE_SOURCE_CHANGES ON)
 
-project(asdf-cxx VERSION 7.0.0 LANGUAGES CXX)
+project(asdf-cxx VERSION 7.1.0 LANGUAGES CXX)
 set(PROJECT_DESCRIPTION
   "asdf-cxx (Advanced Scientific Data Format), C++ implementation")
 set(PROJECT_URL "https://github.com/eschnett/asdf-cxx")