2 Copyright (c) 2004-2009, John Hurst
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions
8 1. Redistributions of source code must retain the above copyright
9 notice, this list of conditions and the following disclaimer.
10 2. Redistributions in binary form must reproduce the above copyright
11 notice, this list of conditions and the following disclaimer in the
12 documentation and/or other materials provided with the distribution.
13 3. The name of the author may not be used to endorse or promote products
14 derived from this software without specific prior written permission.
16 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 /*! \file KM_platform.h
28 \version $Id: KM_platform.h,v 1.6 2010/09/14 19:21:47 msheby Exp $
29 \brief platform portability
32 #ifndef _KM_PLATFORM_H_
33 # define _KM_PLATFORM_H_
36 # ifdef __BIG_ENDIAN__
37 # define KM_BIG_ENDIAN
42 # define WIN32_LEAN_AND_MEAN
45 /* we like the "SendMessage" name, so get rid of the preprocessor define
46 * and replace with an inline function */
59 return SendMessageW(hWnd, Msg, wParam, lParam);
\r
72 return SendMessageA(hWnd, Msg, wParam, lParam);
\r
79 # pragma warning(disable:4786) // Ignore "identifer > 255 characters" warning
81 typedef unsigned __int64 ui64_t;
82 typedef __int64 i64_t;
83 # define i64_C(c) (i64_t)(c)
84 # define ui64_C(c) (ui64_t)(c)
85 # define snprintf _snprintf
86 # define vsnprintf _vsnprintf
89 typedef unsigned long long ui64_t;
90 typedef long long i64_t;
91 # define i64_C(c) c##LL
92 # define ui64_C(c) c##ULL
101 typedef unsigned char byte_t;
103 typedef unsigned char ui8_t;
105 typedef unsigned short ui16_t;
107 typedef unsigned int ui32_t;
112 inline ui16_t Swap2(ui16_t i)
114 return ( (i << 8) | (( i & 0xff00) >> 8) );
117 inline ui32_t Swap4(ui32_t i)
120 ( (i & 0x000000ffUL) << 24 ) |
121 ( (i & 0xff000000UL) >> 24 ) |
122 ( (i & 0x0000ff00UL) << 8 ) |
123 ( (i & 0x00ff0000UL) >> 8 );
126 inline ui64_t Swap8(ui64_t i)
129 ( (i & ui64_C(0x00000000000000FF)) << 56 ) |
130 ( (i & ui64_C(0xFF00000000000000)) >> 56 ) |
131 ( (i & ui64_C(0x000000000000FF00)) << 40 ) |
132 ( (i & ui64_C(0x00FF000000000000)) >> 40 ) |
133 ( (i & ui64_C(0x0000000000FF0000)) << 24 ) |
134 ( (i & ui64_C(0x0000FF0000000000)) >> 24 ) |
135 ( (i & ui64_C(0x00000000FF000000)) << 8 ) |
136 ( (i & ui64_C(0x000000FF00000000)) >> 8 );
141 inline T xmin(T lhs, T rhs) {
142 return (lhs < rhs) ? lhs : rhs;
147 inline T xmax(T lhs, T rhs) {
148 return (lhs > rhs) ? lhs : rhs;
153 inline T xclamp(T v, T l, T h) {
154 if ( v < l ) return l;
155 if ( v > h ) return h;
160 // read an integer from byte-structured storage
162 inline T cp2i(const byte_t* p) { return *(T*)p; }
164 // write an integer to byte-structured storage
166 inline void i2p(T i, byte_t* p) { *(T*)p = i; }
168 # ifdef KM_BIG_ENDIAN
169 # define KM_i16_LE(i) Kumu::Swap2(i)
170 # define KM_i32_LE(i) Kumu::Swap4(i)
171 # define KM_i64_LE(i) Kumu::Swap8(i)
172 # define KM_i16_BE(i) (i)
173 # define KM_i32_BE(i) (i)
174 # define KM_i64_BE(i) (i)
176 # define KM_i16_LE(i) (i)
177 # define KM_i32_LE(i) (i)
178 # define KM_i64_LE(i) (i)
179 # define KM_i16_BE(i) Kumu::Swap2(i)
180 # define KM_i32_BE(i) Kumu::Swap4(i)
181 # define KM_i64_BE(i) Kumu::Swap8(i)
182 # endif // KM_BIG_ENDIAN
184 // A non-reference counting, auto-delete container for internal
185 // member object pointers.
192 T* m_p; // the thing we point to
195 mem_ptr() : m_p(0) {}
196 mem_ptr(T* p) : m_p(p) {}
197 ~mem_ptr() { delete m_p; }
199 inline T& operator*() const { return *m_p; }
200 inline T* operator->() const { return m_p; }
201 inline operator T*()const { return m_p; }
202 inline const mem_ptr<T>& operator=(T* p) { this->set(p); return *this; }
203 inline T* set(T* p) { delete m_p; m_p = p; return m_p; }
204 inline T* get() const { return m_p; }
205 inline void release() { m_p = 0; }
206 inline bool empty() const { return m_p == 0; }
211 // Produces copy constructor boilerplate. Allows convenient private
212 // declatarion of copy constructors to prevent the compiler from
213 // silently manufacturing default methods.
214 # define KM_NO_COPY_CONSTRUCT(T) \
216 T& operator=(const T&)
222 KM_NO_COPY_CONSTRUCT(foo); // accessing private mthods will cause compile time error
228 // Produces copy constructor boilerplate. Implements
229 // copy and assignment, see example below
230 # define KM_EXPLICIT_COPY_CONSTRUCT(T) \
232 const T& operator=(const T&)
234 # define KM_EXPLICIT_COPY_CONSTRUCT_IMPL_START(N, T) \
235 void T##_copy_impl(N::T& lhs, const N::T& rhs) \
238 #define KM_COPY_ITEM(I) lhs.I = rhs.I;
240 # define KM_EXPLICIT_COPY_CONSTRUCT_IMPL_END(N, T) \
242 N::T::T(const N::T& rhs) { T##_copy_impl(*this, rhs); } \
243 const N::T& N::T::operator=(const N::T& rhs) { T##_copy_impl(*this, rhs); return *this; }
254 KM_EXPLICIT_COPY_CONSTRUCT(foo);
260 KM_EXPLICIT_COPY_CONSTRUCT_IMPL_START(bar, foo)
261 KM_COPY_ITEM(param_a)
262 KM_COPY_ITEM(param_b)
263 KM_EXPLICIT_COPY_CONSTRUCT_IMPL_END(bar, foo)
266 #endif // _KM_PLATFORM_H_