pile.hpp

Go to the documentation of this file.

/*********************************************************************/
// dar - disk archive - a backup/restoration program
// Copyright (C) 2002-2024 Denis Corbin
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// to contact the author, see the AUTHOR file
/*********************************************************************/



#ifndef PILE_HPP
#define PILE_HPP

#include "../my_config.h"

#include <list>
#include "generic_file.hpp"

namespace libdar
{



    class pile : public generic_file
    {
    public:


    pile() : generic_file(gf_read_only) { stack.clear(); };
    pile(const pile & ref) = delete;
    pile(pile && ref) noexcept = delete;
    pile & operator = (const pile & ref) = delete;
    pile & operator = (pile && ref) noexcept = delete;
    ~pile() { detruit(); };


    void push(generic_file *f, const std::string & label = "", bool extend_mode = false);


    generic_file *pop();


    template <class T> bool pop_and_close_if_type_is(T *ptr);

    generic_file *top() const { if(stack.empty()) return nullptr; else return stack.back().ptr; };

    generic_file *bottom() const { if(stack.empty()) return nullptr; else return stack[0].ptr; };

    U_I size() const { return stack.size(); };

    bool is_empty() const { return stack.empty(); };

    void clear() { detruit(); };


    template<class T> void find_first_from_top(T * & ref) const;

    template<class T> void find_first_from_bottom(T * & ref) const;


    generic_file *get_below(const generic_file *ref);

    generic_file *get_above(const generic_file *ref);



    generic_file *get_by_label(const std::string & label);




    void clear_label(const std::string & label);



    void add_label(const std::string & label);


    void sync_write_above(generic_file *ptr);

    void flush_read_above(generic_file *ptr);

        // inherited methods from generic_file
        // they all apply to the top generic_file object, they fail by Erange() exception if the stack is empty

    virtual bool skippable(skippability direction, const infinint & amount) override;
    virtual bool skip(const infinint & pos) override;
    virtual bool skip_to_eof() override;
    virtual bool skip_relative(S_I x) override;
    virtual bool truncatable(const infinint & amount) const override;
    virtual infinint get_position() const override;

    void copy_to(generic_file & ref) override;
    void copy_to(generic_file & ref, const infinint & crc_size, crc * & value) override;

    protected:
    virtual void inherited_read_ahead(const infinint & amount) override;
    virtual U_I inherited_read(char *a, U_I size) override;
    virtual void inherited_write(const char *a, U_I size) override;
    virtual void inherited_truncate(const infinint & pos) override;
    virtual void inherited_sync_write() override;
    virtual void inherited_flush_read() override;
    virtual void inherited_terminate() override;

    private:
    struct face
    {
        generic_file * ptr;
        std::list<std::string> labels;
    };  // ok, had not much idea to find a name for that struct, "face" was the first idea found to be associated with "pile", which means stack
        // in French but also is the name of the face of a coin where its value is written. The opposite face of a coin is called "face" in French
        // because often a face is design there and the expression "tirer `a pile ou face" (meaning "to toss up") is very common.

    std::deque<face> stack;

    void detruit();
    std::deque<face>::iterator look_for_label(const std::string & label);
    };


    template <class T> bool pile::pop_and_close_if_type_is(T *ptr)
    {
    generic_file *top = nullptr;

    if(!stack.empty())
    {
        top = stack.back().ptr;
        ptr = dynamic_cast<T *>(top);
        if(ptr != nullptr)
        {
        ptr->terminate();
        stack.pop_back();
        delete ptr;
        return true;
        }
        else
        return false;
    }
    else
        return false;
    }

    template <class T> void pile::find_first_from_top(T * & ref) const
    {
    ref = nullptr;
    for(std::deque<face>::const_reverse_iterator it = stack.rbegin(); it != stack.rend() && ref == nullptr; ++it)
        ref = dynamic_cast<T *>(it->ptr);
    }


    template <class T> void pile::find_first_from_bottom(T * & ref) const
    {
    ref = nullptr;
    for(std::deque<face>::const_iterator it = stack.begin(); it != stack.end() && ref == nullptr; ++it)
        ref = dynamic_cast<T *>(it->ptr);
    }


} // end of namespace

#endif