1/*
2 * Copyright 2024, Haiku, Inc. All rights reserved.
3 * Distributed under the terms of the MIT License.
4 */
5
6#include <stdio.h>
7
8#define DEBUG_QUERY
9#define PRINT(expr) printf expr
10#define __out(message...) PRINT((message))
11#define QUERY_INFORM __out
12#define QUERY_FATAL(message...) { fprintf(stderr, message); abort(); }
13#define QUERY_D(block) block
14#include <file_systems/QueryParser.h>
15
16
17class Entry;
18
19
20class Query {
21public:
22	static	status_t		Create(void* volume, const char* queryString,
23								uint32 flags, port_id port, uint32 token,
24								Query*& _query);
25
26private:
27	struct QueryPolicy;
28	friend struct QueryPolicy;
29	typedef QueryParser::Query<QueryPolicy> QueryImpl;
30
31private:
32							Query();
33
34			status_t		_Init(const char* queryString, uint32 flags,
35								port_id port, uint32 token);
36
37private:
38			QueryImpl*		fImpl;
39};
40
41
42struct Query::QueryPolicy {
43	typedef Query Context;
44	typedef ::Entry Entry;
45	typedef ::Entry Node;
46	typedef void* NodeHolder;
47
48	struct Index {
49		Query*		query;
50
51		Index(Context* context)
52			:
53			query(context)
54		{
55		}
56	};
57
58	struct IndexIterator {
59		Entry* entry;
60	};
61
62	static const int32 kMaxFileNameLength = B_FILE_NAME_LENGTH;
63
64	// Entry interface
65
66	static ino_t EntryGetParentID(Entry* entry)
67	{
68		return -1;
69	}
70
71	static Node* EntryGetNode(Entry* entry)
72	{
73		return entry;
74	}
75
76	static ino_t EntryGetNodeID(Entry* entry)
77	{
78		return -1;
79	}
80
81	static ssize_t EntryGetName(Entry* entry, void* buffer, size_t bufferSize)
82	{
83		return B_ERROR;
84	}
85
86	static const char* EntryGetNameNoCopy(NodeHolder& holder, Entry* entry)
87	{
88		return NULL;
89	}
90
91	// Index interface
92
93	static status_t IndexSetTo(Index& index, const char* attribute)
94	{
95		return B_ERROR;
96	}
97
98	static void IndexUnset(Index& index)
99	{
100	}
101
102	static int32 IndexGetWeightedScore(Index& index, int32 score)
103	{
104		return 0;
105	}
106
107	static type_code IndexGetType(Index& index)
108	{
109		return 0;
110	}
111
112	static int32 IndexGetKeySize(Index& index)
113	{
114		return 0;
115	}
116
117	static IndexIterator* IndexCreateIterator(Index& index)
118	{
119		return NULL;
120	}
121
122	// IndexIterator interface
123
124	static void IndexIteratorDelete(IndexIterator* indexIterator)
125	{
126		delete indexIterator;
127	}
128
129	static status_t IndexIteratorFind(IndexIterator* indexIterator,
130		const void* value, size_t size)
131	{
132		return B_ERROR;
133	}
134
135	static status_t IndexIteratorFetchNextEntry(IndexIterator* indexIterator,
136		void* value, size_t* _valueLength, size_t bufferSize, size_t* duplicate)
137	{
138		return B_ERROR;
139	}
140
141	static status_t IndexIteratorGetEntry(Context* context, IndexIterator* indexIterator,
142		NodeHolder& holder, Entry** _entry)
143	{
144		*_entry = indexIterator->entry;
145		return B_OK;
146	}
147
148	static void IndexIteratorSkipDuplicates(IndexIterator* indexIterator)
149	{
150	}
151
152	static void IndexIteratorSuspend(IndexIterator* indexIterator)
153	{
154	}
155
156	static void IndexIteratorResume(IndexIterator* indexIterator)
157	{
158	}
159
160	// Node interface
161
162	static const off_t NodeGetSize(Node* node)
163	{
164		return 0;
165	}
166
167	static time_t NodeGetLastModifiedTime(Node* node)
168	{
169		return 0;
170	}
171
172	static status_t NodeGetAttribute(NodeHolder& nodeHolder, Node* node,
173		const char* attribute, void* buffer, size_t* _size, int32* _type)
174	{
175		return B_ERROR;
176	}
177
178	static Entry* NodeGetFirstReferrer(Node* node)
179	{
180		return node;
181	}
182
183	static Entry* NodeGetNextReferrer(Node* node, Entry* entry)
184	{
185		return NULL;
186	}
187
188	// Volume interface
189
190	static dev_t ContextGetVolumeID(Context* context)
191	{
192		return 0;
193	}
194};
195
196
197/*static*/ status_t
198Query::Create(void* volume, const char* queryString, uint32 flags,
199	port_id port, uint32 token, Query*& _query)
200{
201	Query* query = new(std::nothrow) Query();
202	if (query == NULL)
203		return B_NO_MEMORY;
204
205	status_t error = query->_Init(queryString, flags, port, token);
206	if (error != B_OK) {
207		delete query;
208		return error;
209	}
210
211	_query = query;
212	return B_OK;
213}
214
215
216Query::Query()
217	:
218	fImpl(NULL)
219{
220}
221
222
223status_t
224Query::_Init(const char* queryString, uint32 flags, port_id port, uint32 token)
225{
226	status_t error = QueryImpl::Create(this, queryString, flags, port, token,
227		fImpl);
228	if (error != B_OK)
229		return error;
230
231	return B_OK;
232}
233
234
235int
236main(int argc, char* argv[])
237{
238	for (int i = 1; i < argc; i++) {
239		Query* query;
240		status_t error = Query::Create(NULL, argv[i], 0, 0, 0, query);
241		if (error != B_OK) {
242			fprintf(stderr, "Error creating query %d: %s\n", i - 1, strerror(error));
243			continue;
244		}
245		delete query;
246	}
247
248	return 0;
249}
250