libqalculate-ruby 0.0.1

data/ext/libqalculate/DataSet.h

@@ -0,0 +1,304 @@
+/*
+    Qalculate    
+
+    Copyright (C) 2004-2006  Niklas Knutsson (nq@altern.org)
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+*/
+
+#ifndef DATA_SET_H
+#define DATA_SET_H
+
+#include <libqalculate/includes.h>
+#include <libqalculate/Function.h>
+
+/** @file */
+
+typedef Sgi::vector<DataProperty*>::iterator DataObjectPropertyIter;
+
+/// A a data set object.
+/** Data objects consist of property-value pairs. */
+class DataObject {
+
+  protected:
+
+	vector<DataProperty*> properties;
+	vector<string> s_properties;
+	vector<string> s_nonlocalized_properties;
+	vector<MathStructure*> m_properties;
+	vector<int> a_properties;
+	DataSet *parent;
+	bool b_uchanged;
+	
+  public:
+ 
+	/** Create a data object.
+	*
+	* @param parent_set Data set that the object will belong to.
+	*/
+	DataObject(DataSet *parent_set);
+
+	/** Unset (erase value) a property.
+	*
+	* @param property Property to unset.
+	*/
+	void eraseProperty(DataProperty *property);
+	/** Set value for a property.
+	*
+	* @param property Property to set (must belong to parent data set).
+	* @param s_vale Value for the property.
+	* @param is_approximate If the value is approximate. 1 for approximate, 0 for exact, -1 for property default.
+	*/
+	void setProperty(DataProperty *property, string s_value, int is_approximate = -1);
+	/** Set an untranslated value for a key property. Used when a text value is translated, but the original value still is needed as a reference key.
+	*
+	* @param property Property to set (must belong to parent data set).
+	* @param s_vale Value for the property.
+	*/
+	void setNonlocalizedKeyProperty(DataProperty *property, string s_value);
+	
+	/** Returns parsed value for a property. Parses the text string value if not parsed before 
+	*
+	* @param property Property to read.
+	* @returns Parsed value or NULL if property value is not set.
+	*/
+	const MathStructure *getPropertyStruct(DataProperty *property);
+	/** Returns unparsed value for a property.
+	*
+	* @param property Property to read.
+	* @param[out] is_approximate If the value is approximate. Is set to 1 for approximate, 0 for exact, -1 for property default, if not NULL.
+	* @returns Unparsed value or empty string if property value is not set.
+	*/
+	const string &getProperty(DataProperty *property, int *is_approximate = NULL);
+	/** Returns unparsed untranslated value for a key property. Used when a text value is translated, but the original value still is needed as a reference key.
+	*
+	* @param property Property to read.
+	* @returns Unparsed untranslated value or empty string if property value is not set.
+	*/
+	const string &getNonlocalizedKeyProperty(DataProperty *property);
+	/** Returns value for a property in a format suitable for use in expressions with unit appended.
+	*
+	* @param property Property to read.
+	* @returns Value in input format or empty string if property value is not set.
+	*/
+	string getPropertyInputString(DataProperty *property);
+	/** Returns value for a property in a format suitable for display with unit appended.
+	*
+	* @param property Property to read.
+	* @returns Value in display format or empty string if property value is not set.
+	*/
+	string getPropertyDisplayString(DataProperty *property);
+
+	/** If the object has been modified by the end user (if setUserModified() has been called).
+	*
+	* @returns true if the object has been modified by the user.
+	*/
+	bool isUserModified() const;
+	/** Specify if the object has been modified by the end user.
+	*
+	* @param user_modified true if the object has been modified by the user.
+	*/
+	void setUserModified(bool user_modified = true);
+
+	/** Returns the data set that the object belongs to.
+	*
+	* @returns Parent data set.
+	*/
+	DataSet *parentSet() const;
+
+};
+
+typedef enum {
+	PROPERTY_EXPRESSION,
+	PROPERTY_NUMBER,
+	PROPERTY_STRING
+} PropertyType;
+
+/// A data set property.
+/** Property definitions for use with data set objects. */
+class DataProperty {
+
+  protected:
+
+	vector<string> names;
+	vector<bool> name_is_ref;
+	string sdescr, stitle, sunit;
+	MathStructure *m_unit;
+	bool b_approximate, b_brackets, b_key, b_case, b_hide;
+	DataSet *parent;
+	PropertyType ptype;
+	bool b_uchanged;
+	
+  public:
+
+	/** Create a data property.
+	*
+	* @param s_name Property name (initial) used for reference.
+	* @param s_title Descriptive name/title.
+	* @param s_description Description.
+	*/
+	DataProperty(DataSet *parent_set, string s_name = "", string s_title = "", string s_description = "");
+	DataProperty(const DataProperty &dp);
+	
+	void set(const DataProperty &dp);
+	void setName(string s_name, bool is_ref = false);
+	void setNameIsReference(size_t index = 1, bool is_ref = true);
+	bool nameIsReference(size_t index = 1) const;
+	void clearNames();
+	void addName(string s_name, bool is_ref = false, size_t index = 0);
+	size_t hasName(const string &s_name);
+	size_t countNames() const;
+	const string &getName(size_t index = 1) const;
+	const string &getReferenceName() const;
+	void setTitle(string s_title);
+	const string &title(bool return_name_if_no_title = true) const;
+	void setDescription(string s_description);
+	const string &description() const;
+	void setUnit(string s_unit);
+	const string &getUnitString() const;
+	const MathStructure *getUnitStruct();
+	string getInputString(const string &valuestr);
+	string getDisplayString(const string &valuestr);
+	MathStructure *generateStruct(const string &valuestr, int is_approximate = -1);
+	void setKey(bool is_key = true);
+	bool isKey() const;
+	void setHidden(bool is_hidden = true);
+	bool isHidden() const;
+	void setCaseSensitive(bool is_case_sensitive = true);
+	bool isCaseSensitive() const;
+	void setUsesBrackets(bool uses_brackets = true);
+	bool usesBrackets() const;
+	void setApproximate(bool is_approximate = true);
+	bool isApproximate() const;
+	void setPropertyType(PropertyType property_type);
+	PropertyType propertyType() const;
+	
+	bool isUserModified() const;
+	void setUserModified(bool user_modified = true);
+	
+	DataSet *parentSet() const;
+	
+};
+
+typedef vector<DataProperty*>::iterator DataPropertyIter;
+typedef vector<DataObject*>::iterator DataObjectIter;
+
+/// A data set.
+/** This is a simple database class for storage of many grouped values, when ordinary variables is not practical.
+*
+* A data set consists of properties and objects, with values for the properties. Qalculate! includes for example a "Planets" data set with properties such as name, mass, speed and density, and an object for each planet in solar system.
+*
+* A data set is also mathemtical function, dataset(object, property), which retrieves values for objects and properties.
+* Data sets can be saved and loaded from a XML file.
+*/
+class DataSet : public MathFunction {
+
+  protected:
+  
+	string sfile, scopyright;
+	bool b_loaded;
+	vector<DataProperty*> properties;
+	vector<DataObject*> objects;
+	
+  public:
+  
+  	DataSet(string s_category = "", string s_name = "", string s_default_file = "", string s_title = "", string s_description = "", bool is_local = true);
+	DataSet(const DataSet *o);
+	
+	ExpressionItem *copy() const;
+	void set(const ExpressionItem *item);
+	int subtype() const;
+	
+	void setCopyright(string s_copyright);
+	const string &copyright() const;
+	void setDefaultDataFile(string s_file);
+	const string &defaultDataFile() const;
+	
+	void setDefaultProperty(string property);
+	const string &defaultProperty() const;
+	
+	int calculate(MathStructure &mstruct, const MathStructure &vargs, const EvaluationOptions &eo);
+	
+	bool loadObjects(const char *file_name = NULL, bool is_user_defs = true);
+	int saveObjects(const char *file_name = NULL, bool save_global = false);
+	bool objectsLoaded() const;
+	void setObjectsLoaded(bool objects_loaded);
+	
+	void addProperty(DataProperty *dp);
+	void delProperty(DataProperty *dp);
+	void delProperty(DataPropertyIter *it);
+	DataProperty *getPrimaryKeyProperty();
+	DataProperty *getProperty(string property);
+	DataProperty *getFirstProperty(DataPropertyIter *it);
+	DataProperty *getNextProperty(DataPropertyIter *it);
+	const string &getFirstPropertyName(DataPropertyIter *it);
+	const string &getNextPropertyName(DataPropertyIter *it);
+	
+	void addObject(DataObject *o);
+	void delObject(DataObject *o);
+	void delObject(DataObjectIter *it);
+	DataObject *getObject(string object);
+	DataObject *getObject(const MathStructure &object);
+	DataObject *getFirstObject(DataObjectIter *it);
+	DataObject *getNextObject(DataObjectIter *it);
+	
+	const MathStructure *getObjectProperyStruct(string property, string object);
+	const string &getObjectProperty(string property, string object);
+	string getObjectPropertyInputString(string property, string object);
+	string getObjectPropertyDisplayString(string property, string object);
+	
+	string printProperties(string object);
+	string printProperties(DataObject *o);
+		
+};
+
+/// Data property function argument.
+class DataPropertyArgument : public Argument {
+
+  protected:
+  
+  	DataSet *o_data;
+  
+	virtual bool subtest(MathStructure &value, const EvaluationOptions &eo) const;  
+	virtual string subprintlong() const;
+
+  public:
+  
+  	DataPropertyArgument(DataSet *data_set, string name_ = "", bool does_test = true, bool does_error = true);
+	DataPropertyArgument(const DataPropertyArgument *arg);
+	~DataPropertyArgument();
+	int type() const;
+	Argument *copy() const;
+	string print() const;
+	DataSet *dataSet() const;
+	void setDataSet(DataSet *data_set);
+	
+};
+
+/// Data object function argument.
+class DataObjectArgument : public Argument {
+
+  protected:
+  
+  	DataSet *o_data;
+  
+	virtual bool subtest(MathStructure &value, const EvaluationOptions &eo) const;  
+	virtual string subprintlong() const;
+
+  public:
+  
+  	DataObjectArgument(DataSet *data_set, string name_ = "", bool does_test = true, bool does_error = true);
+	DataObjectArgument(const DataObjectArgument *arg);
+	~DataObjectArgument();
+	int type() const;
+	Argument *copy() const;
+	string print() const;
+	DataSet *dataSet() const;
+	void setDataSet(DataSet *data_set);
+	
+};
+
+#endif

data/ext/libqalculate/ExpressionItem.h

@@ -0,0 +1,289 @@
+/*
+    Qalculate    
+
+    Copyright (C) 2003-2007  Niklas Knutsson (nq@altern.org)
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+*/
+
+#ifndef EXPRESSIONITEM_H
+#define EXPRESSIONITEM_H
+
+#include <libqalculate/includes.h>
+
+/** @file */
+
+/// A name for an expression item (function, variable or unit)
+/** An expression name has a text std::string representing a name and boolean values describing the names properties.
+*/
+struct ExpressionName {
+	
+	/// If the name is an abbreviation.
+	bool abbreviation;
+	/// If the name has a suffix. If set to true, the part of the name after an underscore should be treated as a suffix.
+	bool suffix;
+	/// If the name contains unicode characters.
+	bool unicode;
+	/// If the name is in plural form.
+	bool plural;
+	/// If the name shall be used as a fixed reference. If this is set to true, the name will kept as it is in addition to translations of it.
+	bool reference;
+	/// If the name is unsuitable for user input.
+	bool avoid_input;
+	/// If the name is case sensitive. The default behavior is that abbreviations are case sensitive and other names are not.
+	bool case_sensitive;
+	/// The name.
+	std::string name;
+	
+	/** Create an empty expression name. All properties are set to false.
+	*/
+	ExpressionName();
+	/** Create an expression name. All properties are set to false, unless the name only has one character in which case abbreviation and case_sesnsitive is set to true.
+	*
+	* @param sname The name.
+	*/
+	ExpressionName(std::string sname);
+	
+	void operator = (const ExpressionName &ename);
+	bool operator == (const ExpressionName &ename) const;
+	bool operator != (const ExpressionName &ename) const;
+	
+};
+
+/// Abstract base class for functions, variables and units.
+/**
+* Expression items have one or more names used to reference it in mathematical expressions and display them in a result.
+* Each name must be fully unique, with the exception that functions can have names used by other types of items
+* (for example "min" is used as a name for the minute unit but also for a function returning smallest value in a vector).
+*
+* Items have an optional title and description for information to the end user.
+* The categoy property is used to organize items, so that the end user can easily find them.
+* Subcategories are separated by a slash, '/' (ex. "Physical Constants/Electromagnetic Constants").
+*
+* A local item is created/edited by the end user.
+*
+* A builtin item has defining properties that can/should not be edited by the user and is usually an item not loaded from the definition files.
+*
+* An inactive item can not be used in expressions and can share the name of an active item.
+*
+* The hidden propery defines if the item should be hidden from the end user.
+*
+* Before an item can be used in expressions, it must be added to the Calculator object using CALCULATOR->addExpressionItem().
+* It is then said to be registered.
+*
+* To delete an ExpressionItem object you should use destroy() to make sure that the item is removed from the Calculator and does not have any referrer.
+*
+*/
+class ExpressionItem {
+
+  protected:
+
+	std::string scat, stitle, sdescr;
+	bool b_local, b_changed, b_builtin, b_approx, b_active, b_registered, b_hidden, b_destroyed;
+	int i_ref, i_precision;
+	vector<ExpressionItem*> v_refs;
+	vector<ExpressionName> names;
+
+  public:
+
+	ExpressionItem(std::string cat_, std::string name_, std::string title_ = "", std::string descr_ = "", bool is_local = true, bool is_builtin = false, bool is_active = true);
+	ExpressionItem();
+	virtual ~ExpressionItem();
+	
+	virtual ExpressionItem *copy() const = 0;
+	virtual void set(const ExpressionItem *item);
+	
+	virtual bool destroy();
+
+	bool isRegistered() const;
+	/// For internal use.
+	void setRegistered(bool is_registered);
+
+	virtual const std::string &name(bool use_unicode = false, bool (*can_display_unicode_string_function) (const char*, void*) = NULL, void *can_display_unicode_string_arg = NULL) const;
+	virtual const std::string &referenceName() const;
+
+	/** Returns the name that best fulfils provided criterias. If two names are equally preferred, the one with lowest index is returned.
+	*
+	* @param abbreviation If an abbreviated name is preferred.
+	* @param use_unicode If a name with unicode characters can be displayed/is preferred (prioritized if false).
+	* @param plural If a name in plural form is preferred.
+	* @param reference If a reference name is preferred (ignored if false).
+	* @param can_display_unicode_string_function Function that tests if the unicode characters in a name can be displayed. If the function returns false, the name will be rejected.
+	* @param can_display_unicode_string_arg Argument to pass to the above test function.
+	* @returns The preferred name.
+	*/
+	virtual const ExpressionName &preferredName(bool abbreviation = false, bool use_unicode = false, bool plural = false, bool reference = false, bool (*can_display_unicode_string_function) (const char*, void*) = NULL, void *can_display_unicode_string_arg = NULL) const;
+	/** Returns the name that best fulfils provided criterias and is suitable for user input. If two names are equally preferred, the one with lowest index is returned.
+	*
+	* @param abbreviation If an abbreviated name is preferred.
+	* @param use_unicode If a name with unicode characters can be displayed/is preferred (prioritized if false).
+	* @param plural If a name in plural form is preferred.
+	* @param reference If a reference name is preferred (ignored if false).
+	* @param can_display_unicode_string_function Function that tests if the unicode characters in a name can be displayed. If the function returns false, the name will be rejected.
+	* @param can_display_unicode_string_arg Argument to pass to the above test function.
+	* @returns The preferred name.
+	*/
+	virtual const ExpressionName &preferredInputName(bool abbreviation = false, bool use_unicode = false, bool plural = false, bool reference = false, bool (*can_display_unicode_string_function) (const char*, void*) = NULL, void *can_display_unicode_string_arg = NULL) const;
+	/** Returns the name that best fulfils provided criterias and is suitable for display. If two names are equally preferred, the one with lowest index is returned.
+	*
+	* @param abbreviation If an abbreviated name is preferred.
+	* @param use_unicode If a name with unicode characters can be displayed/is preferred (prioritized if false).
+	* @param plural If a name in plural form is preferred.
+	* @param reference If a reference name is preferred (ignored if false).
+	* @param can_display_unicode_string_function Function that tests if the unicode characters in a name can be displayed. If the function returns false, the name will be rejected.
+	* @param can_display_unicode_string_arg Argument to pass to the above test function.
+	* @returns The preferred name.
+	*/
+	virtual const ExpressionName &preferredDisplayName(bool abbreviation = false, bool use_unicode = false, bool plural = false, bool reference = false, bool (*can_display_unicode_string_function) (const char*, void*) = NULL, void *can_display_unicode_string_arg = NULL) const;
+	/** Returns name for an index (starting at one). All functions can be traversed by starting at index one and increasing the index until empty_expression_name is returned.
+	*
+	* @param index Index of name.
+	* @returns Name for index or empty_expression_name if not found.
+	*/
+	virtual const ExpressionName &getName(size_t index) const;
+	/** Changes a name. If a name for the provided index is not present, it is added (equivalent to addName(ename, index, force)).
+	*
+	* @param ename The new name.
+	* @param index Index of name to change.
+	* @param force If true, expression items with conflicting names are replaced, otherwise . Only applies if the item is registered.
+	*/
+	virtual void setName(const ExpressionName &ename, size_t index = 1, bool force = true);
+	/** Changes the text string of a name. If a name for the provided index is not present, it is added (equivalent to addName(sname, index, force)).
+	*
+	* @param sname The new name text string.
+	* @param index Index of name to change.
+	* @param force If true, expression items with conflicting names are replaced, otherwise . Only applies if the item is registered.
+	*/
+	virtual void setName(std::string sname, size_t index, bool force = true);
+	virtual void addName(const ExpressionName &ename, size_t index = 0, bool force = true);
+	virtual void addName(std::string sname, size_t index = 0, bool force = true);
+	virtual size_t countNames() const;
+	/** Removes all names. */
+	virtual void clearNames();
+	/** Removes all names that are not used for reference (ExpressionName.reference = true). */
+	virtual void clearNonReferenceNames();
+	virtual void removeName(size_t index);
+	/** Checks if the expression item has a name with a specific text string.
+	*
+	* @param sname A text string to look for (not case sensitive)
+	* @param case_sensitive If the name is case sensitive.
+	* @returns Index of the name with the given text string or zero if such a name was not found.
+	*/
+	virtual size_t hasName(const std::string &sname, bool case_sensitive = true) const;
+	/** Checks if the expression item has a name with a specific case sensitive text string.
+	*
+	* @param sname A text string to look for (case sensitive)
+	* @returns Index of the name with the given text string or zero if such a name was not found.
+	*/
+	virtual size_t hasNameCaseSensitive(const std::string &sname) const;
+	/** Searches for a name with specific properties.
+	*
+	* @param abbreviation If the name must be abbreviated. 1=true, 0=false, -1=ignore.
+	* @param use_unicode If the name must have unicode characters. 1=true, 0=false, -1=ignore.
+	* @param plural If the name must be in plural form. 1=true, 0=false, -1=ignore.
+	* @param can_display_unicode_string_function Function that tests if the unicode characters in a name can be displayed. If the function returns false, the name will be rejected.
+	* @param can_display_unicode_string_arg Argument to pass to the above test function.
+	* @returns The first found name with the specified properties or empty_expression_name if none found.
+	*/
+	virtual const ExpressionName &findName(int abbreviation = -1, int use_unicode = -1, int plural = -1, bool (*can_display_unicode_string_function) (const char*, void*) = NULL, void *can_display_unicode_string_arg = NULL) const;
+
+	/** Returns the title, descriptive name, of the item.
+	*
+	* @param return_name_if_no_title If true, a name is returned if the title string is empty (using preferredName(false, use_unicode, false, false, can_display_unicode_string_function, can_display_unicode_string_arg)).
+	* @param use_unicode If a name with unicode characters can be displayed/is preferred (passed to preferredName()).
+	* @param can_display_unicode_string_function Function that tests if the unicode characters in a name can be displayed. If the function returns false, the name will be rejected (passed to preferredName()).
+	* @param can_display_unicode_string_arg Argument to pass to the above test function (passed to preferredName()).
+	* @returns Item title.
+	*/
+	virtual const std::string &title(bool return_name_if_no_title = true, bool use_unicode = false, bool (*can_display_unicode_string_function) (const char*, void*) = NULL, void *can_display_unicode_string_arg = NULL) const;
+
+	/** Sets the title, descriptive name, of the item. The title can not be used in expressions.
+	*
+	* @param title_ The new title.
+	*/
+	virtual void setTitle(std::string title_);
+
+	/** Returns the expression items description.
+	*
+	* @returns Description.
+	*/
+	virtual const std::string &description() const;
+	/** Sets the expression items description.
+	*
+	* @param descr_ Description.
+	*/
+	virtual void setDescription(std::string descr_);
+
+	/** Returns the category that the expression item belongs to. Subcategories are separated by '/'.
+	*
+	* @returns Category.
+	*/
+	virtual const std::string &category() const;
+	/** Sets which category the expression belongs to. Subcategories are separated by '/'.
+	*
+	* @param cat_ Category.
+	*/
+	virtual void setCategory(std::string cat_);
+
+	/** If the object has been changed since it was created/loaded. */
+	virtual bool hasChanged() const;
+	virtual void setChanged(bool has_changed);
+	
+	virtual bool isLocal() const;
+	virtual bool setLocal(bool is_local = true, int will_be_active = -1);
+	
+	virtual bool isBuiltin() const;
+
+	/** If the item is approximate or exact.
+	* Note that an actual value associated with the item might have a have a lower precision.
+	* For, for example, a mathematical function this defines the precision of the formula, not the result.
+	*
+	* @returns true if the item is approximate
+	*/
+	virtual bool isApproximate() const;
+	virtual void setApproximate(bool is_approx = true);
+
+	/** Returns precision of the item, if it is approximate.
+	* Note that an actual value associated with the item might have a have a lower precision.
+	* For, for example, a mathematical function this defines the precision of the formula, not the result.
+	*/
+	virtual int precision() const;
+	virtual void setPrecision(int prec);
+
+	/** Returns if the expression item is active and can be used in expressions.
+	*
+	* @returns true if active.
+	*/
+	virtual bool isActive() const;
+	virtual void setActive(bool is_active);
+	
+	virtual bool isHidden() const;
+	virtual void setHidden(bool is_hidden);
+
+	/** The reference count is not used to delete the expression item when it becomes zero, but to stop from being deleted while it is in use.
+	*/
+	virtual int refcount() const;
+	virtual void ref();
+	virtual void unref();
+	virtual void ref(ExpressionItem *o);
+	virtual void unref(ExpressionItem *o);
+	virtual ExpressionItem *getReferencer(size_t index = 1) const;
+	virtual bool changeReference(ExpressionItem *o_from, ExpressionItem *o_to);
+
+	/** Returns the type of the expression item, corresponding to which subclass the object belongs to.
+	*
+	* @returns ::ExpressionItemType.
+	*/
+	virtual int type() const = 0;
+	/** Returns the subtype of the expression item, corresponding to which subsubclass the object belongs to.
+	*
+	* @returns Subtype/subsubclass.
+	*/
+	virtual int subtype() const = 0;
+
+};
+
+#endif