Auxiliary Data


Functions

AuxData_pa TecUtilAuxDataDataSetGetRef (void)
  Gets a reference to the current data set's auxiliary data.
AuxData_pa TecUtilAuxDataLineMapGetRef (EntIndex_t Map)
  Gets a reference to the specified line map's auxiliary data.
AuxData_pa TecUtilAuxDataPageGetRef (void)
  Gets a reference to the current page's auxiliary data.
AuxData_pa TecUtilAuxDataFrameGetRef (void)
  Gets a reference to the current frame's auxiliary data.
AuxData_pa TecUtilAuxDataZoneGetRef (EntIndex_t Zone)
  Gets a reference to the specified zone's auxiliary data.
AuxData_pa TecUtilAuxDataVarGetRef (EntIndex_t Var)
  Gets a reference to the specified variable's auxiliary data.
LgIndex_t TecUtilAuxDataGetNumItems (AuxData_pa AuxDataRef)
  Gets the current number of auxiliary data items maintained by the auxiliary data reference.
Boolean_t TecUtilAuxDataGetItemIndex (AuxData_pa AuxDataRef, const char *Name, LgIndex_t *ItemIndex)
  Gets the index of the named auxiliary data item if found or if not found the index where an auxiliary data item could be inserted in sorted order.
void TecUtilAuxDataGetStrItemByIndex (AuxData_pa AuxDataRef, LgIndex_t Index, char **Name, char **Value, Boolean_t *Retain)
  Gets the auxiliary string data item at the specified index.
void TecUtilAuxDataGetItemByIndex (AuxData_pa AuxDataRef, LgIndex_t Index, char **Name, ArbParam_t *Value, AuxDataType_e *Type, Boolean_t *Retain)
  Gets the auxiliary data item at the specified index.
Boolean_t TecUtilAuxDataGetStrItemByName (AuxData_pa AuxDataRef, const char *Name, char **Value, Boolean_t *Retain)
  Gets the auxiliary string data item by the specified name if it exists.
Boolean_t TecUtilAuxDataGetItemByName (AuxData_pa AuxDataRef, const char *Name, ArbParam_t *Value, AuxDataType_e *Type, Boolean_t *Retain)
  Gets the auxiliary data item by the specified name if it exists.
Boolean_t TecUtilAuxDataSetStrItem (AuxData_pa AuxDataRef, const char *Name, const char *Value, Boolean_t Retain)
  Adds the auxiliary data string item to the auxiliary data or replaces it if one already exists by the same name.
Boolean_t TecUtilAuxDataSetItem (AuxData_pa AuxDataRef, const char *Name, ArbParam_t Value, AuxDataType_e Type, Boolean_t Retain)
  Adds the auxiliary data item to the auxiliary data or replaces it if one already exists by the same name.
void TecUtilAuxDataDeleteItemByIndex (AuxData_pa AuxDataRef, LgIndex_t Index)
  Deletes the auxiliary data item.
Boolean_t TecUtilAuxDataDeleteItemByName (AuxData_pa AuxDataRef, const char *Name)
  Deletes the auxiliary data item by the specified name if it exists.

Function Documentation

AuxData_pa TecUtilAuxDataDataSetGetRef ( void   ) 

Gets a reference to the current data set's auxiliary data.

Returns:
Reference to the current data set's auxiliary data.
Precondition:
Must have one or more frames.
Fortran Syntax:
    SUBROUTINE TecUtilAuxDataDataSetGetRef(ResultPtr)
    POINTER (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.AuxDataDataSetGetRef()

  Output:
    Results[0]    ReturnVal            opaque pointer

void TecUtilAuxDataDeleteItemByIndex ( AuxData_pa  AuxDataRef,
LgIndex_t  Index 
)

Deletes the auxiliary data item.

Parameters:
AuxDataRef Reference to the auxiliary data.
Index Index of the auxiliary data item of interest.
Precondition:
AuxDataRef Pointer must be a valid address and non-NULL.
Fortran Syntax:
    SUBROUTINE TecUtilAuxDataDeleteItemByIndex(
   &           AuxDataRefPtr,
   &           Index)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    INTEGER*4       Index

Python Syntax:

  Results = TecUtil.AuxDataDeleteItemByIndex(AuxDataRef, Index)

  Input:
                  AuxDataRef           opaque pointer
                  Index                int
  Output:
    Results[0]    ReturnVal            NONE

Delete the dataset's fourth auxiliary data item:

   AuxData_pa AuxDataRef = TecUtilAuxDataDataSetGetRef();
   if (AuxDataRef != NULL)
     {
       TecUtilAuxDataDeleteItemByIndex(AuxDataRef, 4);
     }
   else
     {
       // ... allocation failure ...
     }

Boolean_t TecUtilAuxDataDeleteItemByName ( AuxData_pa  AuxDataRef,
const char *  Name 
)

Deletes the auxiliary data item by the specified name if it exists.

Parameters:
AuxDataRef Reference to the auxiliary data.
Name Name used for the search. A valid auxiliary data name character must begin with a '_' or alpha character and may be followed by one or more '_', '.', alpha or digit characters.
Returns:
TRUE if successful, FALSE otherwise.
Precondition:
AuxDataRef Pointer must be a valid address and non-NULL.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilAuxDataDeleteItemByName(
   &                   AuxDataRefPtr,
   &                   Name)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    CHARACTER*(*)   Name

Python Syntax:

  Results = TecUtil.AuxDataDeleteItemByName(AuxDataRef, Name)

  Input:
                  AuxDataRef           opaque pointer
                  Name                 string
  Output:
    Results[0]    ReturnVal            boolean

If it exists, delete the dataset's auxiliary data item named "MachNumber":

   AuxData_pa AuxDataRef = TecUtilAuxDataDataSetGetRef();
   if (AuxDataRef != NULL)
     {
       if (TecUtilAuxDataDeleteItemByName(AuxDataRef, "MachNumber"))
         {
           // ... item found and deleted ...
         }
       else
         {
           // ... item not found ...
         }
     }
   else
     {
       // ... allocation failure ...
     }

AuxData_pa TecUtilAuxDataFrameGetRef ( void   ) 

Gets a reference to the current frame's auxiliary data.

This function is Thread Safe.

Returns:
Reference to the current frame's auxiliary data.
Precondition:
Must have one or more frames.
Fortran Syntax:
    SUBROUTINE TecUtilAuxDataFrameGetRef(ResultPtr)
    POINTER (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.AuxDataFrameGetRef()

  Output:
    Results[0]    ReturnVal            opaque pointer

void TecUtilAuxDataGetItemByIndex ( AuxData_pa  AuxDataRef,
LgIndex_t  Index,
char **  Name,
ArbParam_t *  Value,
AuxDataType_e *  Type,
Boolean_t *  Retain 
)

Gets the auxiliary data item at the specified index.

The resulting name and value are allocated copies and therefore it is the client's responsibility to release them when no longer needed. This function is Thread Safe.

See also:
TecUtilStringDealloc()
Note:
This function is only available in C/C++. For other languages use TecUtilAuxDataGetStrItemByIndex().
Parameters:
AuxDataRef Reference to the auxiliary data.
Index Index of the auxiliary data of interest.
Name Address to hold the auxiliary data item name string. It is the client's responsibility release it with TecUtilStringDealloc() when no longer needed.
Value Address to hold the auxiliary data item value. If the value is a pointer to a string, it is the client's responsibility release it with TecUtilStringDealloc() when no longer needed.
Type Address to hold the auxiliary data item type.
Retain Address to hold the auxiliary data item retain flag.
Precondition:
AuxDataRef Pointer must be a valid address and non-NULL.

Name Pointer must be a valid address and non-NULL.

Value Pointer must be a valid address and non-NULL.

Type Pointer must be a valid address and non-NULL.

Retain Pointer must be a valid address and non-NULL.

Get the frame's fourth auxiliary data item:

   AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef();
   if (AuxDataRef != NULL)
     {
       char          *Name;
       ArbParam_t     Value;
       AuxDataType_e  Type;
       Boolean_t      Retain;
       TecUtilAuxDataGetItemByIndex(AuxDataRef, 4,
                                    &Name,
                                    &Value,
                                    &Type,
                                    &Retain);
       if (Type == AuxDataType_String)
         // currently the only type supported
         {
           char *ValueString = (char *)Value;
           if (ValueString != NULL)
             {
              // ... do something with the value string ...
              // release the allocated string copy
               TecUtilStringDealloc(&Name);
               TecUtilStringDealloc(&ValueString);
             }
           else
             {
               // ... handle the NULL condition ...
             }
         }
       else
         {
           // value type not yet supported by this addon
         }
     }
   else
     {
       // ... allocation failure ...
     }

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilAuxDataGetItemByName ( AuxData_pa  AuxDataRef,
const char *  Name,
ArbParam_t *  Value,
AuxDataType_e *  Type,
Boolean_t *  Retain 
)

Gets the auxiliary data item by the specified name if it exists.

This function is Thread Safe.

Note:
The resulting value is an allocated copy and therefore it is the caller's responsibility to release using TecUtilStringDealloc() when no longer needed. This function is only available in C/C++. For other languages, use TecUtilAuxDataGetStrItemByName().
Parameters:
AuxDataRef Reference to the auxiliary data.
Name Auxiliary data name to fetch. A valid auxiliary data name character must begin with a '_' or alpha character and may be followed by one or more '_', '.', alpha or digit characters.
Value Address to hold the auxiliary data item value. If the value is a pointer to a string, it is the client's responsibility release it with TecUtilStringDealloc() when no longer needed.
Type Address to hold the auxiliary data item type.
Retain Address to hold the auxiliary data item retain flag. If Retain is set to TRUE, then saving the data set will include this item.
Precondition:
AuxDataRef Pointer must be a valid address and non-NULL.

Value Pointer must be a valid address and non-NULL.

Type Pointer must be a valid address and non-NULL.

Retain Pointer must be a valid address and non-NULL.

Python Syntax:
    This function is not supported in Python.

If it exists, get the frame's auxiliary data item named "MachNumber":

   // If it exists, get the frame's auxiliary
   // data item named "MachNumber".
   AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef();
   if (AuxDataRef != NULL)
     {
       ArbParam_t    Value;
       AuxDataType_e Type;
       Boolean_t     Retain;
       if (TecUtilAuxDataGetItemByName(AuxDataRef, "MachNumber",
                                       &Value, &Type, &Retain))
         {
           if (Type == AuxDataType_String) // currently the only type supported
             {
               char *ValueString = (char *)Value;
               if (ValueString != NULL)
                 {
                   // ... do something with the value string ...
                   double MachNumber;
                   if (sscanf(ValueString, "%lf", &MachNumber) == 1)
                     {
                     }
                   else
                     {
                       // ... invalid value ...
                     }

                   // release the allocated string copy
                   TecUtilStringDealloc(&ValueString);
                 }
               else
                 {
                   // ... handle the NULL condition ...
                 }
             }
           else
             {
               // ... value type not yet supported by this addon ...
             }
         }
       else
         {
           // ... item not found ...
         }
     }
   else
     {
       // ... allocation failure ...
     }

Boolean_t TecUtilAuxDataGetItemIndex ( AuxData_pa  AuxDataRef,
const char *  Name,
LgIndex_t *  ItemIndex 
)

Gets the index of the named auxiliary data item if found or if not found the index where an auxiliary data item could be inserted in sorted order.

This function is Thread Safe.

Parameters:
AuxDataRef Reference to auxiliary data.
Name Name used for search. A valid auxiliary data name character must begin with a '_' or alpha character and may be followed by one or more '_', '.', alpha or digit characters.
ItemIndex Address to hold the index of the found item or the index where an auxiliary data item could be inserted.
Returns:
TRUE if the named item was found, FALSE otherwise.
Precondition:
AuxDataRef Pointer must be a valid address and non-NULL.

ItemIndex Pointer must be a valid address and non-NULL.

Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilAuxDataGetItemIndex(
   &                   AuxDataRefPtr,
   &                   Name,
   &                   ItemIndex)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    CHARACTER*(*)   Name
    INTEGER*4       ItemIndex

Python Syntax:

  Results = TecUtil.AuxDataGetItemIndex(AuxDataRef, Name)

  Input:
                  AuxDataRef           opaque pointer
                  Name                 string
  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    ItemIndex            int

If it exists, get the item index of the frame's auxiliary data item named "MachNumber":

   // If it exists, get the item index of the frame's
   // auxiliary data item named "MachNumber".
   AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef();
   if (AuxDataRef != NULL)
     {
       LgIndex_t ItemIndex;
       if (TecUtilAuxDataGetItemIndex(AuxDataRef,
                                      "MachNumber",
                                      &ItemIndex))
         {
           // ...do something with the item index ...
         }
       else
         {
           // ...item not found ...
         }
     }
   else
     {
       // ...allocation failure ...
     }

LgIndex_t TecUtilAuxDataGetNumItems ( AuxData_pa  AuxDataRef  ) 

Gets the current number of auxiliary data items maintained by the auxiliary data reference.

This function is Thread Safe.

Parameters:
AuxDataRef Reference to auxiliary data.
Returns:
Number of items maintained by the auxiliary data.
Precondition:
AuxDataRef Pointer must be a valid address and non-NULL.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilAuxDataGetNumItems(AuxDataRefPtr)
    POINTER (AuxDataRefPtr, AuxDataRef)

Python Syntax:

  Results = TecUtil.AuxDataGetNumItems(AuxDataRef)

  Input:
                  AuxDataRef           opaque pointer
  Output:
    Results[0]    ReturnVal            int

Find the number of auxiliary data items linked to the frame:

   AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef();
   if (AuxDataRef != NULL)
     {
       LgIndex_t NumItems = TecUtilAuxDataGetNumItems(AuxDataRef);
       if (NumItems != 0)
         {
           // ... do something with the 1..NumItems items ...
         }
     }
   else
     {
       // ... allocation failure ...
     }

void TecUtilAuxDataGetStrItemByIndex ( AuxData_pa  AuxDataRef,
LgIndex_t  Index,
char **  Name,
char **  Value,
Boolean_t *  Retain 
)

Gets the auxiliary string data item at the specified index.

The resulting name and value are allocated copies and therefore it is the client's responsibility to release them with TecUtilStringDealloc() when no longer needed. This function is Thread Safe.

Since:
11.0-0-007
See also:
TecUtilStringDealloc()
Parameters:
AuxDataRef Reference to the auxiliary data.
Index Index of the auxiliary data of interest.
Name Address to hold the auxiliary data item name string. It is the client's responsibility release it with TecUtilStringDealloc() when no longer needed.
Value Address to hold the auxiliary data item value string. It is the client's responsibility release it with TecUtilStringDealloc() when no longer needed.
Retain Address to hold the auxiliary data item retain flag.
Precondition:
AuxDataRef Pointer must be a valid address and non-NULL.

Name Pointer must be a valid address and non-NULL.

Value Pointer must be a valid address and non-NULL.

Retain Pointer must be a valid address and non-NULL.

Fortran Syntax:
    SUBROUTINE TecUtilAuxDataGetStrItemByIndex(
   &           AuxDataRefPtr,
   &           Index,
   &           Name,
   &           NameLength,
   &           ValuePtr,
   &           Retain)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    INTEGER*4       Index
    CHARACTER*(*)   Name
    INTEGER*4       NameLength
    CHARACTER*(*)   Value
    INTEGER*4       ValueLength
    INTEGER*4       Retain

Python Syntax:

  Results = TecUtil.AuxDataGetStrItemByIndex(AuxDataRef, Index)

  Input:
                  AuxDataRef           opaque pointer
                  Index                int
  Output:
    Results[0]    Name                 string
    Results[1]    Value                string
    Results[2]    Retain               boolean

Get the frame's fourth auxiliary data item:

   AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef();
   if (AuxDataRef != NULL)
     {
       char          *Name = NULL;
       char          *Value = NULL;
       Boolean_t      Retain;
       TecUtilAuxDataGetStrItemByIndex(AuxDataRef,
                                       4,
                                       &Name,
                                       &Value,
                                       &Retain);
       if (Value != NULL)
         {
           // ... do something with the value string ...
           // release the allocated string copy
            TecUtilStringDealloc(&Name);
            TecUtilStringDealloc(&Value);
         }
       else
         {
           // ... handle the NULL condition ...
         }
     }
   else
     {
       // ... allocation failure ...
     }

Boolean_t TecUtilAuxDataGetStrItemByName ( AuxData_pa  AuxDataRef,
const char *  Name,
char **  Value,
Boolean_t *  Retain 
)

Gets the auxiliary string data item by the specified name if it exists.

This function is Thread Safe.

Note:
The resulting value is an allocated copy and therefore it is the caller's responsibility to release using TecUtilStringDealloc() when no longer needed.
Since:
11.0-0-007
Parameters:
AuxDataRef Reference to the auxiliary data.
Name Auxiliary data name to fetch. A valid auxiliary data name character must begin with a '_' or alpha character and may be followed by one or more '_', '.', alpha or digit characters.
Value Address to hold the auxiliary data item value string. It is the client's responsibility release it with TecUtilStringDealloc() when no longer needed.
Retain Address to hold the auxiliary data item retain flag. If Retain is set to TRUE, then saving the data set will include this item.
Precondition:
AuxDataRef Pointer must be a valid address and non-NULL.

Value Pointer must be a valid address and non-NULL.

Retain Pointer must be a valid address and non-NULL.

Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilAuxDataGetStrItemByName(
   &                   AuxDataRefPtr,
   &                   Name,
   &                   ValuePtr,
   &                   Retain)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    CHARACTER*(*)   Name
    POINTER         (ValuePtr, Value)
    INTEGER*4       Type
    INTEGER*4       Retain

Python Syntax:

  Results = TecUtil.AuxDataGetStrItemByName(AuxDataRef, Name)

  Input:
                  AuxDataRef           opaque pointer
                  Name                 string
  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    Value                string
    Results[2]    Retain               boolean

If it exists, get the frame's auxiliary data item named "MachNumber":

   // If it exists, get the frame's auxiliary
   // data item named "MachNumber".
   AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef();
   if (AuxDataRef != NULL)
     {
       char     **Value;
       Boolean_t     Retain;
       if (TecUtilAuxDataGetStrItemByName(AuxDataRef, "MachNumber",
                                          &Value, &Retain))
         {
            if (Value != NULL)
              {
                // ... do something with the value string ...
                double MachNumber;
                if (sscanf(Value, "%lf", &MachNumber) == 1)
                  {
                  }
                else
                  {
                    // ... invalid value ...
                  }
                  // release the allocated string copy
                TecUtilStringDealloc(&Value);
              }
            else
              {
                // ... handle the NULL condition ...
              }
         }
       else
         {
           // ... item not found ...
         }
     }
   else
     {
       // ... allocation failure ...
     }

AuxData_pa TecUtilAuxDataLineMapGetRef ( EntIndex_t  Map  ) 

Gets a reference to the specified line map's auxiliary data.

This function is Thread Safe.

Since:
10.0-3-129
Parameters:
Map Line map number for which the auxiliary data is desired.
Returns:
Reference to the specified line map's auxiliary data.
Precondition:
Must have one or more frames.

Current frame must have a data set with at least one zone.

Fortran Syntax:
    SUBROUTINE TecUtilAuxDataLineMapGetRef(
   &           Map,
   &           ResultPtr)
    INTEGER*4       Map
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.AuxDataLineMapGetRef(Map)

  Input:
                  Map                  int
  Output:
    Results[0]    ReturnVal            opaque pointer

AuxData_pa TecUtilAuxDataPageGetRef ( void   ) 

Gets a reference to the current page's auxiliary data.

This function is Thread Safe.

Returns:
Reference to the current page's auxiliary data.
Precondition:
Must have one or more pages.
Fortran Syntax:
    SUBROUTINE TecUtilAuxDataPageGetRef(ResultPtr)
    POINTER (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.AuxDataPageGetRef()

  Output:
    Results[0]    ReturnVal            opaque pointer

Boolean_t TecUtilAuxDataSetItem ( AuxData_pa  AuxDataRef,
const char *  Name,
ArbParam_t  Value,
AuxDataType_e  Type,
Boolean_t  Retain 
)

Adds the auxiliary data item to the auxiliary data or replaces it if one already exists by the same name.

Note:
This function is available only in C/C++. For other languages, use TecUtilAuxDataSetStrItem.
Parameters:
AuxDataRef Reference to the auxiliary data.
Name Auxiliary data item's name. Be sure to consider a unique naming convention for your auxiliary data to avoid naming conflicts with auxiliary data produced by other addons or macros. By convention, addons that wish to share auxiliary data can prepend the name with the "Common" prefix. For example, the Plot3D loader uses CommonReferenceMachNumber for the reference Mach number. A valid auxiliary data name character must begin with a '_' or alpha character and may be followed by one or more '_', '.', alpha or digit characters.
Value Value of the item to set. If the type is a string, a copy of the string pointed to by Value is used for the auxiliary data value.
Type Type of item being set.
Retain Flag specifying whether or not to retain this item on file export such as writing out a datafile, etc.
Returns:
TRUE if the item was added to the auxiliay data, FALSE if otherwise.
Precondition:
AuxDataRef Pointer must be a valid address and non-NULL.
Python Syntax:
  Results = TecUtil.AuxDataSetItem(AuxDataRef, Name, Value, Type, Retain)

  Input:
                  AuxDataRef           opaque pointer
                  Name                 string
                  Value                (depends on attribute)
                  Type                 AuxDataType_e  (defined in TecVals.py)
                  Retain               boolean
  Output:
    Results[0]    ReturnVal            boolean

Add an item named "MachNumber" to the frame's auxiliary data.

   AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef();
   if (AuxDataRef != NULL)
     {
       ArbParam_t Value = (ArbParam_t)"1.75";
       if (TecUtilAuxDataSetItem(AuxDataRef,
                                 "MachNumber",
                                 Value,
                                 AuxDataType_String,
                                 TRUE)) // Retain
         {
           // ... item was added ...
         }
       else
         {
           // ... item failed to be added ...
         }
     }
   else
     {
       // ... allocation failure ...
     }

Boolean_t TecUtilAuxDataSetStrItem ( AuxData_pa  AuxDataRef,
const char *  Name,
const char *  Value,
Boolean_t  Retain 
)

Adds the auxiliary data string item to the auxiliary data or replaces it if one already exists by the same name.

Parameters:
AuxDataRef Reference to the auxiliary data.
Name Auxiliary data item's name. Be sure to consider a unique naming convention for your auxiliary data to avoid naming conflicts with auxiliary data produed by other addonaddons or macros. By convention addons that wish to share auxiliary data can prepend the name with the "Common" prefix. For example, the Plot3D loader uses CommonReferenceMachNumber for the reference Mach number. A valid auxiliary data name character must begin with a '_' or alpha character and may be followed by one or more '_', '.', alpha or digit characters.
Value Value string pointer of the item to set. A copy of this string is used for the auxiliary data value.
Retain Flag specifying whether or not to retain this item on file export such as writing out a datafile, etc.
Returns:
TRUE if the item was added to the auxiliay data, FALSE if otherwise.
Precondition:
AuxDataRef Pointer must be a valid address and non-NULL.

Value Pointer must be a valid address and non-NULL.

Retain Value must be TRUE or FALSE.

Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilAuxDataSetStrItem(
   &                   AuxDataRefPtr,
   &                   Name,
   &                   ValuePtr,
   &                   Retain)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    CHARACTER*(*)   Name
    POINTER         (ValuePtr, Value)
    INTEGER*4       Retain

Python Syntax:

  Results = TecUtil.AuxDataSetStrItem(AuxDataRef, Name, Value, Retain)

  Input:
                  AuxDataRef           opaque pointer
                  Name                 string
                  Value                string
                  Retain               boolean
  Output:
    Results[0]    ReturnVal            boolean

Add an item named "MachNumber" to the frame's auxiliary data.

   AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef();
   if (AuxDataRef != NULL)
     {
       const char *Value = "1.75";
       if (TecUtilAuxDataSetStrItem(AuxDataRef,
                                 "MachNumber",
                                 Value,
                                 TRUE)) // Retain
         {
           // ... item was added ...
         }
       else
         {
           // ... item failed to be added ...
         }
     }
   else
     {
       // ... allocation failure ...
     }

AuxData_pa TecUtilAuxDataVarGetRef ( EntIndex_t  Var  ) 

Gets a reference to the specified variable's auxiliary data.

This function is Thread Safe.

Since:
10.0-3-129
Parameters:
Var Variable number for which the auxiliary data is desired.
Returns:
Reference to the specified variable's auxiliary data.
Precondition:
Must have one or more frames.
Fortran Syntax:
    SUBROUTINE TecUtilAuxDataVarGetRef(
   &           Var,
   &           ResultPtr)
    INTEGER*4       Var
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.AuxDataVarGetRef(Var)

  Input:
                  Var                  int
  Output:
    Results[0]    ReturnVal            opaque pointer

AuxData_pa TecUtilAuxDataZoneGetRef ( EntIndex_t  Zone  ) 

Gets a reference to the specified zone's auxiliary data.

This function is Thread Safe.

Parameters:
Zone Zone number for which the auxiliary data is desired.
Returns:
Reference to the specified zone's auxiliary data.
Precondition:
Must have one or more frames.

Current frame must have a data set with at least one zone.

Fortran Syntax:
    SUBROUTINE TecUtilAuxDataZoneGetRef(
   &           Zone,
   &           ResultPtr)
    INTEGER*4       Zone
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.AuxDataZoneGetRef(Zone)

  Input:
                  Zone                 int
  Output:
    Results[0]    ReturnVal            opaque pointer

Generated on Tue Mar 12 02:24:40 2013 for Tecplot by  doxygen 1.5.5