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


#include <set>

#include "PackageFile.h"


using namespace BPackageKit;


class Package {
public:
								Package(PackageFile* file);
								~Package();

			PackageFile*		File() const
									{ return fFile; }

			const node_ref&		NodeRef() const
									{ return fFile->NodeRef(); }
			const BString&		FileName() const
									{ return fFile->FileName(); }
			NotOwningEntryRef	EntryRef() const
									{ return fFile->EntryRef(); }

			const BPackageInfo & Info() const
									{ return fFile->Info(); }

			BString				RevisionedName() const
									{ return fFile->RevisionedName(); }
			BString				RevisionedNameThrows() const
									{ return fFile->RevisionedNameThrows(); }

			bool				IsActive() const
									{ return fActive; }
			void				SetActive(bool active)
									{ fActive = active; }

			Package*			Clone() const;

			Package*&			FileNameHashTableNext()
									{ return fFileNameHashTableNext; }
			Package*&			NodeRefHashTableNext()
									{ return fNodeRefHashTableNext; }

private:
			PackageFile*		fFile;
			bool				fActive;
			Package*			fFileNameHashTableNext;
			Package*			fNodeRefHashTableNext;
};


struct PackageFileNameHashDefinition {
	typedef const char*		KeyType;
	typedef	Package			ValueType;

	size_t HashKey(const char* key) const
	{
		return BString::HashValue(key);
	}

	size_t Hash(const Package* value) const
	{
		return HashKey(value->FileName());
	}

	bool Compare(const char* key, const Package* value) const
	{
		return value->FileName() == key;
	}

	Package*& GetLink(Package* value) const
	{
		return value->FileNameHashTableNext();
	}
};


struct PackageNodeRefHashDefinition {
	typedef node_ref		KeyType;
	typedef	Package			ValueType;

	size_t HashKey(const node_ref& key) const
	{
		return (size_t)key.device + 17 * (size_t)key.node;
	}

	size_t Hash(const Package* value) const
	{
		return HashKey(value->NodeRef());
	}

	bool Compare(const node_ref& key, const Package* value) const
	{
		return key == value->NodeRef();
	}

	Package*& GetLink(Package* value) const
	{
		return value->NodeRefHashTableNext();
	}
};


typedef BOpenHashTable<PackageFileNameHashDefinition> PackageFileNameHashTable;
typedef BOpenHashTable<PackageNodeRefHashDefinition> PackageNodeRefHashTable;
typedef std::set<Package*> PackageSet;


#endif	// PACKAGE_H