haiku.git

/*
 * Copyright 2013, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include <PathFinder.h>

#include <AutoDeleter.h>
#include <FindDirectory.h>
#include <Path.h>
#include <StringList.h>


// NOTE: The package kit specific part of BPathFinder (BResolvableExpression
// constructor and SetTo()) is implemented in the package kit.


BPathFinder::BPathFinder(const void* codePointer, const char* dependency)
{
	_SetTo(codePointer, NULL, dependency);
}


BPathFinder::BPathFinder(const char* path, const char* dependency)
{
	_SetTo(NULL, path, dependency);
}


BPathFinder::BPathFinder(const entry_ref& ref, const char* dependency)
{
	SetTo(ref, dependency);
}


status_t
BPathFinder::SetTo(const void* codePointer, const char* dependency)
{
	return _SetTo(codePointer, NULL, dependency);
}


status_t
BPathFinder::SetTo(const char* path, const char* dependency)
{
	return _SetTo(NULL, path, dependency);
}


status_t
BPathFinder::SetTo(const entry_ref& ref, const char* dependency)
{
	BPath path;
	fInitStatus = path.SetTo(&ref);
	if (fInitStatus != B_OK)
		return fInitStatus;

	return _SetTo(NULL, path.Path(), dependency);
}


status_t
BPathFinder::FindPath(const char* architecture,
	path_base_directory baseDirectory, const char* subPath, uint32 flags,
	BPath& _path)
{
	_path.Unset();

	if (fInitStatus != B_OK)
		return fInitStatus;

	const char* dependency = fDependency.IsEmpty()
		? NULL : fDependency.String();

	char pathBuffer[B_PATH_NAME_LENGTH];
	status_t error;

	if (!fPath.IsEmpty()) {
		error = find_path_for_path_etc(fPath, dependency, architecture,
			baseDirectory, subPath, flags, pathBuffer, sizeof(pathBuffer));
	} else {
		error = find_path_etc(fCodePointer, dependency, architecture,
			baseDirectory, subPath, flags, pathBuffer, sizeof(pathBuffer));
	}

	if (error != B_OK)
		return error;

	return _path.SetTo(pathBuffer);
}


status_t
BPathFinder::FindPath(path_base_directory baseDirectory, const char* subPath,
	uint32 flags, BPath& _path)
{
	return FindPath(NULL, baseDirectory, subPath, flags, _path);
}


status_t
BPathFinder::FindPath(path_base_directory baseDirectory, const char* subPath,
	BPath& _path)
{
	return FindPath(NULL, baseDirectory, subPath, 0, _path);
}


status_t
BPathFinder::FindPath(path_base_directory baseDirectory, BPath& _path)
{
	return FindPath(NULL, baseDirectory, NULL, 0, _path);
}


/*static*/ status_t
BPathFinder::FindPaths(const char* architecture,
	path_base_directory baseDirectory, const char* subPath, uint32 flags,
	BStringList& _paths)
{
	_paths.MakeEmpty();

	// get the paths
	char** pathArray;
	size_t pathCount;
	status_t error = find_paths_etc(architecture, baseDirectory, subPath, flags,
		&pathArray, &pathCount);
	if (error != B_OK)
		return error;

	MemoryDeleter pathArrayDeleter(pathArray);

	// add them to BStringList
	for (size_t i = 0; i < pathCount; i++) {
		BString path(pathArray[i]);
		if (path.IsEmpty() || !_paths.Add(path)) {
			_paths.MakeEmpty();
			return B_NO_MEMORY;
		}
	}

	return B_OK;
}


/*static*/ status_t
BPathFinder::FindPaths(path_base_directory baseDirectory, const char* subPath,
	uint32 flags, BStringList& _paths)
{
	return FindPaths(NULL, baseDirectory, subPath, flags, _paths);
}


/*static*/ status_t
BPathFinder::FindPaths(path_base_directory baseDirectory, const char* subPath,
	BStringList& _paths)
{
	return FindPaths(NULL, baseDirectory, subPath, 0, _paths);
}


/*static*/ status_t
BPathFinder::FindPaths(path_base_directory baseDirectory, BStringList& _paths)
{
	return FindPaths(NULL, baseDirectory, NULL, 0, _paths);
}


status_t
BPathFinder::_SetTo(const void* codePointer, const char* path,
	const char* dependency)
{
	fCodePointer = codePointer;
	fPath = path;
	fDependency = dependency;

	if ((path != NULL && path[0] != '\0' && fPath.IsEmpty())
		|| (dependency != NULL && dependency[0] != '\0'
			&& fDependency.IsEmpty())) {
		fInitStatus = B_NO_MEMORY;
	} else
		fInitStatus = B_OK;

	return fInitStatus;
}