/*
 * Copyright 2013, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Ingo Weinhold <ingo_weinhold@gmx.de>
 */


#include <package/solver/SolverPackageSpecifierList.h>

#include <new>
#include <vector>

#include <package/solver/SolverPackageSpecifier.h>


namespace BPackageKit {

class BSolverPackageSpecifierList::Vector
	: public std::vector<BSolverPackageSpecifier> {
public:
	Vector()
		:
		std::vector<BSolverPackageSpecifier>()
	{
	}

	Vector(const std::vector<BSolverPackageSpecifier>& other)
		:
		std::vector<BSolverPackageSpecifier>(other)
	{
	}
};


BSolverPackageSpecifierList::BSolverPackageSpecifierList()
	:
	fSpecifiers(NULL)
{
}


BSolverPackageSpecifierList::BSolverPackageSpecifierList(
	const BSolverPackageSpecifierList& other)
	:
	fSpecifiers(NULL)
{
	*this = other;
}


BSolverPackageSpecifierList::~BSolverPackageSpecifierList()
{
	delete fSpecifiers;
}


bool
BSolverPackageSpecifierList::IsEmpty() const
{
	return fSpecifiers == NULL || fSpecifiers->empty();
}


int32
BSolverPackageSpecifierList::CountSpecifiers() const
{
	return fSpecifiers != NULL ? fSpecifiers->size() : 0;
}


const BSolverPackageSpecifier*
BSolverPackageSpecifierList::SpecifierAt(int32 index) const
{
	if (fSpecifiers == NULL || index < 0
		|| (size_t)index >= fSpecifiers->size()) {
		return NULL;
	}

	return &(*fSpecifiers)[index];
}


bool
BSolverPackageSpecifierList::AppendSpecifier(
	const BSolverPackageSpecifier& specifier)
{
	try {
		if (fSpecifiers == NULL) {
			fSpecifiers = new(std::nothrow) Vector;
			if (fSpecifiers == NULL)
				return false;
		}

		fSpecifiers->push_back(specifier);
		return true;
	} catch (std::bad_alloc&) {
		return false;
	}
}


bool
BSolverPackageSpecifierList::AppendSpecifier(BSolverPackage* package)
{
	return AppendSpecifier(BSolverPackageSpecifier(package));
}


bool
BSolverPackageSpecifierList::AppendSpecifier(const BString& selectString)
{
	return AppendSpecifier(BSolverPackageSpecifier(selectString));
}


bool
BSolverPackageSpecifierList::AppendSpecifiers(const char* const* selectStrings,
	int32 count)
{
	for (int32 i = 0; i < count; i++) {
		if (!AppendSpecifier(selectStrings[i])) {
			for (int32 k = i - 1; k >= 0; k--)
				fSpecifiers->pop_back();
			return false;
		}
	}

	return true;
}


void
BSolverPackageSpecifierList::MakeEmpty()
{
	fSpecifiers->clear();
}


BSolverPackageSpecifierList&
BSolverPackageSpecifierList::operator=(const BSolverPackageSpecifierList& other)
{
	if (this == &other)
		return *this;

	delete fSpecifiers;
	fSpecifiers = NULL;

	if (other.fSpecifiers == NULL)
		return *this;

	try {
		fSpecifiers = new(std::nothrow) Vector(*other.fSpecifiers);
	} catch (std::bad_alloc&) {
	}

	return *this;
}


}	// namespace BPackageKit