HeaderBase.h

Go to the documentation of this file.

/*
 * MIT License
 *
 * Copyright (c) 2018 PulsarSearchSoft
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#ifndef PSS_ASTROTYPES_SIGPROC_HEADERBASE_H
#define PSS_ASTROTYPES_SIGPROC_HEADERBASE_H

#include "../HeaderField.h"
#include <iostream>
#include <exception>
#include <map>

namespace pss {
namespace astrotypes {
namespace sigproc {

template<typename Derived>
class HeaderBase
{
    private:
        friend class HeaderFieldBase;

    public:
        template<typename Stream>
        class InfoSentry {
            public:
                InfoSentry(Stream& os);
                Stream& operator<<(Derived const& os) const;

            private:
                Stream& _os;
        };

    public:
        // Adapter for ouputing debug info about the header
        class Info {
            public:
                Info();
                template<typename Stream>
                InfoSentry<Stream> sentry(Stream& os) const;
        };

    public:
        HeaderBase();
        // maps will not be copied over
        HeaderBase(HeaderBase const&);

        void read(std::istream & stream);

        void write(std::ostream & stream) const;

        bool operator==(HeaderBase const&) const;

        bool operator!=(HeaderBase const&) const;

        std::size_t size() const;

        void reset();

    protected:
        Derived& copy_header_values(Derived const& dst);

        // default implemention overridable in Derived type
        void do_read(std::istream & stream);
        void do_write(std::ostream & stream) const;
        bool do_equal(HeaderBase const&) const;
        void do_reset();

    protected:

        template<typename T>
        std::runtime_error parse_error(std::string const& msg, T const& msg2) const;

        void add(SigProcLabel const& label, HeaderFieldBase& field);

        void add_read(SigProcLabel const& label, HeaderFieldBase& field);

        void add_compare_field(SigProcLabel const&);

        void remove_compare_field(SigProcLabel const&);

    private:
        mutable unsigned _size; // byte size of the header

        std::map<SigProcLabel, HeaderFieldBase*> _headers;
        std::map<SigProcLabel, HeaderFieldBase*> _compare_headers;
        std::map<SigProcLabel, HeaderFieldBase*> _read_only_headers;
};

template<typename Derived>
std::ostream& operator<<(std::ostream& os, HeaderBase<Derived> const&);

template<typename Derived>
std::istream& operator>>(std::istream& os, HeaderBase<Derived>&);

} // namespace sigproc
} // namespace astrotypes
} // namespace pss
#include "HeaderBase.cpp"

#endif // PSS_ASTROTYPES_SIGPROC_HEADERBASE_H