common.hpp

//===- include/pstore/serialize/common.hpp ----------------*- mode: C++ -*-===//
//*                                             *
//*   ___ ___  _ __ ___  _ __ ___   ___  _ __   *
//*  / __/ _ \| '_ ` _ \| '_ ` _ \ / _ \| '_ \  *
//* | (_| (_) | | | | | | | | | | | (_) | | | | *
//*  \___\___/|_| |_| |_|_| |_| |_|\___/|_| |_| *
//*                                             *
//===----------------------------------------------------------------------===//
//
// Part of the pstore project, under the Apache License v2.0 with LLVM Exceptions.
// See https://github.com/SNSystems/pstore/blob/master/LICENSE.txt for license
// information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef PSTORE_SERIALIZE_COMMON_HPP
#define PSTORE_SERIALIZE_COMMON_HPP

namespace pstore {
    namespace serialize {


        template <typename T>
        class sticky_assign {
        public:
            sticky_assign () = default;
            sticky_assign (sticky_assign<T> const & rhs)
                    : t_ (rhs.get ())
                    , is_first_{false} {}

            template <typename Other>
            explicit sticky_assign (Other const & t)
                    : t_ (t)
                    , is_first_{false} {}
            sticky_assign (sticky_assign &&) = delete;

            ~sticky_assign () = default;

            template <typename Other>
            sticky_assign & operator= (Other const & rhs) {
                if (is_first_) {
                    t_ = rhs;
                    is_first_ = false;
                }
                return *this;
            }
            sticky_assign & operator= (sticky_assign const &) = delete;
            sticky_assign & operator= (sticky_assign &&) = delete;

            T const & get () const { return t_; }

        private:
            T t_{};
            bool is_first_ = true;
        };

    } // namespace serialize
} // namespace pstore
#endif // PSTORE_SERIALIZE_COMMON_HPP