OP/OP_OTLDefinition.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:
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        OP_OTLDefinition.h ( OTL Library, C++)
 *
 * COMMENTS:
 *
 */

#ifndef __OP_OTLDefinition__
#define __OP_OTLDefinition__

#include "OP_API.h"
#include "OP_Node.h"
#include <UT/UT_String.h>
#include <UT/UT_PtrArray.h>

class UT_WorkBuffer;

class OP_API OP_OTLDefinition
{
public:
             OP_OTLDefinition();
             OP_OTLDefinition(const OP_OTLDefinition &definition);
    virtual ~OP_OTLDefinition();

    const UT_String     &getName() const
                         { return myName; }
    void                 setName(const char *name)
                         { myName.harden(name); }
    const UT_String     &getLabel() const
                         { return myLabel; }
    void                 setLabel(const char *label)
                         { myLabel.harden(label); }
    const UT_String     &getPath() const
                         { return myPath; }
    void                 setPath(const char *path)
                         { myPath.harden(path); }
    const UT_String     &getIcon() const
                         { return myIcon; }
    void                 setIcon(const char *icon)
                         { myIcon.harden(icon); }
    const UT_String     &getAuthor() const
                         { return myAuthor; }
    void                 setAuthor(const char *author)
                         { myAuthor.harden(author); }
    const UT_String     &getCopyright() const
                         { return myCopyright; }
    void                 setCopyright(const char *copyright)
                         { myCopyright.harden(copyright); }
    const UT_String     &getOpTableName() const
                         { return myOpTableName; }
    void                 setOpTableName(const char *optablename)
                         { myOpTableName.harden(optablename); }
    const UT_String     &getIndexPath() const
                         { return myIndexPath; }
    void                 setIndexPath(const char *indexpath)
                         { myIndexPath.harden(indexpath); }
    const UT_String     &getIndexFile() const
                         { return myIndexFile; }
    void                 setIndexFile(const char *indexfile)
                         { myIndexFile.harden(indexfile); }
    const UT_String     &getLicenseInfo() const
                         { return myLicenseInfo; }
    void                 setLicenseInfo(const char *licenseinfo)
                         { myLicenseInfo.harden(licenseinfo); }
    const UT_String     &getExtraInfo() const
                         { return myExtraInfo; }
    void                 setExtraInfo(const char *extrainfo)
                         { myExtraInfo.harden(extrainfo); }
    int                  getMinInputs() const
                         { return myMinInputs; }
    void                 setMinInputs(int inputs)
                         { myMinInputs = inputs; }
    int                  getMaxInputs() const
                         { return myMaxInputs; }
    void                 setMaxInputs(int inputs)
                         { myMaxInputs = inputs; }
    int                  getModTime() const
                         { return myModTime; }
    void                 setModTime(int modtime)
                         { myModTime = modtime; }
    char                 getIsSubnet() const
                         { return myIsSubnet; }
    void                 setIsSubnet(char issubnet)
                         { myIsSubnet = issubnet; }
    char                 getIsPython() const
                         { return myIsPython; }
    void                 setIsPython(char ispython)
                         { myIsPython = ispython; }
    char                 getIsDummyDefinition() const
                         { return myIsDummyDefinition; }
    void                 setIsDummyDefinition(char isdummy)
                         { myIsDummyDefinition = isdummy; }

    // Return if this is an internally defined operator
    bool                 isInternal() const;

    // Handle options that appear in index files (-icon, -inputs, etc.).
    int                  handleOption(int argc, char *argv[]);
    // Concatenates the op table name and the op name to get a unique name.
    void                 getTableAndName(UT_String &name) const;

    // Converts the table name into an OP_OpTypeId.
    OP_OpTypeId          getOpTypeId() const;

    const OP_OTLDefinition      &operator=(const OP_OTLDefinition &src);
    bool                         load(UT_IStream &is);
    bool                         save(ostream &os);
    // Writes a text description that is easily readable by the user.
    void                         writeTextDescription(UT_WorkBuffer &buffer,
                                      const char *indent = 0) const;
    // Writes a text description based on the format string. The format
    // string is a series of characters. Each character represents one
    // piece of information. The information is output on a single line.
    void                         writeFormattedText(UT_WorkBuffer &buffer,
                                      const char *format) const;
    // Read in a text description written out as above. We return false if an
    // invalid or malformed description is found. We return true if we read in
    // a good description _or_ if we reach the end of the stream before even
    // starting a description.
    bool                         readTextDescription(UT_IStream &is);

    // Utility function for converting a string to a modification time.
    static int                   getModTimeFromString(const char *str);

private:
    UT_String                    myName;
    UT_String                    myLabel;
    UT_String                    myPath;
    UT_String                    myIcon;
    UT_String                    myAuthor;
    UT_String                    myCopyright;
    UT_String                    myOpTableName;
    UT_String                    myIndexPath;
    UT_String                    myIndexFile;
    UT_String                    myLicenseInfo;
    UT_String                    myExtraInfo;
    int                          myMinInputs;
    int                          myMaxInputs;
    int                          myModTime;
    char                         myIsSubnet;
    char                         myIsPython;
    char                         myIsDummyDefinition;
};

typedef UT_PtrArray<OP_OTLDefinition *> OP_OTLDefinitionArray;

#endif

---