OP_NodeVerb.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:        OP_NodeVerb.h  ( OP Library, C++)
 *
 * COMMENTS:
 *      Verb-based API for OP cooking mechanisms.  OPs can return
 *      one of these objects to describe how they cook, allowing the
 *      cook engine to perform additional optimizations.
 *
 *      Because how to actually cook is rather bespoke, this is mostly
 *      a category specific registration class.
 */

#ifndef __OP_NodeVerb_h__
#define __OP_NodeVerb_h__

#include "OP_API.h"
#include "OP_NodeParms.h"
#include "OP_OpTypeId.h"
#include <UT/UT_StringHolder.h>

class UT_StringArray;

///
/// OP_NodeVerb
///
/// This should be a singleton class.  Build it with the Register
/// template to allow it to be discoverable by name.
///
class OP_API OP_NodeVerb
{
public:
             OP_NodeVerb() {}
    virtual ~OP_NodeVerb() {}

    OP_NodeVerb(const OP_NodeVerb &) = delete;
    OP_NodeVerb &operator=(const OP_NodeVerb &) = delete;

    template <typename T>
    class Register
    {
    public:
        Register()
        {
            myVerb = new T();
            OP_NodeVerb::registerVerb(myVerb);
        }
        ~Register()
        {
            OP_NodeVerb::unregisterVerb(myVerb);
            delete myVerb;
        }

        const T *get() const { return myVerb; }
        const T *operator &() const { return myVerb; }
        operator const T &() const { return *myVerb; }

    private:
        T               *myVerb;

    };

    /// When working with a specific category one will use allocCache
    /// and allocParms, which these should chain to in the category baseclass.
    virtual OP_NodeCache        *baseAllocCache() const
                                    { return new OP_NodeCache; }

    virtual OP_NodeParms        *baseAllocParms() const = 0;

    virtual UT_StringHolder      name() const = 0;
    virtual OP_OpTypeId          category() const = 0;

    /// Finds a verb which matches the given name
    static const OP_NodeVerb    *lookupCategoryVerb(OP_OpTypeId cat, const UT_StringRef &name);
    static void                  listCategoryVerbs(OP_OpTypeId cat, UT_StringArray &verbnames);

    // Note: The category is present in the verb so not required.
    static void                  registerVerb(OP_NodeVerb *verb);
    static void                  unregisterVerb(OP_NodeVerb *verb);

protected:
};

#endif