xref: /haiku/headers/private/debugger/model/ExpressionInfo.h (revision fce4895d1884da5ae6fb299d23c735c598e690b1)

/*
 * Copyright 2014, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */
#ifndef EXPRESSION_INFO_H
#define EXPRESSION_INFO_H


#include <String.h>

#include <Referenceable.h>
#include <util/DoublyLinkedList.h>
#include <Variant.h>


class Type;
class Value;
class ValueNodeChild;


enum expression_result_kind {
	EXPRESSION_RESULT_KIND_UNKNOWN = 0,
	EXPRESSION_RESULT_KIND_PRIMITIVE,
	EXPRESSION_RESULT_KIND_VALUE_NODE,
	EXPRESSION_RESULT_KIND_TYPE
};


class ExpressionResult : public BReferenceable {
public:
								ExpressionResult();
	virtual						~ExpressionResult();


			expression_result_kind Kind() const { return fResultKind; }

			Value*				PrimitiveValue() const
									{ return fPrimitiveValue; }
			ValueNodeChild*		ValueNodeValue() const
									{ return fValueNodeValue; }
			Type*				GetType() const
									{ return fTypeResult; }

			void				SetToPrimitive(Value* value);
			void				SetToValueNode(ValueNodeChild* child);
			void				SetToType(Type* type);
private:
			void				_Unset();

private:
			expression_result_kind fResultKind;
			Value*				fPrimitiveValue;
			ValueNodeChild*		fValueNodeValue;
			Type*				fTypeResult;
};


class ExpressionInfo : public BReferenceable {
public:
	class Listener;

public:
								ExpressionInfo();
								ExpressionInfo(const ExpressionInfo& other);
								ExpressionInfo(const BString& expression);
	virtual						~ExpressionInfo();

			void				SetTo(const BString& expression);

			const BString&		Expression() const		{ return fExpression; }

			void				AddListener(Listener* listener);
			void				RemoveListener(Listener* listener);

			void				NotifyExpressionEvaluated(status_t result,
									ExpressionResult* value);

private:
			typedef 			DoublyLinkedList<Listener> ListenerList;

private:
			BString				fExpression;
			ListenerList		fListeners;
};


class ExpressionInfo::Listener : public DoublyLinkedListLinkImpl<Listener> {
public:
	virtual						~Listener();

	virtual	void				ExpressionEvaluated(ExpressionInfo* info,
									status_t result,
									ExpressionResult* value) = 0;
};


#endif	// EXPRESSION_INFO_H