OP/OP_OperatorTable.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.
 *
 * Produced by:
 *      Paul Breslin
 *      Side Effects Software Inc.
 *      477 Richmond St. West
 *      Toronto, Ontario,  M5V 3E7
 *      Canada
 *      416-504-9876
 *
 * NAME:        OP_OperatorTable.h (C++)
 *
 * COMMENTS:    This class is simply a symbol table of OP_Operator's.
 *
 */

#ifndef __OP_OperatorTable_h__
#define __OP_OperatorTable_h__

#include "OP_API.h"
#include <UT/UT_String.h>
#include <UT/UT_SymbolTable.h>
#include <UT/UT_PtrArray.h>
#include "OP_OTLDefinition.h"
#include "OP_Operator.h"

class OP_Node;
class OP_Network;
class OP_OperatorTable;
class OP_ScriptOperator;
class OP_ScriptIndexFile;
class OP_UpdateTableSink;

typedef UT_PtrArray<OP_OperatorTable *>  OP_OperatorTableList;
typedef OP_ScriptOperator *(*OP_ScriptCreatorFunc)
                           (const OP_OTLDefinition &definition);

class OP_API OP_OperatorTable : private UT_SymbolTable
{
public:
     OP_OperatorTable(const char *table_name, const char *script_directory);
    ~OP_OperatorTable();

    static int  getAllOperatorTables(OP_OperatorTableList &list);

    OP_Node             *createNode(OP_Network *parent, const char *type,
                                    const char *name = 0,
                                    int *aliasedScriptedOp = 0);

    OP_Operator         *getOperator(const char *name);
    int                  addOperator(OP_Operator *op);
    void                 removeOperator(OP_Operator *op);

    OP_Operator         *getPrimarySubnetOperator()
                            { return myPrimarySubnet; }

    void                 setScriptCreator(OP_ScriptCreatorFunc func);
    void                 addScriptIndexFile(const char *indexpath,
                                            const char *indexfile,
                                            const char *classid,
                                            const char *extrainfo,
                                            int defaultMinInputs,
                                            int defaultMaxInputs,
                                            bool issubnet,
                                            bool ispython);
    bool                 loadScriptOperator(const char *opname, UT_IStream &is,
                                            OP_OTLLibrary *addToLib);
    bool                 addOperatorIfNew(const OP_OTLDefinition &definition);

    void                 requestReload();

    // Runs the DSO installation function on our currently loaded dso's inthe
    // dso search path.
    void                 runDSOInstall();

    // Loads the given dso file and runs the installation function 
    bool                 loadDSO(const char *dso_file);

    int                  entries() const { return myOpCount; }

    int                  getOperatorList(UT_StringList &list, int english=1);
    int                  getOperators(OP_OperatorList &list,
                                      OP_Network *net = 0,
                                      bool filterhidden = false);

    // This returns the optype id for the given table.
    OP_OpTypeId          getOpTypeID() const;

    // This returns a unique integer for each OP_OperatorTable created
    int                  getUniqueOpTypeID() const { return myUniqueOpTypeID; }
    // Before sorting, you should getOperators(list);
    void                 sortOperators(OP_OperatorList &list,
                                OP_Operator::OP_OperatorCompare method =
                                OP_Operator::OP_COMPARE_GEN_NAME);

    const UT_String     &getName() const        { return myName; }
    const UT_String     &getScriptPath() const  { return myScriptDirectory; }

    unsigned             getOperatorStatus(OP_Operator *op) const;
    unsigned             getStatus(void) const;
    void                 setDefaultType(const char *type);
    const char          *getDefaultType() const;

    // Add an operator alias (from the OPcustomize file).
    bool                 setOpRename(const char *optype, const char *newname);
    // Display all the oprename commands.
    void                 outputOpRenames(ostream &os) const;
    // Add an operator alias (from the OPcustomize file).
    bool                 setOpAlias(const char *original, const char *alias);
    // Display all the opalias commands.
    void                 outputOpAliases(ostream &os) const;
    // Get all the aliases for a particular operator type.
    void                 getOpAliases(const char *opname,
                                      UT_StringArray &opaliases) const;
    // Get the operator type represented by the supplied alias (if any).
    const char          *getOpFromAlias(const char *alias) const;
    // Add an operator to the excluded op list (from the OPcustomize file).
    bool                 addOpExcluded(const char *opname);
    // Is operator excluded?
    bool                 isOpExcluded(const char *opname);
    // Display all the opexclude commands.
    void                 outputOpExcluded(ostream &os) const;
    // Add an operator to the hidden op list (from the OPcustomize file).
    void                 addOpHidden(const char *opname);
    // Delete an operator from the hidden op list (from the OPcustomize file).
    void                 delOpHidden(const char *opname);
    // Is operator hidden?
    bool                 isOpHidden(const char *opname);
    // Display all the ophide commands.
    void                 outputOpHidden(ostream &os) const;

    // When no name is specified for a node, we typically use the type as the
    // prefix for the name.  However, we may want to provide a method for
    // creating alternate default names for operators.
    void                 getDefaultTypeName(const char *type, UT_String &name);

    // If there is an index file that contains scripted subnets for this op
    // table, this function returns a pointer to that file name.
    const char          *getScriptedSubnetIndex() const;

    // Notify those who are interested that our table contents have changed.
    // Don't do this in addOperator - only after bulk operations like
    // loadScriptOperators or OP_Netowkr::loadScriptedOpDefs.
    void                 notifyUpdateTableSinksOfUpdate();

    static inline int    getLoadDSOFlag()       { return theLoadDSOFlag; }
    static inline void   setLoadDSOFlag(int i)  { theLoadDSOFlag = i; }
    static unsigned      getPermissionMask(const OP_Operator *op);
    static void          clearPermissionMask(const OP_Operator *op);

private:
    // Functions for adding or removing a table sink.
    void                 addUpdateTableSink(OP_UpdateTableSink *sink);
    void                 removeUpdateTableSink(OP_UpdateTableSink *sink);
    // Called when the operator is deleted.
    void                 notifyUpdateTableSinksOfDelete();

    // Functions for adding new operator types using an OP_OTLDefinition.
    OP_ScriptOperator   *addNewOperator(const OP_OTLDefinition &definition);
    int                  loadScriptIndexFile(OP_ScriptIndexFile &sif,
                                             bool checkdup);

    UT_String            myName;
    UT_String            myScriptDirectory;
    UT_String            myDefaultType;
    UT_String            myScriptedSubnetIndex;
    OP_Operator         *myPrimarySubnet;
    int                  myOpCount;
    int                  myUniqueOpTypeID;
    static int           theLoadDSOFlag;

    OP_ScriptCreatorFunc                 myScriptCreatorFunc;
    UT_PtrArray<OP_ScriptIndexFile *>    myScriptIndexFiles;
    UT_PtrArray<OP_UpdateTableSink *>    myUpdateTableSinks;
    UT_SymbolTable                       myOpRenames;
    UT_SymbolTable                       myOpAliases;
    UT_StringArray                       myExcludedOps;
    UT_StringArray                       myHiddenOps;

    friend class         OP_UpdateTableSink;
};

class OP_API OP_UpdateTableSink
{
public:
                 OP_UpdateTableSink()   { }
    virtual     ~OP_UpdateTableSink()
                 { removeAllTableSinks(); }

    virtual void tableUpdated(OP_OperatorTable *table) = 0;
    virtual void tableDeleted(OP_OperatorTable *table)
                 { removeUpdateTableSink(table); }

protected:
    void         addUpdateTableSink(OP_OperatorTable *table)
                 {
                     if( !table ) return;
                     table->addUpdateTableSink(this);
                     myOpTables.append(table, 1);
                 }
    void         removeUpdateTableSink(OP_OperatorTable *table)
                 {
                     if( !table ) return;
                     table->removeUpdateTableSink(this);
                     myOpTables.remove(table);
                 }
    void         removeAllTableSinks()
                 {
                     for( int i = myOpTables.entries(); i --> 0; )
                         removeUpdateTableSink(myOpTables(i));
                 }

private:
    OP_OperatorTableList         myOpTables;
};

#endif

---