AAX SDK  2.4.1
Avid Audio Extensions Development Kit
AAX_PageTableUtilities.h
Go to the documentation of this file.
1 /*================================================================================================*/
2 /*
3  * Copyright 2016-2017 by Avid Technology, Inc.
4  * All rights reserved.
5  *
6  * CONFIDENTIAL: This document contains confidential information. Do not
7  * read or examine this document unless you are an Avid Technology employee
8  * or have signed a non-disclosure agreement with Avid Technology which protects
9  * the confidentiality of this document. DO NOT DISCLOSE ANY INFORMATION
10  * CONTAINED IN THIS DOCUMENT TO ANY THIRD-PARTY WITHOUT THE PRIOR WRITTEN CONSENT
11  * OF Avid Technology, INC.
12  */
13 
14 #ifndef AAXLibrary_AAX_PageTableUtilities_h
15 #define AAXLibrary_AAX_PageTableUtilities_h
16 
17 #include "AAX_CString.h"
18 #include "AAX.h"
19 
20 namespace AAX
21 {
26  template <class T1, class T2>
27  inline bool PageTableParameterMappingsAreEqual(const T1& inL, const T2& inR)
28  {
29  AAX_Result errL = AAX_SUCCESS;
30  AAX_Result errR = AAX_SUCCESS;
31 
32  int32_t numPagesL = -1;
33  int32_t numPagesR = -1;
34  errL = inL.GetNumPages(numPagesL);
35  errR = inR.GetNumPages(numPagesR);
36 
37  if (errL != errR || numPagesL != numPagesR) { return false; }
38  else if (AAX_SUCCESS != errL) { return true; } // can't get page data from either table
39 
40  for (int32_t i = 0; i < numPagesL; ++i)
41  {
42  int32_t numParamsL = -1;
43  int32_t numParamsR = -1;
44  errL = inL.GetNumMappedParameterIDs(i, numParamsL);
45  errR = inR.GetNumMappedParameterIDs(i, numParamsR);
46 
47  if (errL != errR || numParamsL != numParamsR) { return false; }
48  else if (AAX_SUCCESS != errL) { continue; } // skip this page if equal errors were returned
49 
50  for (int32_t j = 0; j < numParamsL; ++j)
51  {
52  AAX_CString paramIdentifierL;
53  AAX_CString paramIdentifierR;
54  errL = inL.GetMappedParameterID(i, j, paramIdentifierL);
55  errR = inR.GetMappedParameterID(i, j, paramIdentifierR);
56 
57  if (errL != errR || paramIdentifierL != paramIdentifierR) { return false; }
58  }
59  }
60 
61  return true;
62  }
63 
64  template <class T1, class T2>
65  inline bool PageTableParameterNameVariationsAreEqual(const T1& inL, const T2& inR)
66  {
67  AAX_Result errL = AAX_SUCCESS;
68  AAX_Result errR = AAX_SUCCESS;
69 
70  int32_t numParamIdentifiersL = -1;
71  int32_t numParamIdentifiersR = -1;
72  errL = inL.GetNumParametersWithNameVariations(numParamIdentifiersL);
73  errR = inR.GetNumParametersWithNameVariations(numParamIdentifiersR);
74 
75  if (errL != errR || numParamIdentifiersL != numParamIdentifiersR) { return false; }
76  else if (AAX_SUCCESS != errL) { return true; } // can't get parameter name variation data from either table
77 
78  for (int32_t i = 0; i < numParamIdentifiersL; ++i)
79  {
80  AAX_CString paramIdentifierL;
81  AAX_CString paramIdentifierR;
82  errL = inL.GetNameVariationParameterIDAtIndex(i, paramIdentifierL);
83  errL = inR.GetNameVariationParameterIDAtIndex(i, paramIdentifierR);
84 
85  if (errL != errR || paramIdentifierL != paramIdentifierR) { return false; }
86  else if (AAX_SUCCESS != errL) { continue; } // skip this index if equal errors were returned
87 
88  int32_t numVariationsL = -1;
89  int32_t numVariationsR = -1;
90  errL = inL.GetNumNameVariationsForParameter(paramIdentifierL.Get(), numVariationsL);
91  errL = inR.GetNumNameVariationsForParameter(paramIdentifierR.Get(), numVariationsR);
92 
93  if (errL != errR || numVariationsL != numVariationsR) { return false; }
94  else if (AAX_SUCCESS != errL) { continue; } // skip this index if equal errors were returned
95 
96  for (int32_t j = 0; j < numVariationsL; ++j)
97  {
98  AAX_CString nameVariationL;
99  int32_t lengthL;
100  AAX_CString nameVariationR;
101  int32_t lengthR;
102  errL = inL.GetParameterNameVariationAtIndex(paramIdentifierL.Get(), j, nameVariationL, lengthL);
103  errR = inR.GetParameterNameVariationAtIndex(paramIdentifierR.Get(), j, nameVariationR, lengthR);
104 
105  if (errL != errR || lengthL != lengthR || nameVariationL != nameVariationR) { return false; }
106  }
107  }
108 
109  return true;
110  }
111 
112  template <class T1, class T2>
113  inline bool PageTablesAreEqual(const T1& inL, const T2& inR)
114  {
116  }
117 
122  template <class T>
123  inline void CopyPageTable(T& to, const T& from)
124  {
125  to.Clear();
126 
127  // Copy page tables
128  int32_t curPageIndex;
129  from.GetNumPages(curPageIndex);
130  while (0 < curPageIndex--)
131  {
132  to.InsertPage(0);
133 
134  int32_t numIDsRemaining = 0;
135  from.GetNumMappedParameterIDs(curPageIndex, numIDsRemaining);
136  for (int32_t curSlotIndex = 0; 0 < numIDsRemaining; ++curSlotIndex) // numIDsRemaining is decremented in the loop body
137  {
138  AAX_CString curParam;
139  const AAX_Result getParamResult = from.GetMappedParameterID(curPageIndex, curSlotIndex, curParam);
140  if (AAX_SUCCESS == getParamResult)
141  {
142  to.MapParameterID(curParam.CString(), 0, curSlotIndex);
143  --numIDsRemaining;
144  }
145  }
146  }
147 
148  // Copy name variations
149  int32_t numParameterIdentifiers = 0;
150  to.ClearParameterNameVariations();
151  from.GetNumParametersWithNameVariations(numParameterIdentifiers);
152  for (int32_t curParamIndex = 0; curParamIndex < numParameterIdentifiers; ++curParamIndex)
153  {
154  AAX_CString curParamIdentifier;
155  from.GetNameVariationParameterIDAtIndex(curParamIndex, curParamIdentifier);
156 
157  int32_t numNameVariations = 0;
158  from.GetNumNameVariationsForParameter(curParamIdentifier.Get(), numNameVariations);
159 
160  for (int32_t curNameVariationIndex = 0; curNameVariationIndex < numNameVariations; ++curNameVariationIndex)
161  {
162  int32_t curNameVariationLength;
163  AAX_CString curNameVariation;
164  from.GetParameterNameVariationAtIndex(curParamIdentifier.Get(), curNameVariationIndex, curNameVariation, curNameVariationLength);
165  to.SetParameterNameVariation(curParamIdentifier.Get(), curNameVariation, curNameVariationLength);
166  }
167  }
168  }
169 
176  template <class T>
177  inline std::vector<std::pair<int32_t, int32_t> > FindParameterMappingsInPageTable(const T& inTable, AAX_CParamID inParameterID)
178  {
179  const AAX_CString searchParamID(inParameterID);
180  std::vector<std::pair<int32_t, int32_t> > foundParamMappings;
181 
182  int32_t numPages = 0;
183  inTable.GetNumPages(numPages);
184  for (int32_t i = 0; i < numPages; ++i)
185  {
186  int32_t numIDsRemaining = 0;
187  inTable.GetNumMappedParameterIDs(i, numIDsRemaining);
188  for (int32_t curSlotIndex = 0; 0 < numIDsRemaining; ++curSlotIndex) // numIDs is decremented in the loop body
189  {
190  AAX_CString curParam;
191  const AAX_Result getParamResult = inTable.GetMappedParameterID(i, curSlotIndex, curParam);
192  if (AAX_SUCCESS == getParamResult)
193  {
194  if (searchParamID == curParam)
195  {
196  foundParamMappings.push_back(std::make_pair(i, curSlotIndex));
197  }
198 
199  --numIDsRemaining;
200  }
201  }
202  }
203 
204  return foundParamMappings;
205  }
206 
211  template <class T>
212  inline void ClearMappedParameterByID(T& ioTable, AAX_CParamID inParameterID)
213  {
214  const auto paramMappings(AAX::FindParameterMappingsInPageTable(ioTable, inParameterID));
215  for (const auto& locationPair : paramMappings)
216  {
217  ioTable.ClearMappedParameter(locationPair.first, locationPair.second);
218  }
219  }
220 }
221 
222 #endif
Various utility definitions for AAX.
const char * AAX_CParamID
Parameter identifier.
Definition: AAX.h:352
int32_t AAX_Result
Definition: AAX.h:337
A generic AAX string class with similar functionality to std::string.
@ AAX_SUCCESS
Definition: AAX_Errors.h:39
Definition: AAX_Exception.h:42
bool PageTableParameterNameVariationsAreEqual(const T1 &inL, const T2 &inR)
Definition: AAX_PageTableUtilities.h:65
bool PageTablesAreEqual(const T1 &inL, const T2 &inR)
Definition: AAX_PageTableUtilities.h:113
bool PageTableParameterMappingsAreEqual(const T1 &inL, const T2 &inR)
Definition: AAX_PageTableUtilities.h:27
void CopyPageTable(T &to, const T &from)
Definition: AAX_PageTableUtilities.h:123
std::vector< std::pair< int32_t, int32_t > > FindParameterMappingsInPageTable(const T &inTable, AAX_CParamID inParameterID)
Definition: AAX_PageTableUtilities.h:177
void ClearMappedParameterByID(T &ioTable, AAX_CParamID inParameterID)
Definition: AAX_PageTableUtilities.h:212
A generic AAX string class with similar functionality to std::string
Definition: AAX_CString.h:46
const char * CString() const
const char * Get() const AAX_OVERRIDE