OP/OP_BundleList.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:
 *      Mark Elendt
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        OP_BundleList.h ( OP_BundleList Library, C++)
 *
 * COMMENTS:    Container for bundles of objects
 */

#ifndef __OP_BundleList__
#define __OP_BundleList__

#include "OP_API.h"
#include <iostream.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_IntArray.h>
#include <UT/UT_SymbolTable.h>
#include <UT/UT_Notifier.h>
#include "OP_Node.h"

class UT_String;
class PRM_Name;
class OP_Node;
class OP_Network;
class CMD_Args;
class CMD_Manager;
class OP_Bundle;
class OP_Group;
class OP_BundleFilter;


// a small class for notifications about bundle events
class OP_API OP_BundleListEvent
{
public:

    enum OP_BundleListEventType
    {
        BUNDLE_ADDED,           // bundle was created or added to the list 
        BUNDLE_DELETED          // bundle was removed from the list
    };

    OP_BundleListEvent( OP_BundleListEventType type, OP_Bundle &bundle ) 
        : myEventType( type ), myBundle( bundle ) {}
    
    // the event type
    OP_BundleListEventType           myEventType;
    OP_Bundle                       &myBundle;
};


// definition of the bundle list
class OP_API OP_BundleList 
{
public:
     OP_BundleList();
    ~OP_BundleList();

    void         clear();

    int          entries() const        { return myBundles.entries(); }
    OP_Bundle   *getBundle(int i)       { return myBundles(i); }
    OP_Bundle   *getBundle(const char *name);

    int          internalEntries() const { return myInternal.entries(); }
    OP_Bundle   *getInternalBundle(int i)       { return myInternal(i); }

    OP_Bundle   *createBundle(const char *name, int internal=0);
    OP_Bundle   *duplicateBundle(OP_Bundle * bundle);
    int          destroyBundle(const char *name);
    int          destroyBundle(int index);

    char *       findUniqueBundleName(const char *base = NULL);
    int          renameBundle(const char *oldname, const char *newname);

    //  getMemberships will provide an array of pointers to the bundles that
    //  the specified node is a member of. The return value is the number of
    //  bundles returned. This will NOT return indices to internal bundles.
    int          getMemberships(const OP_Node *node,
                                UT_PtrArray<OP_Bundle *> &memberships) const;

    // Returns the previous filter
    const OP_BundleFilter       *setBundleFilter(const char *bname,
                                                 const char *fname);
    const OP_BundleFilter       *lookupFilter(const char *name) const;

    // obtains a list of existing filters
    void         getFilters( UT_PtrArray<const OP_BundleFilter *> &list );

    // Convenience functions for manipulating bundles within list
    // methods reutnr number of operators added/removed or old filter
    void                     bundleSetLock( OP_Bundle *bundle, bool lock );
    const OP_BundleFilter   *bundleSetFilter(OP_Bundle* bundle, 
                                             const char *fname); 
    const OP_BundleFilter   *bundleSetFilter(OP_Bundle* bundle, 
                                             const OP_BundleFilter *filter);
    void                     bundleClear( OP_Bundle *bundle );
    int                      bundleAddOp( OP_Bundle *bundle, OP_Node* node );
    int                      bundleAddOps(OP_Bundle *bundle,
                                          const OP_NodeList &nodes );
    int                      bundleRemoveOp( OP_Bundle *bundle, OP_Node* node );
    int                      bundleRemoveOps(OP_Bundle *bundle, 
                                             const OP_NodeList &nodes );
    
    // notifiers called by OP_Network
    void         nodeAdded(OP_Node *node);
    void         nodeDeleted(OP_Node *node);
    void         nodeRenamed(OP_Node *node);

    // Refilter the given node as its type (or representative type) may have
    // changed.
    void         refilterOp(OP_Node &node);

    // Called when director is finished loading
    // NB: if loading is nested (as it sometimes happens with nested OTLs)
    //     and we are still loading when this method is invoked,
    //     nodes will be added to a pending list. When the bulkAddNodes is
    //     invoked later (since it is invoked always after endLoading()),
    //     and we are no longer loading, then we process both nodes and pending
    //     nodes. If nodes is NULL then it tries to flush pending unless
    //     director is still loading
    void         bulkAddNodes(const OP_NodeList *nodes);

    int          getTouchTime() const   { return myTouchTime; }

    // This method will get a pattern style (i.e. internal bundle) based on the
    // creator and the pattern specified.  The "style" parameter should be a
    // unique string for the type of pattern (i.e. "lightmask").
    // To maintain proper reference counting, the method takes a reference to a
    // pointer.  This allows the list to maintain the list of referenced
    // patterns.  The subnet_inclusion argument determines whether subnet
    // contents are included unless explicitly excluded.
    OP_Bundle   *getPattern(UT_String &prev_bundle,
                            const OP_Network *creator,
                            const OP_Node *relativeto,
                            const char *pattern,
                            const char *filter = 0,
                            const char *label = 0,
                            bool subnet_inclusion = true,
                            bool addinterest=1);
    void         deReferenceBundle(const UT_String &prev_bundle);

    void         sortBundles();

    // Attempts to simplify the given pattern using this bundle list
    void         simplifyPattern( const OP_Node *root, UT_String &pattern );

    // Attempts to simplify the given pattern in a slightly safer manner than
    // the previous method.  The three main differences are:
    // 1. Supports groups
    // 2. Doesn't care about group/bundle contents (hence a bit faster)
    // 3. Ignores unrecognized tokens instead of removing them
    static void  simplifyPatternSafely( const OP_Node *root, UT_String &pattern );

    void         cmdLs(CMD_Args &args);
    void         cmdAdd(CMD_Args &args);
    void         cmdRm(CMD_Args &args);
    void         cmdOp(CMD_Args &args);
    void         cmdName(CMD_Args &args);
    int          saveToHip(ostream &os);

    void         buildBundleMenu(PRM_Name *menu, int max,
                                 const char *filter=0,
                                 int include_at_sign=1,
                                 int put_in_default_message=1);

    static void  installCommands(CMD_Manager *cmd);
    void         notifyOpsOfGroupChange(OP_Group *group);

    // returns an obiect that emmits events that originated from the
    // bundle list
    UT_NotifierImpl< OP_BundleListEvent& >
                        &getEventNotifier() { return myEventNotifier; }
 
    void                 dumpFilters(ostream &os);

private:
    void                 notifyBundleChange(const char *pattern);
    void                 notifyBundleDeletion(OP_Bundle *);
    void                 touch();
    bool                 getSortedPatternTokenNodes(
                            const OP_Node *root,
                            const char *pattern_token,
                            OP_NodeList &nodes );

    UT_PtrArray<OP_Bundle *>    myBundles;
    UT_PtrArray<OP_Bundle *>    myInternal;
    UT_SymbolTable              myNames;
    int                         mySortDirty;
    int                         myTouchTime;

    void                        nodeAddedRecurse(OP_Bundle *bundle, 
                                                 OP_Node *node);
    void                        nodeDeletedRecurse(OP_Bundle *bundle, 
                                                   OP_Node *node);

    // id's of nodes to add once director complets loading:
    UT_IntArray                 myPendingBulkAdded; 

    // object that nodifies about bundle list events
    UT_NotifierImpl<OP_BundleListEvent&>    myEventNotifier;
};


// helper class for saving/restoring node bundle memberships
class op_NodeBundle;
class OP_API OP_NodeBundleMemberships
{
public:
    OP_NodeBundleMemberships();
    OP_NodeBundleMemberships( OP_BundleList *bundle_list );
    ~OP_NodeBundleMemberships();

    // saves all node bundle memberships including descendents.
    void saveMemberships( OP_Node *node );

    // restore previously saved node bundle memberships
    void restoreMemberships( OP_Node *node );

    // return number of bytes used in RAM
    int64       getMemoryUsage() const;

    int getNumBundles() const;

private: // methods
    void saveChildMemberships( OP_Node *node, OP_Node *root );

private: // data
    UT_PtrArray<op_NodeBundle *>    myNodeBundles;
    OP_BundleList *                 myBundleList;
};

#endif

---