// Copyright (C) 2004  Davis E. King (davis@dlib.net)
// License: Boost Software License   See LICENSE.txt for the full license.
#ifndef DLIB_SLIDING_BUFFER_KERNEl_1_
#define DLIB_SLIDING_BUFFER_KERNEl_1_

#include "sliding_buffer_kernel_abstract.h"
#include "../algs.h"
#include "../interfaces/enumerable.h"
#include "../serialize.h"

namespace dlib
{

    template <
        typename T
        >
    class sliding_buffer_kernel_1 : public enumerable<T>
    {
        /*!
            INITIAL VALUE
                - buffer_size == 0
                - buffer == 0
                - buffer_start == 0
                - current == 0
                - at_start_ == true

            CONVENTION
                - buffer_size == size()
                
                - element() == (*this)[current]
                - current_element_valid() == (current < buffer_size) && at_start_ == false
                - at_start() == at_start_

                - if (buffer_size != 0) then                    
                    - buffer[(buffer_start+i)&(mask)] == operator[](i)   
                    - mask == buffer_size-1
                - else
                    - buffer == 0
                    - buffer_size == 0
        !*/

    public:

        typedef T type;

        sliding_buffer_kernel_1 (
        ) :
            buffer_start(0),
            buffer_size(0),
            buffer(0),
            current(0),
            at_start_(true)
        {}

        virtual ~sliding_buffer_kernel_1 (
        ) { if (buffer) delete [] buffer; }

        void clear(
        ) 
        {
            buffer_size = 0; 
            if (buffer) delete [] buffer;
            buffer = 0;
            at_start_ = true;
            current = 0;
        }

        void set_size (
            unsigned long exp_size
        )
        {
            at_start_ = true;
            if (buffer) delete [] buffer;
            buffer_size = 1;
            while (exp_size != 0)
            {
                --exp_size;
                buffer_size <<= 1;            
            }
            mask = buffer_size-1;
            try { buffer = new T[buffer_size]; }
            catch (...) { buffer = 0; buffer_size = 0; throw; }
        }

        size_t size (
        ) const { return buffer_size; }

        void rotate_left (
            unsigned long amount
        ) { buffer_start = ((buffer_start-amount)&mask); at_start_ = true; }

        void rotate_right (
            unsigned long amount
        ) { buffer_start = ((buffer_start+amount)&mask); at_start_ = true;}

        const T& operator[] (
            unsigned long index
        ) const { return buffer[(buffer_start+index)&mask]; }

        T& operator[] (
            unsigned long index
        ) { return buffer[(buffer_start+index)&mask]; }

        unsigned long get_element_id(
            unsigned long index
        ) const { return ((buffer_start+index)&mask); }

        unsigned long get_element_index (
            unsigned long element_id 
        ) const { return ((element_id-buffer_start)&mask);}

        void swap (
            sliding_buffer_kernel_1<T>& item
        )
        {
            exchange(buffer_start,item.buffer_start);
            exchange(buffer_size,item.buffer_size);
            exchange(buffer,item.buffer);
            exchange(mask,item.mask);
            exchange(current,item.current);
            exchange(at_start_,item.at_start_);
        }


        bool at_start (
        ) const { return at_start_; }

        void reset (
        ) const { at_start_ = true; }

        bool current_element_valid (
        ) const { return (current < buffer_size) && (at_start_ == false); }

        const T& element (
        ) const { return (*this)[current]; }

        T& element (
        ) { return (*this)[current]; }

        bool move_next (
        ) const 
        { 
            if (at_start_ == false)
            {
                if (current+1 < buffer_size)
                {
                    ++current;
                    return true;
                }
                else
                {
                    current = buffer_size;
                    return false;
                }
            }
            else 
            {
                at_start_ = false;
                current = 0;
                return (buffer_size != 0);
            }
        }


    private:

        // data members
        unsigned long buffer_start;
        unsigned long buffer_size;
        T* buffer;
        unsigned long mask;


        mutable unsigned long current;
        mutable bool at_start_;

        // restricted functions
        sliding_buffer_kernel_1(sliding_buffer_kernel_1<T>&);        // copy constructor
        sliding_buffer_kernel_1<T>& operator=(sliding_buffer_kernel_1<T>&);    // assignment operator

    };      

    template <
        typename T
        >
    inline void swap (
        sliding_buffer_kernel_1<T>& a, 
        sliding_buffer_kernel_1<T>& b 
    ) { a.swap(b); }   

    template <
        typename T
        >
    void deserialize (
        sliding_buffer_kernel_1<T>& item, 
        std::istream& in
    )   
    {
        try
        {
            item.clear();
            unsigned long size;
            deserialize(size,in);
            if (size > 0)
            {
                int count = 0;
                while (size != 1)
                {
                    size /= 2;
                    ++count;
                }
                item.set_size(count);

                for (unsigned long i = 0; i < item.size(); ++i)
                    deserialize(item[i],in);
            }
        }
        catch (serialization_error e)
        { 
            item.clear();
            throw serialization_error(e.info + "\n   while deserializing object of type sliding_buffer_kernel_1"); 
        }
    }
}

#endif // DLIB_SLIDING_BUFFER_KERNEl_1_