xarray-dbd 0.2.5__tar.gz → 0.2.7__tar.gz

{xarray_dbd-0.2.5 → xarray_dbd-0.2.7}/.pre-commit-config.yaml

@@ -13,3 +13,14 @@ repos:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]
       - id: ruff-format
+
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.13.0
+    hooks:
+      - id: mypy
+        # Match the CI invocation (xarray_dbd/ only; tests are linted, not typed).
+        files: ^xarray_dbd/
+        additional_dependencies:
+          - numpy>=1.23,<3.0
+          - xarray>=2023.6.0
+          - netCDF4>=1.6

{xarray_dbd-0.2.5 → xarray_dbd-0.2.7}/CHANGELOG.md

@@ -5,6 +5,36 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.6] - 2026-03-30
+
+### Added
+
+- `--list-sensors` flag for `dbd2nc` CLI to print available sensors without conversion
+- `batch_size` parameter for `write_multi_dbd_netcdf()` (was hardcoded at 100)
+- Signal handling in `mkone` — Ctrl+C now terminates child processes cleanly
+- "Working with Glider Data" section in README (sensor discovery, time conversion, fill values)
+- Tests for `get_CTD_sync`, `determine_ctd_type`, `get_global_time_range`, file ordering, batch boundaries
+
+### Changed
+
+- `get_sync()` logs interpolation failures at WARNING level instead of INFO
+- Streaming writer logs summary when batches are skipped due to errors
+- `set_time_limits()` accepts numeric epoch seconds in addition to date strings
+- C++ `SensorsMap::setUpForData()` validates sensor byte sizes across files
+
+### Fixed
+
+- **Data loss in streaming writer**: removed Python-side double-skip at batch boundaries (C++ already handles `skip_first_record`)
+- **dbdreader2 file ordering**: pass `presorted=True` to `read_dbd_files` so C++ respects chronological order from `DBDList.sort()`
+- **mkone worker error propagation**: workers now exit non-zero on failure so parent detects errors
+- **`_get_with_source` time ordering**: results now sorted by time for consistency with normal `get()` path
+- **`sci_extensions` missing `.sbd`**: file pairing now recognizes `.sbd` as a science file type
+- **`set_time_limits` falsy check**: epoch time 0 no longer causes spurious ValueError
+- **inf-to-NaN for repeated values**: code=1 (repeat) now converts infinity consistently with code=2 (new value)
+- Removed unused `"j"` dimension from `DBDDataStore.get_dimensions()`
+- Fixed `--skip-first` help text (was stale after skip semantics change)
+- Fixed README: CLI command names, removed false wildcard `to_keep` claim
+
 ## [0.2.5] - 2026-03-30
 
 ### Added

{xarray_dbd-0.2.5 → xarray_dbd-0.2.7}/CMakeLists.txt

@@ -35,7 +35,6 @@ pybind11_add_module(_dbd_cpp
     csrc/SensorsMap.C
     csrc/KnownBytes.C
     csrc/Decompress.C
-    csrc/Data.C
     csrc/lz4.c
 )
 

{xarray_dbd-0.2.5 → xarray_dbd-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xarray-dbd
-Version: 0.2.5
+Version: 0.2.7
 Summary: Efficient xarray backend for reading glider DBD files
 Keywords: glider,oceanography,dbd,slocum,xarray,netcdf
 Author-Email: Pat Welch <pat@mousebrains.com>
@@ -74,7 +74,7 @@ pip install xarray-dbd
 For the CLI tools only:
 
 ```bash
-pipx install xarray-dbd   # installs dbd2nc and mkone commands
+pipx install xarray-dbd   # installs xdbd command (xdbd 2nc, xdbd mkone, etc.)
 ```
 
 Or install from source (requires a C++ compiler and CMake):
@@ -167,8 +167,8 @@ ds = xdbd.open_multi_dbd_dataset(files, sort="none")
 The `--sort` flag is also available on all CLI commands:
 
 ```bash
-dbd2nc --sort lexicographic -C cache -o output.nc *.dbd
-mkone --sort none --output-prefix /path/to/output/ /path/to/raw/
+xdbd 2nc --sort lexicographic -C cache -o output.nc *.dbd
+xdbd mkone --sort none --output-prefix /path/to/output/ /path/to/raw/
 ```
 
 ### Advanced options
@@ -178,11 +178,15 @@ ds = xdbd.open_dbd_dataset(
     'test.sbd',
     skip_first_record=True,  # Skip first record (default)
     repair=True,             # Attempt to repair corrupted data
-    to_keep=['m_*'],         # Keep sensors matching pattern (future feature)
+    to_keep=['m_depth', 'm_lat'],  # Keep only these sensors
     criteria=['m_present_time'],  # Sensors for record selection
 )
 ```
 
+The corresponding CLI flag on `xdbd 2nc` and `xdbd 2csv` is `--keep-first`
+(default is to skip the first record of every file, matching `mkone` and
+`dbdreader`). Use `--skip-first` to be explicit or `--keep-first` to invert.
+
 ## DBD File Format
 
 DBD (Dinkum Binary Data) files are the native format used by Slocum ocean gliders. The format consists of:
@@ -234,6 +238,27 @@ Open multiple DBD files as a single concatenated xarray Dataset.
 
 **Returns:** `xarray.Dataset`
 
+### `write_multi_dbd_netcdf(filenames, output, **kwargs)`
+
+Stream multiple DBD files directly to a NetCDF file without loading all data
+into memory. Preferred for large datasets (100+ files).
+
+**Parameters:**
+- `filenames` (iterable): Paths to DBD files (duplicates removed automatically)
+- `output` (str or Path): Output NetCDF file path (parent directory created if needed)
+- `skip_first_record` (bool): Skip first record in each file (default: True)
+- `repair` (bool): Attempt to repair corrupted records (default: False)
+- `to_keep` (list of str): Sensor names to keep (default: all)
+- `criteria` (list of str): Sensor names for selection criteria
+- `skip_missions` (list of str): Mission names to skip
+- `keep_missions` (list of str): Mission names to keep
+- `cache_dir` (str, Path, or None): Directory for sensor cache files
+- `compression` (int): Zlib compression level 0-9 (default: 5, 0 disables)
+- `sort` (str): File sort order (default: `"header_time"`)
+- `batch_size` (int): Files per batch (default: 100; smaller reduces peak memory)
+
+**Returns:** `tuple[int, int]` — (n_records, n_files)
+
 ## Migration from dbdreader
 
 The dbdreader2 API is derived from Lucas Merckelbach's
@@ -498,6 +523,7 @@ print(f"Depth units: {ds['m_depth'].attrs['units']}")
 ### Working with trajectories
 
 ```python
+from pathlib import Path
 import xarray_dbd as xdbd
 import matplotlib.pyplot as plt
 
@@ -518,6 +544,7 @@ plt.show()
 ### Extracting science data
 
 ```python
+from pathlib import Path
 # Read full resolution science data
 files = sorted(Path('.').glob('*.ebd'))
 ds = xdbd.open_multi_dbd_dataset(
@@ -538,7 +565,7 @@ print(df.describe())
 | Multiple files, < 1 GB | `xdbd.open_multi_dbd_dataset(files, to_keep=[...])` |
 | Multiple files, large dataset | `xdbd.write_multi_dbd_netcdf(files, "out.nc")` |
 | Interactive / Jupyter | `xdbd.MultiDBD(filenames=files)` with `.get()` (lazy) |
-| Batch processing 1000+ files | `mkone` CLI (multiprocessing) |
+| Batch processing 1000+ files | `xdbd mkone` CLI (multiprocessing) |
 | Drop-in dbdreader replacement | `import xarray_dbd.dbdreader2 as dbdreader` |
 
 ## Slocum File Types
@@ -554,6 +581,50 @@ print(df.describe())
 
 Compressed variants (`.?cd`) use LZ4 framing and are handled transparently.
 
+## Working with Glider Data
+
+### Discovering available sensors
+
+```python
+import xarray_dbd as xdbd
+
+# xarray API
+ds = xdbd.open_dbd_dataset("file.dbd", cache_dir="cache")
+for var in sorted(ds.data_vars):
+    print(f"  {var:30s} {ds[var].attrs.get('units', '')}")
+
+# dbdreader2 API
+dbd = xdbd.MultiDBD(pattern="*.dbd", cacheDir="cache")
+for name in sorted(dbd.parameterNames["eng"]):
+    print(f"  {name:30s} {dbd.parameterUnits.get(name, '')}")
+```
+
+Sensor naming conventions are documented in
+[TWR's masterdata files](https://gliderfs2.ceoas.oregonstate.edu/gliderweb/masterdata/).
+
+### Time conversion
+
+`m_present_time` contains UTC seconds since 1970-01-01 (Unix epoch, float64):
+
+```python
+import pandas as pd
+
+time = pd.to_datetime(ds["m_present_time"].values, unit="s", utc=True)
+```
+
+### Handling fill values
+
+Float sensors use NaN for missing data. Integer sensors use sentinel fill
+values (-127 for int8, -32768 for int16). Filter them out:
+
+```python
+# xarray — replace sentinels with NaN
+ds = ds.where(ds != -32768)
+
+# dbdreader2 — automatic filtering (default)
+t, v = dbd.get("m_depth")  # return_nans=False by default
+```
+
 ## Known Limitations
 
 - **Python 3.10+ required** — uses `from __future__ import annotations` for modern type-hint syntax.

{xarray_dbd-0.2.5 → xarray_dbd-0.2.7}/README.md

@@ -38,7 +38,7 @@ pip install xarray-dbd
 For the CLI tools only:
 
 ```bash
-pipx install xarray-dbd   # installs dbd2nc and mkone commands
+pipx install xarray-dbd   # installs xdbd command (xdbd 2nc, xdbd mkone, etc.)
 ```
 
 Or install from source (requires a C++ compiler and CMake):
@@ -131,8 +131,8 @@ ds = xdbd.open_multi_dbd_dataset(files, sort="none")
 The `--sort` flag is also available on all CLI commands:
 
 ```bash
-dbd2nc --sort lexicographic -C cache -o output.nc *.dbd
-mkone --sort none --output-prefix /path/to/output/ /path/to/raw/
+xdbd 2nc --sort lexicographic -C cache -o output.nc *.dbd
+xdbd mkone --sort none --output-prefix /path/to/output/ /path/to/raw/
 ```
 
 ### Advanced options
@@ -142,11 +142,15 @@ ds = xdbd.open_dbd_dataset(
     'test.sbd',
     skip_first_record=True,  # Skip first record (default)
     repair=True,             # Attempt to repair corrupted data
-    to_keep=['m_*'],         # Keep sensors matching pattern (future feature)
+    to_keep=['m_depth', 'm_lat'],  # Keep only these sensors
     criteria=['m_present_time'],  # Sensors for record selection
 )
 ```
 
+The corresponding CLI flag on `xdbd 2nc` and `xdbd 2csv` is `--keep-first`
+(default is to skip the first record of every file, matching `mkone` and
+`dbdreader`). Use `--skip-first` to be explicit or `--keep-first` to invert.
+
 ## DBD File Format
 
 DBD (Dinkum Binary Data) files are the native format used by Slocum ocean gliders. The format consists of:
@@ -198,6 +202,27 @@ Open multiple DBD files as a single concatenated xarray Dataset.
 
 **Returns:** `xarray.Dataset`
 
+### `write_multi_dbd_netcdf(filenames, output, **kwargs)`
+
+Stream multiple DBD files directly to a NetCDF file without loading all data
+into memory. Preferred for large datasets (100+ files).
+
+**Parameters:**
+- `filenames` (iterable): Paths to DBD files (duplicates removed automatically)
+- `output` (str or Path): Output NetCDF file path (parent directory created if needed)
+- `skip_first_record` (bool): Skip first record in each file (default: True)
+- `repair` (bool): Attempt to repair corrupted records (default: False)
+- `to_keep` (list of str): Sensor names to keep (default: all)
+- `criteria` (list of str): Sensor names for selection criteria
+- `skip_missions` (list of str): Mission names to skip
+- `keep_missions` (list of str): Mission names to keep
+- `cache_dir` (str, Path, or None): Directory for sensor cache files
+- `compression` (int): Zlib compression level 0-9 (default: 5, 0 disables)
+- `sort` (str): File sort order (default: `"header_time"`)
+- `batch_size` (int): Files per batch (default: 100; smaller reduces peak memory)
+
+**Returns:** `tuple[int, int]` — (n_records, n_files)
+
 ## Migration from dbdreader
 
 The dbdreader2 API is derived from Lucas Merckelbach's
@@ -462,6 +487,7 @@ print(f"Depth units: {ds['m_depth'].attrs['units']}")
 ### Working with trajectories
 
 ```python
+from pathlib import Path
 import xarray_dbd as xdbd
 import matplotlib.pyplot as plt
 
@@ -482,6 +508,7 @@ plt.show()
 ### Extracting science data
 
 ```python
+from pathlib import Path
 # Read full resolution science data
 files = sorted(Path('.').glob('*.ebd'))
 ds = xdbd.open_multi_dbd_dataset(
@@ -502,7 +529,7 @@ print(df.describe())
 | Multiple files, < 1 GB | `xdbd.open_multi_dbd_dataset(files, to_keep=[...])` |
 | Multiple files, large dataset | `xdbd.write_multi_dbd_netcdf(files, "out.nc")` |
 | Interactive / Jupyter | `xdbd.MultiDBD(filenames=files)` with `.get()` (lazy) |
-| Batch processing 1000+ files | `mkone` CLI (multiprocessing) |
+| Batch processing 1000+ files | `xdbd mkone` CLI (multiprocessing) |
 | Drop-in dbdreader replacement | `import xarray_dbd.dbdreader2 as dbdreader` |
 
 ## Slocum File Types
@@ -518,6 +545,50 @@ print(df.describe())
 
 Compressed variants (`.?cd`) use LZ4 framing and are handled transparently.
 
+## Working with Glider Data
+
+### Discovering available sensors
+
+```python
+import xarray_dbd as xdbd
+
+# xarray API
+ds = xdbd.open_dbd_dataset("file.dbd", cache_dir="cache")
+for var in sorted(ds.data_vars):
+    print(f"  {var:30s} {ds[var].attrs.get('units', '')}")
+
+# dbdreader2 API
+dbd = xdbd.MultiDBD(pattern="*.dbd", cacheDir="cache")
+for name in sorted(dbd.parameterNames["eng"]):
+    print(f"  {name:30s} {dbd.parameterUnits.get(name, '')}")
+```
+
+Sensor naming conventions are documented in
+[TWR's masterdata files](https://gliderfs2.ceoas.oregonstate.edu/gliderweb/masterdata/).
+
+### Time conversion
+
+`m_present_time` contains UTC seconds since 1970-01-01 (Unix epoch, float64):
+
+```python
+import pandas as pd
+
+time = pd.to_datetime(ds["m_present_time"].values, unit="s", utc=True)
+```
+
+### Handling fill values
+
+Float sensors use NaN for missing data. Integer sensors use sentinel fill
+values (-127 for int8, -32768 for int16). Filter them out:
+
+```python
+# xarray — replace sentinels with NaN
+ds = ds.where(ds != -32768)
+
+# dbdreader2 — automatic filtering (default)
+t, v = dbd.get("m_depth")  # return_nans=False by default
+```
+
 ## Known Limitations
 
 - **Python 3.10+ required** — uses `from __future__ import annotations` for modern type-hint syntax.

{xarray_dbd-0.2.5 → xarray_dbd-0.2.7}/benchmark_performance.py

@@ -36,11 +36,11 @@ def measure_command(cmd, desc):
                 break
             time.sleep(0.01)
 
-        # Final check
+        # Final check — process may already have exited between the loop and here
         try:
             mem_info = process.memory_info()
             peak_memory = max(peak_memory, mem_info.rss)
-        except:
+        except (psutil.NoSuchProcess, psutil.AccessDenied, OSError):
             pass
 
     except KeyboardInterrupt:

{xarray_dbd-0.2.5 → xarray_dbd-0.2.7}/conda/recipe.yaml

@@ -6,7 +6,7 @@ schema_version: 1
 
 context:
   name: xarray-dbd
-  version: "0.1.0"
+  version: "0.2.7"
 
 package:
   name: ${{ name }}
@@ -37,6 +37,7 @@ requirements:
     - python >=3.10
     - numpy >=1.23,<3.0
     - xarray >=2023.6.0
+    - netcdf4 >=1.6
 
 tests:
   - python:
@@ -45,8 +46,9 @@ tests:
         - xarray_dbd._dbd_cpp
       pip_check: true
   - script:
-      - dbd2nc --help
-      - mkone --help
+      - xdbd --help
+      - xdbd 2nc --help
+      - xdbd mkone --help
 
 about:
   summary: Efficient xarray backend for reading Slocum ocean glider DBD files

{xarray_dbd-0.2.5 → xarray_dbd-0.2.7}/csrc/ColumnData.C

@@ -123,7 +123,7 @@ ColumnDataResult read_columns(std::istream& is,
                 qKeep |= sensor.qCriteria();
                 const int oi = outIndex[i];
                 if (oi >= 0) {
-                    // Copy previous value into current row
+                    // Copy previous value into current row, converting inf to NaN
                     std::visit([nRows, oi](auto& col_vec, const auto& prev_vec) {
                         using T = typename std::decay_t<decltype(col_vec)>::value_type;
                         using PT = typename std::decay_t<decltype(prev_vec)>::value_type;
@@ -136,7 +136,11 @@ ColumnDataResult read_columns(std::istream& is,
                                 else
                                     col_vec.resize(col_vec.size() * 2, NAN);
                             }
-                            col_vec[nRows] = prev_vec[0];
+                            T val = prev_vec[0];
+                            if constexpr (std::is_floating_point_v<T>) {
+                                if (std::isinf(val)) val = NAN;
+                            }
+                            col_vec[nRows] = val;
                         }
                     }, columns[oi], prevValues[oi]);
                 }

{xarray_dbd-0.2.5 → xarray_dbd-0.2.7}/csrc/Decompress.C

@@ -38,17 +38,20 @@ int DecompressTWRBuf::underflow() {
     if (!this->mIS.read(frame.data(), n)) { // EOF
       return std::char_traits<char>::eof();
     }
-    const int j = LZ4_decompress_safe(frame.data(), this->mBuffer, static_cast<int>(n), sizeof(this->mBuffer));
+    const int j(LZ4_decompress_safe(frame.data(), this->mBuffer, static_cast<int>(n), sizeof(this->mBuffer)));
     if (j < 0) { // LZ4 decompression error
+      LOG_ERROR("LZ4 decompression failed (error {}) in {} (block size {})",
+                j, this->mFilename, n);
       return std::char_traits<char>::eof();
     }
-    if (static_cast<size_t>(j) > sizeof(this->mBuffer)) { // Probably a corrupted file
-      return std::char_traits<char>::eof();
-    }
-    this->setg(this->mBuffer, this->mBuffer, this->mBuffer + j);
+    const size_t decompressedSize(static_cast<size_t>(j));
+    this->setg(this->mBuffer, this->mBuffer, this->mBuffer + decompressedSize);
+    this->mPos += decompressedSize;
   } else { // Not compressed
     if (this->mIS.read(this->mBuffer, sizeof(this->mBuffer)) || this->mIS.gcount()) {
-      this->setg(this->mBuffer, this->mBuffer, this->mBuffer + this->mIS.gcount());
+      const auto n = this->mIS.gcount();
+      this->setg(this->mBuffer, this->mBuffer, this->mBuffer + n);
+      this->mPos += static_cast<size_t>(n);
     } else {
       return std::char_traits<char>::eof();
     }
@@ -57,6 +60,18 @@ int DecompressTWRBuf::underflow() {
   return std::char_traits<char>::to_int_type(*this->gptr());
 }
 
+DecompressTWRBuf::pos_type
+DecompressTWRBuf::seekoff(off_type off, std::ios_base::seekdir dir,
+                          std::ios_base::openmode /*which*/) {
+  // Only support tellg(): seekoff(0, cur)
+  if (dir == std::ios_base::cur && off == 0) {
+    // mPos is total bytes loaded; subtract unread bytes remaining in buffer
+    const auto remaining = this->egptr() - this->gptr();
+    return static_cast<pos_type>(this->mPos - static_cast<size_t>(remaining));
+  }
+  return pos_type(off_type(-1)); // Seeking not supported
+}
+
 bool qCompressed(const std::string& fn) {
   const std::string suffix(fs::path(fn).extension().string());
   const bool q((suffix.size() == 4) && (std::tolower(static_cast<unsigned char>(suffix[2])) == 'c'));

{xarray_dbd-0.2.5 → xarray_dbd-0.2.7}/csrc/Decompress.H

@@ -9,21 +9,23 @@
 class DecompressTWRBuf: public std::streambuf {
   std::ifstream mIS;
   const bool mqCompressed;
-  char mBuffer[65536];
+  char mBuffer[65536]{}; // zero-init so cppcheck across versions stays happy
   const std::string mFilename;
+  size_t mPos = 0; // Total decompressed bytes loaded into buffer
 public:
   DecompressTWRBuf(const std::string& fn, const bool qCompressed)
     : mIS(fn.c_str(), std::ios::binary)
     , mqCompressed(qCompressed)
     , mFilename(fn)
-
   {}
 
-  ~DecompressTWRBuf() {mIS.close();}
-
   void close() {mIS.close();}
 
-  int underflow();
+  int underflow() override;
+
+protected:
+  pos_type seekoff(off_type off, std::ios_base::seekdir dir,
+                   std::ios_base::openmode which = std::ios_base::in) override;
 };
 
 class DecompressTWR: public std::istream {

{xarray_dbd-0.2.5 → xarray_dbd-0.2.7}/csrc/Header.C

@@ -21,6 +21,10 @@
 #include "MyException.H"
 #include "Logger.H"
 #include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <algorithm>
+#include <limits>
 #include <cstdlib>
 
 namespace {
@@ -35,7 +39,9 @@ namespace {
 Header::Header(std::istream& is, const char *fn)
 {
   size_t cnt = 0;
-  for (tRecords::size_type nLines(10); mRecords.size() < nLines;) {
+  // 14 is the typical ASCII header length in DBD files; num_ascii_tags (if
+  // present in the first 14 lines) overrides this with the exact count.
+  for (tRecords::size_type nLines(14); mRecords.size() < nLines;) {
     std::string line;
     if (!getline(is, line)) {
       break;
@@ -52,7 +58,10 @@ Header::Header(std::istream& is, const char *fn)
     mRecords.insert(std::make_pair(key, value));
     if (key == "num_ascii_tags") {
       try {
-        nLines = std::stoi(value);
+        const int parsed = std::stoi(value);
+        nLines = (parsed > 0 && parsed <= 10000)
+                     ? static_cast<tRecords::size_type>(parsed)
+                     : 0;
       } catch (const std::exception&) {
         nLines = 0;  // Default to 0 on parse error
       }
@@ -87,19 +96,13 @@ Header::trim(std::string str)
 {
   const std::string whitespace(" \t\n");
 
-  std::string::size_type index(str.find_first_not_of(whitespace));
-
-  if (index != str.npos) {
-    str = str.substr(index);
-  }
-
-  index = str.find_last_not_of(whitespace);
-
-  if (index != str.npos) {
-    str = str.substr(0, index + 1);
+  const std::string::size_type first(str.find_first_not_of(whitespace));
+  if (first == str.npos) {
+    return std::string();
   }
 
-  return str;
+  const std::string::size_type last(str.find_last_not_of(whitespace));
+  return str.substr(first, last - first + 1);
 }
 
 void
@@ -126,6 +129,28 @@ Header::qProcessMission(const tMissions& toSkip,
   return toKeep.empty() || (toKeep.find(mission) != toKeep.end());
 }
 
+// Parse a DBD fileopen_time header value (format: "Day_Mon_DD_HH:MM:SS_YYYY")
+// to a UTC epoch seconds. Slocum gliders record fileopen_time in UTC, so we
+// use timegm / _mkgmtime rather than mktime (which would apply local TZ).
+// Returns time_t::max() on empty input or parse failure so the file sorts to
+// the end of a by-time file list.
+time_t
+Header::parseFileOpenTime(const std::string& timeStr)
+{
+  if (timeStr.empty()) return std::numeric_limits<time_t>::max();
+  std::string s(timeStr);
+  std::replace(s.begin(), s.end(), '_', ' ');
+  struct tm tm = {};
+  std::istringstream iss(s);
+  iss >> std::get_time(&tm, "%a %b %d %H:%M:%S %Y");
+  if (iss.fail()) return std::numeric_limits<time_t>::max();
+#ifdef _WIN32
+  return _mkgmtime(&tm);
+#else
+  return timegm(&tm);
+#endif
+}
+
 std::ostream&
 operator << (std::ostream& os,
              const Header& hdr)

{xarray_dbd-0.2.5 → xarray_dbd-0.2.7}/csrc/Header.H

@@ -7,6 +7,7 @@
 #include <string>
 #include <map>
 #include <set>
+#include <ctime>
 
 class Header {
 private:
@@ -30,6 +31,8 @@ public:
   static void addMission(std::string name, tMissions& missionList);
   bool qProcessMission(const tMissions& toSkip, const tMissions& toProcess) const;
 
+  static time_t parseFileOpenTime(const std::string& timeStr);
+
   friend std::ostream& operator << (std::ostream& os, const Header& hdr);
 }; // Header