HeaderField.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_HEADERFIELD_H
#define PSS_ASTROTYPES_SIGPROC_HEADERFIELD_H
#include "pss/astrotypes/sigproc/detail/SigProcVariable.h"
#include "pss/astrotypes/utils/Optional.h"
#include <string>
#include <vector>


namespace pss {
namespace astrotypes {
namespace sigproc {

class Header;

class HeaderFieldBase
{
    protected:
        // allows us to hide HeaderFields from the writer
        HeaderFieldBase() {};

        void add_read(SigProcLabel const& header_label, HeaderFieldBase& field, Header& header);

    public:
        // registers the Field to be read/written by the Header parser
        HeaderFieldBase(SigProcLabel const& header_name, Header& h);
        ~HeaderFieldBase() {}; // virtual not needed, we never expect to pass these around

        // @return the number of bytes read
        virtual unsigned read(std::istream &) { return 0; };

        // @return the number of bytes written
        virtual unsigned write(std::ostream &) const { return 0; };

        virtual void write_info(std::ostream &) const { };

        virtual std::string const& header_info(std::string const& h) const { return h; };

        virtual void reset() = 0;

        virtual bool is_set() const = 0;

        virtual bool operator==(const HeaderFieldBase&) const { return true; };

        virtual void operator=(const HeaderFieldBase&) = 0;
};

template<typename T>
class HeaderField : public HeaderFieldBase
{
        typedef HeaderFieldBase BaseT;

    protected:
        // for expansion only, not to be used as a public interface
        HeaderField() {};

    public:
        HeaderField(SigProcLabel const& header_label, Header& header);
        HeaderField(SigProcLabel const& header_label, Header& header, T const& to_copy);

        // Warning HeaderFieldBase must be convertible to HeaderField
        HeaderField(SigProcLabel const& header_label, Header& header, HeaderField const&);

        operator T const&() const { return *_var; }
        operator T&() { return *_var; }
        operator utils::Optional<T> const&() const { return _var; }
        HeaderField& operator=(T const& var);
        void operator=(const HeaderFieldBase&) override;

        unsigned read(std::istream &) override;
        unsigned write(std::ostream &) const override;
        void write_info(std::ostream &) const override;
        void reset() override;
        bool is_set() const override;
        bool operator==(const HeaderFieldBase&) const override;
        bool operator==(const HeaderField&) const;

    protected:
        utils::Optional<T> _var;
};

template<typename T, typename ToleranceType>
class HeaderFieldWithTolerance : public HeaderField<T>
{
        typedef HeaderField<T> BaseT;

    public:
        HeaderFieldWithTolerance(SigProcLabel const& header_label, Header& header, ToleranceType const&);
        HeaderFieldWithTolerance(SigProcLabel const& header_label, Header& header, ToleranceType const&, HeaderFieldWithTolerance const&);
        HeaderFieldWithTolerance& operator=(T const& var);
        
        bool operator==(const HeaderFieldBase&) const override;
        bool operator==(const HeaderFieldWithTolerance&) const;

    private:
        ToleranceType _tolerance;
};


template<typename T>
class HeaderField<std::vector<T>> : public HeaderFieldBase
{
        typedef HeaderFieldBase BaseT;
        // vectors are marked with start and end tags
        class NullField : public HeaderFieldBase {
            public:
                NullField() {}
                // do content other than the label
                bool is_set() const override { return false; }
                void reset() override {};
                void operator=(const HeaderFieldBase&) override {};
        };

        class ItemField : public HeaderFieldBase {
            // only needs to read
            public:
                ItemField(std::vector<T>& vec) : _vec(vec) {}
                bool is_set() const override { return false; }
                unsigned read(std::istream &) override;
                void reset() override {};
                void operator=(const HeaderFieldBase&) override {}

            private:
                std::vector<T>& _vec;
        };

    public:
        HeaderField(SigProcLabel const& start_label, SigProcLabel const& item_label, SigProcLabel const& end_label, Header& header);
        HeaderField(SigProcLabel const& start_label, SigProcLabel const& item_label, SigProcLabel const& end_label, Header& header, HeaderField const& copy);

        operator std::vector<T> const&() const { return _var; }
        operator std::vector<T>&() { return _var; }
        operator utils::Optional<std::vector<T>> const&() const { return _var; }
        HeaderField& operator=(std::vector<T> const& var);

        unsigned read(std::istream &) override;
        unsigned write(std::ostream &) const override;
        std::string const& header_info(std::string const& h) const override;
        void write_info(std::ostream &) const override;
        bool is_set() const override;
        void reset() override;

        std::vector<T> const& operator*() const { return _var; };
        std::vector<T>& operator*() { return _var; };

        bool operator==(const HeaderFieldBase&) const override;
        bool operator==(const HeaderField&) const;
        void operator=(const HeaderFieldBase&) override;

    private:
        std::vector<T>  _var;
        ItemField       _item_label_handler;
        NullField       _end_label_handler;
        SigProcLabel    _end_label;
        SigProcLabel    _item_label;
};

} // namespace sigproc
} // namespace astrotypes
} // namespace pss

#endif // PSS_ASTROTYPES_SIGPROC_HEADERFIELD_H