CVEX_ValueList.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        CVEX_ValueList.h ( CVEX Library, C++)
 *
 * COMMENTS:    C++ interface to VEX.  This class is used to specify
 *              a list of input/output values
 */

#ifndef __CVEX_ValueList__
#define __CVEX_ValueList__

#include "CVEX_API.h"
#include "CVEX_Value.h"
#include <UT/UT_ValArray.h>
#include <UT/UT_SymbolTable.h>

template <VEX_Precision PREC> class CVEX_ContextT;

/// @brief List of input or output values for a CVEX_Context
///
/// This class maintains a list of the input and output parameters for a CVEX
/// context.
///
/// Both input and output variables are associated with parameters on the VEX
/// function being run.  Output variables are those flagged with the @c export
/// keyword.
template <VEX_Precision PREC>
class CVEX_API CVEX_ValueListT : public UT_NonCopyable
{
public:
     CVEX_ValueListT();
    ~CVEX_ValueListT();

    /// @{
    /// Returns the number of values in the list
    int          entries() const        { return myValues.entries(); }
    int          size() const           { return myValues.size(); }
    /// @}

    /// Get a value by index
    const CVEX_ValueT<PREC> *getValue(int i) const      { return myValues(i); }
    CVEX_ValueT<PREC>   *getValue(int i) { return myValues(i); }

    /// Get a value by name and type. Returns NULL if there's no value by
    /// that name and type.
    const CVEX_ValueT<PREC> *getValue(const UT_StringRef &name, CVEX_Type type) const;
    CVEX_ValueT<PREC>   *getValue(const UT_StringRef &name, CVEX_Type type);

    /// Get a value by name. Returns NULL if there's no value by that name.
    const CVEX_ValueT<PREC> *getValue(const UT_StringRef &name) const
                 { return getValue(name, CVEX_TYPE_INVALID); }
    CVEX_ValueT<PREC>   *getValue(const UT_StringRef &name)
                 { return getValue(name, CVEX_TYPE_INVALID); }
    
    /// Add a value by name type and varying flag.  This fails if:
    /// - There's already a symbol with the name
    /// - The type is invalid
    /// @note Users should call CVEX_Context::addInput()
    bool         addValue(const UT_StringHolder &name,
                          CVEX_Type type, bool varying);

    /// Add a value by name, type and provide data.
    /// @note Users should call CVEX_Context::addInput()
    bool         addValue(const UT_StringHolder &name, CVEX_Type type,
                          void *data, int array_size,
                          bool isconstant);
    
    /// Add a string value (with data)
    /// @note Users should call CVEX_Context::addInput()
    bool         addValue(const UT_StringHolder &name,
                          CVEX_StringArray &strings,
                          bool isconstant);
    bool         addValue(const UT_StringHolder &name,
                          CVEX_DictArray &strings,
                          bool isconstant);

    /// Add an array of integer value (with data)
    /// @note Users should call CVEX_Context::addInput()
    bool         addValue(const UT_StringHolder &name,
                          UT_PackedArrayOfArrays<VEXint<PREC>> &intdata,
                          bool isconstant);

    /// @{
    /// Convenience operators
    const CVEX_ValueT<PREC> *operator[](int i) const { return getValue(i); }
    CVEX_ValueT<PREC>   *operator[](int i)      { return getValue(i); }

    CVEX_ValueT<PREC>   *operator()(int i)      { return getValue(i); }
    CVEX_ValueT<PREC>   *operator()(const UT_StringRef &name, CVEX_Type type)
                        { return getValue(name, type); }
    /// @}

private:
    void                clear();
    void                addValue(CVEX_ValueT<PREC> *value);

    // Clear the value but leave the null entry in myValues
    void                clearValue(int index);

    UT_StringMap<CVEX_ValueT<PREC> *>    mySymbols;
    UT_ValArray<CVEX_ValueT<PREC> *>     myValues;
    UT_String                    myError;

    UT_ValArray<CVEX_ValueT<PREC> *>     myClearedValues;

    template <VEX_Precision ALLPREC>
    friend class        CVEX_ContextT;
};

using CVEX_ValueList = CVEX_ValueListT<VEX_32>;

CVEX_EXTERN_TEMPLATE(CVEX_ValueListT<VEX_32>);
CVEX_EXTERN_TEMPLATE(CVEX_ValueListT<VEX_64>);

#endif