### Dynamic Conversion Availability LightWave® 6.0 Component Modeler Header lwdyna.h This global returns a function that converts between DynaValues of different types. This is most often useful for converting between string and numeric values. DynaValues are used by the command system and by the requester API. Global Call
       DynaConvertFunc *dynacvt;
       dynacvt = global( LWDYNACONVERTFUNC_GLOBAL, GFUSE_TRANSIENT );
The global function returns a pointer to a DynaConvertFunc.
       typedef int DynaConvertFunc (const DynaValue *from, DynaValue *to,
         const DynaStringHint *hint);
`from` The value to convert from. `to` Receives the converted value of the `from` argument. Before calling the conversion function, set the `type` field of the `to` argument to the desired type for the conversion. `hint` Specifies a mapping between `DY_STRING` types and certain kinds of numeric values. If the types involved in the conversion don't require a hint, this is ignored and may be NULL. If the conversion succeeds, the function returns `DYERR_NONE`. Otherwise it returns an error code. Possible error codes include `DYERR_MEMORY`, `DYERR_BADTYPE` and `DYERR_INTERNAL`. String Hints If one of the DynaValues is a string and the other is a choice or a bitfield, the conversion uses the `hint` argument as a lookup table for translating between them. The structure used to pass hints looks like this.
       typedef struct st_DynaStringHint {
          DyChoiceHint   *chc;
          DyBitfieldHint *bits;
       } DynaStringHint;
There are two kinds of hints in a DynaStringHint structure, only one of which will be used for a given string conversion.
       typedef struct st_DyChoiceHint {
          const char *item;
          int         value;
       } DyChoiceHint;
The choice hint is an array of DyChoiceHint used when converting between `DY_STRING` and `DY_CHOICE` types. The `item`/`value` pairs indicate a mapping between choice values and strings. In other words, `hint->chc[i].item` will be converted to `hint->chc[i].value` and vice-versa. The array is terminated with a null `item` string.
       typedef struct st_DyBitfieldHint {
          char code;
          int  bitval;
       } DyBitfieldHint;
The bitfield hint is an array of DyBitfieldHint used when converting between an array of characters (`DY_STRING`) and a bitfield (the bits in a `DY_INTEGER`). Bitfields appear as arguments to certain CommandSequence commands. In the string representation, the presence of a given character corresponds to a set bit in a bitfield, and if that character isn't in the string, the bit is clear. The DyBitfieldHint `code` field contains a character, and the `bitval` field is an integer with a bit pattern. When converting from a `DY_STRING`, if the `code` character (upper or lower case) is present in the string, the `bitval` bits will be bitwise-ORed into the conversion result. When converting from a bitfield, if the `bitval` pattern is present (`value & bitval == bitval`), the `code` character is appended to the string result. The hint list is terminated with a zero `bitval`. Example This code fragment converts between the string and the bitfield representations of a set of compass point flags.
       #include <lwserver.h>
       #include <lwdyna.h>

       #define FLAG_NORTH (1<<0)
       #define FLAG_SOUTH (1<<1)
       #define FLAG_EAST  (1<<2)
       #define FLAG_WEST  (1<<3)

       DyBitfieldHint compass_hint[ 5 ] = {
          'n', FLAG_NORTH,
          's', FLAG_SOUTH,
          'e', FLAG_EAST,
          'w', FLAG_WEST,
          0, 0
       };
       DynaStringHint hint = { NULL, compass_hint };
       DynaValue
          dystr = { DY_STRING },
          dyint = { DY_INTEGER };
       DynaConvertFunc *dynacvt;
       int result;

       dynacvt = global( LWDYNACONVERTFUNC_GLOBAL, GFUSE_TRANSIENT );
       if ( !dynacvt ) return AFUNC_BADGLOBAL;

       dystr.str.buf = "ns";
       result = dynacvt( &dystr, &dyint, &hint );

       if ( result == DYERR_NONE ) {
          ...dyint.intv.value should contain FLAG_NORTH | FLAG_SOUTH...