path: root/src/core/info.h

/*
   core/info.h
   This file is part of the Osirion project and is distributed under
   the terms of the GNU General Public License version 2
*/

#ifndef __INCLUDED_CORE_INFO_H__
#define __INCLUDED_CORE_INFO_H__

#include <iostream>
#include <string>
#include <vector>
#include <deque>

#include "core/label.h"
#include "model/model.h"

namespace core
{

/**
 * @brief an object class information record
 * Describes a class of object
 */
class InfoType : public Label
{
public:
	/**
	 * @brief create a server side object class information record
	 */
	InfoType(const char* label);

	/**
	 * @brief create a client side object class information record
	 */
	 InfoType(const unsigned int id);

	 virtual ~InfoType();

	/* ---- inspectors ------------------------------------------------- */

	inline const unsigned int id() const {
		return infotype_id;
	}

private:
	
	unsigned int			infotype_id;


	/* ---- static infoclass registry ---------------------------------- */

public:
	/// clear infotype registry
	static void clear();

	/// search the infotype registry for a label
	static InfoType *find(const std::string & label);

	/// search the infotype registry for an id
	static InfoType *find(const unsigned int id);


private:
	/// info registry type definition
	typedef std::vector<InfoType*> 	Registry;

	static Registry			infotype_registry;
	static unsigned int		infotype_id_counter;
	
}; // class InfoType

/**
 * @brief an information record
 * An information record holds extended information about a specific entity or item class.
 * This information isexchanged between server and the client, and can be used to build 
 * HUD widgets/
 */
class Info : public Label
{
public:
	/// type definition for the text description
	typedef std::deque<std::string> Text;
	
	/**
	 * @brief create a new server-side information record
	 * This is a server-side constructor and assigns an id
	 */
	Info();
	
	/**
	 * @brief create a new client-side information record
	 * This is a client-side constructor
	 */
	Info(const unsigned int id);

	/// delete the information record
	virtual ~Info();

	/* ---- inspectors ------------------------------------------------- */

	inline const unsigned int id() const {
		return info_id;
	}

	inline const InfoType* type() const {
		return info_type;
	}
	
	inline const std::string & modelname() const {
		return info_modelname;
	}
	
	inline const model::Model *model() const {
		return info_model;
	}

	inline const long price() const {
		return info_price;
	}

	inline const unsigned long &timestamp() const {
		return info_timestamp;
	}

	/// text description
	inline Text & text() {
		return info_text;
	}

	/* ---- mutators --------------------------------------------------- */
	
	void set_modelname(const std::string & modelname);

	void set_modelname(const char *modelname);
	
	void set_model(const model::Model *model);

	void set_price(const long price);

	/// set the timestamp
	void set_timestamp(const unsigned long timestamp);

	/// add a line of info text
	void add_text(const std::string & text);

	/// add a line of info text
	void add_text(const char *text);

	/// clear the info text
	void clear_text();

	/// print info to the system console
	virtual void print() const;
	
	/// clear the timestamp
	void clear_timestamp();

protected:
	
	/// set the info class id
	void set_type(const InfoType *type);
	
public:
	/* ---- serializers ------------------------------------------------ */
	
	/// serialize a server-to-client update on a stream
	void serialize_server_update(std::ostream & os) const;

	/// receive a server-to-client update from a stream
	void receive_server_update(std::istream &is);

private:
	const InfoType*		info_type;
	
	unsigned int		info_id;
	long			info_price;
	unsigned long		info_timestamp;
	std::string		info_modelname;

	const model::Model*	info_model;

	Text			info_text;

	/* ---- static info registry --------------------------------------- */
	
public:
	/// info registry type definition
	typedef std::vector<Info*> Registry;

	/// the info registry
	static inline Registry & registry() {
		return info_registry;
	}

	/// search the info registry for a labeled item
	static Info *find(const char * label);

	/// search the info registry for a label
	static Info *find(const std::string & label);
	
	/// search the info registry for an id
	static Info *find(const unsigned int id);

	/// search the info registry for a record with a matching label or name
	static Info *search(const std::string & searchstr);

	/// search the info registry for a labeled item, belonging to a specific class
	static Info *find(const InfoType *type, const char * label);

	/// search the info registry for a label, belonging to a specific class
	static Info *find(const InfoType *type, const std::string & label);

	/// search the info registry for an id, belonging to a specific class
	static Info *find(const InfoType *type, const unsigned int id);

	/// search the info registry for a record with a matching label or name and belonging to a specific class
	static Info *search(const InfoType *type, const std::string & searchstr);

	/// clear the info registry
	static void clear();

	/// list the info registry
	static void list();

	/// list a single class in the info registry
	static void list_class(const InfoType *type);

private:
	static Registry				info_registry;
	static unsigned int			info_id_counter;
};

}
#endif // __INCLUDED_CORE_INFO_H__