stack.h

Go to the documentation of this file.

// -*- mode: c++; tab-width: 4; indent-tabs-mode: t; c-file-style: "stroustrup"; -*-
// vi:set ts=4 sts=4 sw=4 noet cino+=(0 :
// Copyright 2008, 2011, The TPIE development team
// 
// This file is part of TPIE.
// 
// TPIE is free software: you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the
// Free Software Foundation, either version 3 of the License, or (at your
// option) any later version.
// 
// TPIE 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 Lesser General Public
// License for more details.
// 
// You should have received a copy of the GNU Lesser General Public License
// along with TPIE.  If not, see <http://www.gnu.org/licenses/>


#ifndef _TPIE_AMI_STACK_H
#define _TPIE_AMI_STACK_H

#include <tpie/array.h>
#include <tpie/portability.h>
#include <tpie/deprecated.h>
#include <tpie/stream.h>
#include <tpie/compressed/stream.h>
#include <tpie/tpie_assert.h>

namespace tpie {

template <typename T> 
class stack {
public:

    stack(double blockFactor=1.0)
        : m_stream(blockFactor)
        , m_buffer(buffer_size(blockFactor))
        , m_bufferItems(0)
    {
        m_stream.open(static_cast<memory_size_type>(0), access_normal,
                      compression_normal);
    }

    stack(const std::string & path, double blockFactor=1.0)
        : m_stream(blockFactor)
        , m_buffer(buffer_size(blockFactor))
        , m_bufferItems(0)
    {
        m_stream.open(path, access_read_write,
                      static_cast<memory_size_type>(0), access_normal,
                      compression_normal);
        m_stream.seek(0, file_stream_base::end);
    }

    stack(temp_file & tempFile, double blockFactor=1.0)
        : m_stream(blockFactor)
        , m_buffer(buffer_size(blockFactor))
        , m_bufferItems(0)
    {
        m_stream.open(tempFile, access_read_write,
                      static_cast<memory_size_type>(0), access_normal,
                      compression_normal);
        m_stream.seek(0, file_stream_base::end);
    }


    ~stack() {
        empty_buffer();
        m_stream.truncate(m_stream.get_position());
    }

    inline void push(const T & t) throw(stream_exception) {
        if (m_buffer.size() == m_bufferItems) empty_buffer();
        m_buffer[m_bufferItems++] = t;
    }

    inline const T & pop() throw(stream_exception) {
        if (m_bufferItems) return m_buffer[--m_bufferItems];
        const T & item = m_stream.read_back();
        return item;
    }

    inline const T & top() throw(stream_exception) {
        if (m_bufferItems) return m_buffer[m_bufferItems-1];
        m_buffer[0] = m_stream.read_back();
        m_stream.read();
        return m_buffer[0];
    }

    stream_size_type size() const {
        return m_stream.offset()+m_bufferItems;
    }

    inline bool empty() const {
        return size()  == 0;
    }

    inline static memory_size_type memory_usage(float blockFactor=1.0) {
        return sizeof(stack<T>)
            + file_stream<T>::memory_usage(blockFactor)
            + array<T>::memory_usage(buffer_size(blockFactor));
    }

protected:

    file_stream<T> m_stream;

private:
    array<T> m_buffer;
    size_t m_bufferItems;

    inline void empty_buffer() {
        if (m_bufferItems == 0) return;
        m_stream.truncate(m_stream.get_position());
        m_stream.write(m_buffer.begin(), m_buffer.begin()+m_bufferItems);
        m_bufferItems = 0;
    }

    static memory_size_type buffer_size(double blockFactor) {
        return file_stream<T>::block_size(blockFactor)/sizeof(T);
    }

};

namespace ami {

template<class T> 
class stack {
public:
   
    stack() :
        m_ulate(m_tempFile) {
        // Empty ctor.
    }

    stack(const std::string& path, 
          stream_type type = READ_WRITE_STREAM)
        : m_tempFile(path, true)
        , m_ulate(m_tempFile)
    {
        unused(type);
    }

    err push(const T &t);

    err pop(const T **t); 

    err peek(const T **t); 

    TPIE_OS_OFFSET size() const {
        return m_ulate.size();
    }

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

    void persist(persistence p) {
        m_tempFile.set_persistent(p == PERSIST_PERSISTENT);
    }

    persistence persist() const { 
        return m_tempFile.is_persistent() ? PERSIST_PERSISTENT : PERSIST_DELETE;
    }

    err trim() {
        return NO_ERROR;
    }

    err main_memory_usage(TPIE_OS_SIZE_T *usage,
                          stream_usage usage_type) const;

    TPIE_OS_OFFSET stream_len() const {
        TP_LOG_WARNING_ID("Using AMI_stack<T>::stream_len() is deprecated.");
        return size();
    }

    tpie::stack<T> & underlying_stack() {
        return m_ulate;
    }
private:

    temp_file m_tempFile;

    // em-ulate. get it?
    tpie::stack<T> m_ulate;
};


template<class T>
err stack<T>::push(const T &t) {

    err retval = NO_ERROR;

    try {
        m_ulate.push(t);
    } catch (end_of_stream_exception &) {
        retval = END_OF_STREAM;
    } catch (stream_exception &) {
        retval = IO_ERROR;
    }

    return retval;

}


template<class T>
err stack<T>::pop(const T **t) {
    if(m_ulate.empty())
        return END_OF_STREAM;

    err retval = NO_ERROR;

    try {

        const T & res = m_ulate.pop();
        *t = &res;

    } catch (end_of_stream_exception &) {
        retval = END_OF_STREAM;
    } catch (stream_exception &) {
        retval = IO_ERROR;
    }

    return retval;

}


template<class T>
err stack<T>::peek(const T **t) {
    if(m_ulate.empty())
        return END_OF_STREAM;

    err retval = NO_ERROR;
    
    try {

        const T & res = m_ulate.top();
        *t = &res;

    } catch (end_of_stream_exception &) {
        retval = END_OF_STREAM;
    } catch (stream_exception &) {
        retval = IO_ERROR;
    }

    return retval;

}


template<class T>
err stack<T>::main_memory_usage(TPIE_OS_SIZE_T *usage,
                                stream_usage usage_type) const {
    
    switch (usage_type) {

        //  All these types are o.k.
    case STREAM_USAGE_OVERHEAD:
    case STREAM_USAGE_CURRENT:
    case STREAM_USAGE_MAXIMUM:
    case STREAM_USAGE_SUBSTREAM:
    case STREAM_USAGE_BUFFER:
        *usage = tpie::stack<T>::memory_usage();
        *usage += sizeof(*this);
        break;

    default:
        tp_assert(0, "Unknown mem::stream_usage type added.");  
    }
    
    return NO_ERROR;
}


} // ami namespace

}  //  tpie namespace

#endif // _TPIE_AMI_STACK_H