Serialization.h

Go to the documentation of this file.

//-*- C++ -*-
//-*- coding: utf-8 -*-
//
// Author: Bryan V. Riel
// Copyright 2017-2018

#pragma once

#include <iostream>
#include <sstream>

// isce3::core
#include <isce3/core/DateTime.h>

// isce3::io
#include <isce3/io/IH5.h>

namespace isce3 {
    namespace io {

        template <typename H5obj>
        inline bool exists(H5obj & h5obj, const std::string & name,
                           const std::string start = ".", const std::string type = "BOTH") {
            // Search for objects
            std::vector<std::string> objs = h5obj.find(name, start, type, "FULL");
            // Check size of vector
            if (objs.size() > 0) {
                return true;
            } else {
                return false;
            }
        }

        template <typename H5obj, typename T>
        inline void loadFromH5(H5obj & h5obj, const std::string & datasetPath, T & v) {
            // Open dataset
            isce3::io::IDataSet dataset = h5obj.openDataSet(datasetPath);
            // Read the scalar dataset
            dataset.read(v);
        }

        template <typename H5obj, typename T>
        inline void loadFromH5(H5obj & h5obj, const std::string & datasetPath,
                               std::vector<T> & v) {
            // Open dataset
            isce3::io::IDataSet dataset = h5obj.openDataSet(datasetPath);
            // Read the vector dataset
            dataset.read(v);
        }

        template <typename H5obj, typename T>
        inline void loadFromH5(H5obj & h5obj, const std::string & datasetPath,
                               std::valarray<T> & v) {
            // Open dataset
            isce3::io::IDataSet dataset = h5obj.openDataSet(datasetPath);
            // Read the valarray dataset
            dataset.read(v);
        }

        template <typename H5obj, typename T>
        inline void loadFromH5(H5obj & h5obj, const std::string & datasetPath,
                               isce3::core::Matrix<T> & m) {
            // Open dataset
            isce3::io::IDataSet dataset = h5obj.openDataSet(datasetPath);
            // Read the Matrix dataset using raw pointer interface
            dataset.read(m.data());
        }

        template<typename H5obj, typename T>
        inline void saveToH5(H5obj& h5obj, const std::string &datasetPath,
                          const T &val, const std::string & units="") {
            //Check for existence of dataset
            if (exists(h5obj, datasetPath)) {
                return;
            }
            //Create dataset
            isce3::io::IDataSet dset = h5obj.createDataSet(datasetPath, val);
            //Update units attribute if long enough
            if (units.length() > 0) {
                dset.createAttribute("units", units);
            }
        }

        template <typename H5obj, typename T>
        inline void saveToH5(H5obj & h5obj, const std::string & datasetPath,
                             const std::vector<T> & v, const std::string & units = "") {
            // Check for existence of dataset
            if (exists(h5obj, datasetPath)) {
                return;
            }
            // Create dataset
            isce3::io::IDataSet dset = h5obj.createDataSet(datasetPath, v);
            // Update units attribute if long enough
            if (units.length() > 0) {
                dset.createAttribute("units", units);
            }
        }

        template <typename H5obj, typename T>
        inline void saveToH5(H5obj & h5obj, const std::string & datasetPath,
                             const std::valarray<T> & v, const std::string & units = "") {
            // Check for existence of dataset
            if (exists(h5obj, datasetPath)) {
                return;
            }
            // Create dataset
            isce3::io::IDataSet dset = h5obj.createDataSet(datasetPath, v);
            // Update units attribute if long enough
            if (units.length() > 0) {
                dset.createAttribute("units", units);
            }
        }

        template <typename H5obj, typename T, size_t S>
        inline void saveToH5(H5obj & h5obj, const std::string & datasetPath,
                             const std::vector<T> & v, std::array<size_t, S> dims,
                             const std::string & units = "") {
            // Check for existence of dataset
            if (exists(h5obj, datasetPath)) {
                return;
            }
            // Create dataset
            isce3::io::IDataSet dset = h5obj.createDataSet(datasetPath, v, dims);
            // Update units attribute if long enough
            if (units.length() > 0) {
                dset.createAttribute("units", units);
            }
        }

        template <typename H5obj, typename T, size_t S>
        inline void saveToH5(H5obj & h5obj, const std::string & datasetPath,
                             const std::valarray<T> & v, std::array<size_t, S> dims,
                             const std::string & units = "") {
            // Check for existence of dataset
            if (exists(h5obj, datasetPath)) {
                return;
            }
            // Create dataset
            isce3::io::IDataSet dset = h5obj.createDataSet(datasetPath, v, dims);
            // Update units attribute if long enough
            if (units.length() > 0) {
                dset.createAttribute("units", units);
            }
        }

        template <typename H5obj, typename T>
        inline void saveToH5(H5obj & h5obj, const std::string & datasetPath,
                             const isce3::core::Matrix<T> & mat, 
                             const std::string & units = "") {
            // Check for existence of dataset
            if (exists(h5obj, datasetPath)) {
                return;
            }
            // Create dataset
            std::array<size_t, 2> dims{mat.length(), mat.width()};
            isce3::io::IDataSet dset = h5obj.createDataSet(datasetPath, mat.data(), dims);
            // Update units attribute if long enough
            if (units.length() > 0) {
                dset.createAttribute("units", units);
            }
        }

        template <typename H5obj>
        inline std::vector<int> getImageDims(H5obj & h5obj, const std::string & datasetPath) {
            // Open dataset
            isce3::io::IDataSet dataset = h5obj.openDataSet(datasetPath);
            // Get dimensions
            return dataset.getDimensions();
        }

        template <typename H5obj>
        inline isce3::core::DateTime getRefEpoch(H5obj & h5obj, const std::string & datasetPath) {

            // Open the dataset
            isce3::io::IDataSet dset = h5obj.openDataSet(datasetPath);

            // Get the attribute
            std::string unitAttr;
            std::string attribute("units");
            dset.read(unitAttr, attribute);

            // Parse it
            std::string dummy1, dummy2, datestr, timestr;
            std::istringstream ss(unitAttr);
            ss >> dummy1 >> dummy2 >> datestr >> timestr;
            std::string inputstr = datestr + "T" + timestr + ".00";
            isce3::core::DateTime epoch(inputstr);

            // Done
            return epoch;
        }

        template <typename H5obj>
        inline void setRefEpoch(H5obj & h5obj, const std::string & datasetPath,
                                const isce3::core::DateTime & refEpoch) {

            // Open the dataset
            isce3::io::IDataSet dset = h5obj.openDataSet(datasetPath);
            
            // Need to create string representation of DateTime manually
            char buffer[40];
            sprintf(buffer,
                    "seconds since %04d-%02d-%02d %02d:%02d:%02d",
                    refEpoch.year,
                    refEpoch.months,
                    refEpoch.days,
                    refEpoch.hours,
                    refEpoch.minutes,
                    refEpoch.seconds);
            std::string unitsAttr{buffer};

            // Save buffer to attribute
            dset.createAttribute("units", unitsAttr);
        }

    }
}