00001 /* 00002 * IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. By 00003 * downloading, copying, installing or using the software you agree to 00004 * this license. If you do not agree to this license, do not download, 00005 * install, copy or use the software. 00006 * 00007 * Intel Open Source License 00008 * 00009 * Copyright (c) 2005 Intel Corporation. All rights reserved. 00010 * 00011 * Redistribution and use in source and binary forms, with or without 00012 * modification, are permitted provided that the following conditions are 00013 * met: 00014 * 00015 * Redistributions of source code must retain the above copyright 00016 * notice, this list of conditions and the following disclaimer. 00017 * 00018 * Redistributions in binary form must reproduce the above copyright 00019 * notice, this list of conditions and the following disclaimer in the 00020 * documentation and/or other materials provided with the distribution. 00021 * 00022 * Neither the name of the Intel Corporation nor the names of its 00023 * contributors may be used to endorse or promote products derived from 00024 * this software without specific prior written permission. 00025 * 00026 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 00027 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 00028 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 00029 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR 00030 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 00031 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 00032 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 00033 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 00034 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 00035 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 00036 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 00037 */ 00038 #ifndef __STATIC_SCRATCH_BUFFER__ 00039 #define __STATIC_SCRATCH_BUFFER__ 00040 00041 #include <cstdlib> 00042 #include <cstring> 00043 00044 #include "../debug/DebugUtils.h" 00045 #include "../util/ExpandableBuffer.h" 00046 00047 namespace oasys { 00048 00059 template<typename _memory_t = void*, size_t _static_size = 0> 00060 class ScratchBuffer; 00061 00065 template<typename _memory_t> 00066 class ScratchBuffer<_memory_t, 0> : public ExpandableBuffer { 00067 public: 00068 ScratchBuffer(size_t size = 0) : ExpandableBuffer(size) {} 00069 00071 _memory_t buf(size_t size = 0) { 00072 if (size > buf_len_) { 00073 reserve(size); 00074 } 00075 return reinterpret_cast<_memory_t>(buf_); 00076 } 00077 }; 00078 00083 template<typename _memory_t, size_t _static_size> 00084 class ScratchBuffer : public ExpandableBuffer { 00085 public: 00086 ScratchBuffer() { 00087 buf_ = static_buf_; 00088 buf_len_ = _static_size; 00089 } 00090 00091 ScratchBuffer(size_t size) { 00092 buf_ = static_buf_; 00093 buf_len_ = _static_size; 00094 00095 if (size > buf_len_) { 00096 reserve(size); 00097 } 00098 } 00099 00100 virtual ~ScratchBuffer() { 00101 if (! using_malloc()) { 00102 buf_ = 0; 00103 } 00104 } 00105 00107 _memory_t buf(size_t size = 0) { 00108 if (size != 0) { 00109 reserve(size); 00110 } 00111 return reinterpret_cast<_memory_t>(buf_); 00112 } 00113 00115 virtual void reserve(size_t size = 0) { 00116 if (size == 0) { 00117 size = (buf_len_ == 0) ? 1 : (buf_len_ * 2); 00118 } 00119 00120 if (size <= buf_len_) { 00121 return; 00122 } 00123 00124 if (! using_malloc()) 00125 { 00126 ASSERT(size > _static_size); 00127 buf_ = 0; 00128 size_t old_buf_len = buf_len_; 00129 00130 ExpandableBuffer::reserve(size); 00131 memcpy(buf_, static_buf_, old_buf_len); 00132 } 00133 else 00134 { 00135 ExpandableBuffer::reserve(size); 00136 } 00137 } 00138 00139 private: 00140 char static_buf_[_static_size]; 00141 bool using_malloc() { 00142 return buf_ != static_buf_; 00143 } 00144 }; 00145 00146 } // namespace oasys 00147 00148 #endif //__STATIC_SCRATCH_BUFFER_H__