haiku.git

//----------------------------------------------------------------------
//  This software is part of the Haiku distribution and is covered
//  by the MIT License.
//---------------------------------------------------------------------
/*!
	\file QueryPredicate.h
	BQuery predicate helper classes interface declaration.
*/
#ifndef _QUERY_PREDICATE_H
#define _QUERY_PREDICATE_H

#include <stdio.h>

#include <List.h>
#include <Query.h>
#include <String.h>

namespace BPrivate {
namespace Storage {

// QueryNode
class QueryNode {
public:
	QueryNode();
	virtual ~QueryNode();

	virtual uint32 Arity() const = 0;
	virtual status_t SetChildAt(QueryNode *child, int32 index) = 0;
	virtual QueryNode *ChildAt(int32 index) = 0;

	virtual status_t GetString(BString &predicate) = 0;
};

// LeafNode
class LeafNode : public QueryNode {
public:
	LeafNode();
	virtual ~LeafNode();

	virtual uint32 Arity() const;
	virtual status_t SetChildAt(QueryNode *child, int32 index);
	virtual QueryNode *ChildAt(int32 index);
};

// UnaryNode
class UnaryNode : public QueryNode {
public:
	UnaryNode();
	virtual ~UnaryNode();

	virtual uint32 Arity() const;
	virtual status_t SetChildAt(QueryNode *child, int32 index);
	virtual QueryNode *ChildAt(int32 index);

protected:
	QueryNode	*fChild;
};

// BinaryNode
class BinaryNode : public QueryNode {
public:
	BinaryNode();
	virtual ~BinaryNode();

	virtual uint32 Arity() const;
	virtual status_t SetChildAt(QueryNode *child, int32 index);
	virtual QueryNode *ChildAt(int32 index);

protected:
	QueryNode	*fChild1;
	QueryNode	*fChild2;
};

// AttributeNode
class AttributeNode : public LeafNode {
public:
	AttributeNode(const char *attribute);

	virtual status_t GetString(BString &predicate);

private:
	BString	fAttribute;
};

// StringNode
class StringNode : public LeafNode {
public:
	StringNode(const char *value, bool caseInsensitive = false);

	virtual status_t GetString(BString &predicate);

	inline const char *Value() const { return fValue.String(); }

private:
	BString	fValue;
};

// DateNode
class DateNode : public LeafNode {
public:
	DateNode(const char *value);

	virtual status_t GetString(BString &predicate);

private:
	BString	fValue;
};

// ValueNode
template<typename ValueType>
class ValueNode : public LeafNode {
public:
	ValueNode(const ValueType &value);

	virtual status_t GetString(BString &predicate);

private:
	ValueType	fValue;
};

// constructor
template<typename ValueType>
ValueNode<ValueType>::ValueNode(const ValueType &value)
					: LeafNode(),
					  fValue(value)
{
}

// GetString
template<typename ValueType>
status_t
ValueNode<ValueType>::GetString(BString &predicate)
{
	predicate.SetTo("");
	predicate << fValue;
	return B_OK;
}

// specializations for float and double
template<> status_t ValueNode<float>::GetString(BString &predicate);
template<> status_t ValueNode<double>::GetString(BString &predicate);


// short hands
typedef ValueNode<int32>	Int32ValueNode;
typedef ValueNode<uint32>	UInt32ValueNode;
typedef ValueNode<int64>	Int64ValueNode;
typedef ValueNode<uint64>	UInt64ValueNode;
typedef ValueNode<float>	FloatValueNode;
typedef ValueNode<double>	DoubleValueNode;


// SpecialOpNode
class SpecialOpNode : public LeafNode {
public:
	SpecialOpNode(query_op op);

	virtual status_t GetString(BString &predicate);

private:
	query_op	fOp;
};

// UnaryOpNode
class UnaryOpNode : public UnaryNode {
public:
	UnaryOpNode(query_op op);

	virtual status_t GetString(BString &predicate);

private:
	query_op	fOp;
};

// BinaryOpNode
class BinaryOpNode : public BinaryNode {
public:
	BinaryOpNode(query_op op);

	virtual status_t GetString(BString &predicate);

private:
	query_op	fOp;
};


// QueryStack
class QueryStack {
public:
	QueryStack();
	virtual ~QueryStack();

	status_t PushNode(QueryNode *node);
	QueryNode *PopNode();

	status_t ConvertToTree(QueryNode *&rootNode);

private:
	status_t _GetSubTree(QueryNode *&rootNode);

private:
	BList	fNodes;
};

};	// namespace Storage
};	// namespace BPrivate

#endif	// _QUERY_PREDICATE_H