VOP_AutoConvert.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:        VOP Library (C++)
 *
 *          Note: This is more of an internal class, not  an actual node. It needs to inherit 
 *          from VOP_Node to generate code properly, though. What happens is during code 
 *          generation, copies of it are inserted into the flattened node list, and (before
 *          they are inserted) are told which two nodes and which input/output they go between.
 *          Thus, these are essentially virtual nodes that get created only at code generation 
 *          time and destroyed immediately afterwards.
 *          
 *          During code generation, they pretend they really are connected between the two nodes,
 *          and generate proper auto-conversion code. Auto convert also contains severa static 
 *          functions that determine whether two types can be auto-converted between.
 *
 */

#ifndef __VOP_AutoConvert_h__
#define __VOP_AutoConvert_h__

#include "VOP_API.h"
#include "VOP_AutoNode.h"
#include <string>

// #define DEBUG_DISABLE_AUTOCONVERT

class VOP_API VOP_AutoConvert : public VOP_AutoNode
{
public:
    VOP_AutoConvert(OP_Network *net);
    ~VOP_AutoConvert() override;

    /// Returns true if intype can be converted to outtype.
    static bool         canAutoconvert(VOP_Type intype, VOP_Type outtype,
                                       const VOP_Language *language);
    static bool         canAutoconvert(const VOP_TypeInfo &intype, 
                                       const VOP_TypeInfo &outtype,
                                       const VOP_Language *language);

    // Since this "node" is meant to be used on its own, we override this
    // to let VEX code be generated properly.
    void                getPathWithSubnet(UT_String &str) const override;
    void                getOuterCode(
                                UT_String &codestr,
                                const VOP_CodeGenContext &context) override;
    void                getCode(UT_String &codestr,
                                const VOP_CodeGenContext &context) override;

    OP_Network          *getParentNetwork()  const override;

    OP_Input            *getInputReference(unsigned idx, bool grow) override;
    OP_Input            *getInputReferenceConst(unsigned idx) const override;

    void                 hookupBetween(VOP_Node* input_node, 
                                    VOP_Node* output_node, 
                                    int input_idx, bool tell_nodes);

    bool                 isConnected(int inputidx, bool recursive) override;
    unsigned             getNumVisibleInputs() const override;
    unsigned             getNumVisibleOutputs() const override;
    const char          *inputLabel(unsigned idx) const override;
    const char          *outputLabel(unsigned idx) const override;

    static void         initConversions();

    static const char*  getAutoConvertOpName(const VOP_TypeInfo &from_type, 
                                             const VOP_TypeInfo &to_type);
    static const char*  getAutoConvertOpName(VOP_Type from_type, VOP_Type to_type);
    static VOP_Type     generateCodeFor(VOP_Node *input_node, 
                                VOP_Node *output_node, 
                                int input_idx, UT_String &codestr,
                                bool current_types_only);

    bool                 isAutoConvertNode() const override
                            { return true; }

protected:

    void                 getInputNameSubclass(
                                UT_String &in,
                                int idx) const override;
    int                  getInputFromNameSubclass(
                                const UT_String &in) const override;
    void                 getInputTypeInfoSubclass(
                                VOP_TypeInfo &type_info, 
                                int idx) override;

    void                 getOutputNameSubclass(
                                UT_String &out,
                                int idx) const override;
    void                 getOutputTypeInfoSubclass(
                                VOP_TypeInfo &type_info, 
                                int idx) override;

    static void          getConversionBetween(VOP_Type intype, VOP_Type outtype,
                                std::string& out, const VOP_Language *language);

private:


    // Since autoconversion nodes are only created when generating
    // code, we can just keep the pointers. Also, we can't use setInput(), etc.
    // because that will modify the actual node graph, and disconnect previous nodes.
    // We don't want to do that.
    VOP_Node *myInput, *myOutput;
    int myInputIdx; // input index on the node we output to

    // From-to-type.
    static std::string theConversionTable[VOP_MAX_TYPES][VOP_MAX_TYPES];
    static bool   theDidInitConversions;
    static std::string theConversionNodeNameTable[VOP_MAX_TYPES][VOP_MAX_TYPES];

    VOP_TypeInfo    myConvertedOutputTypeInfo;
};

#endif