serialise.hh

/* vim: set sw=4 sts=4 et foldmethod=syntax : */
 
/*
 * Copyright (c) 2009, 2010, 2011 Ciaran McCreesh
 *
 * This file is part of the Paludis package manager. Paludis is free software;
 * you can redistribute it and/or modify it under the terms of the GNU General
 * Public License version 2, as published by the Free Software Foundation.
 *
 * Paludis is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
#ifndef PALUDIS_GUARD_PALUDIS_SERIALISE_HH
#define PALUDIS_GUARD_PALUDIS_SERIALISE_HH 1
 
#include <paludis/util/attributes.hh>
#include <paludis/util/pimp.hh>
#include <paludis/util/wrapped_forward_iterator-fwd.hh>
#include <paludis/serialise-fwd.hh>
#include <paludis/environment-fwd.hh>
#include <memory>
#include <string>
#include <ostream>
 
namespace paludis
{
    namespace serialise
    {
        struct container;
        struct might_be_null;
    }
 
    template <
        typename Flag1_ = void,
        typename Flag2_ = void,
        typename Flag3_ = void
        >
    struct SerialiserFlags
    {
        typedef Flag1_ Flag1;
        typedef Flag2_ Flag2;
        typedef Flag3_ Flag3;
    };
 
    class PALUDIS_VISIBLE SerialiserObjectWriter
    {
        private:
            Serialiser & _serialiser;
 
        public:
            SerialiserObjectWriter(Serialiser &);
            ~SerialiserObjectWriter();
 
            template <
                typename Flags_,
                typename T_>
            SerialiserObjectWriter & member(
                    const Flags_ &,
                    const std::string & item_name,
                    const T_ &);
    };
 
    class PALUDIS_VISIBLE Serialiser
    {
        private:
            std::ostream & _stream;
 
        public:
            Serialiser(std::ostream &);
            ~Serialiser();
 
            SerialiserObjectWriter object(const std::string & class_name)
                PALUDIS_ATTRIBUTE((warn_unused_result));
 
            std::ostream & raw_stream() PALUDIS_ATTRIBUTE((warn_unused_result));
 
            void escape_write(const std::string &);
    };
 
    class PALUDIS_VISIBLE Deserialiser
    {
        private:
            Pimp<Deserialiser> _imp;
 
        public:
            Deserialiser(const Environment * const, std::istream &);
            ~Deserialiser();
 
            const Environment * environment() const PALUDIS_ATTRIBUTE((warn_unused_result));
 
            std::istream & stream() PALUDIS_ATTRIBUTE((warn_unused_result));
    };
 
    class PALUDIS_VISIBLE Deserialisation
    {
        private:
            Pimp<Deserialisation> _imp;
 
        public:
            Deserialisation(
                    const std::string & class_name,
                    Deserialiser &);
            ~Deserialisation();
 
            const Deserialiser & deserialiser() const PALUDIS_ATTRIBUTE((warn_unused_result));
 
            const std::string item_name() const PALUDIS_ATTRIBUTE((warn_unused_result));
 
            const std::string class_name() const PALUDIS_ATTRIBUTE((warn_unused_result));
 
            const std::string string_value() const PALUDIS_ATTRIBUTE((warn_unused_result));
 
            bool null() const PALUDIS_ATTRIBUTE((warn_unused_result));
 
            struct ConstIteratorTag;
            typedef WrappedForwardIterator<ConstIteratorTag,
                    const std::shared_ptr<Deserialisation> > ConstIterator;
            ConstIterator begin_children() const PALUDIS_ATTRIBUTE((warn_unused_result));
            ConstIterator end_children() const PALUDIS_ATTRIBUTE((warn_unused_result));
    };
 
    class PALUDIS_VISIBLE Deserialisator
    {
        private:
            Pimp<Deserialisator> _imp;
 
        public:
            Deserialisator(
                    Deserialisation &,
                    const std::string & class_name);
 
            ~Deserialisator() noexcept(false);
 
            const Deserialisation & deserialisation() const PALUDIS_ATTRIBUTE((warn_unused_result));
 
            template <typename T_> T_ member(const std::string & key_name);
 
            const std::shared_ptr<Deserialisation> find_remove_member(
                    const std::string &) PALUDIS_ATTRIBUTE((warn_unused_result));
 
    };
 
    template <typename T_>
    std::shared_ptr<T_> deserialise(
            const Environment * const,
            const std::string &,
            const std::string &) PALUDIS_VISIBLE PALUDIS_ATTRIBUTE((warn_unused_result));
 
    extern template class Pimp<Deserialiser>;
    extern template class Pimp<Deserialisation>;
    extern template class Pimp<Deserialisator>;
}
 
#endif