include/memory.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2004 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_MEMORY_H_ 
#define ZYGOMA_MEMORY_H_ 

#include <arch/memory.h>
#include <arch.h>
#include <iterator>

namespace Zygoma
{
  typedef Arch::PhysicalAddress PhysicalAddress;

  using Arch::PAGE_FRAME_SIZE;


  template<int stride>
    class MemoryStrider
    : public std::iterator<std::forward_iterator_tag, const PhysicalAddress>
    {
    public:
      MemoryStrider(PhysicalAddress start = 0)
      : m_curAddress(start)
      { }

      reference
      operator*() const
      { return m_curAddress; }

      MemoryStrider&
      operator++()
      {
        m_curAddress += stride;
        return *this;
      }

      MemoryStrider&
      operator++(int)
      {
        PhysicalAddress oldAddress = *this;
        m_curAddress += stride;
        return oldAddress;
      }

    private:
      PhysicalAddress m_curAddress;
    };


  template<int stride>
    inline bool
    operator==(const MemoryStrider<stride>& lhs,
               const MemoryStrider<stride>& rhs)
    { return *lhs == *rhs; }

  template<int stride>
    inline bool
    operator!=(const MemoryStrider<stride>& lhs,
               const MemoryStrider<stride>& rhs)
    { return *lhs != *rhs; }


  template<int stride>
    class MemoryRange
    {
    public:
      typedef MemoryStrider<stride> iterator;

    public:
      MemoryRange(PhysicalAddress start, PhysicalAddress size)
      : m_start(start)
      , m_size(size)
      { }

      iterator
      begin() const
      { return m_start; }

      iterator
      end() const
      { return m_start + m_size; }

    private:
      PhysicalAddress m_start;
      PhysicalAddress m_size;
    };
}  // namespace Zygoma

#endif // ZYGOMA_MEMORY_H_ 

---