Arma Reforger:Scripting: Automatic Reference Counting - Revision history

Leopard20 at 15:12, 26 February 2026

2026-02-26T15:12:48Z

← Older revision		Revision as of 17:12, 26 February 2026
Line 31:		Line 31:
	Enfusion has an internal counter of strong references to objects; when this counter reaches 0, the object is released from memory.		Enfusion has an internal counter of strong references to objects; when this counter reaches 0, the object is released from memory.

	{{Feature\|warning\|Reference only makes sense with <enforce inline>Managed</enforce> objects; using {{hl\|ref}} with a ''value'' (e.g <enforce inline>ref vector</enforce> or <enforce inline>ref int</enforce>) is incorrect!}}		{{Feature\|warning\|Reference only makes sense with <enforce inline>Managed</enforce> objects; using {{hl\|ref}} with a ''value type'' (e.g <enforce inline>ref vector</enforce> or <enforce inline>ref int</enforce>) is incorrect!}}

	=== Strong Reference ===		=== Strong Reference ===

Leopard20 at 15:11, 26 February 2026

2026-02-26T15:11:42Z

← Older revision		Revision as of 17:11, 26 February 2026
Line 31:		Line 31:
	Enfusion has an internal counter of strong references to objects; when this counter reaches 0, the object is released from memory.		Enfusion has an internal counter of strong references to objects; when this counter reaches 0, the object is released from memory.

	{{Feature\|warning\|Reference only makes sense with <enforce inline>Managed</enforce> objects; using {{hl\|ref}} with a ''value'' (e.g <enforce inline>ref vector ~~m_vMyValue;~~</enforce>) is ~~nonsense~~!}}		{{Feature\|warning\|Reference only makes sense with <enforce inline>Managed</enforce> objects; using {{hl\|ref}} with a ''value'' (e.g <enforce inline>ref vector</enforce> or <enforce inline>ref int</enforce>) is incorrect!}}

	=== Strong Reference ===		=== Strong Reference ===
Line 42:		Line 42:
	* using the {{hl\|[[Arma Reforger:Scripting: Keywords#ref\|ref]]}} keyword		* using the {{hl\|[[Arma Reforger:Scripting: Keywords#ref\|ref]]}} keyword
	* scope lifetime's script reference		* scope lifetime's script reference
	References to local variables in methods are already strong, ~~making~~ <enforce inline>ref</enforce> ~~usage~~ in ~~method pointless~~:		References to local variables in methods are already strong, so using <enforce inline>ref</enforce> in methods is redundant:
	{{{!}} class{{=}}"wikitable"		{{{!}} class{{=}}"wikitable"
	! Do		! Do

Lou Montana: Add important infobox to highlight ref usage

2026-02-26T14:57:06Z

Add important infobox to highlight ref usage

← Older revision		Revision as of 16:57, 26 February 2026
Line 30:		Line 30:

	Enfusion has an internal counter of strong references to objects; when this counter reaches 0, the object is released from memory.		Enfusion has an internal counter of strong references to objects; when this counter reaches 0, the object is released from memory.

			{{Feature\|warning\|Reference only makes sense with <enforce inline>Managed</enforce> objects; using {{hl\|ref}} with a ''value'' (e.g <enforce inline>ref vector m_vMyValue;</enforce>) is nonsense!}}

	=== Strong Reference ===		=== Strong Reference ===
Line 36:		Line 38:
	The referenced object '''cannot''' become null during the referencing object's lifetime unless manually deleted (with the {{hl\|[[Arma Reforger:Scripting: Keywords#delete\|delete]]}} keyword).		The referenced object '''cannot''' become null during the referencing object's lifetime unless manually deleted (with the {{hl\|[[Arma Reforger:Scripting: Keywords#delete\|delete]]}} keyword).

			{{Feature\|important\|
	Strong references:		Strong references:
	* using the {{hl\|[[Arma Reforger:Scripting: Keywords#ref\|ref]]}} keyword		* using the {{hl\|[[Arma Reforger:Scripting: Keywords#ref\|ref]]}} keyword
	* scope lifetime's script reference		* scope lifetime's script reference
			References to local variables in methods are already strong, making <enforce inline>ref</enforce> usage in method pointless:
			{{{!}} class{{=}}"wikitable"
			! Do
			! Don't
			{{!}}-
			{{!}} <enforce>
			void Method(int a, int b, int c)
			{
			array<int> numbers = { a, b, c }; // yes
			foreach (int number : numbers)
			{
			Print(number);
			}
			}
			</enforce>
			{{!}} <enforce>
			void Method(int a, int b, int c)
			{
			ref array<int> numbers = { a, b, c }; // no
			foreach (int number : numbers)
			{
			Print(number);
			}
			}
			</enforce>
			{{!}}}
			}}

	=== Weak Reference ===		=== Weak Reference ===
Line 116:		Line 146:
	}		}

	void ~~main~~()		void Function()
	{		{
	Parent a = new Parent(); // 'a' has 1 reference		Parent a = new Parent(); // 'a' has 1 reference
Line 141:		Line 171:
	}		}

	void ~~main~~()		void Function()
	{		{
	Parent a = new Parent(); // 'a' has 1 strong (scope) reference		Parent a = new Parent(); // 'a' has 1 strong (scope) reference

Lou Montana: Text replacement - "\{\{GameCategory\|armaR\|Modding\|(Guidelines|Tutorials)\|([^=↵]*)\}\}" to "{{GameCategory|armaR|Modding|$2|$1}}"

2025-02-26T12:32:04Z

Text replacement - "\{\{GameCategory\|armaR\|Modding\|(Guidelines|Tutorials)\|([^=↵]*)\}\}" to "{{GameCategory|armaR|Modding|$2|$1}}"

← Older revision		Revision as of 14:32, 26 February 2025
Line 156:		Line 156:


	{{GameCategory\|armaR\|Modding\|Guidelines~~\|Scripting~~}}		{{GameCategory\|armaR\|Modding\|Scripting\|Guidelines}}

Lou Montana: /* Strong Reference */ Fix wording

2024-04-26T10:11:45Z

Strong Reference: Fix wording

← Older revision		Revision as of 12:11, 26 April 2024
Line 33:		Line 33:
	=== Strong Reference ===		=== Strong Reference ===

	A strong reference is a reference to an object that increments the reference counter. The referenced object '''cannot''' become null during the ~~program~~'s lifetime unless manually deleted (with the {{hl\|[[Arma Reforger:Scripting: Keywords#delete\|delete]]}} keyword).		A strong reference is a reference to an object that increments the reference counter.
			The referenced object '''cannot''' become null during the referencing object's lifetime unless manually deleted (with the {{hl\|[[Arma Reforger:Scripting: Keywords#delete\|delete]]}} keyword).

	Strong references:		Strong references:

Lou Montana: Some wiki formatting

2023-06-16T17:02:45Z

Some wiki formatting

← Older revision		Revision as of 19:02, 16 June 2023
Line 22:		Line 22:
	* it is simple to implement (having a good working GC is a big issue)		* it is simple to implement (having a good working GC is a big issue)

	on the negative side, it is open to the cyclic reference problem, described in the {{Link\|#Cyclic Reference}} paragraph below.		On the negative side, it is open to the cyclic reference problem, described in the {{Link\|#Cyclic Reference}} paragraph below.

	{{Feature\|informative\|This whole system impacts '''objects''' passed by '''reference''' - see ~~[[Arma_Reforger~~:Scripting:~~_Values~~#Types\|Types]].}}		{{Feature\|informative\|This whole system impacts '''objects''' passed by '''reference''' - see {{Link\|Arma Reforger:Scripting: Values#Types\|Value Types}}.}}


Line 107:		Line 107:
	class Parent		class Parent
	{		{
	ref Child ~~m_child~~;		ref Child m_Child;
	}		}

	class Child		class Child
	{		{
	ref Parent ~~m_parent~~;		ref Parent m_Parent;
	}		}

Line 119:		Line 119:
	Parent a = new Parent(); // 'a' has 1 reference		Parent a = new Parent(); // 'a' has 1 reference
	Child b = new Child(); // 'b' has 1 reference		Child b = new Child(); // 'b' has 1 reference
	a.~~m_child~~ = b; // 'b' has 2 references		a.m_Child = b; // 'b' has 2 references
	b.~~m_parent~~ = a; // 'a' has 2 references		b.m_Parent = a; // 'a' has 2 references

	// local variables 'a', 'b' are released (reference count is decreased by 1)		// local variables 'a', 'b' are released (reference count is decreased by 1)
Line 132:		Line 132:
	class Parent		class Parent
	{		{
	ref Child ~~m_child~~;		ref Child m_Child;
	}		}

	class Child		class Child
	{		{
	Parent ~~m_parent~~;		Parent m_Parent;
	}		}

Line 144:		Line 144:
	Parent a = new Parent(); // 'a' has 1 strong (scope) reference		Parent a = new Parent(); // 'a' has 1 strong (scope) reference
	Child b = new Child(); // 'b' has 1 strong (scope) reference		Child b = new Child(); // 'b' has 1 strong (scope) reference
	a.~~m_child~~ = b; // 'b' has 2 strong references		a.m_Child = b; // 'b' has 2 strong references
	b.~~m_parent~~ = a; // 'a' has 1 strong reference, 1 weak reference		b.m_Parent = a; // 'a' has 1 strong reference, 1 weak reference

	// local variables 'a', 'b' are released (reference count is decreased by 1)		// local variables 'a', 'b' are released (reference count is decreased by 1)

Lou Montana: Some wiki formatting

2023-05-19T10:33:01Z

Some wiki formatting

← Older revision		Revision as of 12:33, 19 May 2023
Line 1:		Line 1:
			{{TOC\|side}}
	'''Automatic Reference Counting''', shortened to '''ARC''', is a memory management solution used in Enforce Script. Enforce Script does not use Garbage Collection (a.k.a GC).		'''Automatic Reference Counting''', shortened to '''ARC''', is a memory management solution used in Enforce Script. Enforce Script does not use Garbage Collection (a.k.a GC).
	<!--		<!--

Lou Montana: Remove after class' semicolons

2023-05-19T10:32:21Z

Remove after class' semicolons

← Older revision		Revision as of 12:32, 19 May 2023
Line 85:		Line 85:
	// arrayOfWeakRef is destroyed (it only contains NULL),		// arrayOfWeakRef is destroyed (it only contains NULL),
	// arrayOfStrongRef is destroyed (it contains the last strong ref to object, so its contained object is destroyed as well		// arrayOfStrongRef is destroyed (it contains the last strong ref to object, so its contained object is destroyed as well
	};		}
	};		}
	</enforce>		</enforce>

Line 107:		Line 107:
	{		{
	ref Child m_child;		ref Child m_child;
	};		}

	class Child		class Child
	{		{
	ref Parent m_parent;		ref Parent m_parent;
	};		}

	void main()		void main()
Line 123:		Line 123:
	// local variables 'a', 'b' are released (reference count is decreased by 1)		// local variables 'a', 'b' are released (reference count is decreased by 1)
	// both objects remain in memory, having 1 reference each (each other)		// both objects remain in memory, having 1 reference each (each other)
	};		}
	</enforce>		</enforce>

Line 132:		Line 132:
	{		{
	ref Child m_child;		ref Child m_child;
	};		}

	class Child		class Child
	{		{
	Parent m_parent;		Parent m_parent;
	};		}

	void main()		void main()
Line 149:		Line 149:
	// a only has 1 weak reference and is released from memory		// a only has 1 weak reference and is released from memory
	// b loses a's reference and has no more reference to it - it gets released		// b loses a's reference and has no more reference to it - it gets released
	};		}
	</enforce>		</enforce>
	Using weak references makes null-checking take more importance in scripting.		Using weak references makes null-checking take more importance in scripting.

Lou Montana: Fix Wikipedia link

2023-02-24T00:00:26Z

Fix Wikipedia link

← Older revision		Revision as of 02:00, 24 February 2023
Line 16:		Line 16:
	* suitable to use by everyone		* suitable to use by everyone
	-->		-->
	In comparison with the widely used {{~~Wikipedia~~\|~~Tracing garbage collection~~}} (in e.g C#, Java):		In comparison with the widely used {{Link\|https://en.wikipedia.org/wiki/Tracing_garbage_collection}} (in e.g C#, Java):
	* it does not suffer from cleanup stuttering (lags due to high GC load)		* it does not suffer from cleanup stuttering (lags due to high GC load)
	* memory management performance is not dependent on the number of managed instances		* memory management performance is not dependent on the number of managed instances

Lou Montana: Text replacement - "{{HashLink" to "{{Link"

2023-01-04T16:44:08Z

Text replacement - "{{HashLink" to "{{Link"

← Older revision		Revision as of 18:44, 4 January 2023
Line 21:		Line 21:
	* it is simple to implement (having a good working GC is a big issue)		* it is simple to implement (having a good working GC is a big issue)

	on the negative side, it is open to the cyclic reference problem, described in the {{~~HashLink~~\|#Cyclic Reference}} paragraph below.		on the negative side, it is open to the cyclic reference problem, described in the {{Link\|#Cyclic Reference}} paragraph below.

	{{Feature\|informative\|This whole system impacts '''objects''' passed by '''reference''' - see [[Arma_Reforger:Scripting:_Values#Types\|Types]].}}		{{Feature\|informative\|This whole system impacts '''objects''' passed by '''reference''' - see [[Arma_Reforger:Scripting:_Values#Types\|Types]].}}