From 8286ac511144e4f17d34eac9affb97e50646344a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Frings-F=C3=BCrst?= <debian@jff-webhosting.net>
Date: Wed, 23 Jul 2014 15:25:44 +0200
Subject: Imported Upstream version 4.0.0

---
 libcult/cult/mm/new.hxx | 297 ------------------------------------------------
 1 file changed, 297 deletions(-)
 delete mode 100644 libcult/cult/mm/new.hxx

(limited to 'libcult/cult/mm/new.hxx')

diff --git a/libcult/cult/mm/new.hxx b/libcult/cult/mm/new.hxx
deleted file mode 100644
index 2b815b4..0000000
--- a/libcult/cult/mm/new.hxx
+++ /dev/null
@@ -1,297 +0,0 @@
-// file      : cult/mm/new.hxx
-// author    : Boris Kolpackov <boris@kolpackov.net>
-// copyright : Copyright (c) 2005-2010 Boris Kolpackov
-// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
-
-#ifndef CULT_MM_NEW_HXX
-#define CULT_MM_NEW_HXX
-
-#include <cult/config.hxx>
-
-#include <cult/types/fundamental.hxx>
-
-#include <cult/mm/exception.hxx>
-
-#include <cult/meta/polymorphic-p.hxx>
-
-namespace Cult
-{
-  namespace MM
-  {
-    class KeyBase
-    {
-    public:
-      // Returned size should be a multiple of a "perfect" size,
-      // sizeof (size_t) * 2.
-      //
-      virtual Size
-      size () const = 0;
-
-      virtual Void
-      construct (Void* p) const = 0;
-
-      virtual Void
-      destroy (Void* p) const = 0;
-
-      virtual
-      ~KeyBase ()
-      {
-      }
-    };
-
-
-    template <typename X>
-    class Key: public KeyBase, public NonCopyable
-    {
-    public:
-      Key ()
-      {
-      }
-
-      virtual Size
-      size () const
-      {
-        //@@ I can do this transparently in allocate().
-        //
-        Size align (sizeof (Size) * 2);
-        Size size (sizeof (X));
-
-        return align * (size / align + ((size % align) ? 1 : 0));
-      }
-
-      virtual Void
-      construct (Void* p) const
-      {
-        new (p) X;
-      }
-
-      virtual Void
-      destroy (Void* p) const
-      {
-        reinterpret_cast<X*> (p)->~X ();
-      }
-    };
-
-
-    struct Absent : virtual Exception {};
-
-
-    namespace Bits
-    {
-      Void*
-      locate (Void const* p, KeyBase const& k) throw (Absent);
-
-      template <typename X, Boolean poly = Meta::polymorphic_p<X>::r>
-      struct Locator;
-
-      template <typename X>
-      struct Locator<X, false>
-      {
-        static Void*
-        locate (X* p, KeyBase const& k) throw (Absent)
-        {
-          return Bits::locate (p, k);
-        }
-      };
-
-      template <typename X>
-      struct Locator<X, true>
-      {
-        static Void*
-        locate (X* p, KeyBase const& k) throw (Absent)
-        {
-          return Bits::locate (dynamic_cast<Void const*> (p), k);
-        }
-      };
-
-      // Note that this structure has a "perfect" size: sizeof (size_t) * 2.
-      // If its size is added to the properly-aligned pointer the result will
-      // still be a properly-aligned pointer.
-      //
-      struct Offset //@@ better name would be OffsetMap
-      {
-        KeyBase const* key;
-        Size offset;
-      };
-    }
-
-
-    template <typename X, typename Y>
-    inline
-    Y*
-    locate (X* p, Key<Y> const& k) throw (Absent)
-    {
-      return p ? reinterpret_cast<Y*> (Bits::Locator<X>::locate (p, k)) : 0;
-    }
-
-    class KeyList
-    {
-    public:
-      KeyList ()
-          : size_ (0)
-      {
-      }
-
-      KeyList (KeyBase const& k)
-          : size_ (1)
-      {
-        keys_[0] = &k;
-      }
-
-      friend KeyList
-      operator| (KeyList const& list, KeyBase const& key);
-
-    public:
-      typedef KeyBase const* const* Iterator;
-
-      Iterator
-      begin () const
-      {
-        return keys_;
-      }
-
-      Iterator
-      end () const
-      {
-        return &(keys_[size_]);
-      }
-
-      Size
-      size () const
-      {
-        return size_;
-      }
-
-    private:
-      KeyBase const* keys_[8];
-      Size size_;
-    };
-
-    inline KeyList
-    operator| (KeyList const& list, KeyBase const& key)
-    {
-      //@@ Need to throw on overflow.
-      //
-      KeyList r (list);
-      r.keys_[r.size_++] = &key;
-      return r;
-    }
-
-    inline KeyList
-    operator| (KeyBase const& a, KeyBase const& b)
-    {
-      return KeyList (a) | b;
-    }
-  }
-}
-
-namespace Cult
-{
-  namespace MM
-  {
-    namespace Bits
-    {
-      class Block;
-
-#ifdef CULT_THREADS
-      extern __thread
-      Block* first_ __attribute__ ((tls_model ("initial-exec")));
-#else
-      extern
-      Block* first_;
-#endif
-
-      class Block
-      {
-      public:
-        Block ()
-        {
-        }
-
-        ~Block ()
-        {
-          //@@ assert (first_ == this);
-          first_ = next_;
-        }
-
-        Void
-        set (Void* p, Size size)
-        {
-          p_ = reinterpret_cast<Char*> (p);
-          size_ = size;
-
-          next_ = first_;
-          first_ = this;
-        }
-
-      public:
-        static Void*
-        locate (Void const* p)
-        {
-          return locate (p, first_);
-        }
-
-      private:
-        static Void*
-        locate (Void const* p, Block* b)
-        {
-          if (b)
-          {
-            if (p >= b->p_ && p < b->p_ + b->size_) return b->p_;
-            else return locate (p, b->next_);
-          }
-
-          return 0;
-        }
-
-      private:
-        Char* p_;
-        Size size_;
-
-        Block* next_;
-      };
-    }
-  }
-}
-
-Cult::Void*
-operator new (Cult::Size) throw (Cult::MM::StdBadAlloc);
-
-Cult::Void*
-operator new (Cult::Size,
-              Cult::MM::KeyList const&,
-              Cult::MM::Bits::Block const& = Cult::MM::Bits::Block ())
-  throw (Cult::MM::StdBadAlloc);
-
-//@@ Need a special operator new that just allocates memory (to use in
-//   static_ptr for instance).
-//
-
-Cult::Void
-operator delete (Cult::Void*) throw ();
-
-Cult::Void
-operator delete (Cult::Void*, Cult::Size) throw ();
-
-
-namespace Cult
-{
-  namespace MM
-  {
-    // Inherit from this class if you plan to access service objects
-    // from a ctor.
-    //
-    struct ServiceAwareObject
-    {
-      static Void*
-      operator new (Size s, Bits::Block const& b = Bits::Block ());
-
-      static Void
-      operator delete (Void* p, Size s);
-    };
-  }
-}
-
-#include <cult/mm/new.ixx>
-
-#endif  // CULT_MM_NEW_HXX
-- 
cgit v1.2.3