array.h

Go to the documentation of this file.

// See the end of this file for license information.

#ifndef TORSION_ARRAY_H
#define TORSION_ARRAY_H

#include "virtmem.h"
#include "physmem.h"
#include "types.h"


template <class T>
class Array {
protected:
  T* data;        
  Size used_size;     

  Size capacity;
  Size init_capacity;     
  bool physical;      
  static const Size INITIAL_VIRTUAL_CAPACITY = 8;
  static const Size INITIAL_PHYSICAL_CAPACITY = PAGE_SIZE / sizeof(T);

public:
  Array(bool physical = false, Size init_capacity = 0) {
    init(physical, init_capacity);
  }

  void
  init(bool physical = false, Size init_capacity = 0) {
    used_size = 0;
    capacity = 0;
    data = NULL;
    this->physical = physical;
    this->init_capacity = init_capacity;
  }

  inline Size
  size() {
    return used_size;
  }

  inline void
  set_size(unsigned new_size) {
    used_size = new_size;
  }

  inline Size
  get_capacity() {
    return capacity;
  }

  void
  grow(bool set_size_too = false);

  inline void
  ensure_capacity() {
    if (used_size >= capacity)
      grow();
  }

  inline T&
  append(T& element) {
    used_size++;
    ensure_capacity();
    data[used_size - 1] = element;
    return data[used_size - 1];
  }

  inline T&
  operator [](unsigned index) {
    return data[index];
  }

  inline void
  clear() {
    if (data) {
      if (physical)
        physical_pages.free_page(data);
      else
        virtual_mem->free(data);
    }
    data = NULL;
    used_size = 0;
    capacity = 0;
  }
};

template <class T>
void
Array<T>::grow(bool set_size_too) {
  if (physical) {
    if (capacity == 0) {    // initially allocate a data array
      if (init_capacity == 0)
        init_capacity = INITIAL_PHYSICAL_CAPACITY;

      data = (T*)physical_pages.alloc_page(MEM_CLASS_1MB_TO_16MB,
                                           init_capacity * sizeof(T));
      capacity = init_capacity;
    } else {        // resize the data to be twice as big
      data = (T*)physical_pages.resize(data, MEM_CLASS_1MB_TO_16MB,
                                       capacity * 2 * sizeof(T));
      capacity *= 2;
    }
  } else {
    if (capacity == 0) {    // initially allocate a data array
      if (init_capacity == 0)
        init_capacity = INITIAL_VIRTUAL_CAPACITY;
    
      data = (T*)virtual_mem->alloc(init_capacity * sizeof(T));
      capacity = INITIAL_VIRTUAL_CAPACITY;
    } else {        // resize the data to be twice as big
      data = (T*)virtual_mem->resize(data, capacity * 2 * sizeof(T));
      capacity *= 2;
    }
  }

  if (set_size_too)
    used_size = capacity;
}

#endif

/* Torsion Operating System, Copyright (C) 2000-2004 Dan Helfman
 *
 * 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 (in the COPYING file).
 * 
 * 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
 */

---

Torsion Operating System, Copyright (C) 2000-2004 Dan Helfman