unit SharedMLAdapters;
interface

type Relationships = class
public
	function create(_obj: Relationships);
	function Init();

	function GetRelationshipById(_key: string);
	function GetRelationshipByTarget(_key: string);
	function AddRelationship(_value: Relationship);
	function RemoveRelationship(_value: Relationship);

	property RelationshipCount: uinteger read relationship_count_;

private
	object_: Relationships;
	relationship_id_hash_: hash;
	relationship_target_hash_: hash;
	relationship_count_: uinteger;
end;

type Types = class
public
	function create(_obj: Types);
	function Init();

	function GetDefaultByExtension(_key: string);
	function AddDefault(_value: Default);
	function RemoveDefault(_value: Default);
	function Get_OverrideByPartName(_key: string);
	function Add_Override(_value: _Override);
	function Remove_Override(_value: _Override);

	property DefaultCount: uinteger read default_count_;
	property _OverrideCount: uinteger read _override_count_;

private
	object_: Types;
	default_extension_hash_: hash;
	default_count_: uinteger;
	_override_partname_hash_: hash;
	_override_count_: uinteger;
end;

implementation

function Relationships.create(_obj: Relationships);
begin
	object_ := _obj;
	relationship_count_ := 0;
	relationship_id_hash_ := array();
	relationship_target_hash_ := array();
	{self.}Init();
end;

function Relationships.Init();
begin
	elements := object_.Relationships();
	relationship_count_ := length(elements);
	for k,v in elements do
	begin
		relationship_id_hash_[v.Id] := v;
		relationship_target_hash_[v.Target] := v;
	end
end;

function Relationships.GetRelationshipById(_key: string);
begin
	return relationship_id_hash_[_key];
end;

function Relationships.GetRelationshipByTarget(_key: string);
begin
	return relationship_target_hash_[_key];
end;

function Relationships.AddRelationship(_value: Relationship);
begin
	relationship_id_hash_[_value.Id] := _value;
	relationship_target_hash_[_value.Target] := _value;
	relationship_count_++;
end;

function Relationships.RemoveRelationship(_value: Relationship);
begin
	reindex(relationship_id_hash_, array(_value.Id: nil));
	reindex(relationship_target_hash_, array(_value.Target: nil));
	relationship_count_--;
end;

function Types.create(_obj: Types);
begin
	object_ := _obj;
	default_count_ := 0;
	default_extension_hash_ := array();
	_override_count_ := 0;
	_override_partname_hash_ := array();
	{self.}Init();
end;

function Types.Init();
begin
	elements := object_.Defaults();
	default_count_ := length(elements);
	for k,v in elements do
		default_extension_hash_[v.Extension] := v;
	elements := object_.Overrides();
	_override_count_ := length(elements);
	for k,v in elements do
		_override_partname_hash_[v.PartName] := v;
end;

function Types.GetDefaultByExtension(_key: string);
begin
	return default_extension_hash_[_key];
end;

function Types.AddDefault(_value: Default);
begin
	default_extension_hash_[_value.Extension] := _value;
	default_count_++;
end;

function Types.RemoveDefault(_value: Default);
begin
	reindex(default_extension_hash_, array(_value.Extension: nil));
	default_count_--;
end;

function Types.Get_OverrideByPartName(_key: string);
begin
	return _override_partname_hash_[_key];
end;

function Types.Add_Override(_value: _Override);
begin
	_override_partname_hash_[_value.PartName] := _value;
	_override_count_++;
end;

function Types.Remove_Override(_value: _Override);
begin
	reindex(_override_partname_hash_, array(_value.PartName: nil));
	_override_count_--;
end;

end.