pile.hpp

Go to the documentation of this file.

/*********************************************************************/
// dar - disk archive - a backup/restoration program
// Copyright (C) 2002-2052 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
// to contact the author : http://dar.linux.free.fr/email.html
/*********************************************************************/



#ifndef PILE_HPP
#define PILE_HPP

#include "../my_config.h"

#include <vector>
#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) : generic_file(ref) { copy_from(ref); };
        const pile & operator = (const pile & ref) { detruit(); copy_from(ref); return *this; };
        ~pile() { detruit(); };

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

        generic_file *pop();

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

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

        generic_file *bottom() { if(stack.empty()) return NULL; 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);

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


        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);



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

        bool skip(const infinint & pos);
        bool skip_to_eof();
        bool skip_relative(S_I x);
        infinint get_position();
        void copy_to(generic_file & ref);
        void copy_to(generic_file & ref, const infinint & crc_size, crc * & value);

    protected:
        U_I inherited_read(char *a, U_I size);
        void inherited_write(const char *a, U_I size);
        void inherited_sync_write();
        void inherited_terminate();

    private:
        struct face
        {
            generic_file * ptr;
            std::list<std::string> labels;
        };

        std::vector<face> stack;

        void copy_from(const pile & ref)
        {
            throw SRC_BUG; // it is not possible to copy an object to its another of the exact same type when only a pure virtual pointer pointing on it is available, or when no virtual "clone'-like method is available from the root pure virtual class (generic_file here).
        };
        void detruit();
        std::vector<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 = NULL;

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

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


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


} // end of namespace

#endif