ltkcpp_typeregistry.cpp

00001 
00002 /*
00003  *****************************************************************************
00004  *                                                                           *
00005  *                 IMPINJ CONFIDENTIAL AND PROPRIETARY                       *
00006  *                                                                           *
00007  * This source code is the sole property of Impinj, Inc.  Reproduction or    *
00008  * utilization of this source code in whole or in part is forbidden without  *
00009  * the prior written consent of Impinj, Inc.                                 *
00010  *                                                                           *
00011  * (c) Copyright Impinj, Inc. 2007,2008. All rights reserved.                *
00012  *                                                                           *
00013  *****************************************************************************/
00014 
00015 
00016 #include "ltkcpp_platform.h"
00017 #include "ltkcpp_base.h"
00018 
00019 
00020 namespace LLRP
00021 {
00022 
00023 CTypeRegistry::CTypeRegistry (void)
00024 {
00025     memset(m_apStdMessageTypeDescriptors, 0,
00026         sizeof m_apStdMessageTypeDescriptors);
00027 
00028     memset(m_apStdParameterTypeDescriptors, 0,
00029         sizeof m_apStdParameterTypeDescriptors);
00030 }
00031 
00032 CTypeRegistry::~CTypeRegistry (void)
00033 {
00034 }
00035 
00036 EResultCode
00037 CTypeRegistry::enroll (
00038   const CTypeDescriptor *       pTypeDescriptor)
00039 {
00040     if(NULL == pTypeDescriptor->m_pVendorDescriptor)
00041     {
00042         if(1023u < pTypeDescriptor->m_TypeNum)
00043         {
00044             return RC_EnrollBadTypeNumber;
00045         }
00046 
00047         /*
00048          * Standard message or parameter
00049          */
00050         if(pTypeDescriptor->m_bIsMessage)
00051         {
00052             m_apStdMessageTypeDescriptors[pTypeDescriptor->m_TypeNum] =
00053                 pTypeDescriptor;
00054         }
00055         else
00056         {
00057             m_apStdParameterTypeDescriptors[pTypeDescriptor->m_TypeNum] =
00058                 pTypeDescriptor;
00059         }
00060     }
00061     else
00062     {
00063         /*
00064          * Custom messages or parameter
00065          */
00066         if(pTypeDescriptor->m_bIsMessage)
00067         {
00068             m_listCustomMessageTypeDescriptors.push_back(pTypeDescriptor);
00069         }
00070         else
00071         {
00072             m_listCustomParameterTypeDescriptors.push_back(pTypeDescriptor);
00073         }
00074     }
00075 
00076     return RC_OK;
00077 }
00078 
00079 const CTypeDescriptor *
00080 CTypeRegistry::lookupMessage (
00081   unsigned int                  MessageTypeNum) const
00082 {
00083     if(1023u < MessageTypeNum)
00084     {
00085         return NULL;
00086     }
00087 
00088     return m_apStdMessageTypeDescriptors[MessageTypeNum];
00089 }
00090 
00091 const CTypeDescriptor *
00092 CTypeRegistry::lookupParameter (
00093   unsigned int                  ParameterTypeNum) const
00094 {
00095     if(1023u < ParameterTypeNum)
00096     {
00097         /* throw exception? */
00098         return NULL;
00099     }
00100 
00101     return m_apStdParameterTypeDescriptors[ParameterTypeNum];
00102 }
00103 
00104 const CTypeDescriptor *
00105 CTypeRegistry::lookupCustomMessage (
00106   unsigned int                  VendorID,
00107   unsigned int                  MessageSubTypeNum) const
00108 {
00109     for (
00110         std::list<const CTypeDescriptor *>::const_iterator elem =
00111                             m_listCustomMessageTypeDescriptors.begin();
00112         elem != m_listCustomMessageTypeDescriptors.end();
00113         elem++)
00114     {
00115         const CTypeDescriptor * pTypeDescriptor;
00116         pTypeDescriptor = *elem;
00117         if(VendorID == pTypeDescriptor->m_pVendorDescriptor->m_VendorID &&
00118            MessageSubTypeNum == pTypeDescriptor->m_TypeNum)
00119         {
00120             return pTypeDescriptor;
00121         }
00122     }
00123 
00124     return NULL;
00125 }
00126 
00127 const CTypeDescriptor *
00128 CTypeRegistry::lookupCustomParameter (
00129   unsigned int                  VendorID,
00130   unsigned int                  ParameterSubTypeNum) const
00131 {
00132     for (
00133         std::list<const CTypeDescriptor *>::const_iterator elem = 
00134                             m_listCustomParameterTypeDescriptors.begin();
00135         elem != m_listCustomParameterTypeDescriptors.end();
00136         elem++)
00137     {
00138         const CTypeDescriptor * pTypeDescriptor;
00139         pTypeDescriptor = *elem;
00140         if(VendorID == pTypeDescriptor->m_pVendorDescriptor->m_VendorID &&
00141            ParameterSubTypeNum == pTypeDescriptor->m_TypeNum)
00142         {
00143             return pTypeDescriptor;
00144         }
00145     }
00146 
00147     return NULL;
00148 }
00149 
00150 /* look up the type descriptor*/
00151 const CTypeDescriptor *
00152 CTypeRegistry::lookupByName (
00153   char *                    pName) const
00154 {
00155     unsigned int                i;
00156     const CTypeDescriptor *     pTypeDescriptor;
00157 
00158     for(i = 0; i < 1024u; i++)
00159     {
00160         pTypeDescriptor = m_apStdMessageTypeDescriptors[i];
00161         if(NULL == pTypeDescriptor)
00162         {
00163             continue;
00164         }
00165 
00166         if(0 == strcmp(pTypeDescriptor->m_pName, pName))
00167         {
00168             return pTypeDescriptor;
00169         }
00170     }
00171 
00172     for(i = 0; i < 1024u; i++)
00173     {
00174         pTypeDescriptor = m_apStdParameterTypeDescriptors[i];
00175         if(NULL == pTypeDescriptor)
00176         {
00177             continue;
00178         }
00179 
00180         if(0 == strcmp(pTypeDescriptor->m_pName, pName))
00181         {
00182             return pTypeDescriptor;
00183         }
00184     }
00185 
00186     for (
00187         std::list<const CTypeDescriptor *>::const_iterator elem = 
00188                             m_listCustomParameterTypeDescriptors.begin();
00189         elem != m_listCustomParameterTypeDescriptors.end();
00190         elem++)
00191     {
00192         const CTypeDescriptor * pTypeDescriptor;
00193         pTypeDescriptor = *elem;
00194         if(0 == strcmp(pTypeDescriptor->m_pName, pName))
00195         {
00196             return pTypeDescriptor;
00197         }
00198     }
00199 
00200     for (
00201         std::list<const CTypeDescriptor *>::const_iterator elem =
00202                             m_listCustomMessageTypeDescriptors.begin();
00203         elem != m_listCustomMessageTypeDescriptors.end();
00204         elem++)
00205     {
00206         const CTypeDescriptor * pTypeDescriptor;
00207         pTypeDescriptor = *elem;
00208         if(0 == strcmp(pTypeDescriptor->m_pName, pName))
00209         {
00210             return pTypeDescriptor;
00211         }
00212     }
00213     return NULL;
00214 }
00215 
00216 }; /* namespace LLRP */
00217 

Generated on Wed Jun 6 11:55:49 2012 for LTKCPP-- LLRP Toolkit C Plus Plus Library by  doxygen 1.5.9