haiku.git

/*
 * Copyright 2024, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */

#include <stdio.h>

#define DEBUG_QUERY
#define PRINT(expr) printf expr
#define __out(message...) PRINT((message))
#define QUERY_INFORM __out
#define QUERY_FATAL(message...) { fprintf(stderr, message); abort(); }
#define QUERY_D(block) block
#include <file_systems/QueryParser.h>


class Entry;


class Query {
public:
	static	status_t		Create(void* volume, const char* queryString,
								uint32 flags, port_id port, uint32 token,
								Query*& _query);

private:
	struct QueryPolicy;
	friend struct QueryPolicy;
	typedef QueryParser::Query<QueryPolicy> QueryImpl;

private:
							Query();

			status_t		_Init(const char* queryString, uint32 flags,
								port_id port, uint32 token);

private:
			QueryImpl*		fImpl;
};


struct Query::QueryPolicy {
	typedef Query Context;
	typedef ::Entry Entry;
	typedef ::Entry Node;
	typedef void* NodeHolder;

	struct Index {
		Query*		query;

		Index(Context* context)
			:
			query(context)
		{
		}
	};

	struct IndexIterator {
		Entry* entry;
	};

	static const int32 kMaxFileNameLength = B_FILE_NAME_LENGTH;

	// Entry interface

	static ino_t EntryGetParentID(Entry* entry)
	{
		return -1;
	}

	static Node* EntryGetNode(Entry* entry)
	{
		return entry;
	}

	static ino_t EntryGetNodeID(Entry* entry)
	{
		return -1;
	}

	static ssize_t EntryGetName(Entry* entry, void* buffer, size_t bufferSize)
	{
		return B_ERROR;
	}

	static const char* EntryGetNameNoCopy(NodeHolder& holder, Entry* entry)
	{
		return NULL;
	}

	// Index interface

	static status_t IndexSetTo(Index& index, const char* attribute)
	{
		return B_ERROR;
	}

	static void IndexUnset(Index& index)
	{
	}

	static int32 IndexGetSize(Index& index)
	{
		return 0;
	}

	static type_code IndexGetType(Index& index)
	{
		return 0;
	}

	static int32 IndexGetKeySize(Index& index)
	{
		return 0;
	}

	static IndexIterator* IndexCreateIterator(Index& index)
	{
		return NULL;
	}

	// IndexIterator interface

	static void IndexIteratorDelete(IndexIterator* indexIterator)
	{
		delete indexIterator;
	}

	static status_t IndexIteratorFind(IndexIterator* indexIterator,
		const void* value, size_t size)
	{
		return B_ERROR;
	}

	static status_t IndexIteratorFetchNextEntry(IndexIterator* indexIterator,
		void* value, size_t* _valueLength, size_t bufferSize, size_t* duplicate)
	{
		return B_ERROR;
	}

	static status_t IndexIteratorGetEntry(Context* context, IndexIterator* indexIterator,
		NodeHolder& holder, Entry** _entry)
	{
		*_entry = indexIterator->entry;
		return B_OK;
	}

	static void IndexIteratorSkipDuplicates(IndexIterator* indexIterator)
	{
	}

	static void IndexIteratorSuspend(IndexIterator* indexIterator)
	{
	}

	static void IndexIteratorResume(IndexIterator* indexIterator)
	{
	}

	// Node interface

	static const off_t NodeGetSize(Node* node)
	{
		return 0;
	}

	static time_t NodeGetLastModifiedTime(Node* node)
	{
		return 0;
	}

	static status_t NodeGetAttribute(NodeHolder& nodeHolder, Node* node,
		const char* attribute, void* buffer, size_t* _size, int32* _type)
	{
		return B_ERROR;
	}

	static Entry* NodeGetFirstReferrer(Node* node)
	{
		return node;
	}

	static Entry* NodeGetNextReferrer(Node* node, Entry* entry)
	{
		return NULL;
	}

	// Volume interface

	static dev_t ContextGetVolumeID(Context* context)
	{
		return 0;
	}
};


/*static*/ status_t
Query::Create(void* volume, const char* queryString, uint32 flags,
	port_id port, uint32 token, Query*& _query)
{
	Query* query = new(std::nothrow) Query();
	if (query == NULL)
		return B_NO_MEMORY;

	status_t error = query->_Init(queryString, flags, port, token);
	if (error != B_OK) {
		delete query;
		return error;
	}

	_query = query;
	return B_OK;
}


Query::Query()
	:
	fImpl(NULL)
{
}


status_t
Query::_Init(const char* queryString, uint32 flags, port_id port, uint32 token)
{
	status_t error = QueryImpl::Create(this, queryString, flags, port, token,
		fImpl);
	if (error != B_OK)
		return error;

	return B_OK;
}


int
main(int argc, char* argv[])
{
	for (int i = 1; i < argc; i++) {
		Query* query;
		status_t error = Query::Create(NULL, argv[i], 0, 0, 0, query);
		if (error != B_OK) {
			fprintf(stderr, "Error creating query %d: %s\n", i - 1, strerror(error));
			continue;
		}
		delete query;
	}

	return 0;
}