Need a cleaner way of reusing ObservationHeader

[vivekvenkris]

Currently, ObservationHeader has all possible dada header parameters to encompass the wide variety of dada files that we have (antenna voltages, beams, stats). While reading dada files, only a subset of these parameters are present, and since the header.get function has a

    if(strcmp("unset", _buffer) == 0) {
        throw std::runtime_error(std::string("The header key ") + key +
                                 " was unset");
    }

We always hit a runtime error. I have now changed this into a warning, but a more elegant solution of having a subset of dada headers for each file class, that gets passed on to the read_dada_header function of ObservationHeader.cpp is essential. Any ideas?

[ewanbarr]

@vivekvenkris Having this as a warning is not safe, as the ObservationHeader will just end up with a default (or potentially unintialised) value.

I think it is necessary to have only one ObservationHeader and I had hoped to have this be POD but if we need it more complicated we can have it.

In the new version of the DescribedVector code which I have ported over to psrdada_cpp we have something like:

template <typename MetadataType_>
struct MetaDataWrapper
{
   using  MetadataType = MetadataType_;
   
    MetaDataWrapper(){};
    
    MetaDataWrapper(MetaDataWrapper const& other)
        : _metadata(other._metadata), 
          _stale(other._stale)
    {
    }

    void set(MetadataType const& metadata) {
        _metadata = metadata;
        _stale = false;
    }

    template <typename T = MetadataType>
    typename std::enable_if<std::is_same<T, std::vector<typename T::value_type>>::value>::type
    set(MetadataType const& metadata,  std::size_t expected_size) {
        if (metadata.size() != expected_size){
            throw std::runtime_error("Attempted to set metadata with invalid size");
        }
        _metadata = metadata;
        _stale = false;
    }

    MetadataType const& get() const {
        if (_stale){
            throw std::runtime_error("Stale metadata was requested");
        }
        return _metadata;
    }

    void mark_stale(){
        _stale = true;
    }

    MetadataType _metadata;
    bool _stale = true;
};

The ObservationHeader would have to be updated with setters and getters for its metadata which would look like

struct ObservationHeader {
    MetaDataWrapper<std::size_t > nchans{}; // Number of frequency channels in the subband
    MetaDataWrapper<std::size_t > npol{}; // Number of polarisations
    //...etc.

The way this works is that the metadata has to be set at least once to be valid, e.g.

ObservationHeader header;
header.nchans.get() // fails with  throw std::runtime_error("Stale metadata was requested");

header.nchans.set(1024);
header.nchans.get() // returns 1024

The beauty of this solution is that the code will only fail when there is actually a REQUIRED header parameter missing (without you having to explicitly set which ones are required).

[ewanbarr]

You would then do the following in read_dada_header:

void read_dada_header(psrdada_cpp::RawBytes& raw_header,
                      ObservationHeader& header)
{
    auto safe_setter = [&](auto& val, char const* key){
        try {
            val.set(parser.get<typename decltype(val)::MetadataType>(key);)
        } catch (std::runtime_error&)
        {
            BOOST_LOG_TRIVIAL(warning) << "Could not parse " << key << " from header"; 
        }
    }
    Header parser(raw_header);
    safe_setter(header.nchans, "NCHAN");
    ```

[ewanbarr]

Is the warning sufficient now? Should this be closed?

[vivekvenkris]

No, I will do this change once we merge the existing code to main.