--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/deps/Platinum/ThirdParty/Neptune/Source/Core/NptCommon.h	Mon Jul 06 08:06:28 2009 -0700
@@ -0,0 +1,156 @@
+/*****************************************************************
+|
+|   Neptune - Common Definitions
+|
+| Copyright (c) 2002-2008, Axiomatic Systems, LLC.
+| All rights reserved.
+|
+| Redistribution and use in source and binary forms, with or without
+| modification, are permitted provided that the following conditions are met:
+|     * Redistributions of source code must retain the above copyright
+|       notice, this list of conditions and the following disclaimer.
+|     * Redistributions in binary form must reproduce the above copyright
+|       notice, this list of conditions and the following disclaimer in the
+|       documentation and/or other materials provided with the distribution.
+|     * Neither the name of Axiomatic Systems nor the
+|       names of its contributors may be used to endorse or promote products
+|       derived from this software without specific prior written permission.
+|
+| THIS SOFTWARE IS PROVIDED BY AXIOMATIC SYSTEMS ''AS IS'' AND ANY
+| EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+| WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+| DISCLAIMED. IN NO EVENT SHALL AXIOMATIC SYSTEMS BE LIABLE FOR ANY
+| DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+| (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+| LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+| ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+| SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+|
+ ****************************************************************/
+
+#ifndef _NPT_COMMON_H_
+#define _NPT_COMMON_H_
+
+/*----------------------------------------------------------------------
+|   includes
++---------------------------------------------------------------------*/
+#include "NptTypes.h"
+#include "NptResults.h"
+
+/*----------------------------------------------------------------------
+|   NPT_ObjectDeleter
++---------------------------------------------------------------------*/
+template <class T>
+class NPT_ObjectDeleter {
+public:
+    void operator()(T* object) const {
+        delete object;
+    }
+};
+
+/*----------------------------------------------------------------------
+|   NPT_ObjectComparator
++---------------------------------------------------------------------*/
+template <class T>
+class NPT_ObjectComparator {
+public:
+    NPT_ObjectComparator(T& object) : m_Object(object) {}
+    bool operator()(const T& object) const {
+        return object == m_Object;
+    }
+private:
+    T& m_Object;
+};
+
+/*----------------------------------------------------------------------
+|   NPT_ContainerFind
++---------------------------------------------------------------------*/
+template <typename T, typename P>
+NPT_Result NPT_ContainerFind(T&                   container, 
+                             const P&             predicate, 
+                             typename T::Element& item, 
+                             NPT_Ordinal          n=0) 
+{
+    typename T::Iterator found = container.Find(predicate, n);
+    if (found) {
+        item = *found;
+        return NPT_SUCCESS;
+    } else {
+        return NPT_ERROR_NO_SUCH_ITEM;
+    }
+}
+
+/*----------------------------------------------------------------------
+|   NPT_UntilResultEquals
++---------------------------------------------------------------------*/
+class NPT_UntilResultEquals
+{
+public:
+    // methods
+    NPT_UntilResultEquals(NPT_Result condition_result, 
+                          NPT_Result return_value = NPT_SUCCESS) :
+      m_ConditionResult(condition_result),
+      m_ReturnValue(return_value) {}
+    bool operator()(NPT_Result result, NPT_Result& return_value) const {
+        if (result == m_ConditionResult) {
+            return_value = m_ReturnValue;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+private:
+    // members
+    NPT_Result m_ConditionResult;
+    NPT_Result m_ReturnValue;
+};
+
+/*----------------------------------------------------------------------
+|   NPT_UntilResultNotEquals
++---------------------------------------------------------------------*/
+class NPT_UntilResultNotEquals
+{
+public:
+    // methods
+    NPT_UntilResultNotEquals(NPT_Result condition_result) :
+      m_ConditionResult(condition_result) {}
+    bool operator()(NPT_Result result, NPT_Result& return_value) const {
+        if (result != m_ConditionResult) {
+            return_value = result;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+private:
+    // members
+    NPT_Result m_ConditionResult;
+};
+
+/*----------------------------------------------------------------------
+|   NPT_PropertyValue
++---------------------------------------------------------------------*/
+class NPT_PropertyValue
+{
+ public:
+    // typedefs
+    typedef enum {UNKNOWN, INTEGER, STRING} Type;
+
+    // methods
+    NPT_PropertyValue() : m_Type(UNKNOWN), m_Integer(0) {}
+    NPT_PropertyValue(int value)         : m_Type(INTEGER), m_Integer(value) {}
+    NPT_PropertyValue(const char* value) : m_Type(STRING),  m_String(value)  {}
+
+    // members
+    Type m_Type;
+    union {
+        int         m_Integer;
+        const char* m_String;
+    };
+};
+
+#endif // _NPT_COMMON_H_
+