/indra/llvfs/lldiriterator.cpp

/**
 * @file lldiriterator.cpp
 * @brief Iterator through directory entries matching the search pattern.
 *
 * $LicenseInfo:firstyear=2010&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include "lldiriterator.h"

#include <boost/filesystem.hpp>
#include <boost/regex.hpp>

namespace fs = boost::filesystem;

static std::string glob_to_regex(const std::string& glob);

class LLDirIterator::Impl
{
public:
	Impl(const std::string &dirname, const std::string &mask);
	~Impl();

	bool next(std::string &fname);

private:
	boost::regex			mFilterExp;
	fs::directory_iterator	mIter;
	bool					mIsValid;
};

LLDirIterator::Impl::Impl(const std::string &dirname, const std::string &mask)
	: mIsValid(false)
{
	fs::path dir_path(dirname);

	bool is_dir = false;

	// Check if path is a directory.
	try
	{
		is_dir = fs::is_directory(dir_path);
	}
	catch (fs::basic_filesystem_error<fs::path>& e)
	{
		llwarns << e.what() << llendl;
		return;
	}

	if (!is_dir)
	{
		llwarns << "Invalid path: \"" << dir_path.string() << "\"" << llendl;
		return;
	}

	// Initialize the directory iterator for the given path.
	try
	{
		mIter = fs::directory_iterator(dir_path);
	}
	catch (fs::basic_filesystem_error<fs::path>& e)
	{
		llwarns << e.what() << llendl;
		return;
	}

	// Convert the glob mask to a regular expression
	std::string exp = glob_to_regex(mask);

	// Initialize boost::regex with the expression converted from
	// the glob mask.
	// An exception is thrown if the expression is not valid.
	try
	{
		mFilterExp.assign(exp);
	}
	catch (boost::regex_error& e)
	{
		llwarns << "\"" << exp << "\" is not a valid regular expression: "
				<< e.what() << llendl;
		return;
	}

	mIsValid = true;
}

LLDirIterator::Impl::~Impl()
{
}

bool LLDirIterator::Impl::next(std::string &fname)
{
	fname = "";

	if (!mIsValid)
	{
		llwarns << "The iterator is not correctly initialized." << llendl;
		return false;
	}

	fs::directory_iterator end_itr; // default construction yields past-the-end
	bool found = false;
	while (mIter != end_itr && !found)
	{
		boost::smatch match;
		std::string name = mIter->path().filename();
		if (found = boost::regex_match(name, match, mFilterExp))
		{
			fname = name;
		}

		++mIter;
	}

	return found;
}

/**
Converts the incoming glob into a regex. This involves
converting incoming glob expressions to regex equivilents and
at the same time, escaping any regex meaningful characters which
do not have glob meaning, i.e.
            .()+|^$ 
in the input.
*/
std::string glob_to_regex(const std::string& glob)
{
	std::string regex;
	regex.reserve(glob.size()<<1);
	S32 braces = 0;
	bool escaped = false;
	bool square_brace_open = false;

	for (std::string::const_iterator i = glob.begin(); i != glob.end(); ++i)
	{
		char c = *i;

		switch (c)
		{
			case '*':
				if (glob.begin() == i)
				{
					regex+="[^.].*";
				}
				else
				{
					regex+= escaped ? "*" : ".*";
				}
				break;
			case '?':
				regex+= escaped ? '?' : '.';
				break;
			case '{':
				braces++;
				regex+='(';
				break;
			case '}':
				if (!braces)
				{
					llerrs << "glob_to_regex: Closing brace without an equivalent opening brace: " << glob << llendl;
				}

				regex+=')';
				braces--;
				break;
			case ',':
				regex+= braces ? '|' : c;
				break;
			case '!':
				regex+= square_brace_open ? '^' : c;
				break;
			case '.': // This collection have different regex meaning
			case '^': // and so need escaping.
			case '(': 
			case ')':
			case '+':
			case '|':
			case '$':
				regex += '\\'; 
			default:
				regex += c;
				break;
		}

		escaped = ('\\' == c);
		square_brace_open = ('[' == c);
	}

	if (braces)
	{
		llerrs << "glob_to_regex: Unterminated brace expression: " << glob << llendl;
	}

	return regex;
}

LLDirIterator::LLDirIterator(const std::string &dirname, const std::string &mask)
{
	mImpl = new Impl(dirname, mask);
}

LLDirIterator::~LLDirIterator()
{
	delete mImpl;
}

bool LLDirIterator::next(std::string &fname)
{
	return mImpl->next(fname);
}