# OgreMemoryNedPooling.h

Go to the documentation of this file.

    00001 /*
    00002 -----------------------------------------------------------------------------
    00003 This source file is part of OGRE
    00004 (Object-oriented Graphics Rendering Engine)
    00005 For the latest info, see http://www.ogre3d.org/
    00006
    00007 Copyright (c) 2000-2009 Torus Knot Software Ltd
    00008
    00009 Permission is hereby granted, free of charge, to any person obtaining a copy
    00010 of this software and associated documentation files (the "Software"), to deal
    00011 in the Software without restriction, including without limitation the rights
    00012 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    00013 copies of the Software, and to permit persons to whom the Software is
    00014 furnished to do so, subject to the following conditions:
    00015
    00016 The above copyright notice and this permission notice shall be included in
    00017 all copies or substantial portions of the Software.
    00018
    00019 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    00020 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    00021 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    00022 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    00023 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    00024 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    00025 THE SOFTWARE.
    00026 -----------------------------------------------------------------------------
    00027 */
    00028
    00029
    00030 #ifndef __MemoryNedPooling_H__
    00031 #define __MemoryNedPooling_H__
    00032
    00033 #if OGRE_MEMORY_ALLOCATOR == OGRE_MEMORY_ALLOCATOR_NEDPOOLING
    00034
    00035 namespace Ogre
    00036 {
    00045     class _OgreExport NedPoolingImpl
    00046     {
    00047     public:
    00048         static void* allocBytes(size_t count,
    00049             const char* file, int line, const char* func);
    00050         static void deallocBytes(void* ptr);
    00051         static void* allocBytesAligned(size_t align, size_t count,
    00052             const char* file, int line, const char* func);
    00053         static void deallocBytesAligned(size_t align, void* ptr);
    00054
    00055     };
    00056
    00065     class _OgreExport NedPoolingPolicy
    00066     {
    00067     public:
    00068         static inline void* allocateBytes(size_t count,
    00069             const char* file = 0, int line = 0, const char* func = 0)
    00070         {
    00071             return NedPoolingImpl::allocBytes(count, file, line, func);
    00072         }
    00073         static inline void deallocateBytes(void* ptr)
    00074         {
    00075             NedPoolingImpl::deallocBytes(ptr);
    00076         }
    00078         static inline size_t getMaxAllocationSize()
    00079         {
    00080             return std::numeric_limits<size_t>::max();
    00081         }
    00082
    00083     private:
    00084         // No instantiation
    00085         NedPoolingPolicy()
    00086         { }
    00087     };
    00088
    00089
    00102     template <size_t Alignment = 0>
    00103     class NedPoolingAlignedPolicy
    00104     {
    00105     public:
    00106         // compile-time check alignment is available.
    00107         typedef int IsValidAlignment
    00108             [Alignment <= 128 && ((Alignment & (Alignment-1)) == 0) ? +1 : -1];
    00109
    00110         static inline void* allocateBytes(size_t count,
    00111             const char* file = 0, int line = 0, const char* func = 0)
    00112         {
    00113             return NedPoolingImpl::allocBytesAligned(Alignment, count, file, line, func);
    00114         }
    00115
    00116         static inline void deallocateBytes(void* ptr)
    00117         {
    00118             NedPoolingImpl::deallocBytesAligned(Alignment, ptr);
    00119         }
    00120
    00122         static inline size_t getMaxAllocationSize()
    00123         {
    00124             return std::numeric_limits<size_t>::max();
    00125         }
    00126     private:
    00127         // no instantiation allowed
    00128         NedPoolingAlignedPolicy()
    00129         { }
    00130     };
    00131
    00132
    00133
    00134
    00138 }// namespace Ogre
    00139
    00140 #endif
    00141
    00142 #endif // __MemoryNedPooling_H__
    00143

Copyright © 2008 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Sun May 8 2011 20:28:08