GOP/GOP_GroupParse.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
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 */

#ifndef __GOP_GroupParse_h__
#define __GOP_GroupParse_h__

#include "GOP_API.h"

#include "GOP_AdhocGroup.h"

class UT_String;
class GB_Group;

class OP_Node;
typedef void (OP_Node::*GroupOperation)(const GB_Group *, void *);

//___________________________________________________________________________

class gopAddData;
class GU_Detail;
class GB_PrimitiveGroup;
class GB_PointGroup;
class GOP_Manager;

class GOP_API GOP_GroupParse
{
    friend class gopAddData;

public:
                         GOP_GroupParse (GOP_Manager *manager) 
                         {
                             myManager = manager;
                         };
    virtual             ~GOP_GroupParse (void) {};

    // Build a string that contains the id's of the primitives/points in a
    // primitive/point group or a primitive/point selection.  The offset is
    // the amount to add to the id of each primitive/point in the selection.
    static void          buildPrimGroupToken(const GU_Detail *gdp,
                                         const GB_PrimitiveGroup *primgrp,
                                         UT_String &token,
                                         int offset = 0);
    static void          buildPointGroupToken(const GU_Detail *gdp,
                                         const GB_PointGroup *ptgrp,
                                         UT_String &token,
                                         int offset = 0);

    const GB_PrimitiveGroup     *parsePrimitiveGroups(const char *pat, 
                                              GU_Detail *pgdp = 0, 
                                              int numok = 1,
                                              int ordered = 1,
                                              bool strict = false,
                                              int offset = 0)
    {
        return (const GB_PrimitiveGroup *)parseGroups(pat, 1, pgdp, numok, 1,
                                                      ordered, strict, offset);
    }
    const GB_PointGroup *parsePointGroups(const char *pat, 
                                          GU_Detail *pgdp = 0,
                                          int numok = 1,
                                          int ordered = 1,
                                          bool strict = false,
                                          int offset = 0)
    {                                         
        return (const GB_PointGroup *)parseGroups(pat, 0, pgdp, numok, 1,
                                                  ordered, strict, offset);
    }                                         

    //
    // Similar to above, except the caller is free to modify its contents
    //

    GB_PrimitiveGroup   *parsePrimitiveGroupsCopy(const char *pat, 
                                                  GU_Detail *pgdp = 0, 
                                                  int numok = 1,
                                                  int ordered = 1,
                                                  bool strict = false,
                                                  int offset = 0)
    {
        return (GB_PrimitiveGroup *)parseGroups(pat, 1, pgdp, numok, 0,
                                                  ordered, strict, offset);
    }

    GB_PointGroup       *parsePointGroupsCopy(const char *pat, 
                                                  GU_Detail *pgdp = 0, 
                                                  int numok = 1,
                                                  int ordered = 1,
                                                  bool strict = false,
                                                  int offset = 0)
    {
        return (GB_PointGroup *)parseGroups(pat, 0, pgdp, numok, 0,
                                              ordered, strict, offset);
    }



    // Do the operation on a per group basis instead of unioning them together
    int                  parseEachGroup(const char *inpattern, 
                                        GroupOperation operation,
                                        void *data, int isPrim,OP_Node *opThis,
                                        GU_Detail *pgdp=0,
                                        int ordered = 1,
                                        bool strict = false,
                                        int offset = 0,
                                        bool allow_adhoc = true);

    void                 expandGroupNames(const char *pattern, 
                                          UT_String &outNames, 
                                          int isPrim, GU_Detail *gdp=0);
private:

    GOP_Manager         *myManager;

    const GB_Group      *parseGroups(const char *inpattern, int isPrim,
                                     GU_Detail *pgdp,
                                     int allow_numeric = 1,
                                     int allow_reference = 1,
                                     int ordered = 1,
                                     bool strict = false,
                                     int offset = 0);

    // Used parts of pattern are replaced with spaces.
    GB_Group            *extractNumeric(char *pattern, int isPrim,
                                        GU_Detail *pgdp, int &all_numeric,
                                        int ordered, int offset = 0);

    // Creates an adhoc attribute group for each @ escaped
    // expression.
    // Used parts of pattern are replaced with spaces.
    GB_Group            *extractAttributeGroup(char *pattern, bool isPrim,
                                        GU_Detail *pgdp, bool onlyone,
                                        bool ordered);

    void                 parseAttributeGroup(GB_Group *group,
                                    char *pattern, bool isPrim,
                                    GU_Detail *pgdp, bool negate, bool ordered);

    void                 appendAdhocGroup(GU_Detail *gdp, GB_BaseGroup *group,
                                          int isowner);

};

#endif

---