C++ UT_String::tokenize方法代码示例

// When mantra determines that the bounding box needs to be rendered, the 
// render method is called. At this point, the procedural can either 
// generate geometry (VRAY_Procedural::openGeometryObject()) or it can 
// generate further procedurals (VRAY_Procedural::openProceduralObject()).
void
VRAY_ieProcedural::render()
{
	initialisePython();
	ParameterisedProceduralPtr parameterisedProcedural = 0;
	ScopedGILLock giLock;
	try
	{
		object ieCore = g_mainModuleNamespace["IECore"];
		object classLoader = ieCore.attr( "ClassLoader" ).attr( "defaultProceduralLoader" )();
		object procedural = classLoader.attr( "load" )( m_className.buffer(), m_classVersion )();
		boost::python::list params;
		UT_WorkArgs argv;
		if (m_parameterString.tokenize(argv, ","))
		{
            // The Cortex Mantra Inject otl parses the parameters of a 
            // SOP_ProceduralHolder and replaces empty values with a '!' 
            // character to make them easier to parse here.
            // 
            // This hack is upsetting, a pure python procedural in the style 
            // of IECoreRI iePython.dso could parse these parameters correctly
            // like python/IECoreRI/ExecuteProcedural.py
			for (int i = 0; i < argv.getArgc(); i++) 
			{
				std::string s(argv[i]);
				if (s == "!")
				{
					params.append(std::string(""));
				}
				else
				{
					params.append(s);
				}
			}
		}
		object parameterParser = ieCore.attr( "ParameterParser" )();
		parameterParser.attr( "parse" )( params, procedural.attr( "parameters" )() );
		parameterisedProcedural = extract<ParameterisedProceduralPtr>( procedural );
	}
	catch( const error_already_set &e )
	{
		PyErr_Print();
	}
	catch( const std::exception &e )
	{
		msg( Msg::Error, "VRAY_ieProcedural", e.what() );
	}
	catch( ... )
	{
		msg( Msg::Error, "VRAY_ieProcedural", "Caught unknown exception" );
	}
	if( parameterisedProcedural )
	{
		IECoreMantra::RendererPtr renderer = new IECoreMantra::Renderer( this );
		parameterisedProcedural->render( renderer.get(), false, false, true, true ); 
	}
}

void
SOP_PrimGroupCentroid::buildGroupData(UT_String &pattern,
                                      const GU_Detail *input_geo,
                                      UT_Array<GA_Range> &range_array,
                                      UT_StringArray &string_values)
{
    GA_Range                    pr_range;
    const GA_PrimitiveGroup     *group;
    GA_ElementGroupTable::ordered_iterator group_it;

    UT_String                   group_name;
    UT_WorkArgs                 tokens;

    // Tokenize the pattern.
    pattern.tokenize(tokens);

    // Get all the primitive groups.
    const GA_ElementGroupTable &prim_groups = input_geo->primitiveGroups();

    // For each primitive group in order.
    for (group_it=prim_groups.obegin(); !group_it.atEnd(); ++group_it)
    {
        // Get the group.
        group = static_cast<GA_PrimitiveGroup *>(*group_it);

        // Ensure the group is valid.
        if (!group)
            continue;

        // Skip internal groups.
        if (group->getInternal())
            continue;

        // Check to see if this group name matches the pattern.
        group_name = group->getName();
        if (!group_name.matchPattern(tokens))
            continue;

        // Get a range for the primitives in the group.
        pr_range = input_geo->getPrimitiveRange(group);

        // Add the primitive range and the group name to the arrays.
        range_array.append(pr_range);
        string_values.append(group_name);
    }
}

OP_ERROR
SOP_IdBlast::cookMySop(OP_Context &context)
{
    fpreal 		        now;
    exint                       id; 

    GA_Offset                   start, end;

    GA_PointGroup               *group;

    GA_ROAttributeRef           id_gah;
    GA_ROPageHandleI            id_ph;

    UT_String                   pattern;
    UT_WorkArgs                 tokens;

    IdOffsetMap                 id_map, srcid_map;
    GroupIdMapPair              pair;

    now = context.getTime();

    if (lockInputs(context) >= UT_ERROR_ABORT)
        return error();

    // Duplicate the incoming geometry.
    duplicateSource(0, context);

    // Get the id pattern.
    IDS(pattern, now);
    // If it's emptry, don't do anything.
    if (pattern.length() == 0)
    {
        unlockInputs();
        return error();
    }

    // Tokenize the range so we can handle multiple blocks.
    pattern.tokenize(tokens, " ");

    // Try to find the 'id' point attribute on the 1st input geometry.
    id_gah = gdp->findPointAttribute(GA_SCOPE_PUBLIC, "id");
    // If it doesn't exist, display a node error message and exit.
    if (id_gah.isInvalid())
    {
        addError(SOP_MESSAGE, "Input geometry has no 'id' attribute.");
        unlockInputs();
        return error();
    }
  
    // Bind the page handles to the attributes.
    id_ph.bind(id_gah.getAttribute());

    // Iterate over all the points we selected.
    for (GA_Iterator it(gdp->getPointRange()); it.blockAdvance(start, end); )
    {
        // Set the page handle to the start of this block.
        id_ph.setPage(start);
        
        // Iterate over all the points in the block.
        for (GA_Offset pt = start; pt < end; ++pt)
        {
            // Get the 'id' value for the point.
            id = id_ph.get(pt);
            id_map[id] = pt;
        }
    }

    // Create the group.
    group = createAdhocPointGroup(*gdp);

    //  Add the group and the id map to the pair.
    pair.first = group;
    pair.second = &id_map;

    // Iterate over each block in the tokens and add any ids to the group.
    for (int i=0; i < tokens.getArgc(); ++i)
    {
        UT_String id_range(tokens[i]);
        id_range.traversePattern(-1, &pair, addOffsetToGroup);
    }

    // Destroy the points.
    gdp->destroyPointOffsets(GA_Range(*group));

    unlockInputs();
    return error();
}

void HoudiniScene::readTags( NameList &tags, bool includeChildren ) const
{
	tags.clear();
	
	const OP_Node *node = retrieveNode();
	if ( !node )
	{
		return;
	}
	
	// add user supplied tags if we're not inside a SOP
	if ( !m_contentIndex && node->hasParm( pTags.getToken() ) )
	{
		UT_String parmTagStr;
		node->evalString( parmTagStr, pTags.getToken(), 0, 0 );
		if ( !parmTagStr.equal( UT_String::getEmptyString() ) )
		{
			UT_WorkArgs tokens;
			parmTagStr.tokenize( tokens, " " );
			for ( int i = 0; i < tokens.getArgc(); ++i )
			{
				tags.push_back( tokens[i] );
			}
		}
	}
	
	// add tags from the registered tag readers
	std::vector<CustomTagReader> &tagReaders = customTagReaders();
	for ( std::vector<CustomTagReader>::const_iterator it = tagReaders.begin(); it != tagReaders.end(); ++it )
	{
		NameList values;
		it->m_read( node, values, includeChildren );
		tags.insert( tags.end(), values.begin(), values.end() );
	}
	
	// add tags based on primitive groups
	OBJ_Node *contentNode = retrieveNode( true )->castToOBJNode();
	if ( contentNode && contentNode->getObjectType() == OBJ_GEOMETRY && m_splitter )
	{
		GU_DetailHandle newHandle = m_splitter->split( contentPathValue() );
		if ( !newHandle.isNull() )
		{
			GU_DetailHandleAutoReadLock readHandle( newHandle );
			if ( const GU_Detail *geo = readHandle.getGdp() )
			{
				GA_Range prims = geo->getPrimitiveRange();
				for ( GA_GroupTable::iterator<GA_ElementGroup> it=geo->primitiveGroups().beginTraverse(); !it.atEnd(); ++it )
				{
					GA_PrimitiveGroup *group = static_cast<GA_PrimitiveGroup*>( it.group() );
					if ( group->getInternal() || group->isEmpty() )
					{
						continue;
					}
					
					const UT_String &groupName = group->getName();
					if ( groupName.startsWith( tagGroupPrefix ) && group->containsAny( prims ) )
					{
						UT_String tag;
						groupName.substr( tag, tagGroupPrefix.length() );
						tag.substitute( "_", ":" );
						tags.push_back( tag.buffer() );
					}
				}
			}
		}
	}
}

void
SOP_PrimGroupCentroid::buildRefMap(GA_AttributeRefMap &hmap,
                                   UT_String &pattern,
                                   GU_Detail *gdp,
                                   const GU_Detail *input_geo,
                                   int mode,
                                   GA_AttributeOwner owner)
{
    const GA_AttributeDict      *dict;
    GA_AttributeDict::iterator  a_it;

    const GA_Attribute          *source_attr;
    GA_ROAttributeRef           attr_gah;

    UT_String                   attr_name;
    UT_WorkArgs                 tokens;

    // Tokenize the pattern.
    pattern.tokenize(tokens, " ");

    // Select the appropriate attribute dictionary to use.
    if (owner == GA_ATTRIB_PRIMITIVE)
        dict = &input_geo->primitiveAttribs();
    // GA_ATTRIB_POINT
    else
        dict = &input_geo->pointAttribs();

    // Iterate over all the point attributes.
    for (a_it=dict->begin(GA_SCOPE_PUBLIC); !a_it.atEnd(); ++a_it)
    {
        // The current attribute.
        source_attr = a_it.attrib();
        // Get the attribute name.
        attr_name = source_attr->getName();

        // If the name doesn't match our pattern, skip it.
        if (!attr_name.matchPattern(tokens))
            continue;

        // Skip attribute names matching our current mode.  These are left
        // to the 'store' parm setting.
        if (mode == 1 and attr_name == "name")
            continue;
        else if (mode == 2 and attr_name == "class")
            continue;

        // Select the appropriate attribute type to search for.
        if (owner == GA_ATTRIB_PRIMITIVE)
        {
            // Try to find the point attribute on the geometry.
            attr_gah = gdp->findPointAttrib(*source_attr);
        }
        // GA_ATTRIB_POINT
        else
        {
            // If we are doing points, we can ignore P.
            if (attr_name == "P")
                continue;

            // Try to find the primitive attribute on the geometry.
            attr_gah = gdp->findPrimAttrib(*source_attr);
        }

        // If it doesn't exist, create a new attribute.
        if (attr_gah.isInvalid())
        {
            if (owner == GA_ATTRIB_PRIMITIVE)
            {
                // Create a new point attribute on the current geometry
                // that is the same as the source attribute.  Append it and
                // the source to the map.
                hmap.append(gdp->addPointAttrib(source_attr).getAttribute(),
                            source_attr);
            }
            else
            {
                // Create a new point attribute on the current geometry
                // that is the same as the source attribute.  Append it and
                // the source to the map.
                hmap.append(gdp->addPrimAttrib(source_attr).getAttribute(),
                            source_attr);
            }
        }
    }
}