createHashMapObject - Revision history

Dedmen: Fix #type's type

2026-01-15T10:26:48Z

Fix #type's type

← Older revision		Revision as of 12:26, 15 January 2026
Line 29:		Line 29:
	** "unscheduled": all methods (including {{hl\|#clone}} and {{hl\|#create}}) will be executed in {{Link\|Scheduler#Unscheduled Environment\|unscheduled environment}}		** "unscheduled": all methods (including {{hl\|#clone}} and {{hl\|#create}}) will be executed in {{Link\|Scheduler#Unscheduled Environment\|unscheduled environment}}
	* {{hl\|"#base"}}: [[Array]] or [[HashMap]] - declaration of base class for inheritance		* {{hl\|"#base"}}: [[Array]] or [[HashMap]] - declaration of base class for inheritance
	* {{hl\|"#type"}}: [[~~Any~~]] - can be used to give a object a "type name", on inheritance types will be merged into an [[Array]]		* {{hl\|"#type"}}: [[String]] - can be used to give a object a "type name", on inheritance types will be merged into an [[Array]]
	Note that all entries beginning with {{hl\|#}} are reserved, the engine might use these internally without their use being documented.		Note that all entries beginning with {{hl\|#}} are reserved, the engine might use these internally without their use being documented.

Hypoxic125: removed redundant note. basically another copy of example 2

2024-08-27T05:45:32Z

removed redundant note. basically another copy of example 2

← Older revision		Revision as of 07:45, 27 August 2024
Line 132:		Line 132:

	\|seealso= [[call]] [[createHashMap]]		\|seealso= [[call]] [[createHashMap]]
	}}

	~~{{Note~~
	~~\|user= Hypoxic125~~
	~~\|timestamp= 20240827054058~~
	\|text= You can perform '''Constructor Chaining''' by calling the base classes constructor, then followed with your modified constructor to be executed after. Be sure to use the same parameters when chaining.
	~~<sqf>~~
	~~private _baseClass = [~~
	~~["#create", {~~
	~~systemChat "Doing base class things";~~
	}]
	];

	~~private _derivedClass = [~~
	~~["#base", _baseClass],~~
	~~["#create", {~~
	~~// Execute base class constructor~~
	~~_self get "#base" call ["#create", _this];~~

	~~// This class constructor to be performed after~~
	~~systemChat "Doing derived class things";~~
	}]
	];

	~~createHashMapObject [_derivedClass]; // "Doing base class things"~~
	~~// "Doing derived class things"~~
	~~</sqf>~~
	}}		}}

Hypoxic125 at 05:40, 27 August 2024

2024-08-27T05:40:58Z

← Older revision		Revision as of 07:40, 27 August 2024
Line 132:		Line 132:

	\|seealso= [[call]] [[createHashMap]]		\|seealso= [[call]] [[createHashMap]]
			}}

			{{Note
			\|user= Hypoxic125
			\|timestamp= 20240827054058
			\|text= You can perform '''Constructor Chaining''' by calling the base classes constructor, then followed with your modified constructor to be executed after. Be sure to use the same parameters when chaining.
			<sqf>
			private _baseClass = [
			["#create", {
			systemChat "Doing base class things";
			}]
			];

			private _derivedClass = [
			["#base", _baseClass],
			["#create", {
			// Execute base class constructor
			_self get "#base" call ["#create", _this];

			// This class constructor to be performed after
			systemChat "Doing derived class things";
			}]
			];

			createHashMapObject [_derivedClass]; // "Doing base class things"
			// "Doing derived class things"
			</sqf>
	}}		}}

Lou Montana: Some wiki formatting

2023-10-09T13:06:30Z

Some wiki formatting

← Older revision		Revision as of 15:06, 9 October 2023
Line 7:		Line 7:

	\|descr= Create a [[HashMap]] with an {{Link\|https://en.wikipedia.org/wiki/Object-oriented_programming\|Object-Oriented Programming}} behaviour.<br>		\|descr= Create a [[HashMap]] with an {{Link\|https://en.wikipedia.org/wiki/Object-oriented_programming\|Object-Oriented Programming}} behaviour.<br>
	Inside a object, Methods (if they are called correctly, either by engine or via {{Link\|call#Syntax 3}}) will have the objects instance inside the "_self" variable.<br>		Inside a object, Methods (if they are called correctly, either by engine or via {{Link\|call#Syntax 3}}) will have the objects instance inside the <sqf inline>_self</sqf> variable.<br>
	The Destructor ("#delete" method) will be executed when the last reference to the objects variable gets deleted. (Except when the mission is ended and all variables are deleted at once)<br>		The Destructor ("#delete" method) will be executed when the last reference to the objects variable gets deleted. (Except when the mission is ended and all variables are deleted at once)<br>
	<br>		<br>
Line 116:		Line 116:
	params ["_vehicleType", "_vehiclePos", "_lifetimeSeconds"]; // handle constructor arguments		params ["_vehicleType", "_vehiclePos", "_lifetimeSeconds"]; // handle constructor arguments
	private _newVehicle = _vehicleType createVehicle _vehiclePos;		private _newVehicle = _vehicleType createVehicle _vehiclePos;
	_self set ["MyVehicle", _newVehicle ]; // Store the vehicle inside the object for later		_self set ["MyVehicle", _newVehicle]; // Store the vehicle inside the object for later

	// because _self is passed as parameter, it will be referenced by the spawned script until it ends.		// because _self is passed as parameter, it will be referenced by the spawned script until it ends.

7erra: when str is called

2023-09-22T08:52:26Z

when str is called

← Older revision		Revision as of 10:52, 22 September 2023
Line 23:		Line 23:
	* {{hl\|"#clone"}}: [[Code]] - this is code happening when cloning is done on this hashmap object		* {{hl\|"#clone"}}: [[Code]] - this is code happening when cloning is done on this hashmap object
	* {{hl\|"#delete"}}: [[Code]] - this is the hashmap object's destructor. It will always be executed inside [[missionNamespace]].		* {{hl\|"#delete"}}: [[Code]] - this is the hashmap object's destructor. It will always be executed inside [[missionNamespace]].
	* {{hl\|"#str"}}: [[Code]] - code that is used to evaluate what is displayed when - '''must''' return [[String]]		* {{hl\|"#str"}}: [[Code]] - code that is used to evaluate what is displayed when the [[str]] function is called on the object - '''must''' return [[String]]
	* {{hl\|"#flags"}}: [[Array]] of [[String]]s - case-''in''sensitive flags regarding this hashmap object		* {{hl\|"#flags"}}: [[Array]] of [[String]]s - case-''in''sensitive flags regarding this hashmap object
	** "noCopy": forbids copying, <sqf inline>+_hashMapObject</sqf> will throw an error		** "noCopy": forbids copying, <sqf inline>+_hashMapObject</sqf> will throw an error

Lou Montana: Text replacement - " |version1= 2.14 |branch= dev" to " |version1= 2.14"

2023-09-05T17:11:28Z

Text replacement - " |version1= 2.14 |branch= dev" to " |version1= 2.14"

← Older revision		Revision as of 19:11, 5 September 2023
Line 3:		Line 3:
	\|game1= arma3		\|game1= arma3
	\|version1= 2.14		\|version1= 2.14

	~~\|branch= dev~~

	\|gr1= HashMap		\|gr1= HashMap

Lou Montana: Some wiki formatting

2023-05-22T16:28:27Z

Some wiki formatting

← Older revision		Revision as of 18:28, 22 May 2023
Line 17:		Line 17:
	Flags entry will use overwrite behaviour.		Flags entry will use overwrite behaviour.

	\|s1= [[createHashMapObject]] [classDefinition(, constructorArguments)]		\|s1= [[createHashMapObject]] [classDefinition, constructorArguments]

	\|p1= classDefinition: [[HashMap]] or [[Array]] of [[Array]]s, format [name, value]:		\|p1= classDefinition: [[HashMap]] or [[Array]] of [[Array]]s, format [name, value]:
Line 34:		Line 34:
	Note that all entries beginning with {{hl\|#}} are reserved, the engine might use these internally without their use being documented.		Note that all entries beginning with {{hl\|#}} are reserved, the engine might use these internally without their use being documented.

	\|p2= constructorArguments: [[Anything]] -(Optional, default: [[Nothing]]) passed as <sqf inline>_this</sqf> argument to the "#create" method.		\|p2= constructorArguments: [[Anything]] - (Optional, default [[Nothing]]) passed as <sqf inline>_this</sqf> argument to the "#create" method.

	\|r1= [[HashMap]]		\|r1= [[HashMap]]

Lou Montana: Some wiki formatting

2023-05-22T16:27:20Z

Some wiki formatting

← Older revision		Revision as of 18:27, 22 May 2023
Line 19:		Line 19:
	\|s1= [[createHashMapObject]] [classDefinition(, constructorArguments)]		\|s1= [[createHashMapObject]] [classDefinition(, constructorArguments)]

	\|p1= classDefinition: [[Array]] of [[Array]]s in format [name, value] ~~OR [[HashMap]].<br>~~		\|p1= classDefinition: [[HashMap]] or [[Array]] of [[Array]]s, format [name, value]:
	''name'' can be anything like any other [[HashMap]], but it must be a [[String]] for it to be used like an OOP object method (see {{Link\|call#Syntax 3}}).<br>		''name'' can be anything like any other [[HashMap]], but it must be a [[String]] for it to be used like an OOP object method (see {{Link\|call#Syntax 3}}).<br>
	Some special values, starting with {{hl\|#}}, are reserved and expect a specific ''value'' type (they are all optional):		Some special values, starting with {{hl\|#}}, are reserved and expect a specific ''value'' type (they are all optional):
Line 34:		Line 34:
	Note that all entries beginning with {{hl\|#}} are reserved, the engine might use these internally without their use being documented.		Note that all entries beginning with {{hl\|#}} are reserved, the engine might use these internally without their use being documented.

	\|p2= constructorArguments(Optional, default: [[Nothing]])~~: [[Any]] - Passed~~ as _this argument to "#create" method.		\|p2= constructorArguments: [[Anything]] -(Optional, default: [[Nothing]]) passed as <sqf inline>_this</sqf> argument to the "#create" method.

	\|r1= [[HashMap]]		\|r1= [[HashMap]]
Line 58:		Line 58:

	\|x2= Inheritance constructor/destructor/copy orderings: <sqf>		\|x2= Inheritance constructor/destructor/copy orderings: <sqf>
	private _animalDeclaration = [		private _animalDeclaration = [
	["#type", "IAnimal"],		["#type", "IAnimal"],
	["#create", { systemChat "Animal Init" }],		["#create", { systemChat "Animal Init" }],
	["#clone", { systemChat "Animal Copied" }],		["#clone", { systemChat "Animal Copied" }],
	["#delete", { systemChat "Animal Bye" }]		["#delete", { systemChat "Animal Bye" }]
	];		];

	private _pigDeclaration = [		private _pigDeclaration = [
	["#base", _animalDeclaration],		["#base", _animalDeclaration],
	["#type", "Pig"],		["#type", "Pig"],
	["#create", { systemChat "Pig Init" }],		["#create", { systemChat "Pig Init" }],
	["#clone", { systemChat "Pig Copied" }],		["#clone", { systemChat "Pig Copied" }],
	["#delete", { systemChat "Pig Bye" }]		["#delete", { systemChat "Pig Bye" }]
	];		];

	private _smolPigDeclaration = [		private _smolPigDeclaration = [
	["#base", _pigDeclaration],		["#base", _pigDeclaration],
	["#type", "SmolPig"],		["#type", "SmolPig"],
	["#create", { systemChat "SmolPig Init" }],		["#create", { systemChat "SmolPig Init" }],
	["#clone", { systemChat "Smol Copied" }],		["#clone", { systemChat "Smol Copied" }],
	["#delete", { systemChat "Smol Bye" }]		["#delete", { systemChat "Smol Bye" }]
	];		];

	_smolPigInstance = createHashMapObject [_smolPigDeclaration]; // ~~Prints~~ "Animal Init", "Pig Init", "SmolPig Init"		private _smolPigInstance = createHashMapObject [_smolPigDeclaration]; // prints "Animal Init", "Pig Init", "SmolPig Init"
	_copy = +_smolPigInstance; // ~~Prints~~ "Animal Copied", "Pig Copied", "SmolPig Copied"		private _copy = +_smolPigInstance; // prints "Animal Copied", "Pig Copied", "SmolPig Copied"
	_copy = nil; // ~~Prints~~ "SmolPig Bye", "Pig Bye", "Animal Bye"		_copy = nil; // prints "SmolPig Bye", "Pig Bye", "Animal Bye"
	</sqf>		</sqf>

	\|x3= Inheritance type checking: <sqf>		\|x3= Inheritance type checking:
	private _animalDeclaration = [		<sqf>
			private _animalDeclaration = [
	["#type", "IAnimal"],		["#type", "IAnimal"],
	["FurType", { "None" }] // ~~Default~~ implementation		["FurType", { "None" }] // default implementation
	];		];

	private _pigDeclaration = [		private _pigDeclaration = [
	["#base", _animalDeclaration],		["#base", _animalDeclaration],
	["#type", "Pig"],		["#type", "Pig"],
	["FurType", { "Bristles" }] // ~~Override~~ the base class method		["FurType", { "Bristles" }] // override the base class method
	];		];

	private _catDeclaration = [		private _catDeclaration = [
	["#base", _animalDeclaration],		["#base", _animalDeclaration],
	["#type", "Cat"],		["#type", "Cat"],
	["FurType", { "Hair" }] // ~~Override~~ the base class method		["FurType", { "Hair" }] // override the base class method
	];		];

	_instance = createHashMapObject [selectRandom [_pigDeclaration, _catDeclaration]];		private _instance = createHashMapObject [selectRandom [_pigDeclaration, _catDeclaration]];

	if ("IAnimal" in (_instance get "#type")) then { // ~~Check~~ if a object instance is or inherits from a specific type		if ("IAnimal" in (_instance get "#type")) then // check if a object instance is or inherits from a specific type
	_instance call ["FurType"]; // ~~Now~~ that we know it implements IAnimal, we know that "FurType" method will be present		{
			_instance call ["FurType"]; // now that we know it implements IAnimal, we know that "FurType" method will be present
	};		};
	</sqf>		</sqf>

	\|x3= Destructor: <sqf>		\|x4= Destructor: <sqf>
	private _temporaryVehicle = [		private _temporaryVehicle = [
	["#create", {		["#create", {
	params ["_vehicleType", "_vehiclePos", "_lifetimeSeconds"]; // ~~Handle~~ constructor arguments		params ["_vehicleType", "_vehiclePos", "_lifetimeSeconds"]; // handle constructor arguments
	private _newVehicle = _vehicleType createVehicle _vehiclePos;		private _newVehicle = _vehicleType createVehicle _vehiclePos;
	_self set ["MyVehicle", _newVehicle ]; // Store the vehicle inside the object for later		_self set ["MyVehicle", _newVehicle ]; // Store the vehicle inside the object for later
	~~[_lifetimeSeconds, _self] spawn {params ["_lifetimeSeconds", "_self"]; Sleep _lifetimeSeconds; } // Because _self is passed as parameter, it will be referenced by the spawned script until it ends.~~
	~~}],~~
	~~["#delete", {~~
	~~deleteVehicle (_self get "MyVehicle"); // Delete the vehicle when we go away~~
	~~}],~~
	~~["MyVehicle", objNull] // Placeholder, this is not needed~~
	];

	~~createHashMapObject~~ [~~_temporaryVehicle~~, ["~~RoadCone_F~~", ~~getPos player~~, 5]]; // ~~Create~~ a temporary RoadCone, at player position, that will delete itself after 5 seconds.		// because _self is passed as parameter, it will be referenced by the spawned script until it ends.
			[_lifetimeSeconds, _self] spawn { params ["_lifetimeSeconds", "_self"]; sleep _lifetimeSeconds; };
			}],
			["#delete", {
			deleteVehicle (_self get "MyVehicle"); // delete the vehicle when we go away
			}],
			["MyVehicle", objNull] // placeholder, this is not needed
			];

			// create a temporary RoadCone, at player position, that will delete itself after 5 seconds.
			createHashMapObject [_temporaryVehicle, ["RoadCone_F", getPos player, 5]];
	</sqf>		</sqf>

	\|seealso= [[call]] [[createHashMap]]		\|seealso= [[call]] [[createHashMap]]
	}}		}}

Dedmen: More examples and description

2023-05-11T11:51:23Z

More examples and description

← Older revision		Revision as of 13:51, 11 May 2023
Line 9:		Line 9:

	\|descr= Create a [[HashMap]] with an {{Link\|https://en.wikipedia.org/wiki/Object-oriented_programming\|Object-Oriented Programming}} behaviour.<br>		\|descr= Create a [[HashMap]] with an {{Link\|https://en.wikipedia.org/wiki/Object-oriented_programming\|Object-Oriented Programming}} behaviour.<br>
			Inside a object, Methods (if they are called correctly, either by engine or via {{Link\|call#Syntax 3}}) will have the objects instance inside the "_self" variable.<br>
			The Destructor ("#delete" method) will be executed when the last reference to the objects variable gets deleted. (Except when the mission is ended and all variables are deleted at once)<br>
	<br>		<br>
	Inheritance: HashMap objects support a simple form of Inheritance.<br>		Inheritance: HashMap objects support a simple form of Inheritance.<br>
Line 22:		Line 24:
	* {{hl\|"#create"}}: [[Code]] - this is the hashmap object's constructor		* {{hl\|"#create"}}: [[Code]] - this is the hashmap object's constructor
	* {{hl\|"#clone"}}: [[Code]] - this is code happening when cloning is done on this hashmap object		* {{hl\|"#clone"}}: [[Code]] - this is code happening when cloning is done on this hashmap object
	* {{hl\|"#delete"}}: [[Code]] - this is the hashmap object's destructor		* {{hl\|"#delete"}}: [[Code]] - this is the hashmap object's destructor. It will always be executed inside [[missionNamespace]].
	* {{hl\|"#str"}}: [[Code]] - code that is used to evaluate what is displayed when - '''must''' return [[String]]		* {{hl\|"#str"}}: [[Code]] - code that is used to evaluate what is displayed when - '''must''' return [[String]]
	* {{hl\|"#flags"}}: [[Array]] of [[String]]s - case-''in''sensitive flags regarding this hashmap object		* {{hl\|"#flags"}}: [[Array]] of [[String]]s - case-''in''sensitive flags regarding this hashmap object
Line 107:		Line 109:
	_instance call ["FurType"]; // Now that we know it implements IAnimal, we know that "FurType" method will be present		_instance call ["FurType"]; // Now that we know it implements IAnimal, we know that "FurType" method will be present
	};		};
			</sqf>

			\|x3= Destructor: <sqf>
			private _temporaryVehicle = [
			["#create", {
			params ["_vehicleType", "_vehiclePos", "_lifetimeSeconds"]; // Handle constructor arguments
			private _newVehicle = _vehicleType createVehicle _vehiclePos;
			_self set ["MyVehicle", _newVehicle ]; // Store the vehicle inside the object for later
			[_lifetimeSeconds, _self] spawn {params ["_lifetimeSeconds", "_self"]; Sleep _lifetimeSeconds; } // Because _self is passed as parameter, it will be referenced by the spawned script until it ends.
			}],
			["#delete", {
			deleteVehicle (_self get "MyVehicle"); // Delete the vehicle when we go away
			}],
			["MyVehicle", objNull] // Placeholder, this is not needed
			];

			createHashMapObject [_temporaryVehicle, ["RoadCone_F", getPos player, 5]]; // Create a temporary RoadCone, at player position, that will delete itself after 5 seconds.
	</sqf>		</sqf>

	\|seealso= [[call]] [[createHashMap]]		\|seealso= [[call]] [[createHashMap]]
	}}		}}

Dedmen: Inheritance

2023-05-11T11:01:40Z

Inheritance

@@ Line 8: / Line 8: @@
 |gr1= HashMap
-|descr= Create a [[HashMap]] with an {{Link|https://en.wikipedia.org/wiki/Object-oriented_programming|Object-Oriented Programming}} behaviour.
+|descr= Create a [[HashMap]] with an {{Link|https://en.wikipedia.org/wiki/Object-oriented_programming|Object-Oriented Programming}} behaviour.<br>
-|s1= [[createHashMapObject]] [details(, constructorArguments)]
+|s1= [[createHashMapObject]] [classDefinition(, constructorArguments)]
-|p1= details: [[Array]] of [[Array]]s in format [name, value].
+|p1= classDefinition: [[Array]] of [[Array]]s in format [name, value] OR [[HashMap]].<br>
 ''name'' can be anything like any other [[HashMap]], but it must be a [[String]] for it to be used like an OOP object method (see {{Link|call#Syntax 3}}).<br>
 Some special values, starting with {{hl|#}}, are reserved and expect a specific ''value'' type (they are all optional):
@@ Line 23: / Line 28: @@
 ** "sealed": prevents from adding and removing any keys - key values can still be edited
 ** "unscheduled": all methods (including {{hl|#clone}} and {{hl|#create}}) will be executed in {{Link|Scheduler#Unscheduled Environment|unscheduled environment}}
 Note that all entries beginning with {{hl|#}} are reserved, the engine might use these internally without their use being documented.
 |r1= [[HashMap]]
@@ Line 37: / Line 46: @@
 ];
-private _hashMapObject = createHashMapObject _declaration;	// hints "Hello!"
+private _hashMapObject = createHashMapObject [_declaration];	// hints "Hello!"
-_hashMapObject call ["Method"];								// hints "Method has been called"
+_hashMapObject call ["Method"];									// hints "Method has been called"
-hint str _hashMapObject;									// hints "My HashMap Object"
+hint str _hashMapObject;										// hints "My HashMap Object"
-private _shallowCopy = _hashMapObject;						// no hint
+private _shallowCopy = _hashMapObject;							// no hint
-private _deepCopy = +_hashMapObject;						// hints "We were copied!"
+private _deepCopy = +_hashMapObject;							// hints "We were copied!"
 // at the end of the scope, _hashMapObject is deleted and hints "Goodbye"
 </sqf>
 |seealso= [[call]] [[createHashMap]]
-|p2=constructorArguments: [[Any]] - Arguments passed to _this in constructor (if a constructor exists)}}
+}}

← Older revision		Revision as of 10:52, 22 September 2023
Line 23:		Line 23:
	* {{hl\|"#clone"}}: [[Code]] - this is code happening when cloning is done on this hashmap object		* {{hl\|"#clone"}}: [[Code]] - this is code happening when cloning is done on this hashmap object
	* {{hl\|"#delete"}}: [[Code]] - this is the hashmap object's destructor. It will always be executed inside [[missionNamespace]].		* {{hl\|"#delete"}}: [[Code]] - this is the hashmap object's destructor. It will always be executed inside [[missionNamespace]].
	* {{hl\|"#str"}}: [[Code]] - code that is used to evaluate what is displayed when - '''must''' return [[String]]		* {{hl\|"#str"}}: [[Code]] - code that is used to evaluate what is displayed when the [[str]] function is called on the object - '''must''' return [[String]]
	* {{hl\|"#flags"}}: [[Array]] of [[String]]s - case-''in''sensitive flags regarding this hashmap object		* {{hl\|"#flags"}}: [[Array]] of [[String]]s - case-''in''sensitive flags regarding this hashmap object
	** "noCopy": forbids copying, <sqf inline>+_hashMapObject</sqf> will throw an error		** "noCopy": forbids copying, <sqf inline>+_hashMapObject</sqf> will throw an error