Wildcard.h File Reference

#include <string>
#include <vector>

Include dependency graph for Wildcard.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int	allChildren (ObjId start, unsigned int index, const string &insideBrace, vector< ObjId > &ret)
bool	matchBeforeBrace (ObjId id, const string &wild)
int	simpleWildcardFind (const string &path, vector< ObjId > &ret)
int	wildcardFind (const string &n, vector< ObjId > &ret)

Function Documentation

int allChildren	(	ObjId	start,
		unsigned int	index,
		const string &	insideBrace,
		vector< ObjId > &	ret
	)

Recursive function to compare all descendants and cram matches into ret. Returns number of matches. Index is either ALLDATA == ~0U, or a specified number. insideBrace is a string that can be empty, or specify one of the expressions: [TYPE==<string>] [TYPE=<string>] [CLASS=<string>] [ISA=<string>] [ISA==<string>] [TYPE!=<string>] [CLASS!=<string>] [ISA!=<string>] [FIELD(<fieldName)=<string>]

Recursive function to compare all descendants and cram matches into ret. Returns number of matches.

Definition at line 495 of file Wildcard.cpp.

References allChildren(), ALLDATA, Neutral::children(), ObjId::dataIndex, ObjId::eref(), and matchInsideBrace().

Referenced by allChildren(), moose::CompartmentBase::setGeomAndElec(), and singleLevelWildcard().

{
    unsigned int nret = ret.size();
    vector< Id > kids;
    Neutral::children( start.eref(), kids );
    vector< Id >::iterator i;
    for ( i = kids.begin(); i != kids.end(); i++ )
    {
        if ( i->element()->hasFields() )
        {
            if ( matchInsideBrace( *i, insideBrace ) )
            {
                if ( index == ALLDATA )
                {
                    ObjId oid( *i, start.dataIndex );
                    ret.push_back( oid );
                }
                else if (index < i->element()->numField( start.dataIndex ) )
                {
                    ObjId oid( *i, start.dataIndex, index );
                    ret.push_back( oid );
                }
            }
        }
        else
        {
            for ( unsigned int j = 0; j < i->element()->numData(); ++j )
            {
                ObjId oid( *i, j );
                allChildren( oid, index, insideBrace, ret );
                if ( (index == ALLDATA || index == j) && matchInsideBrace( oid, insideBrace ) )
                    ret.push_back( oid );
            }
        }
    }
    return ret.size() - nret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool matchBeforeBrace	(	ObjId	id,
		const string &	wild
	)

matchBeforeBrace checks to see if the wildcard string 'name' matches up with the name of the id. Rules:

may be used at multiple places in the wildcard.

It substitutes for any number of characters.

? may be used any number of times in the wildcard, and must substitute exactly for characters.

If bracesInName, then the Id name itself includes braces.

Definition at line 432 of file Wildcard.cpp.

References Shell::chopString(), and findWithSingleCharWildcard().

Referenced by Neuron::getSpinesFromExpression(), matchName(), and testWildcard().

{
    if ( wild == "#" || wild == "##" )
        return true;

    string ename = id.element()->getName();
    if ( wild == ename )
        return true;

    // Check if the wildcard string has any # or ? symbols.
    if ( wild.find_first_of( "#?" ) == string::npos )
        return false;

    // Break the 'wild' into the sections that must match, at the #s.
    // Then go through each of these sections doing a match to ename.
    // If not found, then return false.
    vector< string > chops;
    Shell::chopString( wild, chops, '#' );
    unsigned int prev = 0;
    unsigned int start = 0;

    for ( vector< string >::iterator
            i = chops.begin(); i != chops.end(); ++i )
    {
        start = findWithSingleCharWildcard( ename, prev, *i );
        if ( start == ~0U )
            return false;
        if ( prev == 0 && start > 0 && wild[0] != '#' )
            return false;
        prev = start + i->length();
    }
    return true;

    /*

    string::size_type pre = name.find( "#" );
    string::size_type post = name.rfind( "#" );

    // # may only be used once in the wildcard, but substitutes for any
    // number of characters.
    if ( pre != string::npos && post == pre ) {
        if ( ename.length() < ( name.length() - post - 1 ) )
                return false;
        unsigned int epos = ename.length() - ( name.length() - post - 1 );
        return ( name.substr( 0, pre ) == ename.substr( 0, pre ) &&
            name.substr( post + 1 ) == ename.substr( epos ) );
    }

    // ? may be used any number of times in the wildcard, and
    // must substitute exactly for characters.
    if ( name.length() != ename.length() )
        return 0;
    for ( unsigned int i = 0; i < name.length(); i++ )
        if ( name[i] != '?' && name[i] != ename[i] )
            return false;
    return true;
    */
}

Here is the call graph for this function:

Here is the caller graph for this function:

int simpleWildcardFind	(	const string &	path,
		vector< ObjId > &	ret
	)

simpleWildcardFind returns the number of Ids found. This is the basic wildcardFind function, working on a single tree. It adds entries into the vector 'ret' with Ids found according to the path string. It preserves the order of the returned Ids as the order of elements traversed in the search. It does NOT eliminate duplicates. This is a depth-first search. Note that it does NOT list every entry in arrays, only the base Element.

Wildcard search rules are like this:

• Multiple wildcard paths can be specified, separated by commas
• Each wildcard path looks like a file path, separated by '/'
• At each level of the wildcard path, we have element specifiers.
• Each specifier can be a single fully specified element, or a wildcard.
• Substrings of the specifier can be wildcarded with '#'
  • The entire specifier can also be a '#'
• Characters of the specifier can be wildcarded with '?'
• An entire recursive tree can be specified using '##'
• As a qualifier to any of the wildcard specifiers we can use expressions enclosed in square brackets. These expressions are of the form: [TYPE==<string>] [TYPE=<string>] [CLASS=<string>] [ISA=<string>] [ISA==<string>] [TYPE!=<string>] [CLASS!=<string>] [ISA!=<string>] [FIELD(<fieldName)=<string>]

This is the basic wildcardFind function, working on a single tree. It adds entries into the vector 'ret' with Ids found according to the path string. It preserves the order of the returned Ids as the order of elements traversed in the search. It does NOT eliminate duplicates. This is a depth-first search. Note that it does the dumb but backward compatible thing with Ids of arrays: it lists every entry.

It returns the number of Ids found here.

Definition at line 137 of file Wildcard.cpp.

References Shell::chopString(), and innerFind().

Referenced by setMethod(), Dsolve::setPath(), testWildcard(), wildcardFind(), and wildcardTestFunc().

{
    if ( path.length() == 0 )
        return 0;
    unsigned int n = ret.size();
    vector< string > wildcards;
    Shell::chopString( path, wildcards, ',' );
    // separateString( path, wildcards, "," );
    vector< string >::iterator i;
    for ( i = wildcards.begin(); i != wildcards.end(); ++i )
        innerFind( *i, ret );

    return ret.size() - n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int wildcardFind	(	const string &	n,
		vector< ObjId > &	ret
	)

wildcardFind returns the number of Ids found. This behaves the same as simpleWildcardFind, except that it eliminates non-unique entries, and in the process will scramble the ordering.

Definition at line 169 of file Wildcard.cpp.

References myUnique(), and simpleWildcardFind().

Referenced by Neuron::buildElist(), doClassSpecificMessaging(), Shell::doStart(), ReadKkit::dumpPlots(), Neuron::getExprElist(), Neuron::getExprVal(), Shell::innerUseClock(), moose_wildcardFind(), Stoich::setPath(), Dsolve::setStoich(), NeuroMesh::setSubTreePath(), writeGroup(), and writeKkit().

{
    ret.resize( 0 );
    simpleWildcardFind( path, ret );
    myUnique( ret );
    return ret.size();
}

Here is the call graph for this function:

Here is the caller graph for this function: