parseFilter.cpp

Go to the documentation of this file.

#include "parser.hpp"

// Matches filename from showlist
bool Parser::findShow( string &p_showName, ConfigOpts *confOpt )
{
    // For each show in the showlist
    for( unsigned int i = 0; i < confOpt->v_showList.size(); i++ )
    {
        // Find the position of the first delimeter in the showlists search terms
        unsigned int pos = confOpt->v_showList[i][1].find( confOpt->getOptions( confOpt->ShowListDelimiter_opt )[1] );
        // Initialize the old position to 0
        int oPos = 0;
        // While the show name index hasn't been set, and the position is within the search term string
        while( pos < confOpt->v_showList[i][1].length() && showNameIndex == -1 )
        {
            // Set the new position to the last found delimeter
            int nPos = pos;
            // Save a term from between delimeters
            string cmpStr = confOpt->v_showList[i][1].substr( oPos, nPos-oPos );
            // Check if the term is found inside the files name
            if ( p_showName.find(cmpStr) < p_showName.length() )
            {
                // check if an override directory is availible
                if( confOpt->v_showList[i].size() == 3 )
                {
                    // Set the override directory flag to 1
                    overrideDir = 1;
                }
                // Set the ShowNameIndex to the showlist matched line
                showNameIndex = i;
                // Return with a match found
                return 1;
            }
            // Set the old position to the new position +1
            oPos = nPos+1;
            // Find the position of the next delimeter in the showlists search terms
            pos = confOpt->v_showList[i][1].find( confOpt->getOptions( confOpt->ShowListDelimiter_opt )[1], pos+1 );
        }
    }

    // Return with no match found
    return 0;
};

// Removes filler and extra white space
void Parser::cleanUp( string &fillStr, ConfigOpts *confOpt )
{
    // Initialize input text counter
    unsigned int i = 0;
    // Initialize filler character counter
    unsigned int k = 0;

    // Create a double space character array
    char sp[] = "  ";

    // Check each character of the passed input text
    for( ; i < fillStr.length(); i++ )
    {
        // Check each character against filler characters
        for( ; k < confOpt->getOptions( confOpt->Filler_opt ).length(); k++ )
        {
            // If the input chacter matches a filler character
            if ( fillStr[i] == confOpt->getOptions( confOpt->Filler_opt )[k] )
            {
                // Replace the input character with a single space
                fillStr[i] = sp[0];
            }
        }
        // Reset the filler counter
        k = 0;
    }

    // Find double whitespaces
    unsigned int found = fillStr.find( sp );
    // While whitespaces are found
    while( found < fillStr.length() )
    {
        // Erase the first whitespace charcter
        fillStr.erase( found, 1 );
        // find the next double whitespace
        found = fillStr.find( sp );
    }

    // Check if whitespace exists at the begining of the string
    if ( fillStr[0] == sp[0] )
    {
        // Remove the first character
        fillStr = fillStr.substr( 1 );
    }

    // Get the new length of the string
    int l = fillStr.length();

    // Check if whitespace exists at the end of the string
    if ( fillStr[l-1] == sp[0] )
    {
        // Remove the last character
        fillStr = fillStr.substr( 0, l-1 );
    }
};

// Removes release group tags
void Parser::removeTag( string &tagStr, ConfigOpts *confOpt )
{
    // For each tag in the blacklist
    for( unsigned int i = 0; i < confOpt->v_blackList.size(); i++ )
    {
        // Search the input text for the blacklisted tag
        unsigned int pos = tagStr.find( confOpt->v_blackList[i] );
        // Check if the tag exists within the input text
        if( pos < tagStr.length() )
        {
            // Remove the tag
            tagStr.erase( pos, confOpt->v_blackList[i].length() );
        }
    }
};

// Corrects capitalization
void Parser::titleCase( string &capStr, ConfigOpts *confOpt )
{
    // Create a an array for characters that can occur after a space but before a letter
    string sp = "\"'[({";

    // Capitalize the first character
    capStr[0] = toupper(capStr[0]);

    // For each chacter in the input text
    for ( unsigned int i=1; i < capStr.length(); i++ )
    {
        // Check for a space
        if ( capStr[i-1] == ' ' )
        {
            // Check if inbetween characters follow the space
            if ( capStr[i] == sp[0] || capStr[i] == sp[1] || capStr[i] == sp[2] || capStr[i] == sp[3] || capStr[i] == sp[4] )
            {
                // Capitalize the next character
                capStr[i+1] = toupper( capStr[i+1] );
            }
            // Capitalize the character
            capStr[i] = toupper( capStr[i] );
        }
        // Check for a hyphen
        if ( capStr[i] == '-' )
        {
            // Capitalize the next character
            capStr[i+1] = toupper( capStr[i+1] );
        }
    }

    // Find the first delimeter in the no capitalization word list
    unsigned int pos = confOpt->getOptions( confOpt->LowerCaseWords_opt ).find( confOpt->getOptions( confOpt->DelimiterWords_opt )[0] );
    // Set the old position to 0
    int oPos = 0;

    // While the delimeter is within the no capitalization list
    while( pos < confOpt->getOptions( confOpt->LowerCaseWords_opt ).length() )
    {
        // Set the new position to the last found position
        int nPos = pos;
        // Save the no capitalization word
        string cmpStr = confOpt->getOptions( confOpt->LowerCaseWords_opt ).substr( oPos, nPos-oPos );
        // Set the old position to the new position +1
        oPos = nPos+1;
        // Find the next delimeter in the no capitalization word list
        pos = confOpt->getOptions( confOpt->LowerCaseWords_opt ).find( confOpt->getOptions( confOpt->DelimiterWords_opt )[0], pos+1 );

        // Find the no capitalization word in the input text
        unsigned int textPos = capStr.find( cmpStr.c_str() );
        // While the no capitalization word exists within the input text
        while( textPos < capStr.length() )
        {
            // Replace the uppercase character with a lowercased one
            capStr[textPos+1] = tolower( cmpStr[1] );
            // Find the no capitalization word again in the input text
            textPos = capStr.find( cmpStr.c_str(), textPos+1 );
        }
    }
};

// Creates new filename
void Parser::newName( ConfigOpts *confOpt )
{
    // Create a temporary input/output string stream
    stringstream tempStr;

    // Save show name and space:
    show = confOpt->v_showList[showNameIndex][0] + " ";
    // Add an S for season info to the show name
    show += "S";
    // Check if the season number is less than 10
    if( season < 10 )
    {
        // Add a 0 to the season info for the show name
        show += "0";
    }
    // Copy the season integer to the temporary input/output string stream
    tempStr << season;
    // Add the season number to the show name
    show += tempStr.str();
    // Clear the temporary input/output string stream
    tempStr.str( "" );
    // Add an E for episode info to the show name
    show += "E";
    // Check if the episode number is less than 10
    if( episode < 10 )
    {
        // Add a 0 to the episode info for the show name
        show += "0";
    }
    // Copy the episode integer to the temporary input/output string stream
    tempStr << episode;
    // Add the episode number to the show name
    show += tempStr.str();
    // Clear the temporary input/output string stream
    tempStr.str( "" );
    // Check if extra episodes exist
    if( xepisode > 0 )
    {
        // Add a hyphon separator between episode info
        show += "-";
        // Check if the extra episode number is less than 10
        if( xepisode < 10 )
        {
            // Add a 0 to the extra episode info for the show name
            show += "0";
        }
        // Copy the extra episode integer to the temporary input/output string stream
        tempStr << xepisode;
        // Add the extra episode number to the show name
        show += tempStr.str();
        // Clear the temporary input/output string stream
        tempStr.str( "" );
    }
    // Check if partial episodes exist
    if( pepisode != "" )
    {
        show += toupper( pepisode[0] );
    }
    // Check if there is a title
    if( title.length() > 0 )
    {
        // Add the title and separator to the show name
        show += confOpt->getOptions( confOpt->TitleFormat_opt ) + title;
    }
    // Add a period and an extension to the show name
    show += "." + extension;
};

// Creates new directory
void Parser::newDir( ConfigOpts *confOpt )
{
    // Create a temporary input/output string stream
    stringstream tempStr;
    // Check if double digit flag is set
    if( confOpt->getFlags( confOpt->SeasonDigit_flag ) )
    {
        // Check if season is less than 10
        if( season < 10 )
        {
            // Add a zero to make the number double digit
            tempStr << 0;
        }
    }
    // Copy the season integer to the temporary input/output string stream
    tempStr << season;
    // Set the element to the show name element
    int i = 0;
    // Check if the over ride directory flag is set
    if( overrideDir )
    {
        // Set the element to the over ride directory element
        i = 2;
    }
    // Save the directory as the output directory / the show name or the over ride directory / season info
    dir = confOpt->getOptions( confOpt->OutputSourceArgument_opt ) + string(SLASH) + confOpt->v_showList[ showNameIndex ][ i ] + string(SLASH) + "Season " + tempStr.str() + string(SLASH);
};