pageframetable.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2003,2004,2005 Bregmasoft
 * 
 * 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
 */
#ifndef ZYGOMA_PAGEFRAMETABLE_H_ 
#define ZYGOMA_PAGEFRAMETABLE_H_ 

#include <cstddef>
#include <iterator>
#include <memory.h>
#include <types.h>
#include <pageframe.h>
#include <spinlock.h>

namespace Zygoma
{
  class PageFrameTable;

  bool
  operator==(const PageFrameTable& lhs, const PageFrameTable& rhs);

  class PageFrameTableIterator
  {
  public:
    typedef std::random_access_iterator_tag iterator_category;
    typedef PageFrame                       value_type;
    typedef std::ptrdiff_t                  difference_type;
    typedef PageFrame*                      pointer;
    typedef PageFrame&                      reference;

  public:

    PageFrameTableIterator(PageFrameTable&, difference_type offset = 0);

    PageFrameTableIterator(const PageFrameTableIterator& rhs);

    PageFrameTableIterator&
    operator=(const PageFrameTableIterator& rhs);

    ~PageFrameTableIterator();

    reference
    operator*();

    reference
    operator[](difference_type);

    pointer
    operator->();

    PageFrameTableIterator&
    operator++();

    PageFrameTableIterator&
    operator++(int);

    PageFrameTableIterator&
    operator--();

    PageFrameTableIterator&
    operator--(int);

    PageFrameTableIterator&
    operator+=(difference_type);

    PageFrameTableIterator&
    operator-(difference_type);

    difference_type
    operator-(const PageFrameTableIterator&);
    /* @} */

    PhysicalAddress
    baseAddress() const;

    bool
    equals(const PageFrameTableIterator& rhs) const
    {
      return (m_pageFrameTable == rhs.m_pageFrameTable)
          && (m_currentOffset  == rhs.m_currentOffset);
    }

    bool
    lessThan(const PageFrameTableIterator& rhs) const
    {
      return (m_pageFrameTable == rhs.m_pageFrameTable)
          && (m_currentOffset  < rhs.m_currentOffset);
    }
    /* @} */

  private:
    PageFrameTable& m_pageFrameTable;
    difference_type m_currentOffset;
  };


  inline bool
  operator==(const PageFrameTableIterator& lhs,
             const PageFrameTableIterator& rhs)
  { return lhs.equals(rhs); }


  inline bool
  operator!=(const PageFrameTableIterator& lhs,
             const PageFrameTableIterator& rhs)
  { return !lhs.equals(rhs); }


  inline bool
  operator<(const PageFrameTableIterator& lhs,
            const PageFrameTableIterator& rhs)
  { return lhs.lessThan(rhs); }


  PageFrameTableIterator
  operator+(PageFrameTableIterator::difference_type n,
            const PageFrameTableIterator& i);


  PageFrameTableIterator
  operator+(const PageFrameTableIterator& i,
            PageFrameTableIterator::difference_type n);


  class PageFrameTable
  {
    friend class PageFrameTableIterator;

  public:
    typedef PageFrame                               value_type;
    typedef value_type*                             pointer;
    typedef const value_type*                       const_pointer;
    typedef value_type&                             reference;
    typedef const value_type&                       const_reference;
    typedef PageFrameTableIterator                  iterator;
    typedef const PageFrameTableIterator            const_iterator;
    typedef PageFrameTableIterator::difference_type difference_type;
    typedef std::size_t                             size_type;
    /* @} */

  public:
    static PageFrameTable*
    create(PhysicalAddress base, PhysicalAddress himem);

    size_type
    size() const;

    size_type
    max_size() const
    { return size(); }

    bool
    empty() const
    { return false; }

    iterator
    begin();

    const_iterator
    begin() const;

    iterator
    end();

    const_iterator
    end() const;

#if 0
// Replace with locking proxy returned from iterator?
    void
    markFrameUsed(FrameIndex frameNumber, int taskId);

    void
    markFrameUnused(FrameIndex frameNumber);
#endif

    iterator
    find(PhysicalAddress address);
    /* @} */

    bool
    equals(const PageFrameTable& rhs) const
    { return &m_frame[0] == &rhs.m_frame[0]; }
    /* @} */

  private:
    PageFrameTable(size_type numFrames);

    PageFrameTable(const PageFrameTable&);
    PageFrameTable& operator=(const PageFrameTable&);

  private:
    size_type     m_numberOfFrames;
    SpinLockMutex m_spinLock;
    PageFrame     m_frame[1];
  };

  inline bool
  operator==(const PageFrameTable& lhs, const PageFrameTable& rhs)
  { return lhs.equals(rhs); }

} // namespace Zygoma
#endif // ZYGOMA_PAGEFRAMETABLE_H_ 

---