i6e::api Namespace Reference

Namespaces
	audio
	components
	detail
	graphics
	gui
	input
	keyboard
	messages
	mouse
	network
	objects
	physics
	ResponseType
	scripting

Classes
class	AnimatedDirectionalLightComponent
	Tells the engine that this GameObject is emitting light. For creating a AnimatedDirectionalLightComponent, these keys are possible: Name Required Type Description Public directionDuration no int duration of one direction interpolation cycle yes directionKey_<timePoint> no Vec3 direction at timePoint encoded in name (timePoint between 0 and 1) yes More...
class	AnimatedLuminousAppearanceComponent
	interpolates light colours and attenuation (e.g. range) For creating a AnimatedLuminousAppearanceComponent, these keys are possible: Name Required Type Description Public diffuseDuration no int duration of one diffuse interpolation cycle yes diffuseKey_<timePoint> no Vec3 diffuse colour at timePoint encoded in name (timePoint between 0 and 1) yes specularDuration no int duration of one specular interpolation cycle yes specularKey_<timePoint> no Vec3 specular colour at timePoint encoded in name (timePoint between 0 and 1) yes attenuationDuration no int duration of one attenuation interpolation cycle yes attenuationKey_<timePoint> no Vec4 attenuation at timePoint encoded in name (timePoint between 0 and 1) yes More...
class	AnimatedSpotLightComponent
	Tells the engine that this GameObject is emitting light. For creating a AnimatedSpotLightComponent, these keys are possible: Name Required Type Description Public directionDuration no int duration of one direction interpolation cycle yes directionKey_<timePoint> no Vec3 direction at timePoint encoded in name (timePoint between 0 and 1) yes innerRangeDuration no int duration of one inner range interpolation cycle yes innerRangeKey_<timePoint> no double inner range at timePoint encoded in name (timePoint between 0 and 1) yes outerRangeDuration no int duration of one outer range interpolation cycle yes outerRangeKey_<timePoint> no double outer range at timePoint encoded in name (timePoint between 0 and 1) yes More...
class	AnimationControllerComponent
	Stores different animation events for animations and registers them again when starting an animation. More...
class	Application
	Interface for the game developer. More...
class	AudioFacade
class	BillboardComponent
	Tells the engine what billboard to show For creating a BillboardComponent, these keys are possible: Name Required Type Description Public material yes std::string Material used for the Billboard yes width yes double relative width yes height yes double relative height yes origin yes int one of BillboardOrigin's int values yes More...
class	CameraComponent
	Attaches a camera to an object. The Camera will follow the object For creating a CameraComponent, these keys are possible: Name Required Type Description Public pos yes Vec3 relative position of camera to SceneNode yes lookAt yes Vec3 absolute look at position in the world yes nearclip yes double near clipping distance yes aspect no double aspect ration of the camera yes viewport no bool defines whether this camera has a viewport or not yes zOrder *) int relative position on the screen depending on other viewports (has to be unique), *) required when viewport true yes vp_left *) double left startpoint of the viewport, value between 0 and 1, *) required when viewport true yes vp_top *) double uppper startpoint of the viewport, value between 0 and 1, *) required when viewport true yes vp_width *) double width of the viewport, value between 0 and 1, *) required when viewport true yes vp_height *) double height of the viewport, value between 0 and 1, *) required when viewport true yes vp_red *) double red part of the viewports background colour, *) required when viewport true yes vp_green *) double green part of the viewports background colour, *) required when viewport true yes vp_blue *) double blue part of the viewports background colour, *) required when viewport true yes vp_alpha *) double alpha part of the viewports background colour, *) required when viewport true yes More...
struct	CollisionGroup
	struct containing the collision info for an object More...
class	Component
	Component Base Class. All Components must derive from Component. More...
class	EngineController
	This class is used as the Controller for the whole engine Create an instance of this class and use the functions to start / stop / ... the Engine. More...
class	FollowComponent
	Component for objects following another one (e.g. projectiles) For creating a FollowComponent, these keys are possible: Name Required Type Description Public targetID yes int64_t id of the GameObject that should be followed yes speed yes double speed in meters / second yes More...
class	GameObject
	Class representing a GameObject in the i6engine. More...
class	GraphicsFacade
class	GUIFacade
	This class manages the GUIWindows and provides some general API methods that aren't related to a special window. More...
class	GUIWidget
	Superclass for all GUI widgets. More...
class	IDManager
	handles IDs for GameObjects More...
class	InputFacade
class	LanguageManager
	handles the current language of the Game a change of the language notifies all registered callbacks More...
class	LifetimeComponent
	destroys the owning game object after given lifetime For creating a LifetimeComponent, these keys are possible: Name Required Type Description Public lifetime yes uint64_t time until this GameObject will be destroyed yes More...
class	LineComponent
	creates a line in a given colour For creating a LineComponent, these keys are possible: Name Required Type Description Public startPos yes Vec3 start position of the line yes endPos yes Vec3 end position of the line yes colour yes Vec3 colour of the line yes More...
class	LuminousAppearanceComponent
	Tells the engine that this GameObject is emitting light. For creating a LuminousAppearanceComponent, these keys are possible: Name Required Type Description Public lightType yes int one of the LightTypes yes diffuseColor yes Vec3 diffuse colour of the light yes specularColor yes Vec3 specular colour of the light yes attenuation yes Vec4 attenuation of the light, W = range (range in world units), X = constant (1.0 never attenuate, 0.0 complete attenuation), Y = linear (linear attenuation depending on distance), Z = quadratic factor yes pos no Vec3 relative position to SceneNode yes direction *) Vec3 direction of the light shaft, *) required if lightType is DIRECTIONAL or SPOT yes spotLightRangeInner *) double range of the inner cone of a spot light in degree, *) required if lightType is SPOT yes spotLightRangeOuter *) double range of the outer cone of a spot light in degree, *) required if lightType is SPOT yes More...
class	MeshAppearanceComponent
	Tells the engine what model/mesh to use when rendering the GameObject. For creating a MeshAppearanceComponent, these keys are possible: Name Required Type Description Public mesh yes std::string mesh file yes visibility no bool is this mesh visible or not, default is true yes pos yes Vec3 relative position to SceneNode yes rot yes Vec3 relative rotation to SceneNode yes scale yes Vec3 relative scale to SceneNode yes material no std::string optional change of the material on the mesh yes shadowCasting no bool defines whether a mesh casts shadows or not, default is true yes More...
class	MessagingFacade
class	MovableTextComponent
	shows a text above a mesh For creating a MovableTextComponent, these keys are possible: Name Required Type Description Public font yes std::string font used for this Text yes text yes std::string the text shown above the GameObject yes size yes double font size yes colour yes Vec3 colour of the text yes More...
class	MoveComponent
	Component used for moving through the world requires both, a MovementComponent and a NavigationComponent to know how to move and get the route. More...
class	MovementComponent
	base class for Movement components More...
class	MoverCircleComponent
	moves an object around a point in a circular way For creating a MoverCircleComponent, these keys are possible: Name Required Type Description Public pos yes Vec3 center of the circle yes axis yes Vec3 axis around which the mover should circle yes radius yes double radius of the circle yes realCenterPos no Vec3 the real start pos of the circle no More...
class	MoverComponent
	This component let's the Object move through the world automatically on fixed paths Use addKeyFrame() to add new keyframes (specific positions in the world) Than call start to start the moving. This component will move the object during each tick. You can control the behaviour by defining a mode, a way and the way of positioning. Consult the enum definitions for a detailed description This Component will soon be split into several subclasses for different Ways. For creating a MoverComponent, these keys are possible: Name Required Type Description Public duration yes uint64_t Duration of one movement cycle yes positioning yes short Absolute or relative positioning yes continue no "true" continues movement instead of starting no startTime *) uint64_t *) required when continue set to synchronize time no lastPos no Vec3 the last position of the circle no linkable no bool should colliding objects (with correct flags) be linked to this mover and moved with it yes started yes bool should this mover start directly yes More...
class	MoverInterpolateComponent
	moving an object interpolating in some way For creating a MoverInterpolateComponent, these keys are possible: Name Required Type Description Public way yes short How are the frames interpolated, one of enum entries of Way yes mode yes short In which order the frames will be processed yes direction yes bool Direction of this mover, true is forward, false is backward yes openTime *) uint64_t time mover stays at end position before moving backwards, *) required when mode is TWOSTATE_OPENTIME yes keyframes yes int number of keyframes to follow yes keyframe__pos *) vector position of i-th keyframe, *) required for all keyframes yes keyframe__rot *) quaternion rotation of i-th keyframe, *) required for all keyframes yes More...
class	MovingCameraComponent
	Attaches a moving camera to an object. This camera will follow the object in a more sophisticated way. More...
class	NavigationComponent
	Used for navigation between points. More...
class	NetworkFacade
class	NetworkSenderComponent
	defines that this gameobject shall be synchronised over network More...
class	ObjectFacade
class	ParticleEmitterComponent
	Emits Particles For creating a ParticleEmitterComponent, these keys are possible: Name Required Type Description Public particleEmitter yes std::string The emitter for the particle yes pos no Vec3 relative position to SceneNode yes fadeOut no bool if set to true, the particle isn't removed immediately but emitters are stopped and so the particle fades out yes fadeOutCooldown *) uint64_t time after stopping emitters until particle will be destroyed, *) required if fadeOut is set yes More...
class	PhysicalStateComponent
	Represents an object's physical state and synchronizes with the Physics subsystem. For creating a PhysicalStateComponent, these keys are possible: Name Required Type Description Public syncPrio no int priority from which upwards updates should be sent through network yes gravity no Vec3 gravity for this object. Replaces default yes pos yes Vec3 position of the SceneNode yes rot yes Quaternion rotation of the SceneNode yes scale yes Vec3 scale of the SceneNode yes collisionGroup yes int int int ResponseType CrashType CrashMask yes shapeType yes int one of the shapeTypes from ShapeType enum yes shatterInterest yes int one of the shatterInterests from ShatterInterest enum yes compound yes bool should this PSC be used as a compound shape together with other ones of this GameObject yes More...
class	PhysicsFacade
	Physics specific functions for the game which targets the whole world - not a single object. More...
class	Point2PointConstraintComponent
	Connects two PhysicalStateComponents in a point RELATIVE to their origin For creating a Point2PointConstraintComponent, these keys are possible: Name Required Type Description Public selfIdentifier yes std::string identifier for this constraint component, must be unique over the complete game yes targetIdentifier yes std::string identifier of the constraint this component is connected to yes selfOffset yes Vec3 offset on which this constraint is connected relative to origin yes targetOffset yes Vec3 offset on which target constraint is connected relative to its origin yes breakingImpulse no double impulse that is necessary to break connection, not breakable if not set yes More...
struct	RayTestResult
	struct containing information from raytest objID: id of GO hit first by the ray sourceID: id of the soure GO collisionPoint: hit point More...
class	ScriptingFacade
class	ShatterComponent
	This class is needed on every GameObject with: TRIGGER The shatter() method is called for detected collisions. More...
class	SoundComponent
	Attaches a sound node to an object. The Sound will follow the object For creating a SoundComponent, these keys are possible: Name Required Type Description Public offset yes Vec3 offset to the position of the PhysicalStateComponent this Component is connected to yes direction yes Vec3 direction of the sound yes file yes std::string sound file for this sound, currently only wav is supported yes looping yes bool is this sound looping or only played once yes maxDist yes double maxmimum distance this sound should be hearable, volume is interpolated yes cache yes bool if set to true, this sound is cached in memory and mustn't be loaded from harddisk every time it is played yes category no std::string specifies the category this sound belongs to, e.g. music, effect, dialog, default value is empty string yes More...
class	SoundListenerComponent
	Attaches a sound listener to an object. The Listener will follow the object. More...
class	SpawnpointComponent
	Only defines this object as a spawnpoint For creating a SpawnpointComponent, these keys are possible: Name Required Type Description Public spawntypes yes std::string GameObject types being spawnable at this Spawnpoint, separated by delimitter ; yes More...
class	StaticStateComponent
	Makes it possible to place a static GameObject For creating a StaticStateComponent, these keys are possible: Name Required Type Description Public pos yes Vec3 position of the SceneNode yes rot yes Quaternion rotation of the SceneNode yes scale yes Vec3 scale of the SceneNode yes More...
class	TerrainAppearanceComponent
	Tells the engine what heightmap and texture to use when rendering the GameObject. For creating a TerrainAppearanceComponent, these keys are possible: Name Required Type Description Public heightmap yes std::string heightmap used for this terrain, either this or heightdata required, if both are provided, heightdata is used yes heightdata yes std::vector<std::vector<double>> heightdata used for this terrain, either this or heightmap required, if both are provided, heightdata is used yes size yes double expansion of the terrain yes inputScale yes double scale factor for the terrain heights, highest point of heightmap gets this height yes vertices yes uint32_t vertices along an edge, must be 2^n + 1 yes layers yes uint32_t amount of layers on the terrain yes minX yes int64_t minimum X for duplicates of the terrain yes maxX yes int64_t maximum X for duplicates of the terrain yes minY yes int64_t maximum Y for duplicates of the terrain yes maxY yes int64_t maximum Y for duplicates of the terrain yes layer__size yes double size of the texture units for every layer yes layer__diffusespecular yes std::string diffuse and specular map for every layer yes layer__normal yes std::string normal and displacement map for every layer yes layer__minHeight yes double minimum height where this layer shall appear, for every layer except the first yes layer__fadeDist yes double defines how fast the layers are blend over, for every layer except the first yes More...
class	TextManager
	handles Texts for the Game More...
class	ToggleWaynetComponent
	Component used to show the waynet. More...
class	VelocityComponent
	Component for objects with more complex velocity handling than just setting an impulse, e.g. a car For creating a VelocityComponent, these keys are possible: Name Required Type Description Public acceleration yes double acceleration of this GameObject, in m / s² yes deceleration no double breaking acceleration of this GameObject, in m / s² yes maxSpeed yes double maximum speed this GameObject can reach, in m / s yes resistanceCoefficient no double resistance coefficient, default: 0.6 yes windage no double windage of this GameObject, default: 0.8 m² yes handling no int handling for reaching maximum speed, keep maximum speed or stop acceleration to roll out, default: 0 (= KeepSpeed) yes More...
class	WaynetManager
	handles the current Waynet More...
class	WaynetNavigationComponent
	Use for navigation by waypoints. More...
class	WaypointComponent
	Represents a Waypoint in the world, containing an identifier and a list of connections For creating a WaypointComponent, these keys are possible: Name Required Type Description Public name yes std::string name of this waypoint yes connections yes std::string names of the waypoints this one is connected to, seperated by delimitter ; yes More...

Typedefs
typedef utils::sharedPtr< Component, Component >	ComPtr
typedef utils::sharedPtr< GameObject, GameObject >	GOPtr
typedef utils::weakPtr< Component >	WeakComPtr
typedef utils::weakPtr< GameObject >	WeakGOPtr
typedef boost::function< ComPtr(const int64_t, const attributeMap &)>	createGOCCallback
typedef std::tuple< AccessState, std::string, boost::function< std::string(void)>, boost::function< bool(std::string)>, std::string >	componentOptions
typedef std::pair< Vec3, Quaternion >	Transform
typedef std::pair< Vec3, Quaternion >	keyFrame
typedef struct i6e::api::RayTestResult	RayTestResult
	struct containing information from raytest objID: id of GO hit first by the ray sourceID: id of the soure GO collisionPoint: hit point More...
typedef std::map< std::string, std::string >	attributeMap
typedef void(*	CreateGO) (GOPtr, const attributeMap &)
typedef core::MessageSubscriber	MessageSubscriberFacade
typedef core::Message	GameMessage
	simple typedef to use in API but leave overhead More...
typedef core::MessageStruct	GameMessageStruct
	simple typedef to use it in API but leave overhead of new struct More...
typedef utils::sequence_map< int64_t, ComPtr >	component_table_t
typedef std::pair< int64_t, ComPtr >	component_table_pair_t

Enumerations
enum	AddStrategy { AddStrategy::ADD, AddStrategy::REPLACE, AddStrategy::REPLACE_DIS, AddStrategy::REJECT }
	defines how new components should be handled More...
enum	AccessState { AccessState::READONLY, AccessState::READWRITE }
	defines the access state of the components objects More...
enum	ComponentOptionsParameter {   ACCESSSTATE, NAME, READFUNC, WRITEFUNC,   WIDGETTYPE }
	enum for easy access of the parameters in the std::tuple More...
enum	ShatterInterest : uint16_t { NONE, START, END, ALWAYS }
	Different flags for collision interest. More...
enum	GameType { GameType::SINGLEPLAYER, GameType::CLIENT, GameType::SERVER }

Functions
template<typename T >
std::enable_if< std::is_enum< T >::value &&!std::is_fundamental< T >::value, void >::type	parseAttribute (attributeMap::const_iterator it, T &value)
	converts a string to enum value More...
template<typename T >
std::enable_if<!std::is_enum< T >::value &&!std::is_fundamental< T >::value &&detail::constructible_from< T, const std::string & >::value, void >::type	parseAttribute (attributeMap::const_iterator it, T &value)
	converts a string to a class using T(const std::string &) constructor More...
template<typename T >
std::enable_if<!std::is_enum< T >::value &&!std::is_fundamental< T >::value &&!detail::constructible_from< T, const std::string & >::value, void >::type	parseAttribute (attributeMap::const_iterator it, T &value)
	converts a string to a class using boost::serialization (used if no T(const std::string &) constructor is available) More...
template<typename T >
std::enable_if<!std::is_enum< T >::value &&std::is_fundamental< T >::value, void >::type	parseAttribute (attributeMap::const_iterator it, T &value)
	converts a string to a fundamental type using boost::lexical_cast More...
template<typename T >
std::enable_if< std::is_enum< T >::value &&!std::is_fundamental< T >::value, void >::type	writeAttribute (attributeMap &params, const std::string &entry, const T &value)
	writes into an attributeMap More...
template<bool Required, typename T >
std::enable_if< Required, void >::type	parseAttribute (const attributeMap &params, const std::string &entry, T &value)
	parses a value from attribute map into a variable with possibility to throw exception, if entry not available More...
template<bool Required, typename T >
std::enable_if<!Required, void >::type	parseAttribute (const attributeMap &params, const std::string &entry, T &value)
	parses an optional value from attribute map into a variable More...
template<typename T >
std::enable_if<!std::is_enum< T >::value &&!std::is_fundamental< T >::value &&!std::is_same< T, std::string >::value &&detail::hasInsertInMap< T >::value, void >::type	writeAttribute (attributeMap &params, const std::string &entry, T value)
	writes a class providing the method insertInMap More...
template<typename T >
std::enable_if<!std::is_enum< T >::value &&!std::is_fundamental< T >::value &&(std::is_same< T, std::string >::value||std::is_same< const char, typename std::remove_pointer< T >::type >::value), void >::type	writeAttribute (attributeMap &params, const std::string &entry, T value)
	writes a string as is More...
template<typename T >
std::enable_if<!std::is_enum< T >::value &&std::is_fundamental< T >::value, void >::type	writeAttribute (attributeMap &params, const std::string &entry, T value)
	writes a fundamental type to the map using std::to_string More...
template<typename T >
std::enable_if<!std::is_enum< T >::value &&!std::is_fundamental< T >::value &&!std::is_same< T, std::string >::value &&!std::is_same< const char, typename std::remove_pointer< T >::type >::value &&!detail::hasInsertInMap< T >::value, void >::type	writeAttribute (attributeMap &params, const std::string &entry, T value)
	writes a class not providing the method insertInMap, so it uses boost::serialization to convert to a string More...

Typedef Documentation

typedef std::map<std::string, std::string> i6e::api::attributeMap

Definition at line 42 of file attributeMap.h.

typedef std::pair<int64_t, ComPtr> i6e::api::component_table_pair_t

Definition at line 54 of file GameObject.h.

typedef utils::sequence_map<int64_t, ComPtr> i6e::api::component_table_t

Definition at line 53 of file GameObject.h.

typedef std::tuple<AccessState, std::string, boost::function<std::string(void)>, boost::function<bool(std::string)>, std::string> i6e::api::componentOptions

Definition at line 91 of file Component.h.

typedef utils::sharedPtr< Component, Component > i6e::api::ComPtr

Definition at line 52 of file Component.h.

typedef void(* i6e::api::CreateGO) (GOPtr, const attributeMap &)

Definition at line 49 of file ObjectConfig.h.

typedef boost::function< ComPtr(const int64_t, const attributeMap &)> i6e::api::createGOCCallback

A pointer to a function which creates a new Components

See also

Components

Definition at line 58 of file Component.h.

typedef core::Message i6e::api::GameMessage

simple typedef to use in API but leave overhead

Definition at line 36 of file GameMessage.h.

typedef core::MessageStruct i6e::api::GameMessageStruct

simple typedef to use it in API but leave overhead of new struct

Definition at line 36 of file GameMessageStruct.h.

typedef utils::sharedPtr< GameObject, GameObject > i6e::api::GOPtr

Definition at line 55 of file Component.h.

typedef std::pair<Vec3, Quaternion> i6e::api::keyFrame

Definition at line 38 of file MoverComponent.h.

typedef core::MessageSubscriber i6e::api::MessageSubscriberFacade

Definition at line 33 of file MessageSubscriberFacade.h.

typedef struct i6e::api::RayTestResult i6e::api::RayTestResult

struct containing information from raytest objID: id of GO hit first by the ray sourceID: id of the soure GO collisionPoint: hit point

typedef std::pair<Vec3, Quaternion> i6e::api::Transform

Definition at line 49 of file MeshAppearanceComponent.h.

typedef utils::weakPtr< Component > i6e::api::WeakComPtr

Definition at line 56 of file Component.h.

typedef utils::weakPtr< GameObject > i6e::api::WeakGOPtr

Definition at line 57 of file Component.h.

Function Documentation

template<typename T >

std::enable_if<std::is_enum<T>::value && !std::is_fundamental<T>::value, void>::type i6e::api::parseAttribute	(	attributeMap::const_iterator	it,
		T &	value
	)

converts a string to enum value

Definition at line 76 of file attributeMap.h.

template<typename T >

std::enable_if<!std::is_enum<T>::value && !std::is_fundamental<T>::value && detail::constructible_from<T, const std::string &>::value, void>::type i6e::api::parseAttribute	(	attributeMap::const_iterator	it,
		T &	value
	)

converts a string to a class using T(const std::string &) constructor

Definition at line 84 of file attributeMap.h.

template<typename T >

std::enable_if<!std::is_enum<T>::value && !std::is_fundamental<T>::value && !detail::constructible_from<T, const std::string &>::value, void>::type i6e::api::parseAttribute	(	attributeMap::const_iterator	it,
		T &	value
	)

converts a string to a class using boost::serialization (used if no T(const std::string &) constructor is available)

Definition at line 92 of file attributeMap.h.

template<typename T >

std::enable_if<!std::is_enum<T>::value && std::is_fundamental<T>::value, void>::type i6e::api::parseAttribute	(	attributeMap::const_iterator	it,
		T &	value
	)

converts a string to a fundamental type using boost::lexical_cast

Definition at line 102 of file attributeMap.h.

template<bool Required, typename T >

std::enable_if<Required, void>::type i6e::api::parseAttribute	(	const attributeMap &	params,
		const std::string &	entry,
		T &	value
	)

parses a value from attribute map into a variable with possibility to throw exception, if entry not available

Definition at line 118 of file attributeMap.h.

template<bool Required, typename T >

std::enable_if<!Required, void>::type i6e::api::parseAttribute	(	const attributeMap &	params,
		const std::string &	entry,
		T &	value
	)

parses an optional value from attribute map into a variable

Definition at line 131 of file attributeMap.h.

template<typename T >

std::enable_if<std::is_enum<T>::value && !std::is_fundamental<T>::value, void>::type i6e::api::writeAttribute	(	attributeMap &	params,
		const std::string &	entry,
		const T &	value
	)

writes into an attributeMap

Definition at line 110 of file attributeMap.h.

template<typename T >

std::enable_if<!std::is_enum<T>::value && !std::is_fundamental<T>::value && !std::is_same<T, std::string>::value && detail::hasInsertInMap<T>::value, void>::type i6e::api::writeAttribute	(	attributeMap &	params,
		const std::string &	entry,
		T	value
	)

writes a class providing the method insertInMap

Definition at line 142 of file attributeMap.h.

template<typename T >

std::enable_if<!std::is_enum<T>::value && !std::is_fundamental<T>::value && (std::is_same<T, std::string>::value || std::is_same<const char, typename std::remove_pointer<T>::type>::value), void>::type i6e::api::writeAttribute	(	attributeMap &	params,
		const std::string &	entry,
		T	value
	)

writes a string as is

Definition at line 150 of file attributeMap.h.

template<typename T >

std::enable_if<!std::is_enum<T>::value && std::is_fundamental<T>::value, void>::type i6e::api::writeAttribute	(	attributeMap &	params,
		const std::string &	entry,
		T	value
	)

writes a fundamental type to the map using std::to_string

Definition at line 158 of file attributeMap.h.

template<typename T >

std::enable_if<!std::is_enum<T>::value && !std::is_fundamental<T>::value && !std::is_same<T, std::string>::value && !std::is_same<const char, typename std::remove_pointer<T>::type>::value && !detail::hasInsertInMap<T>::value, void>::type i6e::api::writeAttribute	(	attributeMap &	params,
		const std::string &	entry,
		T	value
	)

writes a class not providing the method insertInMap, so it uses boost::serialization to convert to a string

Definition at line 166 of file attributeMap.h.