HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
PRM_Conditional.h
Go to the documentation of this file.
1 /*
2  * PROPRIETARY INFORMATION. This software is proprietary to
3  * Side Effects Software Inc., and is not to be reproduced,
4  * transmitted, or disclosed in any way without written permission.
5  *
6  * NAME: PRM_Conditional.h ( PRM Library, C++)
7  *
8  * COMMENTS: Conditional information based on a conditional string.
9  */
10 
11 #ifndef __PRM_Conditional__
12 #define __PRM_Conditional__
13 
14 #include "PRM_API.h"
15 #include "PRM_ConditionalType.h"
16 
17 #include <UT/UT_Array.h>
18 #include <UT/UT_IntArray.h>
19 #include <UT/UT_Map.h>
20 #include <UT/UT_NonCopyable.h>
21 #include <UT/UT_StringArray.h>
22 #include <UT/UT_UniquePtr.h>
23 #include <UT/UT_ValArray.h>
24 #include <UT/UT_Variadic.h>
25 #include <utility>
26 
27 class PRM_Parm;
28 class PRM_ParmList;
29 class PRM_Conditional;
30 
32 {
33  PRM_CONDGROUPTYPE_NONE, // Not a group
34  PRM_CONDGROUPTYPE_SINGLE, // Single group of PRM_Conditional(s)
35  PRM_CONDGROUPTYPE_SWITCHER // Switcher group with a main group + tab groups
36 };
37 
39 {
48 };
49 
54 class PRM_Conditional;
56 
57 /// A container class for a set of AND clauses, representing a single brace
58 /// group (e.g "{ foo == 0 bar == 1}"). If one condition inside this class
59 /// fails, the whole conditional clause fails. A list of PRM_ConditionalInfos
60 /// can be stringed together for an OR behavior (e.g. "{foo==0} {bar==1}").
62 {
63 public:
64  PRM_ConditionalInfo() = default;
65 
66  int64 getMemoryUsage(bool inclusive) const
67  {
68  int64 mem = 0;
69  mem += myControlParms.getMemoryUsage(false);
70  mem += myControlValues.getMemoryUsage(false);
71  mem += myTestOperators.getMemoryUsage(false);
72  return mem;
73  }
74 
75  // Create a new instance of the conditional information for parameters
76  // contained within multi-parms.
77  PRM_ConditionalInfoPtr instance(const UT_IntArray &index_list) const;
78 
79  void clear()
80  {
81  myControlParms.clear();
82  myControlValues.clear();
83  myTestOperators.clear();
84  }
85  void addCondition(const UT_StringHolder &parm,
86  const UT_StringHolder &value,
88  {
89  myControlParms.append(parm);
90  myControlValues.append(value);
91  myTestOperators.append(op);
92  }
93 
95  { return myControlParms; }
97  { return myControlValues; }
99  { return myTestOperators; }
100 
101 private:
102  UT_StringArray myControlParms;
103  UT_StringArray myControlValues;
104  UT_Array<PRM_ConditionalOperator> myTestOperators;
105 };
106 
107 /// Base class for PRM_Conditional*. It allows passing either PRM_Conditional,
108 /// PRM_ConditionalGroup, or PRM_ConditionalSwitcher to a PRM_Template without
109 /// casting.
111 {
112 public:
113  PRM_ConditionalBase() = default;
114  virtual ~PRM_ConditionalBase() = default;
115 
117 
118  // Allows us to avoid an expensive dynamic_cast. See:
119  // http://tinodidriksen.com/2010/04/14/cpp-dynamic-cast-performance/
120  virtual PRM_ConditionalGroupType groupType() const = 0;
121 
122  // Create a new conditional for use within multi-parms. Since the
123  // conditional information may be dependent on the index of the multiparm,
124  // we need to replace any #'s in the conditional infos with the actual
125  // index.
126  virtual PRM_ConditionalBasePtr instance(
127  const UT_IntArray &index_list)const = 0;
128 
129  virtual PRM_Conditional *getConditional(PRM_ConditionalType type) = 0;
130  virtual const PRM_Conditional*getConditional(
131  PRM_ConditionalType type) const = 0;
132 
133  virtual int64 getMemoryUsage(bool inclusive) const = 0;
134 };
135 
136 
137 /// This class allow setting a single conditional type for a PRM_Template.
138 /// If multiple conditional types are required, use PRM_ConditionalGroup.
140 {
141 public:
144  PRM_Conditional(const PRM_Conditional &other);
145  explicit PRM_Conditional(const char *conditional,
148  ~PRM_Conditional() override;
149 
150  int64 getMemoryUsage(bool inclusive) const override;
151 
153  { return PRM_CONDGROUPTYPE_NONE; }
155  {
156  return myType;
157  }
158 
159  static const char *getName(PRM_ConditionalType type,
160  bool label);
161  const char *getName(bool label) const;
162 
164  const UT_IntArray &indices) const override;
166  PRM_ConditionalType type) override;
168  PRM_ConditionalType type) const override;
169 
170  int entries() const;
171  const PRM_ConditionalInfo *operator()(int index) const;
173 
174  void clear();
175  PRM_ConditionalInfo *createInfo();
176 
177  void getStringFromList(
178  UT_StringHolder &str,
179  const UT_StringArray *validparms = nullptr
180  ) const;
181  void getStringFromList(UT_String &str) const;
182  void getStringFromList(UT_String &str,
183  const UT_StringArray &validparms) const;
184  bool setListFromString(const char *conditional,
186 
187  // Verifies the provided string is in proper conditional format.
188  // Proper format is:
189  // All non-whitespace is enclosed in { }.
190  // Inside brackets, each parm name has a value paired to it.
191  // All open quotes have matching close quotes.
192  static bool verifyConditionalString(const char *conditional,
194 
195  static bool getOperatorFromString(const char *testoperator,
197 
198  static bool isValidOperator(const char *testoperator);
199 
200  bool eval(const PRM_Parm &prm,
201  const PRM_ParmList &pl,
202  const UT_StringArray *skip_parms) const;
203 
204 private:
205  static bool parseOperatorString(const char *&testoperator,
207 
208  static bool parseConditionalString(const char *str,
209  PRM_Conditional *cond,
211 
212  void getStringFromList(UT_WorkBuffer &str,
213  const UT_StringArray *validparms) const;
214 
215  void evalFunction(const PRM_Parm &prm,
216  const PRM_ParmList &pl,
217  const UT_StringRef &function,
218  UT_String &result) const;
219 
220  UT_Array<PRM_ConditionalInfoPtr> myConditionalInfos;
221  PRM_ConditionalType myType;
222 };
223 
224 typedef std::pair<const char *, PRM_ConditionalType> PRM_ConditionalGroupItem;
226 
227 /// This class allow setting multiple conditionals for a PRM_Template.
229 {
230 public:
231  ///
233 
235  { }
236 
238  PRM_ConditionalGroup &operator=(const PRM_ConditionalGroup &other) = delete;
239 
240  ~PRM_ConditionalGroup() override;
241 
242  int64 getMemoryUsage(bool inclusive) const override;
243 
245  { return PRM_CONDGROUPTYPE_SINGLE; }
246 
248  const UT_IntArray &indices) const override;
249 
250  void addConditional(const PRM_Conditional &cond);
251  void addConditional(const char *conditional,
253  void addConditional(PRM_ConditionalPtr cond);
254 
256  PRM_ConditionalType type) override;
258  PRM_ConditionalType type) const override;
259 
260  void clear();
261 
262 protected:
263  void instanceIndices(
264  PRM_ConditionalGroup *group,
265  const UT_IntArray &index_list) const;
266 
267 private:
268  using prm_ConditionalMap
270 
271  prm_ConditionalMap myConditionals;
272 };
273 
275 {
276 public:
278  : myIndex(index)
279  , myConditional(conditional)
280  , myType(type)
281  {
282  }
283  int myIndex; // Tab index
284  const char *myConditional;
286 };
288 
289 /// This class can be passed to the PRM_Template constructor when constructing
290 /// a template for a folder switcher. This allows the caller to set a different
291 /// conditional for each folder.
293 {
294 public:
296  { }
297 
299  ~PRM_ConditionalSwitcher() override;
300 
302 
303  int64 getMemoryUsage(bool inclusive) const override;
304 
305  PRM_ConditionalGroupType groupType() const override
306  { return PRM_CONDGROUPTYPE_SWITCHER; }
308  const UT_IntArray &indices) const override;
309 
310  PRM_Conditional *getTabConditional(
311  int index,
312  PRM_ConditionalType type) const;
313  PRM_ConditionalBase *getTabConditional(int index) const;
314 
315  void setTabConditional(
316  int index,
317  const PRM_ConditionalBase &cond );
318  void addTabConditional(
319  int index,
320  const PRM_Conditional &conditional);
321 
322  void clear();
323 private:
324  using prm_SwitcherMap = UT_SortedMap<int, PRM_ConditionalBasePtr>;
325  prm_SwitcherMap myTabConditionals;
326 };
327 
328 
331 
332 
333 #endif
GLsizei GLenum const void * indices
Definition: glcorearb.h:406
GLuint GLsizei const GLchar * label
Definition: glcorearb.h:2545
#define SYS_DEPRECATED(__V__)
GLsizei const GLfloat * value
Definition: glcorearb.h:824
virtual PRM_Conditional * getConditional(PRM_ConditionalType type)=0
UT_UniquePtr< PRM_ConditionalBase > PRM_ConditionalBasePtr
**But if you need a result
Definition: thread.h:622
const UT_StringArray & getControlValues() const
PRM_ConditionalType myType
std::unique_ptr< T, Deleter > UT_UniquePtr
A smart pointer for unique ownership of dynamically allocated objects.
Definition: UT_UniquePtr.h:39
< returns > If no error
Definition: snippets.dox:2
virtual int64 getMemoryUsage(bool inclusive) const =0
UT_UniquePtr< PRM_ConditionalInfo > PRM_ConditionalInfoPtr
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:108
PRM_ConditionalBasePtr instance(const UT_IntArray &indices) const override
UT_VariadicT< PRM_ConditionalSwitcherItem > PRM_ConditionalSwitcherArgs
const UT_StringArray & getControlParms() const
std::pair< const char *, PRM_ConditionalType > PRM_ConditionalGroupItem
PRM_ConditionalSwitcherItem(int index, const char *conditional, PRM_ConditionalType type)
const UT_Array< PRM_ConditionalOperator > & getTestOperators() const
PXL_API const char * getName(const ColorSpace *space)
Return the name of the color space.
PRM_ConditionalGroupType
#define UT_NON_COPYABLE(CLASS)
Define deleted copy constructor and assignment operator inside a class.
PRM_ConditionalGroupType groupType() const override
long long int64
Definition: SYS_Types.h:116
UT_UniquePtr< PRM_Conditional > PRM_ConditionalPtr
PRM_ConditionalOperator
HUSD_API bool eval(VtValue &val, T &ret_val)
virtual PRM_ConditionalBasePtr instance(const UT_IntArray &index_list) const =0
UT_VariadicT< PRM_ConditionalGroupItem > PRM_ConditionalGroupArgs
void addCondition(const UT_StringHolder &parm, const UT_StringHolder &value, PRM_ConditionalOperator op)
PRM_ConditionalGroupType groupType() const override
int64 getMemoryUsage(bool inclusive) const
PRM_ConditionalType
LeafData & operator=(const LeafData &)=delete
GLuint index
Definition: glcorearb.h:786
This class allow setting multiple conditionals for a PRM_Template.
**If you just want to fire and args
Definition: thread.h:618
PRM_ConditionalType getType() const
#define PRM_API
Definition: PRM_API.h:10
GLenum src
Definition: glcorearb.h:1793