OpenNI 1.5.7
XnQueue.h
Go to the documentation of this file.
00001 /*****************************************************************************
00002 *                                                                            *
00003 *  OpenNI 1.x Alpha                                                          *
00004 *  Copyright (C) 2012 PrimeSense Ltd.                                        *
00005 *                                                                            *
00006 *  This file is part of OpenNI.                                              *
00007 *                                                                            *
00008 *  Licensed under the Apache License, Version 2.0 (the "License");           *
00009 *  you may not use this file except in compliance with the License.          *
00010 *  You may obtain a copy of the License at                                   *
00011 *                                                                            *
00012 *      http://www.apache.org/licenses/LICENSE-2.0                            *
00013 *                                                                            *
00014 *  Unless required by applicable law or agreed to in writing, software       *
00015 *  distributed under the License is distributed on an "AS IS" BASIS,         *
00016 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
00017 *  See the License for the specific language governing permissions and       *
00018 *  limitations under the License.                                            *
00019 *                                                                            *
00020 *****************************************************************************/
00021 #ifndef _XN_QUEUE_H
00022 #define _XN_QUEUE_H
00023 
00024 //---------------------------------------------------------------------------
00025 // Includes
00026 //---------------------------------------------------------------------------
00027 #include "XnList.h"
00028 
00029 //---------------------------------------------------------------------------
00030 // Types
00031 //---------------------------------------------------------------------------
00035 class XnQueue
00036 {
00037 public:
00041     XnQueue() {}
00045     virtual ~XnQueue() {}
00046 
00050     virtual XnStatus Init()
00051     {
00052         return (XN_STATUS_OK);
00053     }
00054 
00062     virtual XnStatus Push(XnValue const& value)
00063     {
00064         XnStatus nRetVal = XN_STATUS_OK;
00065 
00066         nRetVal = m_List.AddLast(value);
00067         XN_IS_STATUS_OK(nRetVal);
00068 
00069         return (XN_STATUS_OK);
00070     }
00078     virtual XnStatus Pop(XnValue& value)
00079     {
00080         if (IsEmpty())
00081         {
00082             return XN_STATUS_IS_EMPTY;
00083         }
00084 
00085         value = *(m_List.begin());
00086         return m_List.Remove(m_List.begin());
00087     }
00088 
00094     XnValue const& Top() const
00095     {
00096         return *(m_List.begin());
00097     }
00098 
00104     XnValue& Top()
00105     {
00106         return *(m_List.begin());
00107     }
00108 
00112     XnBool IsEmpty() const
00113     {
00114         return m_List.IsEmpty();
00115     }
00116 
00120     virtual XnUInt32 Size() const
00121     {
00122         return m_List.Size();
00123     }
00124 
00125 private:
00126     XN_DISABLE_COPY_AND_ASSIGN(XnQueue);
00127 
00129     XnList m_List;
00130 };
00131 
00137 #define XN_DECLARE_QUEUE_WITH_TRANSLATOR_DECL(decl, Type, ClassName, Translator, base)  \
00138     class decl ClassName : public base                                                  \
00139     {                                                                                   \
00140     public:                                                                             \
00141         ClassName() {}                                                                  \
00142         ~ClassName()                                                                    \
00143         {                                                                               \
00144             /* We do this using Pop() to make sure memory is freed. */                  \
00145             Type dummy;                                                                 \
00146             while (Size() != 0)                                                         \
00147                 Pop(dummy);                                                             \
00148         }                                                                               \
00149         XnStatus Push(Type const& value)                                                \
00150         {                                                                               \
00151             XnValue val = Translator::CreateValueCopy(value);                           \
00152             XnStatus nRetVal = base::Push(val);                                         \
00153             if (nRetVal != XN_STATUS_OK)                                                \
00154             {                                                                           \
00155                 Translator::FreeValue(val);                                             \
00156                 return (nRetVal);                                                       \
00157             }                                                                           \
00158             return XN_STATUS_OK;                                                        \
00159         }                                                                               \
00160         XnStatus Pop(Type& value)                                                       \
00161         {                                                                               \
00162             XnValue val;                                                                \
00163             XnStatus nRetVal = base::Pop(val);                                          \
00164             if (nRetVal != XN_STATUS_OK) return (nRetVal);                              \
00165             value = Translator::GetFromValue(val);                                      \
00166             Translator::FreeValue(val);                                                 \
00167             return XN_STATUS_OK;                                                        \
00168         }                                                                               \
00169         inline Type const& Top() const { return Translator::GetFromValue(base::Top()); }\
00170         inline Type& Top() { return Translator::GetFromValue(base::Top()); }            \
00171     private:                                                                            \
00172         XN_DISABLE_COPY_AND_ASSIGN(ClassName);                                          \
00173     };
00174 
00180 #define XN_DECLARE_QUEUE_WITH_TRANSLATOR(Type, ClassName, Translator, base)             \
00181     XN_DECLARE_QUEUE_WITH_TRANSLATOR_DECL(, Type, ClassName, Translator, base)
00182 
00187 #define XN_DECLARE_QUEUE_DECL(decl, Type, ClassName)                                                    \
00188     XN_DECLARE_DEFAULT_VALUE_TRANSLATOR_DECL(decl, Type, XN_DEFAULT_TRANSLATOR_NAME(ClassName))         \
00189     XN_DECLARE_QUEUE_WITH_TRANSLATOR_DECL(decl, Type, ClassName, XN_DEFAULT_TRANSLATOR_NAME(ClassName), XnQueue)
00190 
00194 #define XN_DECLARE_QUEUE(Type, ClassName)       \
00195     XN_DECLARE_QUEUE_DECL(, Type, ClassName)
00196 
00197 #endif // _XN_QUEUE_H