main page modules namespaces classes files
Gecode home

allocators.hpp

Go to the documentation of this file.

/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Filip Konvicka <filip.konvicka@logis.cz>
 *
 *  Copyright:
 *     LOGIS, s.r.o., 2009
 *
 *  Bugfixes provided by:
 *     Gustavo Gutierrez
 *
 *  Last modified:
 *     $Date: 2009-11-24 23:12:38 +0100 (Tue, 24 Nov 2009) $ by $Author: schulte $
 *     $Revision: 10122 $
 *
 *  Permission is hereby granted, free of charge, to any person obtaining
 *  a copy of this software and associated documentation files (the
 *  "Software"), to deal in the Software without restriction, including
 *  without limitation the rights to use, copy, modify, merge, publish,
 *  distribute, sublicense, and/or sell copies of the Software, and to
 *  permit persons to whom the Software is furnished to do so, subject to
 *  the following conditions:
 *
 *  The above copyright notice and this permission notice shall be
 *  included in all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include <limits>

namespace Gecode {

  template<class T> struct space_allocator;

  template<> 
  struct space_allocator<void> {
    typedef void*       pointer;
    typedef const void* const_pointer;
    typedef void        value_type;
    template<class U> struct rebind {
      typedef space_allocator<U> other;
    };
  };

  template<class T> 
  struct space_allocator {
    typedef T value_type;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef T* pointer;
    typedef T const* const_pointer;
    typedef T& reference;
    typedef T const&  const_reference;
    template<class U> struct rebind { 
      typedef space_allocator<U> other;
    };

    Space& space;

    space_allocator(Space& space) throw() : space(space) {}
    space_allocator(space_allocator const& al) throw() : space(al.space) {}
    space_allocator& operator =(space_allocator const& al) {
      assert(&space == &al.space);
      return *this;
    }
    template<class U> 
    space_allocator(space_allocator<U> const& al) throw() : space(al.space) {}

    pointer address(reference x) const { return &x; }
    const_pointer address(const_reference x) const { return &x; }
    size_type max_size() const throw() {
      return std::numeric_limits<size_type>::max() / 
        (sizeof(T)>0 ? sizeof(T) : 1);
    }
    pointer allocate(size_type count) {
      return static_cast<pointer>(space.ralloc(sizeof(T)*count));
    }

    pointer allocate(size_type count, const void * const hint) {
      (void) hint;
      return allocate(count);
    }

    void deallocate(pointer p, size_type count) {
      space.rfree(static_cast<void*>(p), count);
    }

    /*
     * \brief Constructs an object 
     *
     * Constructs an object of type \a T with the initial value of \a t 
     * at the location specified by \a element. This function calls 
     * the <i>placement new()</i> operator.
     */
    void construct(pointer element, const_reference t) {
      new (element) T(t);
    }

    void destroy(pointer element) {
      element->~T();
    }
  };

  template<class T1, class T2>
  bool operator==(space_allocator<T1> const& al1, 
                  space_allocator<T2> const& al2) throw() {
    return &al1.space == &al2.space;
  }

  template<class T1, class T2>
  bool operator!=(space_allocator<T1> const& al1, 
                  space_allocator<T2> const& al2) throw() {
    return &al1.space != &al2.space;
  }


  template<class T> struct region_allocator;

  template<> 
  struct region_allocator<void> {
    typedef void* pointer;
    typedef const void* const_pointer;
    typedef void value_type;
    template<class U> struct rebind {
      typedef region_allocator<U> other;
    };
  };

  template<class T> 
  struct region_allocator {
    typedef T value_type;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef T* pointer;
    typedef T const*  const_pointer;
    typedef T&  reference;
    typedef T const& const_reference;

    template<class U> struct rebind { 
     typedef region_allocator<U> other;
    };

    Region& region;

    region_allocator(Region& region) throw() 
      : region(region) {}
    region_allocator(region_allocator const& al) throw() 
      : region(al.region) {}
    template<class U> 
    region_allocator(region_allocator<U> const& al) throw() 
      : region(al.region) {}

    pointer address(reference x) const { return &x; }
    const_pointer address(const_reference x) const { return &x; }
    size_type max_size() const throw() {
      return std::numeric_limits<size_type>::max() 
        / (sizeof(T)>0 ? sizeof(T) : 1);
    }

    pointer allocate(size_type count) {
      return static_cast<pointer>(region.ralloc(sizeof(T)*count));
    }

    pointer allocate(size_type count, const void * const hint) {
      (void) hint;
      return allocate(count);
    }
    
    void deallocate(pointer* p, size_type count) {
      region.rfree(static_cast<void*>(p), count);
    }

     void construct(pointer element, const_reference t) {
      new (element) T(t);
    }

    void destroy(pointer element) {
      element->~T();
    }
  };

  /*
   * \brief Tests two region allocators for equality
   *
   * Two allocators are equal when each can release storage allocated 
   * from the other.
   */
  template<class T1, class T2>
  bool operator==(region_allocator<T1> const& al1, 
                  region_allocator<T2> const& al2) throw() {
    return &al1.region == &al2.region;
  }

  /*
   * \brief Tests two region allocators for inequality
   *
   * Two allocators are equal when each can release storage allocated
   * from the other.
   */
  template<class T1, class T2>
  bool operator!=(region_allocator<T1> const& al1, 
                  region_allocator<T2> const& al2) throw() {
    return &al1.region != &al2.region;
  }

}

// STATISTICS: kernel-other