pragma Ada_2012;
with Ada.Containers;
with Ada.Unchecked_Deallocation;
with Ada.Calendar;
with Ada.Real_Time;
with Interfaces;
private with Interfaces.C;
with Interfaces.C.Strings;
with DDS_Support;
with DDS_Support.Sequences_Generic;
with RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_trust_h;
with RTIDDS.Low_Level.ndds_dds_c_dds_c_common_h;
with RTIDDS.Low_Level.ndds_dds_c_dds_c_subscription_h;
with RTIDDS.Low_Level.ndds_ndds_config_c_h;
with RTIDDS.Low_Level.ndds_ndds_config_common_h;
with System;
with RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_h;
with RTIDDS.Low_Level.ndds_dds_c_dds_c_builtintypes_h;
with RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h;
with RTIDDS.Low_Level.ndds_dds_c_dds_c_publication_h;
with RTIDDS.Low_Level.ndds_dds_c_dds_c_sqlfilter_h;
with RTIDDS.Low_Level.ndds_dds_c_dds_c_topic_h;
with RTIDDS.Low_Level.ndds_dds_c_dds_c_domain_h;
with RTIDDS.Low_Level.ndds_dds_c_dds_c_flowcontroller_h;
with RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_impl_h;
with RTIDDS.Low_Level.ndds_dds_c_dds_c_typecode_h;
with RTIDDS.Low_Level.ndds_dds_c_dds_c_typeobject_h;
with RTIDDS.Low_Level.ndds_pres_pres_common_impl_h;
with RTIDDS.Low_Level.ndds_osapi_osapi_hash_h;
with RTIDDS.Low_Level.ndds_reda_reda_fastBuffer_h;
with RTIDDS.Low_Level.ndds_pres_pres_participant_h;
with Ada.Finalization;
pragma Ignore_Pragma (Compile_Time_Error);
pragma Elaborate_All (DDS_Support.Sequences_Generic);
package DDS is
Binding_Version : constant Standard.String := "7.2.0";
type Short is new Interfaces.C.short;
type Long is new Interfaces.C.int;
subtype Integer is Long;
subtype Natural is Integer range 0 .. Integer'Last;
subtype Positive is Integer range 1 .. Integer'Last;
type Long_Long is new Interfaces.Integer_64;
pragma Compile_Time_Error (Long_Long'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_common_h.DDS_LongLong'Size, "Long_Long'Size missmatch");
type Unsigned_Short is new Interfaces.Unsigned_16;
pragma Compile_Time_Error (Unsigned_Short'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_common_h.DDS_UnsignedShort'Size, "Unsigned_Short'Size missmatch");
type Unsigned_Long is new Interfaces.Unsigned_32;
pragma Compile_Time_Error (Unsigned_Long'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_common_h.DDS_UnsignedLong'Size, "Unsigned_Long'Size missmatch");
type Unsigned_Long_Long is new Interfaces.Unsigned_64;
pragma Compile_Time_Error (Unsigned_Long_Long'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_common_h.DDS_UnsignedLongLong'Size, "Unsigned_Long_Long'Size missmatch");
type Enum is new Interfaces.Unsigned_32;
type Float is new Interfaces.IEEE_Float_32;
type Double is new Interfaces.IEEE_Float_64;
type Long_Double is new Interfaces.IEEE_Extended_Float;
subtype Char is Standard.Character;
subtype Wchar is Standard.Wide_Character;
subtype Octet is Interfaces.Unsigned_8;
function Image (Item : Octet) return Standard.String;
INFINITE : constant := -1;
type Octets is record
Length : Integer;
Value : System.Address;
end record with Convention => C;
pragma Compile_Time_Error (Octets'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_builtintypes_h.DDS_Octets'Size, "Octets size missmatch.");
Null_Octets : constant Octets := (0, System.Null_Address);
subtype Boolean is Standard.Boolean;
type String is limited record
Data : aliased Interfaces.C.Strings.chars_ptr := Interfaces.C.Strings.Null_Ptr;
pragma Obsolescent (Data, "This is internal data and not to be referenced outside the DDS hierachy:" &
"use Operations on the whole record instead!");
end record with
Convention => C;
function Length (Item : String) return Natural;
function "=" (L : DDS.String; R : Standard.String) return Standard.Boolean;
function "=" (L : Standard.String; R : DDS.String) return Standard.Boolean;
function "&" (L : DDS.String; R : Standard.String) return Standard.String;
function "&" (L : Standard.String; R : DDS.String) return Standard.String;
procedure Append (To : in out DDS.String; Data : DDS.String);
procedure Append (To : in out DDS.String; Data : Standard.String);
procedure Prepend (To : in out DDS.String; Data : DDS.String);
procedure Prepend (To : in out DDS.String; Data : Standard.String);
type KeyedString is record
Key : DDS.String;
Value : DDS.String;
end record with Convention => C;
pragma Compile_Time_Error (KeyedString'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_builtintypes_h.DDS_KeyedString'Size, "KeyedString size missmatch.");
type KeyedOctets is record
Key : DDS.String;
Value : Octets;
end record with Convention => C;
pragma Compile_Time_Error (KeyedOctets'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_builtintypes_h.DDS_KeyedOctets'Size, "KeyedOctets size missmatch.");
NULL_STRING : constant DDS.String := (Data => Interfaces.C.Strings.Null_Ptr);
type Wchars_Ptr is access all Standard.Wide_Character
with Convention => C;
type Wide_String is limited record
Data : Wchars_Ptr;
end record with
Convention => C;
function WValue (Item : Wchars_Ptr) return Interfaces.C.char16_array;
function "+" (Left : Wchars_Ptr; Right : Interfaces.C.size_t) return Wchars_Ptr;
function Peek (From : Wchars_Ptr) return Standard.Wide_Character;
type Short_Ptr is access all Short;
type Long_Ptr is access all Long;
type Long_Long_Ptr is access all Long_Long;
type Unsigned_Short_Ptr is access all Unsigned_Short;
type Unsigned_Long_Ptr is access all Unsigned_Long;
type Unsigned_Long_Long_Ptr is access all Unsigned_Long_Long;
type Enum_Ptr is access all Enum;
type Float_Ptr is access all Float;
type Double_Ptr is access all Double;
type Long_Double_Ptr is access all Long_Double;
type Char_Ptr is access all Char;
type Wchar_Ptr is access all Wchar;
type Octet_Ptr is access all Octet;
type Octets_Ptr is access all Octets;
type Boolean_Ptr is access all Boolean;
type String_Ptr is access all String;
type KeyedString_Ptr is access all KeyedString;
type KeyedOctets_Ptr is access all KeyedOctets;
type Wide_String_Ptr is access all Wide_String;
procedure Deallocate is new Ada.Unchecked_Deallocation (Short, Short_Ptr);
procedure Deallocate is new Ada.Unchecked_Deallocation (Long, Long_Ptr);
procedure Deallocate is new Ada.Unchecked_Deallocation (Long_Long, Long_Long_Ptr);
procedure Deallocate is new Ada.Unchecked_Deallocation (Unsigned_Short, Unsigned_Short_Ptr);
procedure Deallocate is new Ada.Unchecked_Deallocation (Unsigned_Long, Unsigned_Long_Ptr);
procedure Deallocate is new Ada.Unchecked_Deallocation (Unsigned_Long_Long, Unsigned_Long_Long_Ptr);
procedure Deallocate is new Ada.Unchecked_Deallocation (Enum, Enum_Ptr);
procedure Deallocate is new Ada.Unchecked_Deallocation (Float, Float_Ptr);
procedure Deallocate is new Ada.Unchecked_Deallocation (Double, Double_Ptr);
procedure Deallocate is new Ada.Unchecked_Deallocation (Long_Double, Long_Double_Ptr);
procedure Deallocate is new Ada.Unchecked_Deallocation (Char, Char_Ptr);
procedure Deallocate is new Ada.Unchecked_Deallocation (Wchar, Wchar_Ptr);
procedure Deallocate is new Ada.Unchecked_Deallocation (Octet, Octet_Ptr);
procedure Deallocate is new Ada.Unchecked_Deallocation (Boolean, Boolean_Ptr);
procedure Deallocate is new Ada.Unchecked_Deallocation (String, String_Ptr);
procedure Deallocate is new Ada.Unchecked_Deallocation (Wide_String, Wide_String_Ptr);
DOMAIN_ID_MAX : constant := 250;
type DomainId_T is new Long range 0 .. DOMAIN_ID_MAX;
Default_Domain : constant DomainId_T := 0;
type Short_Array is array (Natural range <>) of aliased Short;
procedure Initialize (Self : in out Short);
procedure Finalize (Self : in out Short);
procedure Copy (Dst : in out Short; Src : in Short);
package Short_Seq is new DDS_Support.Sequences_Generic
(Short,
Short_Ptr,
DDS.Natural,
1,
Short_Array);
type Long_Array is array (Natural range <>) of aliased Long;
procedure Initialize (Self : in out Long);
procedure Finalize (Self : in out Long);
procedure Copy (Dst : in out Long; Src : in Long);
package Long_Seq is new DDS_Support.Sequences_Generic
(Long,
Long_Ptr,
DDS.Natural,
1,
Long_Array);
type Long_Long_Array is array (Natural range <>) of aliased Long_Long;
procedure Initialize (Self : in out Long_Long);
procedure Finalize (Self : in out Long_Long);
procedure Copy (Dst : in out Long_Long; Src : in Long_Long);
package Long_Long_Seq is new DDS_Support.Sequences_Generic
(Long_Long,
Long_Long_Ptr,
DDS.Natural,
1,
Long_Long_Array);
type Unsigned_Short_Array is array (Natural range <>) of aliased Unsigned_Short;
procedure Initialize (Self : in out Unsigned_Short);
procedure Finalize (Self : in out Unsigned_Short);
procedure Copy (Dst : in out Unsigned_Short; Src : in Unsigned_Short);
package Unsigned_Short_Seq is new DDS_Support.Sequences_Generic
(Unsigned_Short,
Unsigned_Short_Ptr,
DDS.Natural,
1,
Unsigned_Short_Array);
type Unsigned_Long_Array is array (Natural range <>) of aliased Unsigned_Long;
procedure Initialize (Self : in out Unsigned_Long);
procedure Finalize (Self : in out Unsigned_Long);
procedure Copy (Dst : in out Unsigned_Long; Src : in Unsigned_Long);
package Unsigned_Long_Seq is new DDS_Support.Sequences_Generic
(Unsigned_Long,
Unsigned_Long_Ptr,
DDS.Natural,
1,
Unsigned_Long_Array);
type Unsigned_Long_Long_Array is array (Natural range <>) of aliased Unsigned_Long_Long;
procedure Initialize (Self : in out Unsigned_Long_Long);
procedure Finalize (Self : in out Unsigned_Long_Long);
procedure Copy (Dst : in out Unsigned_Long_Long; Src : in Unsigned_Long_Long);
package Unsigned_Long_Long_Seq is new DDS_Support.Sequences_Generic
(Unsigned_Long_Long,
Unsigned_Long_Long_Ptr,
DDS.Natural,
1,
Unsigned_Long_Long_Array);
type Enum_Array is array (Natural range <>) of aliased Enum;
procedure Initialize (Self : in out Enum);
procedure Finalize (Self : in out Enum);
procedure Copy (Dst : in out Enum; Src : in Enum);
package Enum_Seq is new DDS_Support.Sequences_Generic
(Enum,
Enum_Ptr,
DDS.Natural,
1,
Enum_Array);
type Float_Array is array (Natural range <>) of aliased Float;
procedure Initialize (Self : in out Float);
procedure Finalize (Self : in out Float);
procedure Copy (Dst : in out Float; Src : in Float);
package Float_Seq is new DDS_Support.Sequences_Generic
(Float,
Float_Ptr,
DDS.Natural,
1,
Float_Array);
type Double_Array is array (Natural range <>) of aliased Double;
procedure Initialize (Self : in out Double);
procedure Finalize (Self : in out Double);
procedure Copy (Dst : in out Double; Src : in Double);
package Double_Seq is new DDS_Support.Sequences_Generic
(Double,
Double_Ptr,
DDS.Natural,
1,
Double_Array);
type Long_Double_Array is array (Natural range <>) of aliased Long_Double;
procedure Initialize (Self : in out Long_Double);
procedure Finalize (Self : in out Long_Double);
procedure Copy (Dst : in out Long_Double; Src : in Long_Double);
package Long_Double_Seq is new DDS_Support.Sequences_Generic
(Long_Double,
Long_Double_Ptr,
DDS.Natural,
1,
Long_Double_Array);
type Char_Array is array (Natural range <>) of aliased Char;
procedure Initialize (Self : in out Char);
procedure Finalize (Self : in out Char);
procedure Copy (Dst : in out Char; Src : in Char);
package Char_Seq is new DDS_Support.Sequences_Generic
(Char,
Char_Ptr,
DDS.Natural,
1,
Char_Array);
type Wchar_Array is array (Natural range <>) of aliased Wchar;
procedure Initialize (Self : in out Wchar);
procedure Finalize (Self : in out Wchar);
procedure Copy (Dst : in out Wchar; Src : in Wchar);
package Wchar_Seq is new DDS_Support.Sequences_Generic
(Wchar,
Wchar_Ptr,
DDS.Natural,
1,
Wchar_Array);
type Octet_Array is array (Natural range <>) of aliased Octet;
pragma Convention (C, Octet_Array);
procedure Initialize (Self : in out Octet);
procedure Finalize (Self : in out Octet);
procedure Copy (Dst : in out Octet; Src : in Octet);
package Octet_Seq is new DDS_Support.Sequences_Generic
(Octet,
Octet_Ptr,
DDS.Natural,
1,
Octet_Array);
function Octets_Of (Item : Octet_Array) return Octets is
(Octets'(Length => Item'Length, Value => Item (Item'First)'Address));
function Octets_Of (Item : Octet_Seq.Sequence) return Octets is
(Octets'(Length => Item.Length, Value => Item.Contiguous_Buffer.all'Address));
type Octets_Array is array (Natural range <>) of aliased Octets;
pragma Convention (C, Octets_Array);
procedure Initialize (Self : in out Octets);
procedure Finalize (Self : in out Octets);
procedure Copy (Dst : in out Octets; Src : in Octets);
package Octets_Seq is new DDS_Support.Sequences_Generic
(Octets,
Octets_Ptr,
DDS.Natural,
1,
Octets_Array);
type Boolean_Array is array (Natural range <>) of aliased Boolean;
procedure Initialize (Self : in out Boolean);
procedure Finalize (Self : in out Boolean);
procedure Copy (Dst : in out Boolean; Src : in Boolean);
package Boolean_Seq is new DDS_Support.Sequences_Generic
(Boolean,
Boolean_Ptr,
DDS.Natural,
1,
Boolean_Array);
function To_DDS_String (Source : Standard.String) return DDS.String is
(Data => Interfaces.C.Strings.New_String (Source));
function To_Standard_String (Source : DDS.String) return Standard.String;
procedure Copy (Dst : in out DDS.String; Src : in Standard.String);
procedure Copy (Dst : in out Standard.String; Src : in DDS.String);
function "=" (L, R : DDS.String) return Boolean;
type String_Array is array (Natural range <>) of aliased DDS.String;
procedure Initialize (Self : in out DDS.String);
procedure Finalize (Self : in out DDS.String);
procedure Copy (Dst : in out DDS.String; Src : in DDS.String);
package String_Seq is new DDS_Support.Sequences_Generic
(DDS.String,
String_Ptr,
DDS.Natural,
1,
String_Array);
function To_DDS_KeyedString (Key : Standard.String; Source : Standard.String) return DDS.KeyedString;
function To_Standard_String (Source : DDS.KeyedString) return Standard.String;
function Get_Key_From_KeyedString (Source : DDS.KeyedString) return Standard.String;
function "=" (L, R : DDS.KeyedString) return Boolean;
type KeyedString_Array is array (Natural range <>) of aliased DDS.KeyedString;
procedure Initialize (Self : in out DDS.KeyedString);
procedure Finalize (Self : in out DDS.KeyedString);
procedure Copy (Dst : in out DDS.KeyedString; Src : in DDS.KeyedString);
package KeyedString_Seq is new DDS_Support.Sequences_Generic
(DDS.KeyedString,
KeyedString_Ptr,
DDS.Natural,
1,
KeyedString_Array);
function KeyedString_Of (Value : DDS.String; Key : DDS.String) return KeyedString;
function KeyedString_Of (Key : DDS.String) return KeyedString;
function KeyedString_Of (Value : Standard.String; Key : Standard.String) return KeyedString;
function KeyedString_Of (Key : Standard.String) return KeyedString;
type KeyedOctets_Array is array (Natural range <>) of aliased DDS.KeyedOctets;
procedure Initialize (Self : in out DDS.KeyedOctets);
procedure Finalize (Self : in out DDS.KeyedOctets);
procedure Copy (Dst : in out DDS.KeyedOctets; Src : in DDS.KeyedOctets);
package KeyedOctets_Seq is new DDS_Support.Sequences_Generic
(DDS.KeyedOctets,
KeyedOctets_Ptr,
DDS.Natural,
1,
KeyedOctets_Array);
function KeyedOctets_Of (Key : String; Value : Octets := Null_Octets) return KeyedOctets;
function KeyedOctets_Of (Key : String; Value : Octet_Array) return KeyedOctets;
function KeyedOctets_Of (Key : String; Value : Octet_Seq.Sequence) return KeyedOctets;
generic
type Data_Type is private;
function KeyedOctets_Of_Generic (Key : String; Value : Data_Type) return KeyedOctets;
function To_DDS_Wide_String (Source : Standard.Wide_String) return DDS.Wide_String;
function To_Standard_Wide_String (Source : DDS.Wide_String) return Standard.Wide_String;
procedure Copy (Dst : in out DDS.Wide_String; Src : in Standard.Wide_String);
procedure Copy (Dst : in out Standard.Wide_String; Src : in DDS.Wide_String);
function "=" (L, R : DDS.Wide_String) return Boolean;
type Wide_String_Array is array (Natural range <>) of aliased DDS.Wide_String;
procedure Initialize (Self : in out DDS.Wide_String);
procedure Finalize (Self : in out DDS.Wide_String);
procedure Copy (Dst : in out DDS.Wide_String; Src : in DDS.Wide_String);
package Wide_String_Seq is new DDS_Support.Sequences_Generic
(DDS.Wide_String,
Wide_String_Ptr,
DDS.Natural,
1,
Wide_String_Array);
type Time_T is record
Sec : Long_Long := 0;
Nanosec : Unsigned_Long := 0;
end record with Convention => C;
function "<" (L : Time_T; R : Time_T) return Boolean;
function ">" (L : Time_T; R : Time_T) return Boolean;
function "<=" (L : Time_T; R : Time_T) return Boolean;
function ">=" (L : Time_T; R : Time_T) return Boolean;
function "+" (L : Time_T; R : Time_T) return Time_T with
Obsolescent => "Time + Time Does not make sense, but duration + duration does !";
Time_Zero : constant Time_T := (0, 0);
TIME_INVALID_SEC : constant Long_Long := -1;
TIME_INVALID_NSEC : constant Unsigned_Long := 4_294_967_295;
Time_Invalid : constant Time_T := (TIME_INVALID_SEC, TIME_INVALID_NSEC);
function Time_Is_Zero
(T : Time_T)
return Boolean;
function Time_Is_Invalid
(T : Time_T)
return Boolean;
function To_Time (T : Time_T) return Ada.Calendar.Time;
function To_Time (T : Time_T) return Ada.Real_Time.Time;
function To_Time_T (T : Ada.Calendar.Time) return Time_T;
function To_Time_T (T : Ada.Real_Time.Time) return Time_T;
type Duration_T is record
Sec : Long := 0;
Nanosec : Unsigned_Long := 0;
end record with
Convention => C;
DURATION_ZERO_SEC : constant Long := 0;
DURATION_ZERO_NSEC : constant Unsigned_Long := 0;
DURATION_ZERO : Duration_T := (DURATION_ZERO_SEC, DURATION_ZERO_NSEC);
DURATION_INFINITE_SEC : constant Long := 2_147_483_647;
DURATION_INFINITE_NSEC : constant Unsigned_Long := 4_294_967_295;
DURATION_INFINITE : constant Duration_T :=
(DURATION_INFINITE_SEC, DURATION_INFINITE_NSEC);
DURATION_AUTO_SEC : constant Long := 2_1474_83_647;
DURATION_AUTO_NSEC : constant Unsigned_Long := 0;
DURATION_AUTO : constant Duration_T :=
(DURATION_AUTO_SEC, DURATION_AUTO_NSEC);
function Duration_Is_Zero
(D : Duration_T)
return Boolean;
function Duration_Is_Infinite
(D : Duration_T)
return Boolean;
function Duration_Is_Auto
(D : Duration_T)
return Boolean;
function To_Duration (D : Duration_T) return Standard.Duration;
function To_Duration_T (D : Standard.Duration) return Duration_T;
function "+" (L : Time_T; R : Duration_T) return Time_T;
function "+" (L : Duration_T; R : Time_T) return Time_T;
function "-" (L : Time_T; R : Duration_T) return Time_T;
function "+" (L : Duration_T; R : Duration_T) return Duration_T;
function "-" (L : Duration_T; R : Duration_T) return Duration_T;
function "<" (L : Duration_T; R : Duration_T) return Boolean;
function ">" (L : Duration_T; R : Duration_T) return Boolean;
function "-" (L : Time_T; R : Time_T) return Duration_T;
type CompressionSettings_T is record
Compression_Ids : aliased Unsigned_Long := 0;
Writer_Compression_Level : aliased Unsigned_Long := 10;
Writer_Compression_Threshold : aliased Long := 0;
end record with
Convention => C;
COMPRESSION_SETTINGS_T_DEFAULT : constant CompressionSettings_T := (others => <>);
type Builtin_Topic_Key_Type_Native is new Interfaces.Unsigned_32;
type InstanceHandle_T is new RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_InstanceHandle_t;
pragma Compile_Time_Error (InstanceHandle_T'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_InstanceHandle_t'Size, "InstanceHandle_T size missmatch.");
Null_InstanceHandle_T : aliased constant InstanceHandle_T := InstanceHandle_T (RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_HANDLE_NIL);
HANDLE_NIL : aliased constant InstanceHandle_T := Null_InstanceHandle_T;
type InstanceHandle_T_Access is access all InstanceHandle_T;
type InstanceHandle_T_Array is array (Natural range <>) of aliased InstanceHandle_T;
procedure Initialize (Self : in out InstanceHandle_T);
procedure Finalize (Self : in out InstanceHandle_T);
procedure Copy (Dst : in out InstanceHandle_T; Src : in InstanceHandle_T);
package InstanceHandle_Seq is new DDS_Support.Sequences_Generic
(InstanceHandle_T,
InstanceHandle_T_Access,
DDS.Natural,
1,
InstanceHandle_T_Array);
function InstanceHandle_Equals
(Self : not null access InstanceHandle_T; Other : not null access InstanceHandle_T) return Boolean;
function "=" (Self : not null access InstanceHandle_T; Other : not null access InstanceHandle_T)
return Boolean renames InstanceHandle_Equals;
function InstanceHandle_Is_Nil
(Self : not null access InstanceHandle_T) return Boolean;
subtype GUID_T_Value_Array is Octet_Array (0 .. 15);
type Guid_T is record
Value : aliased GUID_T_Value_Array := (others => 0);
end record with Convention => C;
pragma Compile_Time_Error (DDS.Guid_T'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_GUID_t'Size, "DDS_GUID_t size mismatch");
type Guid_T_Access is access all Guid_T;
GUID_AUTO : aliased constant Guid_T := (Value => (others => 0));
GUID_UNKNOWN : Guid_T renames GUID_AUTO;
function Hash (Handle : DDS.InstanceHandle_T) return Ada.Containers.Hash_Type;
function Create (From : DDS.Guid_T) return DDS.InstanceHandle_T;
function Guid_Equals
(Self : not null Guid_T_Access;
Other : not null Guid_T_Access)
return Boolean;
function Guid_Compare
(Self : not null Guid_T_Access;
Other : not null Guid_T_Access)
return Boolean;
procedure Guid_Copy
(Self : Guid_T_Access;
Other : Guid_T_Access);
pragma Import (C, Guid_Copy, "DDS_GUID_copy");
procedure Guid_Print (Self : Guid_T_Access;
Desc : String;
Indent : Unsigned_Long);
pragma Import (C, Guid_Print, "DDS_GUID_print");
procedure Guid_Zero (Self : Guid_T_Access);
pragma Import (C, Guid_Zero, "DDS_GUID_zero");
function Image (Item : Guid_T) return DDS.String;
function Image (Item : Guid_T) return Standard.String;
function Value (Item : Standard.String) return Guid_T with
Pre => (Item'Length = GUID_T_Value_Array'Length * 2);
type SequenceNumber_T is record
High : aliased DDS.Long := 0;
Low : aliased DDS.Unsigned_Long := 0;
end record with
Convention => C;
type SequenceNumber_T_Access is access all SequenceNumber_T;
SEQUENCE_NUMBER_UNKNOWN : constant SequenceNumber_T := (High => -1, Low => 16#FFFF_FFFF#);
SEQUENCE_NUMBER_ZERO : constant SequenceNumber_T := (High => 0, Low => 0);
SEQUENCE_NUMBER_MAX : constant SequenceNumber_T := (High => 2147483647, Low => 16#FFFF_FFFF#);
AUTO_SEQUENCE_NUMBER : constant SequenceNumber_T := (High => -1, Low => 16#FFFF_FFFF#);
function "-" (L, R : SequenceNumber_T) return SequenceNumber_T;
function "+" (L, R : SequenceNumber_T) return SequenceNumber_T;
function ">" (L, R : SequenceNumber_T) return Boolean;
function "<" (L, R : SequenceNumber_T) return Boolean;
procedure Increment (Item : in out SequenceNumber_T);
procedure Decrement (Item : in out SequenceNumber_T);
function Image (Item : SequenceNumber_T) return Standard.String;
type OriginalWriterInfo_T is record
Writer_Guid : Guid_T;
Sequence_Number : SequenceNumber_T;
end record with
Convention => C;
ERROR : exception;
UNSUPPORTED : exception;
BAD_PARAMETER : exception;
PRECONDITION_NOT_MET : exception;
OUT_OF_RESOURCES : exception;
NOT_ENABLED : exception;
IMMUTABLE_POLICY : exception;
INCONSISTENT_POLICY : exception;
ALREADY_DELETED : exception;
TIMEOUT : exception;
NO_DATA : exception;
ILLEGAL_OPERATION : exception;
NOT_ALLOWED_BY_SECURITY : exception;
type ReturnCode_T is
(RETCODE_OK,
RETCODE_ERROR,
RETCODE_UNSUPPORTED,
RETCODE_BAD_PARAMETER,
RETCODE_PRECONDITION_NOT_MET,
RETCODE_OUT_OF_RESOURCES,
RETCODE_NOT_ENABLED,
RETCODE_IMMUTABLE_POLICY,
RETCODE_INCONSISTENT_POLICY,
RETCODE_ALREADY_DELETED,
RETCODE_TIMEOUT,
RETCODE_NO_DATA,
RETCODE_ILLEGAL_OPERATION,
RETCODE_NOT_ALLOWED_BY_SECURITY
) with Default_Value => RETCODE_OK;
pragma Convention (C, ReturnCode_T);
procedure Ret_Code_To_Exception (Code : ReturnCode_T; Message : Standard.String := "");
type StatusKind is new Unsigned_Long;
INCONSISTENT_TOPIC_STATUS : constant StatusKind := 2#0000_0000_0000_0001#;
OFFERED_DEADLINE_MISSED_STATUS : constant StatusKind := 2#0000_0000_0000_0010#;
REQUESTED_DEADLINE_MISSED_STATUS : constant StatusKind := 2#0000_0000_0000_0100#;
OFFERED_INCOMPATIBLE_QOS_STATUS : constant StatusKind := 2#0000_0000_0010_0000#;
REQUESTED_INCOMPATIBLE_QOS_STATUS : constant StatusKind := 2#0000_0000_0100_0000#;
SAMPLE_LOST_STATUS : constant StatusKind := 2#0000_0000_1000_0000#;
SAMPLE_REJECTED_STATUS : constant StatusKind := 2#0000_0001_0000_0000#;
DATA_ON_READERS_STATUS : constant StatusKind := 2#0000_0010_0000_0000#;
DATA_AVAILABLE_STATUS : constant StatusKind := 2#0000_0100_0000_0000#;
LIVELINESS_LOST_STATUS : constant StatusKind := 2#0000_1000_0000_0000#;
LIVELINESS_CHANGED_STATUS : constant StatusKind := 2#0001_0000_0000_0000#;
PUBLICATION_MATCH_STATUS : constant StatusKind := 2#0010_0000_0000_0000#;
SUBSCRIPTION_MATCH_STATUS : constant StatusKind := 2#0100_0000_0000_0000#;
pragma Warnings (Off);
function "+" (Left, Right : StatusKind) return StatusKind renames "or";
pragma Warnings (On);
DATA_WRITER_APPLICATION_ACKNOWLEDGMENT_STATUS : constant StatusKind :=
2#0000_0000_0100_0000_0000_0000_0000_0000#;
DATA_WRITER_INSTANCE_REPLACED_STATUS : constant StatusKind :=
2#0000_0000_1000_0000_0000_0000_0000_0000#;
RELIABLE_WRITER_CACHE_CHANGED_STATUS : constant StatusKind :=
2#0000_0001_0000_0000_0000_0000_0000_0000#;
RELIABLE_READER_ACTIVITY_CHANGED_STATUS : constant StatusKind :=
2#0000_0010_0000_0000_0000_0000_0000_0000#;
DATA_WRITER_CACHE_STATUS : constant StatusKind :=
2#0000_0100_0000_0000_0000_0000_0000_0000#;
DATA_WRITER_PROTOCOL_STATUS : constant StatusKind :=
2#0000_1000_0000_0000_0000_0000_0000_0000#;
DATA_READER_CACHE_STATUS : constant StatusKind :=
2#0001_0000_0000_0000_0000_0000_0000_0000#;
DATA_READER_PROTOCOL_STATUS : constant StatusKind :=
2#0010_0000_0000_0000_0000_0000_0000_0000#;
DATA_WRITER_DESTINATION_UNREACHABLE_STATUS : constant StatusKind :=
2#0100_0000_0000_0000_0000_0000_0000_0000#;
DATA_WRITER_SAMPLE_REMOVED_STATUS : constant StatusKind :=
2#1000_0000_0000_0000_0000_0000_0000_0000#;
subtype StatusMask is StatusKind;
STATUS_MASK_NONE : constant StatusMask := 2#0000_0000_0000_0000_0000_0000_0000_0000#;
STATUS_MASK_ALL : constant StatusMask := 2#1111_1111_1111_1111_1111_1111_1111_1111#;
type StatusKind_Access is access constant StatusKind;
type ThreadSettings is new Unsigned_Long;
subtype ThreadSettingsKindMask is ThreadSettings;
THREAD_SETTINGS_OPTION_DEFAULT : constant := 16#00#;
THREAD_SETTINGS_OPTION_FLOATING_POINT : constant := 16#01#;
THREAD_SETTINGS_OPTION_STDIO : constant := 16#02#;
THREAD_SETTINGS_OPTION_REALTIME_PRIORITY : constant := 16#08#;
THREAD_SETTINGS_OPTION_PRIORITY_ENFORCE : constant := 16#10#;
THREAD_SETTINGS_OPTION_CANCEL_ASYNCHRONOUS : constant := 16#20#;
THREAD_SETTINGS_KIND_MASK_DEFAULT : constant ThreadSettingsKindMask :=
THREAD_SETTINGS_OPTION_DEFAULT;
type ThreadSettingsCpuRotationKind_T is new Unsigned_Long;
THREAD_SETTINGS_CPU_NO_ROTATION : constant ThreadSettingsCpuRotationKind_T := 0;
THREAD_SETTINGS_CPU_RR_ROTATION : constant ThreadSettingsCpuRotationKind_T := 1;
THREAD_SETTINGS_CPU_ROTATION_DEFAULT : constant ThreadSettingsCpuRotationKind_T :=
THREAD_SETTINGS_CPU_NO_ROTATION;
type ThreadSettings_T is record
Mask : aliased ThreadSettingsKindMask := THREAD_SETTINGS_OPTION_DEFAULT;
Priority : aliased Long := -9999999;
Stack_Size : aliased Long := -1;
Cpu_List : aliased Long_Seq.Sequence;
Cpu_Rotation : aliased ThreadSettingsCpuRotationKind_T := THREAD_SETTINGS_CPU_ROTATION_DEFAULT;
end record with Convention => C;
type ThreadSettings_T_Access is access all ThreadSettings_T;
procedure ThreadSettings_T_Get_Default (Self : not null ThreadSettings_T_Access);
pragma Import (C, ThreadSettings_T_Get_Default, "DDS_ThreadSettings_get_default");
function ThreadSettings_T_Is_Equal
(Self : not null ThreadSettings_T_Access;
Other : not null ThreadSettings_T_Access)
return Boolean;
type QosPolicyId_T is new Unsigned_Long;
QOS_POLICY_COUNT : constant Long := 63;
INVALID_QOS_POLICY_ID : constant QosPolicyId_T := 0;
USERDATA_QOS_POLICY_ID : constant QosPolicyId_T := 1;
DURABILITY_QOS_POLICY_ID : constant QosPolicyId_T := 2;
PRESENTATION_QOS_POLICY_ID : constant QosPolicyId_T := 3;
DEADLINE_QOS_POLICY_ID : constant QosPolicyId_T := 4;
LATENCYBUDGET_QOS_POLICY_ID : constant QosPolicyId_T := 5;
OWNERSHIP_QOS_POLICY_ID : constant QosPolicyId_T := 6;
OWNERSHIPSTRENGTH_QOS_POLICY_ID : constant QosPolicyId_T := 7;
LIVELINESS_QOS_POLICY_ID : constant QosPolicyId_T := 8;
TIMEBASEDFILTER_QOS_POLICY_ID : constant QosPolicyId_T := 9;
PARTITION_QOS_POLICY_ID : constant QosPolicyId_T := 10;
RELIABILITY_QOS_POLICY_ID : constant QosPolicyId_T := 11;
DESTINATIONORDER_QOS_POLICY_ID : constant QosPolicyId_T := 12;
HISTORY_QOS_POLICY_ID : constant QosPolicyId_T := 13;
RESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 14;
ENTITYFACTORY_QOS_POLICY_ID : constant QosPolicyId_T := 15;
WRITERDATALIFECYCLE_QOS_POLICY_ID : constant QosPolicyId_T := 16;
READERDATALIFECYCLE_QOS_POLICY_ID : constant QosPolicyId_T := 17;
TOPICDATA_QOS_POLICY_ID : constant QosPolicyId_T := 18;
GROUPDATA_QOS_POLICY_ID : constant QosPolicyId_T := 19;
TRANSPORTPRIORITY_QOS_POLICY_ID : constant QosPolicyId_T := 20;
LIFESPAN_QOS_POLICY_ID : constant QosPolicyId_T := 21;
DURABILITYSERVICE_QOS_POLICY_ID : constant QosPolicyId_T := 22;
DATA_REPRESENTATION_QOS_POLICY_ID : constant QosPolicyId_T := 23;
TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_ID : constant QosPolicyId_T := 24;
DATATAG_QOS_POLICY_ID : constant QosPolicyId_T := 25;
WIREPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1000;
DISCOVERY_QOS_POLICY_ID : constant QosPolicyId_T := 1001;
DATAREADERRESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 1003;
DATAWRITERRESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 1004;
DATAREADERPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1005;
DATAWRITERPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1006;
DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 1007;
EVENT_QOS_POLICY_ID : constant QosPolicyId_T := 1008;
DATABASE_QOS_POLICY_ID : constant QosPolicyId_T := 1009;
RECEIVERPOOL_QOS_POLICY_ID : constant QosPolicyId_T := 1010;
DISCOVERYCONFIG_QOS_POLICY_ID : constant QosPolicyId_T := 1011;
EXCLUSIVEAREA_QOS_POLICY_ID : constant QosPolicyId_T := 1012;
USEROBJECT_QOS_POLICY_ID : constant QosPolicyId_T := 1013;
SYSTEMRESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 1014;
TRANSPORTSELECTION_QOS_POLICY_ID : constant QosPolicyId_T := 1015;
TRANSPORTUNICAST_QOS_POLICY_ID : constant QosPolicyId_T := 1016;
TRANSPORTMULTICAST_QOS_POLICY_ID : constant QosPolicyId_T := 1017;
TRANSPORTBUILTIN_QOS_POLICY_ID : constant QosPolicyId_T := 1018;
TYPESUPPORT_QOS_POLICY_ID : constant QosPolicyId_T := 1019;
PROPERTY_QOS_POLICY_ID : constant QosPolicyId_T := 1020;
PUBLISHMODE_QOS_POLICY_ID : constant QosPolicyId_T := 1021;
ASYNCHRONOUSPUBLISHER_QOS_POLICY_ID : constant QosPolicyId_T := 1022;
ENTITYNAME_QOS_POLICY_ID : constant QosPolicyId_T := 1023;
SERVICE_QOS_POLICY_ID : constant QosPolicyId_T := 1025;
BATCH_QOS_POLICY_ID : constant QosPolicyId_T := 1026;
PROFILE_QOS_POLICY_ID : constant QosPolicyId_T := 1027;
LOCATORFILTER_QOS_POLICY_ID : constant QosPolicyId_T := 1028;
MULTICHANNEL_QOS_POLICY_ID : constant QosPolicyId_T := 1029;
TRANSPORTENCAPSULATION_QOS_POLICY_ID : constant QosPolicyId_T := 1030;
PUBLISHERPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1031;
SUBSCRIBERPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1032;
TOPICPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1033;
DOMAINPARTICIPANTPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1034;
AVAILABILITY_QOS_POLICY_ID : constant QosPolicyId_T := 1035;
TRANSPORTMULTICASTMAPPING_QOS_POLICY_ID : constant QosPolicyId_T := 1036;
LOGGING_QOS_POLICY_ID : constant QosPolicyId_T := 1037;
TOPICQUERYDISPATCH_QOS_POLICY_ID : constant QosPolicyId_T := 1038;
DATAWRITERTRANSFERMODE_QOS_POLICY_ID : constant QosPolicyId_T := 1039;
type QosPolicyCount is record
Policy_Id : aliased QosPolicyId_T := INVALID_QOS_POLICY_ID;
Count : aliased Long := 0;
end record with Convention => C;
pragma Compile_Time_Error (QosPolicyCount'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_QosPolicyCount'Size, "QosPolicyCount size missmatch.");
type QosPolicyCount_Access is access all QosPolicyCount;
type QosPolicyCount_Array is array (Natural range <>) of aliased QosPolicyCount;
procedure Initialize (Self : in out QosPolicyCount);
procedure Finalize (Self : in out QosPolicyCount);
procedure Copy (Dst : in out QosPolicyCount; Src : in QosPolicyCount);
package QosPolicyCount_Seq is new DDS_Support.Sequences_Generic
(QosPolicyCount,
QosPolicyCount_Access,
DDS.Natural,
1,
QosPolicyCount_Array);
type EntityKind_T is (UNKNOWN_ENTITY_KIND,
PARTICIPANT_ENTITY_KIND,
PUBLISHER_ENTITY_KIND,
SUBSCRIBER_ENTITY_KIND,
TOPIC_ENTITY_KIND,
DATAREADER_ENTITY_KIND,
DATAWRITER_ENTITY_KIND);
pragma Annotate (EntityKind_T, Source, RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_EntityKind_t);
USERDATA_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("UserData");
type UserDataQosPolicy is limited record
Value : aliased Octet_Seq.Sequence;
end record with
Convention => C;
TOPICDATA_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TopicData");
type TopicDataQosPolicy is limited record
Value : aliased Octet_Seq.Sequence;
end record with Convention => C;
pragma Compile_Time_Error (TopicDataQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_TopicDataQosPolicy'Size, "TopicDataQosPolicy Size missmatch");
type Tags_T is limited record
Name : aliased DDS.String;
Value : aliased DDS.String;
end record with Convention => C;
type Tags_T_Access is access all Tags_T with Convention => C;
type Tags_T_Array is array
(Natural range <>) of aliased Tags_T;
procedure Initialize (Self : in out Tags_T);
procedure Finalize (Self : in out Tags_T);
procedure Copy (Dst : in out Tags_T;
Src : in Tags_T);
package Tags_Seq is new DDS_Support.Sequences_Generic
(Tags_T,
Tags_T_Access,
DDS.Natural,
1,
Tags_T_Array);
type DataTagQosPolicy is limited record
Value : aliased Tags_Seq.Sequence;
end record with Convention => C;
function Lookup_Tag
(Policy : in DataTagQosPolicy;
Name : in DDS.String) return Tags_T_Access;
procedure Assert_Tag
(Policy : in DataTagQosPolicy;
Name : in DDS.String;
Value : in DDS.String);
procedure Add_Tag
(Policy : in DataTagQosPolicy;
Name : in DDS.String;
Value : in DDS.String);
procedure Remove_Tag
(Policy : in DataTagQosPolicy;
Name : in DDS.String);
function Get_Number_Of_Tags
(Policy : in DataTagQosPolicy) return DDS.Long;
GROUPDATA_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("GroupData");
type GroupDataQosPolicy is limited record
Value : aliased Octet_Seq.Sequence;
end record with
Convention => C;
TOPICPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TopicProtocol");
type TopicProtocolQosPolicy is limited record
Vendor_Specific_Entity : Boolean := False;
end record with Convention => C;
pragma Compile_Time_Error (TopicProtocolQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_TopicProtocolQosPolicy'Size, "TopicProtocolQosPolicy size missmatch.");
TOPIC_PROTOCOL_QOS_POLICY_DEFAULT : constant TopicProtocolQosPolicy :=
(Vendor_Specific_Entity => False);
DOMAINPARTICIPANTPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DomainParticipantProtocol");
type DomainParticipantProtocolQosPolicy is limited record
Vendor_Specific_Entity : Boolean := False;
end record with
Convention => C;
DOMAIN_PARTICIPANT_PROTOCOL_QOS_POLICY_DEFAULT : constant DomainParticipantProtocolQosPolicy :=
(Vendor_Specific_Entity => False);
BUFFER_POOL_UNLIMITED : constant := RTIDDS.Low_Level.ndds_reda_reda_fastBuffer_h.REDA_FAST_BUFFER_POOL_UNLIMITED;
BUFFER_POOL_AUTO : constant := RTIDDS.Low_Level.ndds_reda_reda_fastBuffer_h.REDA_FAST_BUFFER_POOL_AUTO;
BUFFER_POOL_BUFFER_SIZE_AUTO : constant := RTIDDS.Low_Level.ndds_reda_reda_fastBuffer_h.REDA_FAST_BUFFER_POOL_BUFFER_SIZE_AUTO;
type AllocationSettings_T is record
Initial_Count : aliased Long := BUFFER_POOL_BUFFER_SIZE_AUTO;
Max_Count : aliased Long := BUFFER_POOL_BUFFER_SIZE_AUTO;
Incremental_Count : aliased Long := BUFFER_POOL_BUFFER_SIZE_AUTO;
end record with Convention => C;
pragma Compile_Time_Error (AllocationSettings_T'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_AllocationSettings_t'Size, "AllocationSettings_T size missmatch");
AllocationSettings_T_AUTO : constant AllocationSettings_T := (others => <>);
type AllocationSettings_T_Access is access all AllocationSettings_T;
function "+" (Left, Right : aliased AllocationSettings_T) return AllocationSettings_T;
DURABILITY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Durability");
type DurabilityQosPolicyKind is new Unsigned_Long;
VOLATILE_DURABILITY_QOS : constant DurabilityQosPolicyKind := 0;
TRANSIENT_LOCAL_DURABILITY_QOS : constant DurabilityQosPolicyKind := 1;
TRANSIENT_DURABILITY_QOS : constant DurabilityQosPolicyKind := 2;
PERSISTENT_DURABILITY_QOS : constant DurabilityQosPolicyKind := 3;
type PersistentJournalKind is new Unsigned_Long;
DELETE_PERSISTENT_JOURNAL : constant PersistentJournalKind := 0;
TRUNCATE_PERSISTENT_JOURNAL : constant PersistentJournalKind := 1;
PERSIST_PERSISTENT_JOURNAL : constant PersistentJournalKind := 2;
MEMORY_PERSISTENT_JOURNAL : constant PersistentJournalKind := 3;
WAL_PERSISTENT_JOURNAL : constant PersistentJournalKind := 4;
OFF_PERSISTENT_JOURNAL : constant PersistentJournalKind := 5;
type PersistentSynchronizationKind is new Unsigned_Long;
NORMAL_PERSISTENT_SYNCHRONIZATION : constant PersistentSynchronizationKind := 0;
FULL_PERSISTENT_SYNCHRONIZATION : constant PersistentSynchronizationKind := 1;
OFF_PERSISTENT_SYNCHRONIZATION : constant PersistentSynchronizationKind := 2;
type PersistentStorageSettings is record
Enable : aliased DDS.Boolean := False;
File_Name : aliased DDS.String;
Trace_File_Name : aliased DDS.String;
Journal_Kind : aliased PersistentJournalKind := WAL_PERSISTENT_JOURNAL;
Synchronization_Kind : aliased PersistentSynchronizationKind := NORMAL_PERSISTENT_SYNCHRONIZATION;
Vacuum : aliased DDS.Boolean := True;
Restore : aliased DDS.Boolean := True;
Writer_Instance_Cache_Allocation : aliased AllocationSettings_T := (-2, -2, -1);
Writer_Sample_Cache_Allocation : aliased AllocationSettings_T := (32, 32, -2);
Writer_Memory_State : aliased DDS.Boolean := True;
Reader_Checkpoint_Frequency : aliased Unsigned_Long := 1;
end record with Convention => C;
pragma Compile_Time_Error (PersistentStorageSettings'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_PersistentStorageSettings'Size, "PersistentStorageSettings size missmatch.");
PERSISTENT_STORAGE_SETTINGS_DEFAULT : constant PersistentStorageSettings := (others => <>);
type DurabilityQosPolicy is record
Kind : aliased DurabilityQosPolicyKind := VOLATILE_DURABILITY_QOS;
Direct_Communication : aliased DDS.Boolean := True;
Writer_Depth : aliased DDS.Long := 0;
Storage_Settings : aliased PersistentStorageSettings;
end record with Convention => C;
function "=" (Left, Right : DurabilityQosPolicy) return Standard.Boolean;
pragma Compile_Time_Error (DurabilityQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DurabilityQosPolicy'Size, "DurabilityQosPolicy size missmatch.");
type DurabilityQosPolicy_Access is access all DurabilityQosPolicy;
DURABILITY_QOS_POLICY_DEFAULT : constant DurabilityQosPolicy := (others => <>);
PRESENTATION_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Presentation");
type PresentationQosPolicyAccessScopeKind is new Unsigned_Long;
INSTANCE_PRESENTATION_QOS : constant PresentationQosPolicyAccessScopeKind := 0;
TOPIC_PRESENTATION_QOS : constant PresentationQosPolicyAccessScopeKind := 1;
GROUP_PRESENTATION_QOS : constant PresentationQosPolicyAccessScopeKind := 2;
HIGHEST_OFFERED_PRESENTATION_QOS : constant PresentationQosPolicyAccessScopeKind := 3;
type PresentationQosPolicy is record
Access_Scope : aliased PresentationQosPolicyAccessScopeKind := INSTANCE_PRESENTATION_QOS;
Coherent_Access : aliased DDS.Boolean := False;
Ordered_Access : aliased DDS.Boolean := False;
end record with Convention => C;
pragma Compile_Time_Error (PresentationQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_PresentationQosPolicy'Size, "PresentationQosPolicy size missmatch.");
PRESENTATION_QOS_POLICY_DEFAULT : constant PresentationQosPolicy := (others => <>);
DEADLINE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Deadline");
type DeadlineQosPolicy is record
Period : aliased Duration_T := DURATION_INFINITE;
end record with Convention => C;
pragma Compile_Time_Error (DeadlineQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DeadlineQosPolicy'Size, "DeadlineQosPolicy size missmatch.");
DEADLINE_QOS_POLICY_DEFAULT : constant DeadlineQosPolicy :=
(Period => DURATION_INFINITE);
LATENCYBUDGET_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("LatencyBudget");
type LatencyBudgetQosPolicy is record
Duration : aliased Duration_T := DURATION_ZERO;
end record with Convention => C;
pragma Compile_Time_Error (LatencyBudgetQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_LatencyBudgetQosPolicy'Size, "LatencyBudgetQosPolicy size missmatch.");
LATENCY_BUDGET_QOS_POLICY_DEFAULT : constant LatencyBudgetQosPolicy := (others => <>);
OWNERSHIP_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Ownership");
type OwnershipQosPolicyKind is new Unsigned_Long;
SHARED_OWNERSHIP_QOS : constant OwnershipQosPolicyKind := 0;
EXCLUSIVE_OWNERSHIP_QOS : constant OwnershipQosPolicyKind := 1;
type OwnershipQosPolicy is record
Kind : aliased OwnershipQosPolicyKind := SHARED_OWNERSHIP_QOS;
end record with Convention => C;
pragma Compile_Time_Error (OwnershipQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_OwnershipQosPolicy'Size, "OwnershipQosPolicy size missmatch.");
OWNERSHIP_QOS_POLICY_DEFAULT : constant OwnershipQosPolicy := (others => <>);
OWNERSHIPSTRENGTH_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("OwnershipStrength");
type OwnershipStrengthQosPolicy is record
Value : aliased Long := 0;
end record with Convention => C;
pragma Compile_Time_Error (OwnershipStrengthQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_OwnershipStrengthQosPolicy'Size, "OwnershipStrengthQosPolicy size missmatch.");
OWNERSHIP_STRENGTH_QOS_POLICY_DEFAULT : constant OwnershipStrengthQosPolicy :=
(Value => 0);
LIVELINESS_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Liveliness");
type LivelinessQosPolicyKind is new Unsigned_Long;
AUTOMATIC_LIVELINESS_QOS : constant LivelinessQosPolicyKind := 0;
MANUAL_BY_PARTICIPANT_LIVELINESS_QOS : constant LivelinessQosPolicyKind := 1;
MANUAL_BY_TOPIC_LIVELINESS_QOS : constant LivelinessQosPolicyKind := 2;
type LivelinessQosPolicy is record
Kind : aliased LivelinessQosPolicyKind := AUTOMATIC_LIVELINESS_QOS;
Lease_Duration : aliased Duration_T := DURATION_INFINITE;
Assertions_Per_Lease_Duration : aliased Long := 3;
end record with Convention => C;
pragma Compile_Time_Error (LivelinessQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_LivelinessQosPolicy'Size, "LivelinessQosPolicy size missmatch.");
LIVELINESS_QOS_POLICY_DEFAULT : constant LivelinessQosPolicy := (others => <>);
TIMEBASEDFILTER_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TimeBasedFilter");
type TimeBasedFilterQosPolicy is record
Minimum_Separation : aliased Duration_T := DURATION_ZERO;
end record with Convention => C;
pragma Compile_Time_Error (TimeBasedFilterQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_TimeBasedFilterQosPolicy'Size, "TimeBasedFilterQosPolicy size missmatch.");
TIME_BASED_FILTER_QOS_POLICY_DEFAULT : constant TimeBasedFilterQosPolicy := (others => <>);
PARTITION_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Partition");
type PartitionQosPolicy is record
Name : aliased String_Seq.Sequence;
end record with Convention => C;
pragma Compile_Time_Error (PartitionQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_PartitionQosPolicy'Size, "PartitionQosPolicy size missmatch.");
RELIABILITY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Reliability");
type ReliabilityQosPolicyKind is new Unsigned_Long;
BEST_EFFORT_RELIABILITY_QOS : constant ReliabilityQosPolicyKind := 0;
RELIABLE_RELIABILITY_QOS : constant ReliabilityQosPolicyKind := 1;
type ReliabilityQosPolicyAcknowledgmentModeKind is new Unsigned_Long;
PROTOCOL_ACKNOWLEDGMENT_MODE : constant ReliabilityQosPolicyAcknowledgmentModeKind := 0;
APPICATION_AUTO_ACKNOWLEDGMENT_MODE : constant ReliabilityQosPolicyAcknowledgmentModeKind := 1;
APPICATION_ORDERED_ACKNOWLEDGMENT_MODE : constant ReliabilityQosPolicyAcknowledgmentModeKind := 2;
APPICATION_EXPLICIT_ACKNOWLEDGMENT_MODE : constant ReliabilityQosPolicyAcknowledgmentModeKind := 3;
type InstanceStateRecoveryKind is (NO_INSTANCE_STATE_RECOVERY, RECOVER_INSTANCE_STATE_RECOVERY);
type ReliabilityQosPolicy is record
Kind : aliased ReliabilityQosPolicyKind := BEST_EFFORT_RELIABILITY_QOS;
Max_Blocking_Time : aliased Duration_T := (0, 100_000_000);
Acknowledgment_Kind : aliased ReliabilityQosPolicyAcknowledgmentModeKind := PROTOCOL_ACKNOWLEDGMENT_MODE;
Instance_State_Recovery_Kind : aliased InstanceStateRecoveryKind := NO_INSTANCE_STATE_RECOVERY;
end record with Convention => C;
pragma Compile_Time_Error (ReliabilityQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_ReliabilityQosPolicy'Size, "ReliabilityQosPolicy size missmatch.");
RELIABILITY_QOS_POLICY_DEFAULT : constant ReliabilityQosPolicy := (others => <>);
DESTINATIONORDER_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DestinationOrder");
type DestinationOrderQosPolicyKind is new Unsigned_Long;
BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS : constant DestinationOrderQosPolicyKind := 0;
BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS : constant DestinationOrderQosPolicyKind := 1;
type DestinationOrderQosPolicyScopeKind is new Unsigned_Long;
INSTANCE_SCOPE_DESTINATIONORDER_QOS : constant DestinationOrderQosPolicyScopeKind := 0;
TOPIC_SCOPE_DESTINATIONORDER_QOS : constant DestinationOrderQosPolicyScopeKind := 1;
type DestinationOrderQosPolicy is record
Kind : aliased DestinationOrderQosPolicyKind := BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS;
Scope : aliased DestinationOrderQosPolicyScopeKind := INSTANCE_SCOPE_DESTINATIONORDER_QOS;
Source_Timestamp_Tolerance : aliased Duration_T := DURATION_ZERO;
end record with Convention => C;
pragma Compile_Time_Error (DestinationOrderQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DestinationOrderQosPolicy'Size, "DestinationOrderQosPolicy size missmatch.");
DESTINATION_ORDER_QOS_POLICY_DEFAULT : constant DestinationOrderQosPolicy := (others => <>);
HISTORY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("History");
type HistoryQosPolicyKind is new Unsigned_Long;
KEEP_LAST_HISTORY_QOS : constant HistoryQosPolicyKind := 0;
KEEP_ALL_HISTORY_QOS : constant HistoryQosPolicyKind := 1;
type HistoryQosPolicy is record
Kind : aliased HistoryQosPolicyKind := KEEP_LAST_HISTORY_QOS;
Depth : aliased Long := 1;
end record with Convention => C;
pragma Compile_Time_Error (HistoryQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_HistoryQosPolicy'Size, "HistoryQosPolicy size missmatch.");
HISTORY_QOS_POLICY_DEFAULT : constant HistoryQosPolicy := (others => <>);
LENGTH_UNLIMITED : constant Long := -1;
DURABILITYSERVICE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DurabilityService");
type DurabilityServiceQosPolicy is record
Service_Cleanup_Delay : aliased Duration_T := DURATION_ZERO;
History_Kind : aliased HistoryQosPolicyKind := KEEP_LAST_HISTORY_QOS;
History_Depth : aliased Long := 1;
Max_Samples : aliased Long := LENGTH_UNLIMITED;
Max_Instances : aliased Long := LENGTH_UNLIMITED;
Max_Samples_Per_Instance : aliased Long := LENGTH_UNLIMITED;
end record with Convention => C;
pragma Compile_Time_Error (DurabilityServiceQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DurabilityServiceQosPolicy'Size, "DurabilityServiceQosPolicy size missmatch.");
DURABILITY_SERVICE_QOS_POLICY_DEFAULT : constant DurabilityServiceQosPolicy := (others => <>);
RESOURCELIMITS_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("ResourceLimits");
type ResourceLimitsQosPolicy is record
Max_Samples : aliased Long := LENGTH_UNLIMITED;
Max_Instances : aliased Long := LENGTH_UNLIMITED;
Max_Samples_Per_Instance : aliased Long := LENGTH_UNLIMITED;
Initial_Samples : aliased Long := 32;
Initial_Instances : aliased Long := 32;
Instance_Hash_Buckets : aliased Long := 32;
end record with Convention => C;
pragma Compile_Time_Error (ResourceLimitsQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_ResourceLimitsQosPolicy'Size, "ResourceLimitsQosPolicy size missmatch.");
RESOURCE_LIMITS_QOS_POLICY_DEFAULT : constant ResourceLimitsQosPolicy := (others => <>);
TRANSPORTPRIORITY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportPriority");
type TransportPriorityQosPolicy is record
Value : aliased Long := 0;
end record with Convention => C;
pragma Compile_Time_Error (TransportPriorityQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_TransportPriorityQosPolicy'Size, "TransportPriorityQosPolicy size missmatch.");
TRANSPORT_PRIORITY_QOS_POLICY_DEFAULT : constant TransportPriorityQosPolicy := (others => <>);
LIFESPAN_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Lifespan");
type LifespanQosPolicy is record
Duration : aliased Duration_T := DURATION_INFINITE;
end record with Convention => C;
pragma Compile_Time_Error (LifespanQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_LifespanQosPolicy'Size, "LifespanQosPolicy size missmatch.");
LIFESPAN_QOS_POLICY_DEFAULT : constant LifespanQosPolicy := (others => <>);
WRITERDATALIFECYCLE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("WriterDataLifecycle");
type WriterDataLifecycleQosPolicy is record
Autodispose_Unregistered_Instances : aliased DDS.Boolean := True;
Autopurge_Unregistered_Instances_Delay : aliased DDS.Duration_T := DURATION_INFINITE;
Autopurge_Disposed_Instances_Delay : aliased DDS.Duration_T := DURATION_INFINITE;
end record with Convention => C;
pragma Compile_Time_Error (WriterDataLifecycleQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_WriterDataLifecycleQosPolicy'Size, "WriterDataLifecycleQosPolicy size missmatch.");
WRITER_DATA_LIFECYCLE_QOS_POLICY_DEFAULT : constant WriterDataLifecycleQosPolicy := (others => <>);
READERDATALIFECYCLE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("ReaderDataLifecycle");
type ReaderDataLifecycleQosPolicy is record
Autopurge_Nowriter_Samples_Delay : aliased Duration_T := DURATION_INFINITE;
Autopurge_Disposed_Samples_Delay : aliased Duration_T := DURATION_INFINITE;
Autopurge_Disposed_Instances_Delay : aliased Duration_T := DURATION_INFINITE;
Autopurge_Nowriter_Instances_Delay : aliased Duration_T := DURATION_ZERO;
end record with Convention => C;
pragma Compile_Time_Error (ReaderDataLifecycleQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_ReaderDataLifecycleQosPolicy'Size, "ReaderDataLifecycleQosPolicy size missmatch.");
READER_DATA_LIFECYCLE_QOS_POLICY_DEFAULT : constant ReaderDataLifecycleQosPolicy := (others => <>);
ENTITYFACTORY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("EntityFactory");
type EntityFactoryQosPolicy is record
Autoenable_Created_Entities : aliased DDS.Boolean := True;
end record with Convention => C;
pragma Compile_Time_Error (EntityFactoryQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_EntityFactoryQosPolicy'Size, "EntityFactoryQosPolicy size missmatch.");
ENTITY_FACTORY_QOS_POLICY_DEFAULT : constant EntityFactoryQosPolicy := (others => <>);
type RtpsReliableReaderProtocol_T is record
Min_Heartbeat_Response_Delay : aliased Duration_T := (0, 0);
Max_Heartbeat_Response_Delay : aliased Duration_T := (0, 500_000_000);
Heartbeat_Suppression_Duration : aliased Duration_T := (0, 62_500_000);
Nack_Period : aliased Duration_T := (5, 0);
Receive_Window_Size : aliased Long := 256;
Round_Trip_Time : aliased Duration_T := (0, 0);
App_Ack_Period : aliased Duration_T := (5, 0);
Min_App_Ack_Response_Keep_Duration : aliased Duration_T := (0, 0);
Samples_Per_App_Ack : aliased Long := 1;
end record with Convention => C;
pragma Compile_Time_Error (RtpsReliableReaderProtocol_T'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_RtpsReliableReaderProtocol_t'Size, "DDS_RtpsReliableReaderProtocol_t size missmatch");
RTPS_RELIABLE_READER_PROTOCOL_DEFAULT : aliased constant RtpsReliableReaderProtocol_T := (others => <>);
RTPS_RELIABLE_READER_PROTOCOL_DISCOVERY_CONFIG_DEFAULT :
aliased constant RtpsReliableReaderProtocol_T := (Max_Heartbeat_Response_Delay => (0, 0),
others => <>);
RTPS_PARTICIPANT_MESSAGE_READER_DISCOVERY_CONFIG_DEFAULT :
aliased constant RtpsReliableReaderProtocol_T := (Max_Heartbeat_Response_Delay => (0, 0),
others => <>);
type RtpsReliableWriterProtocol_T is record
Low_Watermark : aliased Long := 0;
High_Watermark : aliased Long := 1;
Heartbeat_Period : aliased Duration_T := (3, 0);
Fast_Heartbeat_Period : aliased Duration_T := (3, 0);
Late_Joiner_Heartbeat_Period : aliased Duration_T := (3, 0);
Virtual_Heartbeat_Period : aliased Duration_T := DURATION_INFINITE;
Samples_Per_Virtual_Heartbeat : aliased Long := -1;
Max_Heartbeat_Retries : aliased Long := 10;
Inactivate_Nonprogressing_Readers : aliased Boolean := False;
Heartbeats_Per_Max_Samples : aliased Long := 8;
Min_Nack_Response_Delay : aliased Duration_T := (0, 0);
Max_Nack_Response_Delay : aliased Duration_T := (0, 200_000_000);
Nack_Suppression_Duration : aliased Duration_T := (0, 0);
Max_Bytes_Per_Nack_Response : aliased Long := 131072;
Disable_Positive_Acks_Min_Sample_Keep_Duration : aliased Duration_T := (0, 1_000_000);
Disable_Positive_Acks_Max_Sample_Keep_Duration : aliased Duration_T := (1, 0);
Disable_Positive_Acks_Sample_Min_Separation : aliased Duration_T := (0, 1_000_000);
Disable_Positive_Acks_Enable_Adaptive_Sample_Keep_Duration : aliased Boolean := True;
Disable_Positive_Acks_Enable_Spin_Wait : aliased Boolean := False;
Disable_Positive_Acks_Decrease_Sample_Keep_Duration_Factor : aliased Long := 0;
Disable_Positive_Acks_Increase_Sample_Keep_Duration_Factor : aliased Long := 3;
Min_Send_Window_Size : aliased Long := 32;
Max_Send_Window_Size : aliased Long := 256;
Send_Window_Update_Period : aliased Duration_T := (3, 0);
Send_Window_Increase_Factor : aliased Long := 105;
Send_Window_Decrease_Factor : aliased Long := 70;
Enable_Multicast_Periodic_Heartbeat : aliased Boolean := False;
Multicast_Resend_Threshold : aliased Long := 2;
Disable_Repair_Piggyback_Heartbeat : aliased Boolean := False;
end record with Convention => C;
RTPS_RELIABLE_WRITER_PROTOCOL_DEFAULT : constant RtpsReliableWriterProtocol_T := (others => <>);
RTPS_RELIABLE_WRITER_PROTOCOL_DISCOVERY_CONFIG_DEFAULT : constant RtpsReliableWriterProtocol_T := (others => <>);
RTPS_PARTICIPANT_MESSAGE_WRITER_DISCOVERY_CONFIG_DEFAULT :
constant RtpsReliableWriterProtocol_T := (Low_Watermark => 0,
High_Watermark => 1,
Heartbeat_Period => (1, 0),
Fast_Heartbeat_Period => (1, 0),
Late_Joiner_Heartbeat_Period => (1, 0),
Virtual_Heartbeat_Period => DURATION_INFINITE,
Samples_Per_Virtual_Heartbeat => -1,
Max_Heartbeat_Retries => 10,
Inactivate_Nonprogressing_Readers => False,
Heartbeats_Per_Max_Samples => 1,
Min_Nack_Response_Delay => (0, 0),
Max_Nack_Response_Delay => (0, 0),
Nack_Suppression_Duration => (0, 0),
Max_Bytes_Per_Nack_Response => 9216,
Disable_Positive_Acks_Min_Sample_Keep_Duration => (0, 1_000_000),
Disable_Positive_Acks_Max_Sample_Keep_Duration => (1, 0),
Disable_Positive_Acks_Sample_Min_Separation => (0, 100_000),
Disable_Positive_Acks_Enable_Adaptive_Sample_Keep_Duration => True,
Disable_Positive_Acks_Enable_Spin_Wait => False,
Disable_Positive_Acks_Decrease_Sample_Keep_Duration_Factor => 95,
Disable_Positive_Acks_Increase_Sample_Keep_Duration_Factor => 150,
Min_Send_Window_Size => -1,
Max_Send_Window_Size => -1,
Send_Window_Update_Period => (1, 0),
Send_Window_Increase_Factor => 105,
Send_Window_Decrease_Factor => 50,
Enable_Multicast_Periodic_Heartbeat => False,
Multicast_Resend_Threshold => 2,
Disable_Repair_Piggyback_Heartbeat => False
);
type UserObjectSettings_T is record
Size : aliased Long := 0;
Alignment : aliased Long := 0;
end record with
Convention => C;
type TransportUnicastSettings_T is record
Transports : aliased String_Seq.Sequence;
Receive_Port : aliased Long := 0;
end record with
Convention => C;
type TransportUnicastSettings_T_Access is access all TransportUnicastSettings_T;
type TransportUnicastSettings_T_Array is array
(Natural range <>) of aliased TransportUnicastSettings_T;
procedure Initialize (Self : in out TransportUnicastSettings_T);
procedure Finalize (Self : in out TransportUnicastSettings_T);
procedure Copy (Dst : in out TransportUnicastSettings_T;
Src : in TransportUnicastSettings_T);
package TransportUnicastSettings_Seq is new DDS_Support.Sequences_Generic
(TransportUnicastSettings_T,
TransportUnicastSettings_T_Access,
DDS.Natural,
1,
TransportUnicastSettings_T_Array);
type TransportMulticastSettings_T is record
Transports : DDS.String_Seq.Sequence;
Receive_Address : DDS.String;
Receive_Port : Long := 0;
end record with
Convention => C;
TRANSPORT_MULTICAST_LOCATORS_DEFAULT : constant TransportMulticastSettings_T := (others => <>);
type TransportMulticastSettings_T_Access is access all TransportMulticastSettings_T;
type TransportMulticastSettings_T_Array is array
(Natural range <>) of aliased TransportMulticastSettings_T;
procedure Initialize (Self : in out TransportMulticastSettings_T);
procedure Finalize (Self : in out TransportMulticastSettings_T);
procedure Copy (Dst : in out TransportMulticastSettings_T;
Src : in TransportMulticastSettings_T);
package TransportMulticastSettings_Seq is new DDS_Support.Sequences_Generic
(TransportMulticastSettings_T,
TransportMulticastSettings_T_Access,
DDS.Natural,
1,
TransportMulticastSettings_T_Array);
type TransportMulticastMappingFunction_T is record
Dll : DDS.String;
Function_Name : DDS.String;
end record with
Convention => C;
TRANSPORT_MULTICAST_MAPPING_FUNCTION_DEFAULT : constant TransportMulticastMappingFunction_T := (others => <>);
type TransportMulticastMapping_T is record
Addresses : DDS.String;
Topic_Expression : DDS.String;
Mapping_Function : TransportMulticastMappingFunction_T;
end record with
Convention => C;
TRANSPORT_MULTICAST_MAPPING_DEFAULT : constant TransportMulticastMapping_T := (others => <>);
type TransportMulticastMapping_T_Access is access all TransportMulticastMapping_T;
type TransportMulticastMapping_T_Array is array
(Natural range <>) of aliased TransportMulticastMapping_T;
procedure Initialize (Self : in out TransportMulticastMapping_T);
procedure Finalize (Self : in out TransportMulticastMapping_T);
procedure Copy (Dst : in out TransportMulticastMapping_T;
Src : in TransportMulticastMapping_T);
package TransportMulticastMapping_Seq is new DDS_Support.Sequences_Generic
(TransportMulticastMapping_T,
TransportMulticastMapping_T_Access,
DDS.Natural,
1,
TransportMulticastMapping_T_Array);
type EncapsulationId_T is new Unsigned_Short;
type EncapsulationId_T_Access is access all EncapsulationId_T;
type EncapsulationId_T_Array is array
(Natural range <>) of aliased EncapsulationId_T;
procedure Initialize (Self : in out EncapsulationId_T);
procedure Finalize (Self : in out EncapsulationId_T);
procedure Copy (Dst : in out EncapsulationId_T;
Src : in EncapsulationId_T);
package EncapsulationId_Seq is new DDS_Support.Sequences_Generic
(EncapsulationId_T,
EncapsulationId_T_Access,
DDS.Natural,
1,
EncapsulationId_T_Array);
ENCAPSULATION_ID_CDR_BE : constant EncapsulationId_T := 0;
ENCAPSULATION_ID_CDR_LE : constant EncapsulationId_T := 1;
ENCAPSULATION_ID_CDR_NATIVE : constant EncapsulationId_T := System.Bit_Order'Pos (System.Default_Bit_Order);
ENCAPSULATION_ID_CDR2_BE : constant EncapsulationId_T := 0;
ENCAPSULATION_ID_CDR2_LE : constant EncapsulationId_T := 1;
ENCAPSULATION_ID_CDR2_NATIVE : constant EncapsulationId_T := System.Bit_Order'Pos (System.Default_Bit_Order);
ENCAPSULATION_ID_SHMEM_REF_PLAIN : EncapsulationId_T := 16#C000#;
ENCAPSULATION_ID_SHMEM_REF_FLAT_DATA : EncapsulationId_T := 16#C001#;
type TransportEncapsulationSettings_T is record
Transports : aliased DDS.String_Seq.Sequence;
Encapsulations : aliased EncapsulationId_Seq.Sequence;
end record with
Convention => C;
type TransportEncapsulationSettings_T_Access is access all TransportEncapsulationSettings_T;
type TransportEncapsulationSettings_T_Array is array
(Natural range <>) of aliased TransportEncapsulationSettings_T;
procedure Initialize (Self : in out TransportEncapsulationSettings_T);
procedure Finalize (Self : in out TransportEncapsulationSettings_T);
procedure Copy (Dst : in out TransportEncapsulationSettings_T;
Src : in TransportEncapsulationSettings_T);
package TransportEncapsulationSettings_Seq is new DDS_Support.Sequences_Generic
(TransportEncapsulationSettings_T,
TransportEncapsulationSettings_T_Access,
DDS.Natural,
1,
TransportEncapsulationSettings_T_Array);
type DataRepresentationId_T is new RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DataRepresentationId_t
with Convention => C;
XCDR_DATA_REPRESENTATION : aliased constant DataRepresentationId_T :=
DataRepresentationId_T (RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_XCDR_DATA_REPRESENTATION);
XML_DATA_REPRESENTATION : aliased constant DataRepresentationId_T :=
DataRepresentationId_T (RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_XML_DATA_REPRESENTATION);
XCDR2_DATA_REPRESENTATION : aliased constant DataRepresentationId_T :=
DataRepresentationId_T (RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_XCDR2_DATA_REPRESENTATION);
AUTO_DATA_REPRESENTATION : aliased constant DataRepresentationId_T :=
DataRepresentationId_T (RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_XCDR2_DATA_REPRESENTATION);
type DataRepresentationId_T_Access is access all DataRepresentationId_T;
type DataRepresentationId_T_Array is array
(Natural range <>) of aliased DataRepresentationId_T;
procedure Initialize (Self : in out DataRepresentationId_T);
procedure Finalize (Self : in out DataRepresentationId_T);
procedure Copy (Dst : in out DataRepresentationId_T;
Src : in DataRepresentationId_T);
package DataRepresentationId_Seq is new DDS_Support.Sequences_Generic
(DataRepresentationId_T,
DataRepresentationId_T_Access,
DDS.Natural,
1,
DataRepresentationId_T_Array);
type DataRepresentationQosPolicy is limited record
Value : aliased DataRepresentationId_Seq.Sequence;
Compression_Settings : aliased CompressionSettings_T := COMPRESSION_SETTINGS_T_DEFAULT;
end record with Convention => C;
pragma Compile_Time_Error (DataRepresentationQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DataRepresentationQosPolicy'Size, "DataRepresentationQosPolicy size missmatch.");
function Contains
(Policy : in DataRepresentationQosPolicy;
Id : in DataRepresentationId_T) return Standard.Boolean;
function Equals
(Left, Right : in DataRepresentationQosPolicy) return Standard.Boolean;
function "="
(Left, Right : in DataRepresentationQosPolicy) return Standard.Boolean
renames Equals;
function Get_Native_Encapsulation
(Id : in DataRepresentationId_T) return EncapsulationId_T;
pragma Import (C, Get_Native_Encapsulation, "DDS_DataRepresentationQosPolicy_getNativeEncapsulation");
TRANSPORTSELECTION_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportSelection");
type TransportSelectionQosPolicy is record
Enabled_Transports : aliased DDS.String_Seq.Sequence := DDS.String_Seq.DEFAULT_SEQUENCE;
end record with Convention => C;
pragma Compile_Time_Error (TransportSelectionQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_TransportSelectionQosPolicy'Size, "TransportSelectionQosPolicy size missmatch.");
TRANSPORT_SELECTION_QOS_POLICY_DEFAULT : constant TransportSelectionQosPolicy := (others => <>);
TRANSPORTUNICAST_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportUnicast");
type TransportUnicastQosPolicy is record
Value : TransportUnicastSettings_Seq.Sequence;
end record with Convention => C;
pragma Compile_Time_Error (TransportUnicastQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_TransportUnicastQosPolicy'Size, "TransportUnicastQosPolicy size missmatch.");
TRANSPORT_UNICAST_QOS_POLICY_DEFAULT : constant TransportUnicastQosPolicy := (others => <>);
TRANSPORTMULTICAST_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportMulticast");
type TransportMulticastQosPolicyKind is new Unsigned_Long;
AUTOMATIC_TRANSPORT_MULTICAST_QOS : constant TransportMulticastQosPolicyKind := 0;
UNICAST_ONLY_TRANSPORT_MULTICAST_QOS : constant TransportMulticastQosPolicyKind := 1;
type TransportMulticastQosPolicy is record
Value : TransportMulticastSettings_Seq.Sequence := TransportMulticastSettings_Seq.DEFAULT_SEQUENCE;
Kind : TransportMulticastQosPolicyKind := AUTOMATIC_TRANSPORT_MULTICAST_QOS;
end record with Convention => C;
pragma Compile_Time_Error (TransportMulticastQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_TransportMulticastQosPolicy'Size, "TransportMulticastQosPolicy size missmatch.");
TRANSPORTMULTICASTMAPPING_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportMulticastMapping");
type TransportMulticastMappingQosPolicy is record
Value : TransportMulticastMapping_Seq.Sequence;
end record with Convention => C;
pragma Compile_Time_Error (TransportMulticastMappingQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_TransportMulticastMappingQosPolicy'Size, "TransportMulticastMappingQosPolicy size missmatch.");
TRANSPORTENCAPSULATION_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportEncapsulation");
type TransportEncapsulationQosPolicy is record
Value : aliased TransportEncapsulationSettings_Seq.Sequence;
end record with Convention => C;
pragma Compile_Time_Error (TransportEncapsulationQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_TransportEncapsulationQosPolicy'Size, "TransportEncapsulationQosPolicy size missmatch.");
DISCOVERY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Discovery");
type DiscoveryQosPolicy is record
Enabled_Transports : aliased String_Seq.Sequence;
Initial_Peers : aliased String_Seq.Sequence;
Multicast_Receive_Addresses : aliased String_Seq.Sequence;
Metatraffic_Transport_Priority : aliased Long := 0;
Accept_Unknown_Peers : aliased DDS.Boolean := True;
Enable_Endpoint_Discovery : aliased DDS.Boolean := True;
end record with
Convention => C;
DISCOVERY_QOS_POLICY_DEFAULT : constant DiscoveryQosPolicy := (others => <>);
type Discovery_ParticipantInformation is record
Participant_Discovery_Id : aliased Long := 0;
Participant_Discovery_Version : aliased Long := 0;
Participant_Discovery_Vendor_Id : aliased Long := 0;
Participant_Discovery_Parameters : aliased Octet_Seq.Sequence;
end record with
Convention => C;
type Discovery_ParticipantInformation_Access is access all Discovery_ParticipantInformation;
type Discovery_ParticipantInformation_Array is array
(Natural range <>) of aliased Discovery_ParticipantInformation;
procedure Initialize (Self : in out Discovery_ParticipantInformation);
procedure Finalize (Self : in out Discovery_ParticipantInformation);
procedure Copy (Dst : in out Discovery_ParticipantInformation;
Src : in Discovery_ParticipantInformation);
package Discovery_ParticipantInformationSeq is new DDS_Support.Sequences_Generic
(Discovery_ParticipantInformation,
Discovery_ParticipantInformation_Access,
DDS.Natural,
1,
Discovery_ParticipantInformation_Array);
type Discovery_EndpointInformation is record
Endpoint_Discovery_Id : aliased Long := 0;
Endpoint_Discovery_Version : aliased Long := 0;
Endpoint_Discovery_Vendor_Id : aliased Long := 0;
Endpoint_Discovery_Parameters : aliased Octet_Seq.Sequence;
end record with Convention => C;
pragma Compile_Time_Error (Discovery_EndpointInformation'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_Discovery_EndpointInformation'Size, "Discovery_EndpointInformation size missmatch.");
type Discovery_EndpointInformation_Access is access all Discovery_EndpointInformation;
type Discovery_EndpointInformation_Array is array
(Natural range <>) of aliased Discovery_EndpointInformation;
procedure Initialize (Self : in out Discovery_EndpointInformation);
procedure Finalize (Self : in out Discovery_EndpointInformation);
procedure Copy (Dst : in out Discovery_EndpointInformation;
Src : in Discovery_EndpointInformation);
package Discovery_EndpointInformationSeq is new DDS_Support.Sequences_Generic
(Discovery_EndpointInformation,
Discovery_EndpointInformation_Access,
DDS.Natural,
1,
Discovery_EndpointInformation_Array);
TRANSPORTBUILTIN_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportBuiltin");
type TransportBuiltinKind is new Unsigned_Long;
TRANSPORTBUILTIN_UDPv4 : constant TransportBuiltinKind := 2 ** 0;
TRANSPORTBUILTIN_SHMEM : constant TransportBuiltinKind := 2 ** 1;
TRANSPORTBUILTIN_INTRA : constant TransportBuiltinKind := 2 ** 2;
TRANSPORTBUILTIN_UDPv6 : constant TransportBuiltinKind := 2 ** 3;
TRANSPORTBUILTIN_INTRA_ALIAS : constant DDS.String := To_DDS_String ("builtin.intra");
TRANSPORTBUILTIN_SHMEM_ALIAS : constant DDS.String := To_DDS_String ("builtin.shmem");
TRANSPORTBUILTIN_UDPv4_ALIAS : constant DDS.String := To_DDS_String ("builtin.udpv4");
TRANSPORTBUILTIN_UDPv6_ALIAS : constant DDS.String := To_DDS_String ("builtin.udpv");
subtype TransportBuiltinKindMask is TransportBuiltinKind;
TRANSPORTBUILTIN_MASK_NONE : constant TransportBuiltinKindMask := 0;
TRANSPORTBUILTIN_MASK_DEFAULT : constant TransportBuiltinKindMask :=
(TRANSPORTBUILTIN_UDPv4 or TRANSPORTBUILTIN_SHMEM);
TRANSPORTBUILTIN_MASK_ALL : constant TransportBuiltinKindMask := 16#FFFF_FFFF#;
type TransportBuiltinQosPolicy is record
Mask : TransportBuiltinKindMask;
end record with Convention => C;
pragma Compile_Time_Error (TransportBuiltinQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_TransportBuiltinQosPolicy'Size, "TransportBuiltinQosPolicy size missmatch.");
TRANSPORT_BUILTIN_QOS_POLICY_DEFAULT : constant TransportBuiltinQosPolicy :=
(Mask => TRANSPORTBUILTIN_MASK_DEFAULT);
type RtpsWellKnownPorts_T is record
Port_Base : aliased Long := 7400;
Domain_Id_Gain : aliased Long := 10;
Participant_Id_Gain : aliased Long := 1000;
Builtin_Multicast_Port_Offset : aliased Long := 2;
Builtin_Unicast_Port_Offset : aliased Long := 0;
User_Multicast_Port_Offset : aliased Long := 1;
User_Unicast_Port_Offset : aliased Long := 3;
end record with
Convention => C;
RTI_BACKWARDS_COMPATIBLE_RTPS_WELL_KNOWN_PORTS : constant RtpsWellKnownPorts_T := (others => <>);
INTEROPERABLE_RTPS_WELL_KNOWN_PORTS : constant RtpsWellKnownPorts_T
:= (Domain_Id_Gain => 250,
Builtin_Unicast_Port_Offset => 10,
User_Unicast_Port_Offset => 11,
others => <>);
RTPS_WELL_KNOWN_PORTS_DEFAULT : constant RtpsWellKnownPorts_T := (others => <>);
type RtpsReservedPortKind is new Unsigned_Long;
RTPS_RESERVED_PORT_BUILTIN_UNICAST : constant RtpsReservedPortKind := 2#0001#;
RTPS_RESERVED_PORT_BUILTIN_MULTICAST : constant RtpsReservedPortKind := 2#0010#;
RTPS_RESERVED_PORT_USER_UNICAST : constant RtpsReservedPortKind := 2#0100#;
RTPS_RESERVED_PORT_USER_MULTICAST : constant RtpsReservedPortKind := 2#1000#;
subtype RtpsReservedPortKindMask is RtpsReservedPortKind;
RTPS_RESERVED_PORT_MASK_DEFAULT : constant RtpsReservedPortKindMask :=
(RTPS_RESERVED_PORT_BUILTIN_UNICAST or RTPS_RESERVED_PORT_BUILTIN_MULTICAST or
RTPS_RESERVED_PORT_USER_UNICAST);
RTPS_RESERVED_PORT_MASK_NONE : constant RtpsReservedPortKindMask := 0;
RTPS_RESERVED_PORT_MASK_ALL : constant RtpsReservedPortKindMask := 16#FFFF_FFFF#;
WIREPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("WireProtocol");
type WireProtocolQosPolicyAutoKind is new Unsigned_Long;
RTPS_AUTO_ID_FROM_IP : constant WireProtocolQosPolicyAutoKind := 0;
RTPS_AUTO_ID_FROM_MAC : constant WireProtocolQosPolicyAutoKind := 1;
RTPS_AUTO_ID : constant Unsigned_Long := 0;
type WireProtocolQosPolicy is record
Participant_Id : aliased Long := -1;
Rtps_Host_Id : aliased Unsigned_Long := RTPS_AUTO_ID;
Rtps_App_Id : aliased Unsigned_Long := RTPS_AUTO_ID;
Rtps_Instance_Id : aliased Unsigned_Long := RTPS_AUTO_ID;
Rtps_Well_Known_Ports : aliased RtpsWellKnownPorts_T := RTPS_WELL_KNOWN_PORTS_DEFAULT;
Rtps_Reserved_Port_Mask : aliased Long := 0;
Rtps_Auto_Id_Kind : aliased WireProtocolQosPolicyAutoKind := RTPS_AUTO_ID_FROM_IP;
Compute_Crc : aliased Boolean := False;
Check_Crc : aliased Boolean := False;
end record with Convention => C;
pragma Compile_Time_Error (WireProtocolQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_WireProtocolQosPolicy'Size, "WireProtocolQosPolicy size missmatch.");
WIRE_PROTOCOL_QOS_POLICY_DEFAULT : constant WireProtocolQosPolicy := (others => <>);
LOCATOR_ADDRESS_LENGTH_MAX : constant Unsigned_Long := 16;
type Locator_Address_Array_T is array (0 .. LOCATOR_ADDRESS_LENGTH_MAX - 1) of Octet;
type Locator_T is record
Kind : aliased Long := 0;
Port : aliased Unsigned_Long := 0;
Address : aliased Locator_Address_Array_T := (others => 0);
Encapsulations : aliased EncapsulationId_Seq.Sequence;
end record with
Convention => C;
type Locator_T_Access is access all Locator_T;
type Locator_T_Array is array (Natural range <>) of aliased Locator_T;
procedure Initialize (Self : in out Locator_T);
procedure Finalize (Self : in out Locator_T);
procedure Copy (Dst : in out Locator_T; Src : in Locator_T);
package Locator_Seq is new DDS_Support.Sequences_Generic
(Locator_T,
Locator_T_Access,
DDS.Natural,
1,
Locator_T_Array);
LOCATOR_INVALID : constant Locator_T :=
(Kind => -1,
Port => 0,
Address => (others => 00),
Encapsulations => EncapsulationId_Seq.DEFAULT_SEQUENCE);
LOCATOR_KIND_INVALID : constant Long := -1;
LOCATOR_PORT_INVALID : constant Unsigned_Long := 0;
LOCATOR_ADDRESS_INVALID : constant Locator_Address_Array_T := (others => 0);
LOCATOR_KIND_ANY : constant Long := 0;
LOCATOR_KIND_UDPv4 : constant Long := 1;
LOCATOR_KIND_SHMEM : constant Long := 2;
LOCATOR_KIND_INTRA : constant Long := 3;
LOCATOR_KIND_UDPv6 : constant Long := 5;
LOCATOR_KIND_DTLS : constant Long := 6;
LOCATOR_KIND_WAN : constant Long := 7;
LOCATOR_KIND_TCPV4_LAN : constant Long := 8;
LOCATOR_KIND_TCPV4_WAN : constant Long := 9;
LOCATOR_KIND_TLSV4_LAN : constant Long := 10;
LOCATOR_KIND_TLSV4_WAN : constant Long := 11;
LOCATOR_KIND_RESERVED : constant Long := 1000;
type ProtocolVersion_T is record
Major : aliased Octet := 0;
Minor : aliased Octet := 0;
end record with
Convention => C;
PROTOCOL_VERSION_DEFAULT : constant ProtocolVersion_T := (others => <>);
PROTOCOLVERSION_1_0 : constant ProtocolVersion_T :=
(Major => 1,
Minor => 0);
PROTOCOLVERSION_1_1 : constant ProtocolVersion_T :=
(Major => 1,
Minor => 1);
PROTOCOLVERSION_1_2 : constant ProtocolVersion_T :=
(Major => 1,
Minor => 2);
PROTOCOLVERSION_2_0 : constant ProtocolVersion_T :=
(Major => 2,
Minor => 0);
PROTOCOLVERSION_2_1 : constant ProtocolVersion_T :=
(Major => 2,
Minor => 1);
PROTOCOLVERSION : constant ProtocolVersion_T :=
(Major => 2,
Minor => 1);
VENDOR_ID_LENGTH_MAX : constant := 2;
type VendorId_Array_T is array (0 .. VENDOR_ID_LENGTH_MAX - 1) of Octet;
type VendorId_T is record
VendorId : aliased VendorId_Array_T := (others => 0);
end record with
Convention => C;
VENDOR_ID_DEFAULT : constant VendorId_T := (VendorId => (0, 0));
VENDORID_UNKNOWN : constant VendorId_T := (VendorId => (0, 0));
type ProductVersion_T is record
Major : aliased Char := Char (ASCII.NUL);
Minor : aliased Char := Char (ASCII.NUL);
Release : aliased Char := '0';
Revision : aliased Char := Char (ASCII.NUL);
end record with
Convention => C;
PRODUCTVERSION_UNKNOWN : constant ProductVersion_T := (others => <>);
type DataReaderResourceLimitsInstanceReplacementSettings is record
Alive_Instance_Removal : aliased Unsigned_Long := 0;
Disposed_Instance_Removal : aliased Unsigned_Long := 0;
No_Writers_Instance_Removal : aliased Unsigned_Long := 1;
end record with
Convention => C;
DATAREADER_RESOURCELIMITS_INSTANCEREPLACEMENT_SETTINGS_DEFAULT : constant
DataReaderResourceLimitsInstanceReplacementSettings := (others => <>);
DATAREADERRESOURCELIMITS_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DataReaderResourceLimits");
type DataReaderResourceLimitsQosPolicy is record
Max_Remote_Writers : aliased Long := -1;
Max_Remote_Writers_Per_Instance : aliased Long := -1;
Max_Samples_Per_Remote_Writer : aliased Long := -1;
Max_Infos : aliased Long := -1;
Initial_Remote_Writers : aliased Long := 2;
Initial_Remote_Writers_Per_Instance : aliased Long := 2;
Initial_Infos : aliased Long := 32;
Initial_Outstanding_Reads : aliased Long := 2;
Max_Outstanding_Reads : aliased Long := -1;
Max_Samples_Per_Read : aliased Long := 1024;
Disable_Fragmentation_Support : aliased DDS.Boolean := False;
Max_Fragmented_Samples : aliased Long := 1024;
Initial_Fragmented_Samples : aliased Long := 4;
Max_Fragmented_Samples_Per_Remote_Writer : aliased Long := 256;
Max_Fragments_Per_Sample : aliased Long := 512;
Dynamically_Allocate_Fragmented_Samples : aliased DDS.Boolean := False;
Max_Total_Instances : aliased Long := 32;
Max_Remote_Virtual_Writers : aliased Long := -1;
Initial_Remote_Virtual_Writers : aliased Long := 2;
Max_Remote_Virtual_Writers_Per_Instance : aliased Long := -1;
Initial_Remote_Virtual_Writers_Per_Instance : aliased Long := 2;
Max_Remote_Writers_Per_Sample : aliased Long := 3;
Max_Query_Condition_Filters : aliased Long := 4;
Max_App_Ack_Response_Length : aliased Long := 1;
Keep_Minimum_State_For_Instances : aliased DDS.Boolean := True;
Initial_Topic_Queries : aliased Long := 1;
Max_Topic_Queries : aliased Long := -1;
Shmem_Ref_Transfer_Mode_Attached_Segment_Allocation : aliased AllocationSettings_T := AllocationSettings_T_AUTO;
Instance_Replacement : aliased DataReaderResourceLimitsInstanceReplacementSettings := DATAREADER_RESOURCELIMITS_INSTANCEREPLACEMENT_SETTINGS_DEFAULT;
Autopurge_Remote_Not_Alive_Writer_Delay : aliased Duration_T := DURATION_AUTO;
Autopurge_Remote_Virtual_Writer_Delay : aliased Duration_T := DURATION_INFINITE;
end record with Convention => C;
pragma Compile_Time_Error (DataReaderResourceLimitsQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DataReaderResourceLimitsQosPolicy'Size, "DataReaderResourceLimitsQosPolicy size missmatch.");
AUTO_MAX_TOTAL_INSTANCES : constant Long := 0;
DATA_READER_RESOURCE_LIMITS_QOS_POLICY_DEFAULT : constant DataReaderResourceLimitsQosPolicy := (others => <>);
DATAWRITERRESOURCELIMITS_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DataWriterResourceLimits");
type DataWriterResourceLimitsInstanceReplacementKind is new Unsigned_Long;
UNREGISTERED_INSTANCE_REPLACEMENT : constant DataWriterResourceLimitsInstanceReplacementKind := 0;
ALIVE_INSTANCE_REPLACEMENT : constant DataWriterResourceLimitsInstanceReplacementKind := 1;
DISPOSED_INSTANCE_REPLACEMENT : constant DataWriterResourceLimitsInstanceReplacementKind := 2;
ALIVE_THEN_DISPOSED_INSTANCE_REPLACEMENT : constant DataWriterResourceLimitsInstanceReplacementKind := 3;
DISPOSED_THEN_ALIVE_INSTANCE_REPLACEMENT : constant DataWriterResourceLimitsInstanceReplacementKind := 4;
ALIVE_OR_DISPOSED_INSTANCE_REPLACEMENT : constant DataWriterResourceLimitsInstanceReplacementKind := 5;
type DataWriterResourceLimitsQosPolicy is record
Initial_Concurrent_Blocking_Threads : aliased DDS.Long := 1;
Max_Concurrent_Blocking_Threads : aliased DDS.Long := -1;
Max_Remote_Reader_Filters : aliased DDS.Long := 32;
Initial_Batches : aliased DDS.Long := 8;
Max_Batches : aliased DDS.Long := -1;
Cookie_Max_Length : aliased DDS.Long := -1;
Instance_Replacement : aliased DataWriterResourceLimitsInstanceReplacementKind := UNREGISTERED_INSTANCE_REPLACEMENT;
Replace_Empty_Instances : aliased DDS.Boolean := False;
Autoregister_Instances : aliased DDS.Boolean := False;
Initial_Virtual_Writers : aliased DDS.Long := 1;
Max_Virtual_Writers : aliased DDS.Long := -1;
Max_Remote_Readers : aliased DDS.Long := -1;
Max_App_Ack_Remote_Readers : aliased DDS.Long := -1;
Initial_Active_Topic_Queries : aliased DDS.Long := 1;
Max_Topic_Queries : aliased DDS.Long := -1;
Writer_Loaned_Sample_Allocation : aliased AllocationSettings_T := AllocationSettings_T_AUTO;
Initialize_Writer_Loaned_Sample : aliased DDS.Boolean := False;
end record with Convention => C;
pragma Compile_Time_Error (DataWriterResourceLimitsQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DataWriterResourceLimitsQosPolicy'Size, "DataWriterResourceLimitsQosPolicy size missmatch.");
DATA_WRITER_RESOURCE_LIMITS_QOS_POLICY_DEFAULT : constant DataWriterResourceLimitsQosPolicy := (others => <>);
SERVICE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Service");
type ServiceQosPolicyKind is new Unsigned_Long;
NO_SERVICE_QOS : constant ServiceQosPolicyKind := 0;
PERSISTENCE_SERVICE_QOS : constant ServiceQosPolicyKind := 1;
QUEUING_SERVICE_QOS : constant ServiceQosPolicyKind := 2;
ROUTING_SERVICE_QOS : constant ServiceQosPolicyKind := 3;
RECORDING_SERVICE_QOS : constant ServiceQosPolicyKind := 4;
REPLAY_SERVICE_QOS : constant ServiceQosPolicyKind := 5;
DATABASE_INTEGRATION_SERVICE_QOS : constant ServiceQosPolicyKind := 6;
DDS_WEB_INTEGRATION_SERVICE_QOS : constant ServiceQosPolicyKind := 7;
type ServiceQosPolicy is record
Kind : ServiceQosPolicyKind := NO_SERVICE_QOS;
end record with Convention => C;
pragma Compile_Time_Error (ServiceQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_ServiceQosPolicy'Size, "ServiceQosPolicy size missmatch.");
SERVICE_QOS_POLICY_DEFAULT : constant ServiceQosPolicy := (others => <>);
PUBLISHERPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("PublisherProtocol");
type PublisherProtocolQosPolicy is record
Vendor_Specific_Entity : DDS.Boolean := False;
end record with Convention => C;
pragma Compile_Time_Error (PublisherProtocolQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_PublisherProtocolQosPolicy'Size, "PublisherProtocolQosPolicy size missmatch.");
PUBLISHER_PROTOCOL_QOS_POLICY_DEFAULT : constant PublisherProtocolQosPolicy :=
(Vendor_Specific_Entity => False);
SUBSCRIBERPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("SubscriberProtocol");
type SubscriberProtocolQosPolicy is record
Vendor_Specific_Entity : DDS.Boolean := False;
end record with Convention => C;
pragma Compile_Time_Error (SubscriberProtocolQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_SubscriberProtocolQosPolicy'Size, "SubscriberProtocolQosPolicy size missmatch.");
SUBSCRIBER_PROTOCOL_QOS_POLICY_DEFAULT : constant SubscriberProtocolQosPolicy :=
(Vendor_Specific_Entity => False);
DATAREADERPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DataReaderProtocol");
type DataReaderProtocolQosPolicy is record
Virtual_Guid : aliased Guid_T;
Rtps_Object_Id : aliased Unsigned_Long := RTPS_AUTO_ID;
Expects_Inline_Qos : aliased DDS.Boolean := False;
Disable_Positive_Acks : aliased DDS.Boolean := False;
Propagate_Dispose_Of_Unregistered_Instances : aliased DDS.Boolean := False;
Propagate_Unregister_Of_Disposed_Instances : aliased DDS.Boolean := False;
Rtps_Reliable_Reader : aliased RtpsReliableReaderProtocol_T := RTPS_RELIABLE_READER_PROTOCOL_DEFAULT;
Vendor_Specific_Entity : aliased DDS.Boolean := False;
Meta_Entity : aliased DDS.Boolean := False;
end record with Convention => C;
pragma Compile_Time_Error (DataReaderProtocolQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DataReaderProtocolQosPolicy'Size, "DataReaderProtocolQosPolicy size missmatch.");
DATA_READER_PROTOCOL_QOS_POLICY_DEFAULT : constant DataReaderProtocolQosPolicy := (others => <>);
DATAWRITERPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DataWriterProtocol");
type DataWriterProtocolQosPolicy is record
Virtual_Guid : aliased Guid_T;
Rtps_Object_Id : aliased Unsigned_Long := RTPS_AUTO_ID;
Push_On_Write : aliased DDS.Boolean := False;
Disable_Positive_Acks : aliased DDS.Boolean := False;
Disable_Inline_Keyhash : aliased DDS.Boolean := False;
Serialize_Key_With_Dispose : aliased DDS.Boolean := False;
Propagate_App_Ack_With_No_Response : aliased DDS.Boolean := True;
Rtps_Reliable_Writer : aliased RtpsReliableWriterProtocol_T := RTPS_RELIABLE_WRITER_PROTOCOL_DEFAULT;
Initial_Virtual_Sequence_Number : aliased DDS.SequenceNumber_T := (-2147483648, 16#FFFF_FFFF#);
Vendor_Specific_Entity : aliased DDS.Boolean := False;
end record with Convention => C;
pragma Compile_Time_Error (DataWriterProtocolQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DataWriterProtocolQosPolicy'Size, "DataWriterProtocolQosPolicy size missmatch.");
DATA_WRITER_PROTOCOL_QOS_POLICY_DEFAULT : constant DataWriterProtocolQosPolicy := (others => <>);
SYSTEMRESOURCELIMITS_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("SystemResourceLimits");
type SystemResourceLimitsQosPolicy is record
Max_Objects_Per_Thread : Long := 261120;
Initial_Objects_Per_Thread : Long := 1024;
end record with Convention => C;
pragma Compile_Time_Error (SystemResourceLimitsQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_SystemResourceLimitsQosPolicy'Size, "SystemResourceLimitsQosPolicy size missmatch.");
SYSTEM_RESOURCE_LIMITS_QOS_POLICY_DEFAULT : constant SystemResourceLimitsQosPolicy := (others => <>);
DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DomainParticipantResourceLimits");
DomainParticipantResourceLimitsQosPolicy_MATCH_INIT : constant DDS.Long := 32;
type DomainParticipantResourceLimitsIgnoredEntityReplacementKind is new Unsigned_Long;
NO_REPLACEMENT_IGNORED_ENTITY_REPLACEMENT :
constant DomainParticipantResourceLimitsIgnoredEntityReplacementKind := 0;
DDS_NOT_ALIVE_FIRST_IGNORED_ENTITY_REPLACEMENT :
constant DomainParticipantResourceLimitsIgnoredEntityReplacementKind := 1;
type DomainParticipantResourceLimitsQosPolicy is record
Local_Writer_Allocation : aliased AllocationSettings_T := (16, -1, -1);
Local_Reader_Allocation : aliased AllocationSettings_T := (16, -1, -1);
Local_Publisher_Allocation : aliased AllocationSettings_T := (4, -1, -1);
Local_Subscriber_Allocation : aliased AllocationSettings_T := (4, -1, -1);
Local_Topic_Allocation : aliased AllocationSettings_T := (16, -1, -1);
Remote_Writer_Allocation : aliased AllocationSettings_T := (64, -1, -1);
Remote_Reader_Allocation : aliased AllocationSettings_T := (64, -1, -1);
Remote_Participant_Allocation : aliased AllocationSettings_T := (16, -1, -1);
Matching_Writer_Reader_Pair_Allocation : aliased AllocationSettings_T := (DomainParticipantResourceLimitsQosPolicy_MATCH_INIT, -1, -1);
Matching_Reader_Writer_Pair_Allocation : aliased AllocationSettings_T := (DomainParticipantResourceLimitsQosPolicy_MATCH_INIT, -1, -1);
Ignored_Entity_Allocation : aliased AllocationSettings_T := (8, -1, -1);
Content_Filtered_Topic_Allocation : aliased AllocationSettings_T := (4, -1, -1);
Content_Filter_Allocation : aliased AllocationSettings_T := (4, -1, -1);
Read_Condition_Allocation : aliased AllocationSettings_T := (4, -1, -1);
Query_Condition_Allocation : aliased AllocationSettings_T := (4, -1, -1);
Outstanding_Asynchronous_Sample_Allocation : aliased AllocationSettings_T := (64, -1, -1);
Flow_Controller_Allocation : aliased AllocationSettings_T := (4, -1, -1);
Local_Writer_Hash_Buckets : aliased Long := 4;
Local_Reader_Hash_Buckets : aliased Long := 4;
Local_Publisher_Hash_Buckets : aliased Long := 1;
Local_Subscriber_Hash_Buckets : aliased Long := 1;
Local_Topic_Hash_Buckets : aliased Long := 4;
Remote_Writer_Hash_Buckets : aliased Long := 16;
Remote_Reader_Hash_Buckets : aliased Long := 16;
Remote_Participant_Hash_Buckets : aliased Long := 4;
Matching_Writer_Reader_Pair_Hash_Buckets : aliased Long := 32;
Matching_Reader_Writer_Pair_Hash_Buckets : aliased Long := 32;
Ignored_Entity_Hash_Buckets : aliased Long := 1;
Content_Filtered_Topic_Hash_Buckets : aliased Long := 1;
Content_Filter_Hash_Buckets : aliased Long := 1;
Flow_Controller_Hash_Buckets : aliased Long := 1;
Max_Gather_Destinations : aliased Long := 8;
Participant_User_Data_Max_Length : aliased Long := 256;
Inter_Participant_Data_Max_Length : aliased Long := 256;
Topic_Data_Max_Length : aliased Long := 256;
Publisher_Group_Data_Max_Length : aliased Long := 256;
Subscriber_Group_Data_Max_Length : aliased Long := 256;
Writer_User_Data_Max_Length : aliased Long := 256;
Reader_User_Data_Max_Length : aliased Long := 256;
Max_Partitions : aliased Long := 64;
Max_Partition_Cumulative_Characters : aliased Long := 256;
Default_Partition_Matches_All : aliased Boolean := False;
Allow_No_Partitions : aliased Boolean := False;
Type_Code_Max_Serialized_Length : aliased Long := 0;
Type_Object_Max_Serialized_Length : aliased Long := 8192;
Serialized_Type_Object_Dynamic_Allocation_Threshold : aliased Long := 8192;
Type_Object_Max_Deserialized_Length : aliased Long := -1;
Deserialized_Type_Object_Dynamic_Allocation_Threshold : aliased Long := 4096;
Contentfilter_Property_Max_Length : aliased Long := 256;
Channel_Seq_Max_Length : aliased Long := 32;
Channel_Filter_Expression_Max_Length : aliased Long := 256;
Participant_Property_List_Max_Length : aliased Long := 32;
Participant_Property_String_Max_Length : aliased Long := 4096;
Writer_Property_List_Max_Length : aliased Long := 32;
Writer_Property_String_Max_Length : aliased Long := 1024;
Reader_Property_List_Max_Length : aliased Long := 32;
Reader_Property_String_Max_Length : aliased Long := 1024;
Plugin_Info_Parameter_Max_Length : aliased Long := 265;
Max_Endpoint_Groups : aliased Long := 32;
Max_Endpoint_Group_Cumulative_Characters : aliased Long := 1024;
Transport_Info_List_Max_Length : aliased Long := 12;
Ignored_Entity_Replacement_Kind : aliased DomainParticipantResourceLimitsIgnoredEntityReplacementKind
:= NO_REPLACEMENT_IGNORED_ENTITY_REPLACEMENT;
Remote_Topic_Query_Allocation : aliased AllocationSettings_T := (1, -1, -1);
Remote_Topic_Query_Hash_Buckets : aliased Long := 1;
Writer_Data_Tag_List_Max_Length : aliased Long := 0;
Writer_Data_Tag_String_Max_Length : aliased Long := 0;
Reader_Data_Tag_List_Max_Length : aliased Long := 0;
Reader_Data_Tag_String_Max_Length : aliased Long := 0;
Shmem_Ref_Transfer_Mode_Max_Segments : aliased Unsigned_Long := RTIDDS.Low_Level.ndds_pres_pres_participant_h.PRES_SHMEM_REF_TRANSFER_MODE_MAX_SEGMENTS;
end record with Convention => C;
pragma Compile_Time_Error (DomainParticipantResourceLimitsQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DomainParticipantResourceLimitsQosPolicy'Size, "DomainParticipantResourceLimitsQosPolicy size missmatch.");
DOMAIN_PARTICIPANT_RESOURCE_LIMITS_QOS_POLICY_DEFAULT : constant DomainParticipantResourceLimitsQosPolicy := (others => <>);
EVENT_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Event");
type EventQosPolicy is record
Thread : aliased ThreadSettings_T;
Initial_Count : aliased Long := 256;
Max_Count : aliased Long := -1;
end record with Convention => C;
pragma Compile_Time_Error (EventQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_EventQosPolicy'Size, "EventQosPolicy size missmatch.");
EVENT_QOS_POLICY_DEFAULT : constant EventQosPolicy := (others => <>);
DATABASE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Database");
type DatabaseQosPolicy is record
Thread : aliased ThreadSettings_T;
Shutdown_Timeout : aliased Duration_T := (15, 0);
Cleanup_Period : aliased Duration_T := (61, 0);
Shutdown_Cleanup_Period : aliased Duration_T := (1, 0);
Initial_Records : aliased Long := 1024;
Max_Skiplist_Level : aliased Long := 7;
Table_Allocation_Block_Size : aliased Long := 48;
Max_Weak_References : aliased Long := -1;
Initial_Weak_References : aliased Long := 2049;
end record with Convention => C;
pragma Compile_Time_Error (DatabaseQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DatabaseQosPolicy'Size, "DatabaseQosPolicy size missmatch.");
DATABASE_QOS_POLICY_DEFAULT : constant DatabaseQosPolicy := (others => <>);
RECEIVERPOOL_QOS_POLICY_NAME : DDS.String := To_DDS_String ("ReceiverPool");
ReceiverPoolQosPolicy_MAX_RECEIVE_THREADS_DEFAULT : constant Long := -1;
type ReceiverPoolQosPolicy is record
Thread : aliased ThreadSettings_T;
Initial_Receive_Threads : aliased Long := 4;
Max_Receive_Threads : aliased Long := ReceiverPoolQosPolicy_MAX_RECEIVE_THREADS_DEFAULT;
Buffer_Size : aliased Long := 9216;
Buffer_Alignment : aliased Long := 16;
Is_Timestamp_Enabled : aliased DDS.Boolean := True;
end record with Convention => C;
pragma Compile_Time_Error (ReceiverPoolQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_ReceiverPoolQosPolicy'Size, "ReceiverPoolQosPolicy size missmatch.");
RECEIVER_POOL_QOS_POLICY_DEFAULT : constant ReceiverPoolQosPolicy := (others => <>);
type BuiltinTopicReaderResourceLimits_T is record
Initial_Samples : aliased Long := 64;
Max_Samples : aliased Long := -1;
Initial_Infos : aliased Long := 64;
Max_Infos : aliased Long := -1;
Initial_Outstanding_Reads : aliased Long := 2;
Max_Outstanding_Reads : aliased Long := -1;
Max_Samples_Per_Read : aliased Long := 1024;
Disable_Fragmentation_Support : aliased DDS.Boolean := False;
Max_Fragmented_Samples : aliased Long := 1024;
Initial_Fragmented_Samples : aliased Long := 4;
Max_Fragmented_Samples_Per_Remote_Writer : aliased Long := 256;
Max_Fragments_Per_Sample : aliased Long := 512;
Dynamically_Allocate_Fragmented_Samples : aliased DDS.Boolean := False;
end record with Convention => C;
BUILTIN_TOPIC_READER_RESOURCE_LIMITS_DEFAULT : constant BuiltinTopicReaderResourceLimits_T := (others => <>);
BUILTIN_TOPIC_KEY_TYPE_NATIVE_LENGTH : constant := 4;
type BuiltinTopicKey_Array_T is array
(0 .. BUILTIN_TOPIC_KEY_TYPE_NATIVE_LENGTH - 1) of Builtin_Topic_Key_Type_Native;
type BuiltinTopicKey_T is record
Value : BuiltinTopicKey_Array_T := (others => 0);
end record with Convention => C;
function Hash (Item : DDS.BuiltinTopicKey_T) return Ada.Containers.Hash_Type;
type BuiltinTopicKey_T_Access is access all BuiltinTopicKey_T;
BuiltinTopicKey_T_INITIALIZER : constant BuiltinTopicKey_T :=
(Value => (0, 0, 0, 0));
function BuiltinTopicKey_Equals (A : in BuiltinTopicKey_T_Access;
B : in BuiltinTopicKey_T_Access)
return DDS.Boolean;
PUBLISHMODE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("PublishMode");
type PublishModeQosPolicyKind is new Unsigned_Long;
SYNCHRONOUS_PUBLISH_MODE_QOS : constant PublishModeQosPolicyKind := 0;
ASYNCHRONOUS_PUBLISH_MODE_QOS : constant PublishModeQosPolicyKind := 1;
PUBLICATION_PRIORITY_UNDEFINED : constant Long := 0;
PUBLICATION_PRIORITY_AUTOMATIC : constant Long := -1;
type PublishModeQosPolicy is record
Kind : aliased PublishModeQosPolicyKind := SYNCHRONOUS_PUBLISH_MODE_QOS;
Flow_Controller_Name : aliased DDS.String;
Priority : aliased Long := PUBLICATION_PRIORITY_UNDEFINED;
end record with Convention => C;
pragma Compile_Time_Error (PublishModeQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_PublishModeQosPolicy'Size, "PublishModeQosPolicy size missmatch.");
PUBLISH_MODE_QOS_POLICY_DEFAULT : constant PublishModeQosPolicy :=
(Kind => SYNCHRONOUS_PUBLISH_MODE_QOS,
Flow_Controller_Name => (Data => DDS.NULL_STRING.Data),
Priority => PUBLICATION_PRIORITY_UNDEFINED
);
DISCOVERYCONFIG_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DiscoveryConfig");
type DiscoveryConfigBuiltinPluginKind is new DDS.Unsigned_Long;
subtype DiscoveryConfigBuiltinPluginKindMask is DiscoveryConfigBuiltinPluginKind;
DISCOVERYCONFIG_BUILTIN_SPDP : constant DiscoveryConfigBuiltinPluginKindMask := 2#0001#;
DISCOVERYCONFIG_BUILTIN_SEDP : constant DiscoveryConfigBuiltinPluginKindMask := 2#0010#;
DISCOVERYCONFIG_BUILTIN_SDP : constant DiscoveryConfigBuiltinPluginKindMask :=
(DISCOVERYCONFIG_BUILTIN_SPDP or DISCOVERYCONFIG_BUILTIN_SEDP);
DISCOVERYCONFIG_BUILTIN_EDS : constant DiscoveryConfigBuiltinPluginKindMask := 2#0100#;
DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_ALL :
constant DiscoveryConfigBuiltinPluginKindMask := 16#EFFF#;
DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_NONE :
constant DiscoveryConfigBuiltinPluginKindMask := 0;
DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_DEFAULT :
constant DiscoveryConfigBuiltinPluginKindMask := DISCOVERYCONFIG_BUILTIN_SDP;
type DiscoveryConfigBuiltinChannelKindMask is mod 2 ** 32;
type DiscoveryPluginPromiscuityKind is new Unsigned_Long;
DISCOVERYPLUGIN_DISCOVER_MATCHING_REMOTE_ENTITIES_PROMISCUITY : constant DiscoveryPluginPromiscuityKind := 1;
DISCOVERYPLUGIN_DISCOVER_ALL_REMOTE_ENTITIES_PROMISCUITY : constant DiscoveryPluginPromiscuityKind := 16#FFFF#;
type RemoteParticipantPurgeKind is new Unsigned_Long;
LIVELINESS_BASED_REMOTE_PARTICIPANT_PURGE : constant RemoteParticipantPurgeKind := 0;
NO_REMOTE_PARTICIPANT_PURGE : constant RemoteParticipantPurgeKind := 1;
type DiscoveryBuiltinReaderFragmentationResourceLimits_T is record
Disable_Fragmentation_Support : aliased DDS.Boolean := False;
Max_Fragmented_Samples : aliased Long := 1024;
Initial_Fragmented_Samples : aliased Long := 4;
Max_Fragmented_Samples_Per_Remote_Writer : aliased Long := 256;
Max_Fragments_Per_Sample : aliased Long := 512;
Dynamically_Allocate_Fragmented_Samples : aliased DDS.Boolean := False;
end record with Convention => C;
pragma Compile_Time_Error (DiscoveryBuiltinReaderFragmentationResourceLimits_T'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DiscoveryBuiltinReaderFragmentationResourceLimits_t'Size, "DiscoveryBuiltinReaderFragmentationResourceLimits_t size Missmatch");
DISCOVERY_BUILTIN_READER_FRAGMENTATION_RESOURCE_LIMITS_DEFAULT : constant DiscoveryBuiltinReaderFragmentationResourceLimits_T := (others => <>);
TYPESUPPORT_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TypeSupport");
type CdrPaddingKind is
(ZERO_CDR_PADDING,
NOT_SET_CDR_PADDING,
AUTO_CDR_PADDING);
pragma Convention (C, CdrPaddingKind);
type TypeSupportQosPolicy is record
Plugin_Data : aliased DDS_Support.Void_Ptr;
Cdr_Padding_Kind : aliased CdrPaddingKind;
end record with Convention => C;
pragma Compile_Time_Error (TypeSupportQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_TypeSupportQosPolicy'Size, "TypeSupportQosPolicy size missmatch.");
TYPESUPPORT_QOS_POLICY_DEFAULT : constant TypeSupportQosPolicy :=
(Plugin_Data => System.Null_Address,
Cdr_Padding_Kind => AUTO_CDR_PADDING);
type ThreadBlockingKind is new Unsigned_Long;
SEMAPHORE_BLOCKING_KIND : constant ThreadBlockingKind := 0;
SPIN_BLOCKING_KIND : constant ThreadBlockingKind := 1;
ASYNCHRONOUSPUBLISHER_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("AsynchronousPublisher");
type AsynchronousPublisherQosPolicy is record
Disable_Asynchronous_Write : aliased DDS.Boolean := False;
Thread : aliased ThreadSettings_T;
Disable_Asynchronous_Batch : aliased Boolean := False;
Asynchronous_Batch_Thread : aliased ThreadSettings_T;
Asynchronous_Batch_Blocking_Kind : aliased ThreadBlockingKind := 0;
Disable_Topic_Query_Publication : aliased DDS.Boolean := False;
Topic_Query_Publication_Thread : aliased ThreadSettings_T;
end record with Convention => C;
pragma Compile_Time_Error (AsynchronousPublisherQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_AsynchronousPublisherQosPolicy'Size, "AsynchronousPublisherQosPolicy size missmatch.");
ASYNCHRONOUS_PUBLISHER_QOS_POLICY_DEFAULT : constant AsynchronousPublisherQosPolicy := (others => <>);
type RtpsReliableWriterProtocol is record
Low_Watermark : aliased Long := 0;
High_Watermark : aliased Long := 0;
Heartbeat_Period : aliased Duration_T := DURATION_ZERO;
Fast_Heartbeat_Period : aliased Duration_T := DURATION_ZERO;
Late_Joiner_Heartbeat_Period : aliased Duration_T := DURATION_ZERO;
Virtual_Heartbeat_Period : aliased Duration_T := DURATION_ZERO;
Samples_Per_Virtual_Heartbeat : aliased Long := 0;
Max_Heartbeat_Retries : aliased Long := 0;
Inactivate_Nonprogressing_Readers : aliased Boolean := False;
Heartbeats_Per_Max_Samples : aliased Long := 0;
Min_Nack_Response_Delay : aliased Duration_T := DURATION_ZERO;
Max_Nack_Response_Delay : aliased Duration_T := DURATION_ZERO;
Nack_Suppression_Duration : aliased Duration_T := DURATION_ZERO;
Max_Bytes_Per_Nack_Response : aliased Long := 0;
Disable_Positive_Acks_Min_Sample_Keep_Duration : aliased Duration_T := DURATION_ZERO;
Disable_Positive_Acks_Max_Sample_Keep_Duration : aliased Duration_T := DURATION_ZERO;
Disable_Positive_Acks_Sample_Min_Separation : aliased Duration_T := DURATION_ZERO;
Disable_Positive_Acks_Enable_Adaptive_Sample_Keep_Duration : aliased Boolean := False;
Disable_Positive_Acks_Enable_Spin_Wait : aliased Boolean := False;
Disable_Positive_Acks_Decrease_Sample_Keep_Duration_Factor : aliased Long := 0;
Disable_Positive_Acks_Increase_Sample_Keep_Duration_Factor : aliased Long := 0;
Min_Send_Window_Size : aliased Long := 0;
Max_Send_Window_Size : aliased Long := 0;
Send_Window_Update_Period : aliased Duration_T := DURATION_ZERO;
Send_Window_Increase_Factor : aliased Long := 0;
Send_Window_Decrease_Factor : aliased Long := 0;
Enable_Multicast_Periodic_Heartbeat : aliased Boolean := False;
Multicast_Resend_Threshold : aliased Long := 0;
Disable_Repair_Piggyback_Heartbeat : aliased Boolean := False;
end record
with Convention => C;
pragma Compile_Time_Error (RtpsReliableWriterProtocol'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_RtpsReliableWriterProtocol_t'Size, "RtpsReliableWriterProtocol'size missmatch");
type RtpsReliableReaderProtocol is record
Min_Heartbeat_Response_Delay : aliased Duration_T := DURATION_ZERO;
Max_Heartbeat_Response_Delay : aliased Duration_T := DURATION_ZERO;
Heartbeat_Suppression_Duration : aliased Duration_T := DURATION_ZERO;
Nack_Period : aliased Duration_T := DURATION_ZERO;
Receive_Window_Size : aliased Long := 0;
Round_Trip_Time : aliased Duration_T := DURATION_ZERO;
App_Ack_Period : aliased Duration_T := DURATION_ZERO;
Min_App_Ack_Response_Keep_Duration : aliased Duration_T := DURATION_ZERO;
Samples_Per_App_Ack : aliased Long := 0;
end record
with Convention => C;
pragma Compile_Time_Error (RtpsReliableReaderProtocol'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_RtpsReliableReaderProtocol_t'Size, "RtpsReliableReaderProtocol'size missmatch");
type BuiltinTopicReaderResourceLimits is record
Initial_Samples : aliased Long := 0;
Max_Samples : aliased Long := 0;
Initial_Infos : aliased Long := 0;
Max_Infos : aliased Long := 0;
Initial_Outstanding_Reads : aliased Long := 0;
Max_Outstanding_Reads : aliased Long := 0;
Max_Samples_Per_Read : aliased Long := 0;
Disable_Fragmentation_Support : aliased Boolean := False;
Max_Fragmented_Samples : aliased Long := 0;
Initial_Fragmented_Samples : aliased Long := 0;
Max_Fragmented_Samples_Per_Remote_Writer : aliased Long := 0;
Max_Fragments_Per_Sample : aliased Long := 0;
Dynamically_Allocate_Fragmented_Samples : aliased Boolean := False;
end record
with Convention => C;
pragma Compile_Time_Error (BuiltinTopicReaderResourceLimits'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_BuiltinTopicReaderResourceLimits_t'Size, "BuiltinTopicReaderResourceLimits size missmatch");
type DiscoveryConfigQosPolicy is record
Participant_Liveliness_Lease_Duration : aliased Duration_T := (100, 0);
Participant_Liveliness_Assert_Period : aliased Duration_T := (30, 0);
Participant_Announcement_Period : aliased Duration_T;
Remote_Participant_Purge_Kind : aliased RemoteParticipantPurgeKind := LIVELINESS_BASED_REMOTE_PARTICIPANT_PURGE;
Max_Liveliness_Loss_Detection_Period : aliased Duration_T := (60, 0);
Initial_Participant_Announcements : aliased Long := 5;
New_Remote_Participant_Announcements : aliased Long := 5;
Min_Initial_Participant_Announcement_Period : aliased Duration_T := (1, 0);
Max_Initial_Participant_Announcement_Period : aliased Duration_T := (1, 0);
Participant_Reader_Resource_Limits : aliased BuiltinTopicReaderResourceLimits_T := BUILTIN_TOPIC_READER_RESOURCE_LIMITS_DEFAULT;
Publication_Reader : aliased RtpsReliableReaderProtocol_T := RTPS_RELIABLE_READER_PROTOCOL_DISCOVERY_CONFIG_DEFAULT;
Publication_Reader_Resource_Limits : aliased BuiltinTopicReaderResourceLimits_T;
Subscription_Reader : aliased RtpsReliableReaderProtocol_T;
Subscription_Reader_Resource_Limits : aliased BuiltinTopicReaderResourceLimits_T;
Publication_Writer : aliased RtpsReliableWriterProtocol_T;
Publication_Writer_Data_Lifecycle : aliased WriterDataLifecycleQosPolicy;
Subscription_Writer : aliased RtpsReliableWriterProtocol_T;
Subscription_Writer_Data_Lifecycle : aliased WriterDataLifecycleQosPolicy;
Endpoint_Plugin_Redundancy_Level : aliased Long := 0;
Builtin_Discovery_Plugins : aliased DiscoveryConfigBuiltinPluginKindMask := DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_DEFAULT;
Enabled_Builtin_Channels : aliased DiscoveryConfigBuiltinChannelKindMask := 2#0000_0000_0000_0000#;
Participant_Message_Reader_Reliability_Kind : aliased ReliabilityQosPolicyKind := BEST_EFFORT_RELIABILITY_QOS;
Participant_Message_Reader : aliased RtpsReliableReaderProtocol_T;
Participant_Message_Writer : aliased RtpsReliableWriterProtocol_T;
Publication_Writer_Publish_Mode : aliased PublishModeQosPolicy;
Subscription_Writer_Publish_Mode : aliased PublishModeQosPolicy;
Asynchronous_Publisher : aliased AsynchronousPublisherQosPolicy;
Default_Domain_Announcement_Period : aliased Duration_T;
Ignore_Default_Domain_Announcements : aliased Boolean := False;
Service_Request_Writer : aliased RtpsReliableWriterProtocol_T;
Service_Request_Writer_Data_Lifecycle : aliased WriterDataLifecycleQosPolicy;
Service_Request_Writer_Publish_Mode : aliased PublishModeQosPolicy;
Service_Request_Reader : aliased RtpsReliableReaderProtocol_T;
Locator_Reachability_Assert_Period : aliased Duration_T;
Locator_Reachability_Lease_Duration : aliased Duration_T;
Locator_Reachability_Change_Detection_Period : aliased Duration_T;
Secure_Volatile_Writer : aliased RtpsReliableWriterProtocol_T;
Secure_Volatile_Writer_Publish_Mode : aliased PublishModeQosPolicy;
Secure_Volatile_Reader : aliased RtpsReliableReaderProtocol_T;
Endpoint_Type_Object_LB_Serialization_Threshold : aliased Long := 0;
Dns_Tracker_Polling_Period : aliased Duration_T;
Participant_Configuration_Writer_Publish_Mode : aliased PublishModeQosPolicy;
Participant_Configuration_Writer : aliased RtpsReliableWriterProtocol;
Participant_Configuration_Writer_Data_Lifecycle : aliased WriterDataLifecycleQosPolicy;
Participant_Configuration_Reader : aliased RtpsReliableReaderProtocol;
Participant_Configuration_Reader_Resource_Limits : aliased BuiltinTopicReaderResourceLimits;
Sedp_Rely_On_Spdp_Only : aliased Boolean := False;
Publication_Writer_Latency_Budget : aliased LatencyBudgetQosPolicy;
Publication_Writer_Push_On_Write : aliased Boolean := True;
Subscription_Writer_Latency_Budget : aliased LatencyBudgetQosPolicy;
Subscription_Writer_Push_On_Write : aliased Boolean := False;
Participant_State_Writer : aliased RtpsReliableWriterProtocol_T;
Participant_State_Writer_Latency_Budget : aliased LatencyBudgetQosPolicy;
Participant_State_Writer_Push_On_Write : aliased Boolean := False;
Participant_State_Writer_Publish_Mode : aliased PublishModeQosPolicy;
Participant_Proxy_Reader : aliased RtpsReliableReaderProtocol_T;
Participant_Proxy_Reader_Fragmentation_Resource_Limits : aliased DiscoveryBuiltinReaderFragmentationResourceLimits_T;
end record with Convention => C;
pragma Compile_Time_Error (DiscoveryConfigQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DiscoveryConfigQosPolicy'Size, "DiscoveryConfigQosPolicy size missmatch.");
DISCOVERY_CONFIG_QOS_POLICY_DEFAULT : constant DiscoveryConfigQosPolicy := (others => <>);
USEROBJECT_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("UserObject");
type UserObjectQosPolicy is record
Participant_User_Object : aliased UserObjectSettings_T;
Topic_User_Object : aliased UserObjectSettings_T;
Content_Filtered_Topic_User_Object : aliased UserObjectSettings_T;
Publisher_User_Object : aliased UserObjectSettings_T;
Data_Writer_User_Object : aliased UserObjectSettings_T;
Subscriber_User_Object : aliased UserObjectSettings_T;
Data_Reader_User_Object : aliased UserObjectSettings_T;
Read_Condition_User_Object : aliased UserObjectSettings_T;
Query_Condition_User_Object : aliased UserObjectSettings_T;
Index_Condition_User_Object : aliased UserObjectSettings_T;
Flow_Controller_User_Object : aliased UserObjectSettings_T;
end record with Convention => C;
pragma Compile_Time_Error (UserObjectQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_UserObjectQosPolicy'Size, "UserObjectQosPolicy size missmatch.");
USER_OBJECT_QOS_POLICY_DEFAULT : constant UserObjectQosPolicy := (others => <>);
EXCLUSIVEAREA_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("ExclusiveArea");
type ExclusiveAreaQosPolicy is record
Use_Shared_Exclusive_Area : aliased DDS.Boolean;
Level : aliased DDS.Long;
end record with Convention => C;
pragma Compile_Time_Error (ExclusiveAreaQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_ExclusiveAreaQosPolicy'Size, "ExclusiveAreaQosPolicy size missmatch.");
EXCLUSIVE_AREA_AUTO_LEVEL : constant DDS.Long := -1;
EXCLUSIVE_AREA_QOS_POLICY_DEFAULT : constant ExclusiveAreaQosPolicy :=
(Use_Shared_Exclusive_Area => False,
Level => EXCLUSIVE_AREA_AUTO_LEVEL);
DATAWRITERTRANSFERMODE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DataWriterTransferMode");
type DataWriterShmemRefTransferModeSettings is record
Enable_Data_Consistency_Check : aliased DDS.Boolean;
end record with Convention => C;
pragma Compile_Time_Error (DataWriterShmemRefTransferModeSettings'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DataWriterShmemRefTransferModeSettings'Size, "DataWriterShmemRefTransferModeSettings size missmatch.");
DataWriterShmemRefTransferModeSettings_INITIALIZER : constant DataWriterShmemRefTransferModeSettings :=
(Enable_Data_Consistency_Check => True);
type DataWriterShmemRefTransferModeSettings_Access is access all DataWriterShmemRefTransferModeSettings;
function DataWriterShmemRefTransferModeSettings_Equals
(Self : in DataWriterShmemRefTransferModeSettings_Access;
Other : in DataWriterShmemRefTransferModeSettings_Access)
return DDS.Boolean;
pragma Warnings (Off, DataWriterShmemRefTransferModeSettings_Equals);
pragma Import (C, DataWriterShmemRefTransferModeSettings_Equals, "DDS_DataWriterShmemRefTransferModeSettings_equals");
type DataWriterTransferModeQosPolicy is record
Shmem_Ref_Settings : aliased DataWriterShmemRefTransferModeSettings;
end record with Convention => C;
pragma Compile_Time_Error (DataWriterTransferModeQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DataWriterTransferModeQosPolicy'Size, "DataWriterTransferModeQosPolicy size missmatch.");
DataWriterTransferModeQosPolicy_INITIALIZER : constant DataWriterTransferModeQosPolicy :=
(Shmem_Ref_Settings => DataWriterShmemRefTransferModeSettings_INITIALIZER);
type DataWriterTransferModeQosPolicy_Access is access all DataWriterTransferModeQosPolicy;
function DataWriterTransferModeQosPolicy_Equals
(Self : in DataWriterTransferModeQosPolicy_Access;
Other : in DataWriterTransferModeQosPolicy_Access)
return DDS.Boolean;
pragma Warnings (Off, DataWriterTransferModeQosPolicy_Equals);
pragma Import (C, DataWriterTransferModeQosPolicy_Equals, "DDS_DataWriterTransferModeQosPolicy_equals");
TOPIC_QUERY_DISPATCH_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TopicQueryDispatch");
type TopicQueryDispatchQosPolicy is record
Enable : aliased DDS.Boolean := False;
Publication_Period : aliased Duration_T := (16#0000_0001#, 16#0000_0000#);
Samples_Per_Period : aliased DDS.Long := -1;
end record with Convention => C;
pragma Compile_Time_Error (TopicQueryDispatchQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_TopicQueryDispatchQosPolicy'Size, "TopicQueryDispatchQosPolicy size missmatch.");
TOPIC_QUERY_DISPATCH_QOS_POLICY_DEFAULT : constant TopicQueryDispatchQosPolicy := (others => <>);
BATCH_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Batch");
type BatchQosPolicy is record
Enable : aliased DDS.Boolean := False;
Max_Data_Bytes : aliased DDS.Long := 1024;
Max_Meta_Data_Bytes : aliased DDS.Long := LENGTH_UNLIMITED;
Max_Samples : aliased DDS.Long := LENGTH_UNLIMITED;
Max_Flush_Delay : aliased Duration_T := DURATION_INFINITE;
Source_Timestamp_Resolution : aliased Duration_T := DURATION_INFINITE;
Thread_Safe_Write : aliased DDS.Boolean := True;
end record with Convention => C;
pragma Compile_Time_Error (BatchQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_BatchQosPolicy'Size, "BatchQosPolicy size missmatch.");
BATCH_QOS_POLICY_DEFAULT : constant BatchQosPolicy := (others => <>);
TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TypeConsistencyEnforcement");
type TypeConsistencyKind is new Unsigned_Long;
DISALLOW_TYPE_COERCION : constant TypeConsistencyKind := 0;
ALLOW_TYPE_COERCION : constant TypeConsistencyKind := 1;
AUTO_TYPE_COERCION : constant TypeConsistencyKind := 2;
type TypeConsistencyEnforcementQosPolicy is record
Kind : aliased TypeConsistencyKind := ALLOW_TYPE_COERCION;
Ignore_Sequence_Bounds : aliased Boolean := False;
Ignore_String_Bounds : aliased Boolean := False;
Ignore_Member_Names : aliased Boolean := False;
Prevent_Type_Widening : aliased Boolean := False;
Force_Type_Validation : aliased Boolean := False;
Ignore_Enum_Literal_Names : aliased Boolean := False;
end record with Convention => C;
pragma Compile_Time_Error (TypeConsistencyEnforcementQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_TypeConsistencyEnforcementQosPolicy'Size, "TypeConsistencyEnforcementQosPolicy size missmatch.");
TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_DEFAULT : constant TypeConsistencyEnforcementQosPolicy := (others => <>);
type LocatorFilter_T is record
Locators : aliased Locator_Seq.Sequence;
Filter_Expression : DDS.String;
end record with Convention => C;
type LocatorFilter_T_Access is access all LocatorFilter_T;
type LocatorFilter_T_Array is array
(Natural range <>) of aliased LocatorFilter_T;
procedure Initialize (Self : in out LocatorFilter_T);
procedure Finalize (Self : in out LocatorFilter_T);
procedure Copy (Dst : in out LocatorFilter_T;
Src : in LocatorFilter_T);
package LocatorFilter_Seq is new DDS_Support.Sequences_Generic
(LocatorFilter_T,
LocatorFilter_T_Access,
DDS.Natural,
1,
LocatorFilter_T_Array);
LOCATORFILTER_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("LocatorFilter");
type LocatorFilterQosPolicy is record
Locator_Filters : aliased DDS.LocatorFilter_Seq.Sequence;
Filter_Name : aliased DDS.String;
end record with Convention => C;
pragma Compile_Time_Error (LocatorFilterQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_LocatorFilterQosPolicy'Size, "LocatorFilterQosPolicy size missmatch.");
LOCATOR_FILTER_QOS_POLICY_DEFAULT : constant LocatorFilterQosPolicy := (others => <>);
type ChannelSettings_T is record
Multicast_Settings : aliased TransportMulticastSettings_Seq.Sequence;
Filter_Expression : DDS.String;
Priority : DDS.Long;
end record with Convention => C;
type ChannelSettings_T_Access is access all ChannelSettings_T;
type ChannelSettings_T_Array is array
(Natural range <>) of aliased ChannelSettings_T;
procedure Initialize (Self : in out ChannelSettings_T);
procedure Finalize (Self : in out ChannelSettings_T);
procedure Copy (Dst : in out ChannelSettings_T;
Src : in ChannelSettings_T);
package ChannelSettings_Seq is new DDS_Support.Sequences_Generic
(ChannelSettings_T,
ChannelSettings_T_Access,
DDS.Natural,
1,
ChannelSettings_T_Array);
MULTICHANNEL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("MultiChannel");
type MultiChannelQosPolicy is record
Channels : aliased DDS.ChannelSettings_Seq.Sequence;
Filter_Name : aliased DDS.String;
end record with Convention => C;
pragma Compile_Time_Error (MultiChannelQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_MultiChannelQosPolicy'Size, "MultiChannelQosPolicy size missmatch.");
type Property_T is record
Name : aliased DDS.String;
Value : aliased DDS.String;
Propagate : aliased DDS.Boolean := False;
end record with Convention => C;
type Property_T_Access is access all Property_T;
type Property_T_Array is array (Natural range <>) of aliased Property_T;
procedure Initialize (Self : in out Property_T);
procedure Finalize (Self : in out Property_T);
procedure Copy (Dst : in out Property_T; Src : in Property_T);
package Property_T_Seq is new DDS_Support.Sequences_Generic
(Property_T,
Property_T_Access,
DDS.Natural,
1,
Property_T_Array);
type Property_T_Seq_Access is access all Property_T_Seq.Sequence;
PROPERTY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Property");
type PropertyQosPolicy is record
Value : aliased Property_T_Seq.Sequence;
end record with Convention => C;
pragma Compile_Time_Error (PropertyQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_PropertyQosPolicy'Size, "PropertyQosPolicy size missmatch.");
type PropertyQosPolicy_Access is access all PropertyQosPolicy;
PROPERTY_QOS_POLICY_DEFAULT : constant PropertyQosPolicy :=
(Value => Property_T_Seq.DEFAULT_SEQUENCE);
function Contains (P : PropertyQosPolicy;
Name : Standard.String) return Boolean;
function Contains (P : PropertyQosPolicy;
Name : DDS.String) return Boolean;
function Length (P : PropertyQosPolicy) return Natural;
procedure Append (P : in out PropertyQosPolicy;
Name : Standard.String;
Value : Standard.String;
Propagate : Boolean := False);
procedure Append (P : in out PropertyQosPolicy;
Name : DDS.String;
Value : DDS.String;
Propagate : Boolean := False);
procedure Delete (P : in out PropertyQosPolicy; Name : Standard.String);
procedure Delete (P : in out PropertyQosPolicy; Name : DDS.String);
function Get (P : PropertyQosPolicy;
Name : Standard.String) return Standard.String;
function Get (P : PropertyQosPolicy;
Name : DDS.String) return DDS.String;
procedure Add_Property (Policy : in PropertyQosPolicy_Access;
Name : in Standard.String;
Value : in Standard.String;
Propagate : in DDS.Boolean);
procedure Remove_Property (Policy : in PropertyQosPolicy_Access;
Name : in Standard.String);
type WaitSetProperty_T is record
Max_Event_Count : aliased Long := 0;
Max_Event_Delay : aliased Duration_T;
end record with Convention => C;
type EndpointGroup_T is record
Role_Name : aliased DDS.String;
Quorum_Count : aliased Integer := 0;
end record with Convention => C;
type EndpointGroup_T_Access is access all EndpointGroup_T;
type EndpointGroup_T_Array is array (Natural range <>) of aliased EndpointGroup_T;
pragma Convention (C, EndpointGroup_T_Array);
procedure Initialize (Self : in out EndpointGroup_T);
procedure Finalize (Self : in out EndpointGroup_T);
procedure Copy (Dst : in out EndpointGroup_T; Src : in EndpointGroup_T);
package EndpointGroup_T_Seq is new DDS_Support.Sequences_Generic
(Element => EndpointGroup_T,
Element_Access => EndpointGroup_T_Access,
Index_Type => Natural,
First_Element => 1,
Element_Array => EndpointGroup_T_Array);
type EndpointGroup_T_Seq_Access is access all EndpointGroup_T_Seq.Sequence;
type AvailabilityQosPolicy is record
Enable_Required_Subscriptions : aliased Boolean := False;
Max_Data_Availability_Waiting_Time : aliased Duration_T := (1, 0);
Max_Endpoint_Availability_Waiting_Time : aliased Duration_T := (1, 0);
Required_Matched_Endpoint_Groups : aliased EndpointGroup_T_Seq.Sequence;
end record with Convention => C;
pragma Compile_Time_Error (AvailabilityQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_AvailabilityQosPolicy'Size, "AvailabilityQosPolicy size missmatch.");
AVAILABILITY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Availability");
type ContentFilterProperty_T is record
Content_Filter_Topic_Name : aliased DDS.String;
Related_Topic_Name : aliased DDS.String;
Filter_Class_Name : aliased DDS.String;
Filter_Expression : aliased DDS.String;
Expression_Parameters : aliased DDS.String_Seq.Sequence;
end record with Convention => C;
CONTENT_FILTER_PROPERTY_DEFAULT : constant ContentFilterProperty_T := (others => <>);
ENTITYNAME_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("EntityName");
type EntityNameQosPolicy is record
Name : aliased DDS.String;
Role_Name : aliased DDS.String;
end record with Convention => C;
pragma Compile_Time_Error (EntityNameQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_EntityNameQosPolicy'Size, "EntityNameQosPolicy size missmatch.");
ENTITY_NAME_QOS_POLICY_DEFAULT : constant EntityNameQosPolicy :=
(Name => (Data => DDS.NULL_STRING.Data),
Role_Name => (Data => DDS.NULL_STRING.Data));
LOGGING_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Logging");
PROFILE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Profile");
type ProfileQosPolicy is record
String_Profile : aliased String_Seq.Sequence;
Url_Profile : aliased String_Seq.Sequence;
Ignore_User_Profile : aliased Boolean := False;
Ignore_Environment_Profile : aliased Boolean := False;
Ignore_Resource_Profile : aliased Boolean := False;
String_Profile_Dtd : aliased String_Seq.Sequence;
Ignore_Is_Default_Qos_Attribute : aliased Boolean := False;
end record with Convention => C;
pragma Compile_Time_Error (ProfileQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_ProfileQosPolicy'Size, "ProfileQosPolicy size missmatch.");
type SampleIdentity_T is record
Writer_Guid : aliased Guid_T;
Sequence_Number : aliased DDS.SequenceNumber_T;
end record with
Convention => C;
AUTO_SAMPLE_IDENTITY : constant SampleIdentity_T :=
(Writer_Guid => GUID_AUTO,
Sequence_Number => SEQUENCE_NUMBER_UNKNOWN);
UNKNOWN_SAMPLE_IDENTITY : constant SampleIdentity_T :=
(Writer_Guid => GUID_AUTO,
Sequence_Number => SEQUENCE_NUMBER_UNKNOWN);
NULL_SAMPLE_IDENTITY : constant SampleIdentity_T :=
(Writer_Guid => GUID_UNKNOWN,
Sequence_Number => SEQUENCE_NUMBER_ZERO);
type Cookie_T is record
Value : aliased Octet_Seq.Sequence;
end record with Convention => C;
function "=" (Left, Right : Cookie_T) return Standard.Boolean;
COOKIE_DEFAULT : constant Cookie_T := (Value => Octet_Seq.DEFAULT_SEQUENCE);
type Cookie_T_Access is access all Cookie_T;
type Cookie_T_Array is array (Natural range <>) of aliased Cookie_T;
procedure Initialize (Self : in out Cookie_T);
procedure Finalize (Self : in out Cookie_T);
procedure Copy (Dst : in out Cookie_T; Src : in Cookie_T);
package Cookie_T_Seq is new DDS_Support.Sequences_Generic
(Cookie_T,
Cookie_T_Access,
DDS.Natural,
1,
Cookie_T_Array);
type AckResponseData_T is record
Value : aliased Octet_Seq.Sequence;
end record with
Convention => C;
type SampleFlagBits is new Unsigned_Long;
REDELIVERED_SAMPLE : constant SampleFlagBits := 2#0000_0001#;
INTERMEDIATE_REPLY_SEQUENCE_SAMPLE : constant SampleFlagBits := 2#0000_0010#;
REPLICATE_SAMPLE : constant SampleFlagBits := 2#0000_0100#;
LAST_SHARED_READER_QUEUE_SAMPLE : constant SampleFlagBits := 2#0000_1000#;
INTERMEDIATE_TOPIC_QUERY_SAMPLE : constant SampleFlagBits := 2#0001_0000#;
WRITER_REMOVED_BATCH_SAMPLE : constant SampleFlagBits := 2#0010_0000#;
DISCOVERY_SERVICE_SAMPLE : constant SampleFlagBits := 2#0100_0000#;
subtype SampleFlag is SampleFlagBits;
type WriteParams_T is record
Replace_Auto : aliased DDS.Boolean := False;
Identity : aliased SampleIdentity_T := AUTO_SAMPLE_IDENTITY;
Related_Sample_Identity : aliased SampleIdentity_T := UNKNOWN_SAMPLE_IDENTITY;
Source_Timestamp : aliased DDS.Time_T := Time_Invalid;
Cookie : aliased DDS.Cookie_T := COOKIE_DEFAULT;
Handle : aliased DDS.InstanceHandle_T := Null_InstanceHandle_T;
Priority : aliased Long := 0;
Flush_On_Write : aliased DDS.Boolean := False;
Flag : aliased SampleFlag := 0;
Source_Guid : aliased Guid_T := GUID_AUTO;
Related_Source_Guid : aliased Guid_T := GUID_UNKNOWN;
Related_Reader_Guid : aliased Guid_T := GUID_UNKNOWN;
Topic_Query_Guid : aliased Guid_T := GUID_UNKNOWN;
Related_Epoch : aliased DDS.SequenceNumber_T := SEQUENCE_NUMBER_ZERO;
end record with Convention => C;
pragma Compile_Time_Error (DDS.WriteParams_T'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_WriteParams_t'Size, "DDS.WriteParams_T size mismatch");
WRITEPARAMS_DEFAULT : constant WriteParams_T := (others => <>);
type WriteParams_T_Access is access all WriteParams_T;
procedure Initialize (Self : in out WriteParams_T);
procedure Finalize (Self : in out WriteParams_T);
procedure Copy (Dst : in out WriteParams_T; Src : in WriteParams_T);
function WriteParams_Equals (Self : in WriteParams_T_Access; Other : in WriteParams_T_Access)
return DDS.Boolean;
pragma Warnings (Off, WriteParams_Equals);
pragma Import (C, WriteParams_Equals, "DDS_WriteParams_equals");
type TypeCode is private;
type TypeCode_Access is access all TypeCode;
type TypeObject is private;
type TypeObject_Access is access all TypeObject;
BUILTIN_TOPIC_MAX_STRING_LENGTH : constant := 256;
type Transport_ClassId_T is new Long;
type TransportInfo_T is record
Class_Id : aliased Transport_ClassId_T := 0;
Message_Size_Max : aliased Long := 1024;
end record with Convention => C;
type TransportInfo_Access is access all TransportInfo_T;
type TransportInfo_Array is array (Natural range <>) of aliased TransportInfo_T with Convention => C;
procedure Initialize (This : in out TransportInfo_T);
procedure Finalize (This : in out TransportInfo_T);
procedure Copy (Dst : in out TransportInfo_T;
Src : in TransportInfo_T);
package TransportInfo_Seq is new DDS_Support.Sequences_Generic
(Element => DDS.TransportInfo_T,
Element_Access => DDS.TransportInfo_Access,
Index_Type => Natural,
First_Element => 1,
Element_Array => DDS.TransportInfo_Array);
type ParticipantTrustAttributesMask is mod 2 ** 32;
type PluginParticipantTrustAttributesMask is mod 2 ** 32;
type ParticipantTrustProtectionInfo is record
Bitmask : aliased ParticipantTrustAttributesMask := 0;
Plugin_Bitmask : aliased PluginParticipantTrustAttributesMask := 0;
end record
with Convention => C;
pragma Compile_Time_Error (RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_trust_h.DDS_ParticipantTrustProtectionInfo'Size /= ParticipantTrustProtectionInfo'Size, "ParticipantTrustProtectionInfo got wrong size");
type EndpointTrustAttributesMask is mod 2 ** 32;
type PluginEndpointTrustAttributesMask is mod 2 ** 32;
type EndpointTrustProtectionInfo is record
Bitmask : aliased EndpointTrustAttributesMask := 0;
Plugin_Bitmask : aliased PluginEndpointTrustAttributesMask := 0;
end record
with Convention => C;
type TrustAlgorithmBit is mod 2 ** 32;
type TrustAlgorithmSet is mod 2 ** 32;
type TrustAlgorithmRequirements is record
Supported_Mask : aliased TrustAlgorithmSet := 0;
Required_Mask : aliased TrustAlgorithmSet := 0;
end record
with Convention => C;
type ParticipantTrustSignatureAlgorithmInfo is record
Trust_Chain : aliased TrustAlgorithmRequirements;
Message_Auth : aliased TrustAlgorithmRequirements;
end record
with Convention => C;
type ParticipantTrustKeyEstablishmentAlgorithmInfo is record
Shared_Secret : aliased TrustAlgorithmRequirements;
end record
with Convention => C;
type ParticipantTrustInterceptorAlgorithmInfo is record
Supported_Mask : aliased TrustAlgorithmSet := 0;
Builtin_Endpoints_Required_Mask : aliased TrustAlgorithmSet := 0;
Builtin_Kx_Endpoints_Required_Mask : aliased TrustAlgorithmSet := 0;
User_Endpoints_Default_Required_Mask : aliased TrustAlgorithmSet := 0;
end record
with Convention => C;
type ParticipantTrustAlgorithmInfo is record
Signature : aliased ParticipantTrustSignatureAlgorithmInfo;
Key_Establishment : aliased ParticipantTrustKeyEstablishmentAlgorithmInfo;
Interceptor : aliased ParticipantTrustInterceptorAlgorithmInfo;
end record
with Convention => C_Pass_By_Copy;
type EndpointTrustInterceptorAlgorithmInfo is record
Required_Mask : aliased TrustAlgorithmSet := 0;
Supported_Mask : aliased TrustAlgorithmSet := 0;
end record
with Convention => C_Pass_By_Copy;
type EndpointTrustAlgorithmInfo is record
Interceptor : aliased EndpointTrustInterceptorAlgorithmInfo;
end record
with Convention => C_Pass_By_Copy;
PARTICIPANT_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSParticipant");
PARTICIPANT_TRUSTED_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSParticipantSecure");
PARTICIPANT_MESSAGE_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSParticipantMessage");
PARTICIPANT_MESSAGE_TRUSTED_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSParticipantMessageSecure");
PARTICIPANT_PROXY_TOPIC_NAME : constant DDS.String := To_DDS_String ("DDSParticipantProxy");
PARTICIPANT_STATE_TOPIC_NAME : constant DDS.String := To_DDS_String ("DDSParticipantState");
ParticipantBuiltinTopicData_TypeName : DDS.String := (Data => RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_impl_h.DDS_PARTICIPANT_TYPE_NAME);
type ParticipantBuiltinTopicData is record
Key : aliased BuiltinTopicKey_T;
User_Data : aliased UserDataQosPolicy;
Property : aliased PropertyQosPolicy;
Rtps_Protocol_Version : aliased ProtocolVersion_T;
Rtps_Vendor_Id : aliased VendorId_T;
Dds_Builtin_Endpoints : aliased Unsigned_Long := 0;
Metatraffic_Unicast_Locators : aliased Locator_Seq.Sequence;
Metatraffic_Multicast_Locators : aliased Locator_Seq.Sequence;
Default_Unicast_Locators : aliased Locator_Seq.Sequence;
Lease_Duration : aliased Duration_T;
Product_Version : aliased ProductVersion_T;
Participant_Name : aliased EntityNameQosPolicy;
Domain_Id : aliased DomainId_T := 0;
Transport_Info : aliased TransportInfo_Seq.Sequence;
Reachability_Lease_Duration : aliased Duration_T;
Partition : aliased PartitionQosPolicy;
Trust_Protection_Info : aliased ParticipantTrustProtectionInfo;
Trust_Algorithm_Info : aliased ParticipantTrustAlgorithmInfo;
Partial_Configuration : aliased Boolean := False;
Vendor_Builtin_Endpoints : aliased Unsigned_Long := 0;
Service : aliased ServiceQosPolicy;
end record with Convention => C;
pragma Compile_Time_Error (ParticipantBuiltinTopicData'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_h.DDS_ParticipantBuiltinTopicData'Size, "ParticipantBuiltinTopicData size missmatch.");
type ParticipantBuiltinTopicData_Access is access all ParticipantBuiltinTopicData;
ParticipantBuiltinTopicData_INITIALIZER : constant ParticipantBuiltinTopicData := (others => <>);
function Hash (Item : DDS.ParticipantBuiltinTopicData) return Ada.Containers.Hash_Type;
procedure Print (UserData : ParticipantBuiltinTopicData_Access;
Desc : DDS.String;
Indent : Long) with
Convention => C,
Import => True,
Link_Name => "DDS_ParticipantBuiltinTopicDataPlugin_print";
type ParticipantBuiltinTopicData_Array is array (Natural range <>) of aliased ParticipantBuiltinTopicData;
pragma Convention (C, ParticipantBuiltinTopicData_Array);
function ParticipantBuiltinTopicData_Get_TypeCode return Standard.DDS.TypeCode_Access;
pragma Import (C, ParticipantBuiltinTopicData_Get_TypeCode, "DDS_ParticipantBuiltinTopicData_get_typecode");
procedure Initialize (This : in out ParticipantBuiltinTopicData);
procedure Finalize (This : in out ParticipantBuiltinTopicData);
procedure Copy (Dst : in out ParticipantBuiltinTopicData;
Src : in ParticipantBuiltinTopicData);
package ParticipantBuiltinTopicData_Seq is new DDS_Support.Sequences_Generic
(Element => DDS.ParticipantBuiltinTopicData,
Element_Access => DDS.ParticipantBuiltinTopicData_Access,
Index_Type => Natural,
First_Element => 1,
Element_Array => DDS.ParticipantBuiltinTopicData_Array);
TOPIC_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSTopic");
TopicBuiltinTopicData_TypeName : DDS.String := (Data => RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_impl_h.DDS_TOPIC_TYPE_NAME);
type TopicBuiltinTopicData is record
Key : aliased BuiltinTopicKey_T;
Name : aliased DDS.String;
Type_Name : aliased DDS.String;
Durability : aliased DurabilityQosPolicy;
Durability_Service : aliased DurabilityServiceQosPolicy;
Deadline : aliased DeadlineQosPolicy;
Latency_Budget : aliased LatencyBudgetQosPolicy;
Liveliness : aliased LivelinessQosPolicy;
Reliability : aliased ReliabilityQosPolicy;
Transport_Priority : aliased TransportPriorityQosPolicy;
Lifespan : aliased LifespanQosPolicy;
Destination_Order : aliased DestinationOrderQosPolicy;
History : aliased HistoryQosPolicy;
Resource_Limits : aliased ResourceLimitsQosPolicy;
Ownership : aliased OwnershipQosPolicy;
Topic_Data : aliased TopicDataQosPolicy;
Representation : aliased DataRepresentationQosPolicy;
end record with Convention => C;
pragma Compile_Time_Error (TopicBuiltinTopicData'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_h.DDS_TopicBuiltinTopicData'Size, "TopicBuiltinTopicData size missmatch.");
type TopicBuiltinTopicData_Access is access all TopicBuiltinTopicData;
TopicBuiltinTopicData_INITIALIZER : constant TopicBuiltinTopicData := (others => <>);
type TopicBuiltinTopicData_Array is array (Natural range <>) of aliased TopicBuiltinTopicData;
pragma Convention (C, TopicBuiltinTopicData_Array);
function TopicBuiltinTopicData_Get_TypeCode return Standard.DDS.TypeCode_Access;
pragma Import (C, TopicBuiltinTopicData_Get_TypeCode, "DDS_TopicBuiltinTopicData_get_typecode");
procedure Initialize (This : in out TopicBuiltinTopicData);
procedure Finalize (This : in out TopicBuiltinTopicData);
procedure Copy (Dst : in out TopicBuiltinTopicData;
Src : in TopicBuiltinTopicData);
package TopicBuiltinTopicData_Seq is new DDS_Support.Sequences_Generic
(Element => DDS.TopicBuiltinTopicData,
Element_Access => DDS.TopicBuiltinTopicData_Access,
Index_Type => Natural,
First_Element => 1,
Element_Array => DDS.TopicBuiltinTopicData_Array);
type ServiceRequestInternalTopicData is record
Service_Id : aliased Long := 0;
Instance_Id : aliased Guid_T;
Request_Body : aliased Octet_Seq.Sequence;
end record with Convention => C;
type ServiceRequestInternalTopicData_Access is access all ServiceRequestInternalTopicData;
PUBLICATION_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSPublication");
PUBLICATION_TRUSTED_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSPublicationSecure");
PublicationBuiltinTopicData_TypeName : DDS.String := (Data => RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_impl_h.DDS_PUBLICATION_TYPE_NAME);
type PublicationBuiltinTopicData is record
Key : aliased BuiltinTopicKey_T;
Participant_Key : aliased BuiltinTopicKey_T;
Topic_Name : aliased DDS.String;
Type_Name : aliased DDS.String;
Max_Sample_Serialize_Size : aliased Long := 0;
Durability : aliased DurabilityQosPolicy;
Durability_Service : aliased DurabilityServiceQosPolicy;
Deadline : aliased DeadlineQosPolicy;
Latency_Budget : aliased LatencyBudgetQosPolicy;
Liveliness : aliased LivelinessQosPolicy;
Reliability : aliased ReliabilityQosPolicy;
Lifespan : aliased LifespanQosPolicy;
User_Data : aliased UserDataQosPolicy;
Ownership : aliased OwnershipQosPolicy;
Ownership_Strength : aliased OwnershipStrengthQosPolicy;
Destination_Order : aliased DestinationOrderQosPolicy;
Presentation : aliased PresentationQosPolicy;
Partition : aliased PartitionQosPolicy;
Topic_Data : aliased TopicDataQosPolicy;
Group_Data : aliased GroupDataQosPolicy;
Type_Object : aliased TypeObject_Access;
Representation : aliased DataRepresentationQosPolicy;
Data_Tags : aliased DataTagQosPolicy;
Type_Code : aliased TypeCode_Access;
Publisher_Key : aliased BuiltinTopicKey_T;
Property : aliased PropertyQosPolicy;
Unicast_Locators : aliased Locator_Seq.Sequence;
Virtual_Guid : aliased Guid_T;
Service : aliased ServiceQosPolicy;
Rtps_Protocol_Version : aliased ProtocolVersion_T;
Rtps_Vendor_Id : aliased VendorId_T;
Product_Version : aliased ProductVersion_T;
Locator_Filter : aliased LocatorFilterQosPolicy;
Disable_Positive_Acks : aliased Boolean := False;
Send_Queue_Size : aliased Long := 0;
Is_Incompatible : aliased Boolean := False;
Publication_Name : aliased EntityNameQosPolicy;
Trust_Protection_Info : aliased EndpointTrustProtectionInfo;
Trust_Algorithm_Info : aliased EndpointTrustAlgorithmInfo;
end record with Convention => C;
pragma Compile_Time_Error (PublicationBuiltinTopicData'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_h.DDS_PublicationBuiltinTopicData'Size, "PublicationBuiltinTopicData size missmatch.");
function Hash (Item : DDS.PublicationBuiltinTopicData) return Ada.Containers.Hash_Type;
type PublicationBuiltinTopicData_Access is access all PublicationBuiltinTopicData;
type PublicationBuiltinTopicData_Array is array (Natural range <>) of aliased PublicationBuiltinTopicData;
pragma Convention (C, PublicationBuiltinTopicData_Array);
function PublicationBuiltinTopicData_Get_TypeCode return Standard.DDS.TypeCode_Access;
pragma Import (C, PublicationBuiltinTopicData_Get_TypeCode, "DDS_PublicationBuiltinTopicData_get_typecode");
procedure Initialize (This : in out PublicationBuiltinTopicData);
procedure Finalize (This : in out PublicationBuiltinTopicData);
procedure Copy (Dst : in out PublicationBuiltinTopicData;
Src : in PublicationBuiltinTopicData);
package PublicationBuiltinTopicData_Seq is new DDS_Support.Sequences_Generic
(Element => DDS.PublicationBuiltinTopicData,
Element_Access => DDS.PublicationBuiltinTopicData_Access,
Index_Type => Natural,
First_Element => 1,
Element_Array => DDS.PublicationBuiltinTopicData_Array);
SUBSCRIPTION_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSSubscription");
SUBSCRIPTION_TRUSTED_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSSubscriptionSecure");
SubscriptionBuiltinTopicData_TypeName : DDS.String := (Data => RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_impl_h.DDS_SUBSCRIPTION_TYPE_NAME);
type SubscriptionBuiltinTopicData is record
Key : aliased BuiltinTopicKey_T;
Participant_Key : aliased BuiltinTopicKey_T;
Topic_Name : aliased DDS.String;
Type_Name : aliased DDS.String;
Durability : aliased DurabilityQosPolicy;
Deadline : aliased DeadlineQosPolicy;
Latency_Budget : aliased LatencyBudgetQosPolicy;
Liveliness : aliased LivelinessQosPolicy;
Reliability : aliased ReliabilityQosPolicy;
Ownership : aliased OwnershipQosPolicy;
Destination_Order : aliased DestinationOrderQosPolicy;
User_Data : aliased UserDataQosPolicy;
Time_Based_Filter : aliased TimeBasedFilterQosPolicy;
Presentation : aliased PresentationQosPolicy;
Partition : aliased PartitionQosPolicy;
Topic_Data : aliased TopicDataQosPolicy;
Group_Data : aliased GroupDataQosPolicy;
Type_Consistency : aliased TypeConsistencyEnforcementQosPolicy;
Type_Object : aliased TypeObject_Access;
Representation : aliased DataRepresentationQosPolicy;
Data_Tags : aliased DataTagQosPolicy;
Type_Code : aliased TypeCode_Access;
Subscriber_Key : aliased BuiltinTopicKey_T;
Property : aliased PropertyQosPolicy;
Unicast_Locators : aliased Locator_Seq.Sequence;
Multicast_Locators : aliased Locator_Seq.Sequence;
Content_Filter_Property : aliased ContentFilterProperty_T;
Virtual_Guid : aliased Guid_T;
Service : aliased ServiceQosPolicy;
Rtps_Protocol_Version : aliased ProtocolVersion_T;
Rtps_Vendor_Id : aliased VendorId_T;
Product_Version : aliased ProductVersion_T;
Disable_Positive_Acks : aliased Boolean := False;
Expects_Inline_Qos : aliased Boolean := False;
Receive_Queue_Size : aliased Long := 0;
Is_Incompatible : aliased Boolean := False;
Subscription_Name : aliased EntityNameQosPolicy;
Trust_Protection_Info : aliased EndpointTrustProtectionInfo;
Trust_Algorithm_Info : aliased EndpointTrustAlgorithmInfo;
end record with Convention => C;
pragma Compile_Time_Error (SubscriptionBuiltinTopicData'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_h.DDS_SubscriptionBuiltinTopicData'Size, "SubscriptionBuiltinTopicData size missmatch.");
function Hash (Item : DDS.SubscriptionBuiltinTopicData) return Ada.Containers.Hash_Type;
type SubscriptionBuiltinTopicData_Access is access all SubscriptionBuiltinTopicData;
type SubscriptionBuiltinTopicData_Array is array (Natural range <>) of aliased SubscriptionBuiltinTopicData;
pragma Convention (C, SubscriptionBuiltinTopicData_Array);
function SubscriptionBuiltinTopicData_Get_TypeCode return Standard.DDS.TypeCode_Access;
pragma Import (C, SubscriptionBuiltinTopicData_Get_TypeCode, "DDS_SubscriptionBuiltinTopicData_get_typecode");
procedure Initialize (This : in out SubscriptionBuiltinTopicData);
procedure Finalize (This : in out SubscriptionBuiltinTopicData);
procedure Copy (Dst : in out SubscriptionBuiltinTopicData;
Src : in SubscriptionBuiltinTopicData);
package SubscriptionBuiltinTopicData_Seq is new DDS_Support.Sequences_Generic
(Element => DDS.SubscriptionBuiltinTopicData,
Element_Access => DDS.SubscriptionBuiltinTopicData_Access,
Index_Type => Natural,
First_Element => 1,
Element_Array => DDS.SubscriptionBuiltinTopicData_Array);
type KeyHash_Value_Array is array (0 .. 15) of aliased DDS.Octet;
type KeyHash_T is record
Value : aliased KeyHash_Value_Array := (others => 0);
Length : aliased DDS.Unsigned_Long := 0;
end record with
Convention => C;
type InconsistentTopicStatus is record
Total_Count : aliased Long := 0;
Total_Count_Change : aliased Long := 0;
end record with Convention => C;
pragma Compile_Time_Error (InconsistentTopicStatus'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_topic_h.DDS_InconsistentTopicStatus'Size, "InconsistentTopicStatus size missmatch.");
InconsistentTopicStatus_INITIALIZER : constant InconsistentTopicStatus := (others => <>);
type TopicQos is new Ada.Finalization.Limited_Controlled with record
Topic_Data : aliased TopicDataQosPolicy;
Durability : aliased DurabilityQosPolicy;
Durability_Service : aliased DurabilityServiceQosPolicy;
Deadline : aliased DeadlineQosPolicy;
Latency_Budget : aliased LatencyBudgetQosPolicy;
Liveliness : aliased LivelinessQosPolicy;
Reliability : aliased ReliabilityQosPolicy;
Destination_Order : aliased DestinationOrderQosPolicy;
History : aliased HistoryQosPolicy;
Resource_Limits : aliased ResourceLimitsQosPolicy;
Transport_Priority : aliased TransportPriorityQosPolicy;
Lifespan : aliased LifespanQosPolicy;
Ownership : aliased OwnershipQosPolicy;
Representation : aliased DataRepresentationQosPolicy;
Protocol : aliased TopicProtocolQosPolicy;
end record with Convention => C;
type TopicQos_Access is access TopicQos;
procedure Initialize
(Self : in out TopicQos);
procedure Finalize
(Self : in out TopicQos);
procedure Copy
(Target : in out TopicQos;
Source : in TopicQos);
type OfferedDeadlineMissedStatus is record
Total_Count : aliased Long := 0;
Total_Count_Change : aliased Long := 0;
Last_Instance_Handle : aliased InstanceHandle_T := Null_InstanceHandle_T;
end record with Convention => C;
pragma Compile_Time_Error (OfferedDeadlineMissedStatus'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_publication_h.DDS_OfferedDeadlineMissedStatus'Size, "OfferedDeadlineMissedStatus size missmatch.");
OfferedDeadlineMissedStatus_INITIALIZER : constant OfferedDeadlineMissedStatus := (others => <>);
type LivelinessLostStatus is record
Total_Count : aliased Long := 0;
Total_Count_Change : aliased Long := 0;
end record with Convention => C;
pragma Compile_Time_Error (LivelinessLostStatus'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_publication_h.DDS_LivelinessLostStatus'Size, "LivelinessLostStatus size missmatch.");
LivelinessLostStatus_INITIALIZER : constant LivelinessLostStatus := (others => <>);
type OfferedIncompatibleQosStatus is record
Total_Count : aliased Long := 0;
Total_Count_Change : aliased Long := 0;
Last_Policy_Id : aliased QosPolicyId_T := INVALID_QOS_POLICY_ID;
Policies : aliased QosPolicyCount_Seq.Sequence;
end record with Convention => C;
pragma Compile_Time_Error (OfferedIncompatibleQosStatus'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_publication_h.DDS_OfferedIncompatibleQosStatus'Size, "OfferedIncompatibleQosStatus size missmatch.");
type OfferedIncompatibleQosStatus_Access is access all OfferedIncompatibleQosStatus;
OfferedIncompatibleQosStatus_INITIALIZER : constant OfferedIncompatibleQosStatus := (others => <>);
type PublicationMatchedStatus is record
Total_Count : aliased Long := 0;
Total_Count_Change : aliased Long := 0;
Current_Count : aliased Long := 0;
Current_Count_Peak : aliased Long := 0;
Current_Count_Change : aliased Long := 0;
Last_Subscription_Handle : aliased InstanceHandle_T := Null_InstanceHandle_T;
end record with Convention => C;
pragma Compile_Time_Error (PublicationMatchedStatus'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_publication_h.DDS_PublicationMatchedStatus'Size, "PublicationMatchedStatus size missmatch.");
PublicationMatchedStatus_INITIALIZER : constant PublicationMatchedStatus := (others => <>);
type ReliableWriterCacheEventCount is record
Total_Count : aliased Long := 0;
Total_Count_Change : aliased Long := 0;
end record with Convention => C;
pragma Compile_Time_Error (ReliableWriterCacheEventCount'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_publication_h.DDS_ReliableWriterCacheEventCount'Size, "ReliableWriterCacheEventCount size missmatch.");
ReliableWriterCacheEventCount_INITIALIZER : constant ReliableWriterCacheEventCount := (others => <>);
type ReliableWriterCacheChangedStatus is record
Empty_Reliable_Writer_Cache : aliased ReliableWriterCacheEventCount;
Full_Reliable_Writer_Cache : aliased ReliableWriterCacheEventCount;
Low_Watermark_Reliable_Writer_Cache : aliased ReliableWriterCacheEventCount;
High_Watermark_Reliable_Writer_Cache : aliased ReliableWriterCacheEventCount;
Unacknowledged_Sample_Count : aliased Long := 0;
Unacknowledged_Sample_Count_Peak : aliased Long := 0;
Replaced_Unacknowledged_Sample_Count : aliased Long_Long := 0;
end record with Convention => C;
pragma Compile_Time_Error (ReliableWriterCacheChangedStatus'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_publication_h.DDS_ReliableWriterCacheChangedStatus'Size, "ReliableWriterCacheChangedStatus size missmatch.");
ReliableWriterCacheChangedStatus_INITIALIZER : constant ReliableWriterCacheChangedStatus := (others => <>);
type ReliableReaderActivityChangedStatus is record
Active_Count : aliased Long := 0;
Inactive_Count : aliased Long := 0;
Active_Count_Change : aliased Long := 0;
Inactive_Count_Change : aliased Long := 0;
Last_Instance_Handle : aliased InstanceHandle_T := Null_InstanceHandle_T;
end record with Convention => C;
pragma Compile_Time_Error (ReliableReaderActivityChangedStatus'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_publication_h.DDS_ReliableReaderActivityChangedStatus'Size, "ReliableReaderActivityChangedStatus size missmatch.");
ReliableReaderActivityChangedStatus_INITIALIZER : constant ReliableReaderActivityChangedStatus := (others => <>);
type AcknowledgmentInfo is record
Subscription_Handle : aliased InstanceHandle_T := Null_InstanceHandle_T;
Sample_Identity : aliased SampleIdentity_T;
Cookie : aliased Cookie_T;
Valid_Response_Data : aliased Boolean := False;
Response_Data : aliased AckResponseData_T;
end record with Convention => C;
pragma Compile_Time_Error (AcknowledgmentInfo'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_publication_h.DDS_AcknowledgmentInfo'Size, "AcknowledgmentInfo size missmatch.");
type AcknowledgmentInfo_Access is access all AcknowledgmentInfo;
type ServiceRequestAcceptedStatus is new RTIDDS.Low_Level.ndds_dds_c_dds_c_publication_h.DDS_ServiceRequestAcceptedStatus;
type ServiceRequestAcceptedStatus_Access is access all ServiceRequestAcceptedStatus with Storage_Size => 0;
type DataWriterQos is new Ada.Finalization.Limited_Controlled with record
Durability : aliased DurabilityQosPolicy;
Durability_Service : aliased DurabilityServiceQosPolicy;
Deadline : aliased DeadlineQosPolicy;
Latency_Budget : aliased LatencyBudgetQosPolicy;
Liveliness : aliased LivelinessQosPolicy;
Reliability : aliased ReliabilityQosPolicy;
Destination_Order : aliased DestinationOrderQosPolicy;
History : aliased HistoryQosPolicy;
Resource_Limits : aliased ResourceLimitsQosPolicy;
Transport_Priority : aliased TransportPriorityQosPolicy;
Lifespan : aliased LifespanQosPolicy;
User_Data : aliased UserDataQosPolicy;
Ownership : aliased OwnershipQosPolicy;
Ownership_Strength : aliased OwnershipStrengthQosPolicy;
Writer_Data_Lifecycle : aliased WriterDataLifecycleQosPolicy;
Representation : aliased DataRepresentationQosPolicy;
Data_Tags : aliased DataTagQosPolicy;
Writer_Resource_Limits : aliased DataWriterResourceLimitsQosPolicy;
Protocol : aliased DataWriterProtocolQosPolicy;
Transport_Selection : aliased TransportSelectionQosPolicy;
Unicast : aliased TransportUnicastQosPolicy;
Encapsulation : aliased TransportEncapsulationQosPolicy;
Publish_Mode : aliased PublishModeQosPolicy;
Property : aliased PropertyQosPolicy;
Service : aliased ServiceQosPolicy;
Batch : aliased BatchQosPolicy;
Multi_Channel : aliased MultiChannelQosPolicy;
Availability : aliased AvailabilityQosPolicy;
Publication_Name : aliased EntityNameQosPolicy;
Topic_Query_Dispatch : aliased TopicQueryDispatchQosPolicy;
Transfer_Mode : aliased DataWriterTransferModeQosPolicy;
Type_Support : aliased TypeSupportQosPolicy;
end record;
pragma Convention (C, DataWriterQos);
procedure Initialize
(Self : in out DataWriterQos);
procedure Finalize
(Self : in out DataWriterQos);
procedure Copy
(Target : out DataWriterQos;
Source : in DataWriterQos);
type PublisherQos is new Ada.Finalization.Limited_Controlled with record
Presentation : PresentationQosPolicy;
Partition : PartitionQosPolicy;
Group_Data : GroupDataQosPolicy;
Entity_Factory : EntityFactoryQosPolicy;
Asynchronous_Publisher : aliased AsynchronousPublisherQosPolicy;
Exclusive_Area : aliased ExclusiveAreaQosPolicy;
Protocol : aliased PublisherProtocolQosPolicy;
Publisher_Name : aliased EntityNameQosPolicy;
end record;
pragma Convention (C, PublisherQos);
type PublisherQos_Access is access PublisherQos;
procedure Initialize
(Self : in out PublisherQos);
procedure Finalize
(Self : in out PublisherQos);
procedure Copy
(Target : out PublisherQos;
Source : in PublisherQos);
type DataWriterCacheStatus is record
Sample_Count_Peak : aliased Long_Long := 0;
Sample_Count : aliased Long_Long := 0;
Alive_Instance_Count : aliased Long_Long := 0;
Alive_Instance_Count_Peak : aliased Long_Long := 0;
Disposed_Instance_Count : aliased Long_Long := 0;
Disposed_Instance_Count_Peak : aliased Long_Long := 0;
Unregistered_Instance_Count : aliased Long_Long := 0;
Unregistered_Instance_Count_Peak : aliased Long_Long := 0;
end record with Convention => C;
pragma Compile_Time_Error (DataWriterCacheStatus'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_publication_h.DDS_DataWriterCacheStatus'Size, "DataWriterCacheStatus size missmatch.");
type DataWriterProtocolStatus is record
Pushed_Sample_Count : aliased DDS.Long_Long := 0;
Pushed_Sample_Count_Change : aliased DDS.Long_Long := 0;
Pushed_Sample_Bytes : aliased DDS.Long_Long := 0;
Pushed_Sample_Bytes_Change : aliased DDS.Long_Long := 0;
Filtered_Sample_Count : aliased DDS.Long_Long := 0;
Filtered_Sample_Count_Change : aliased DDS.Long_Long := 0;
Filtered_Sample_Bytes : aliased DDS.Long_Long := 0;
Filtered_Sample_Bytes_Change : aliased DDS.Long_Long := 0;
Sent_Heartbeat_Count : aliased DDS.Long_Long := 0;
Sent_Heartbeat_Count_Change : aliased DDS.Long_Long := 0;
Sent_Heartbeat_Bytes : aliased DDS.Long_Long := 0;
Sent_Heartbeat_Bytes_Change : aliased DDS.Long_Long := 0;
Pulled_Sample_Count : aliased DDS.Long_Long := 0;
Pulled_Sample_Count_Change : aliased DDS.Long_Long := 0;
Pulled_Sample_Bytes : aliased DDS.Long_Long := 0;
Pulled_Sample_Bytes_Change : aliased DDS.Long_Long := 0;
Received_Ack_Count : aliased DDS.Long_Long := 0;
Received_Ack_Count_Change : aliased DDS.Long_Long := 0;
Received_Ack_Bytes : aliased DDS.Long_Long := 0;
Received_Ack_Bytes_Change : aliased DDS.Long_Long := 0;
Received_Nack_Count : aliased DDS.Long_Long := 0;
Received_Nack_Count_Change : aliased DDS.Long_Long := 0;
Received_Nack_Bytes : aliased DDS.Long_Long := 0;
Received_Nack_Bytes_Change : aliased DDS.Long_Long := 0;
Sent_Gap_Count : aliased DDS.Long_Long := 0;
Sent_Gap_Count_Change : aliased DDS.Long_Long := 0;
Sent_Gap_Bytes : aliased DDS.Long_Long := 0;
Sent_Gap_Bytes_Change : aliased DDS.Long_Long := 0;
Rejected_Sample_Count : aliased DDS.Long_Long := 0;
Rejected_Sample_Count_Change : aliased DDS.Long_Long := 0;
Send_Window_Size : aliased DDS.Long := 0;
First_Available_Sample_Sequence_Number : aliased DDS.SequenceNumber_T;
Last_Available_Sample_Sequence_Number : aliased DDS.SequenceNumber_T;
First_Unacknowledged_Sample_Sequence_Number : aliased DDS.SequenceNumber_T;
First_Available_Sample_Virtual_Sequence_Number : aliased DDS.SequenceNumber_T;
Last_Available_Sample_Virtual_Sequence_Number : aliased DDS.SequenceNumber_T;
First_Unacknowledged_Sample_Virtual_Sequence_Number : aliased DDS.SequenceNumber_T;
First_Unacknowledged_Sample_Subscription_Handle : aliased DDS.InstanceHandle_T;
First_Unelapsed_Keep_Duration_Sample_Sequence_Number : aliased DDS.SequenceNumber_T;
Pushed_Fragment_Count : aliased DDS.Long_Long := 0;
Pushed_Fragment_Bytes : aliased DDS.Long_Long := 0;
Pulled_Fragment_Count : aliased DDS.Long_Long := 0;
Pulled_Fragment_Bytes : aliased DDS.Long_Long := 0;
Received_Nack_Fragment_Count : aliased DDS.Long_Long := 0;
Received_Nack_Fragment_Bytes : aliased DDS.Long_Long := 0;
end record;
pragma Convention (C_Pass_By_Copy, DataWriterProtocolStatus);
type RequestedDeadlineMissedStatus is record
Total_Count : aliased Long := 0;
Total_Count_Change : aliased Long := 0;
Last_Instance_Handle : aliased InstanceHandle_T := Null_InstanceHandle_T;
end record with Convention => C;
pragma Compile_Time_Error (RequestedDeadlineMissedStatus'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_subscription_h.DDS_RequestedDeadlineMissedStatus'Size, "RequestedDeadlineMissedStatus size missmatch.");
RequestedDeadlineMissedStatus_INITIALIZER : constant RequestedDeadlineMissedStatus := (others => <>);
type LivelinessChangedStatus is record
Alive_Count : aliased Long := 0;
Not_Alive_Count : aliased Long := 0;
Alive_Count_Change : aliased Long := 0;
Not_Alive_Count_Change : aliased Long := 0;
Last_Publication_Handle : aliased InstanceHandle_T := Null_InstanceHandle_T;
end record with Convention => C;
pragma Compile_Time_Error (LivelinessChangedStatus'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_subscription_h.DDS_LivelinessChangedStatus'Size, "LivelinessChangedStatus size missmatch.");
LivelinessChangedStatus_INITIALIZER : constant LivelinessChangedStatus := (others => <>);
type RequestedIncompatibleQosStatus is record
Total_Count : aliased Long := 0;
Total_Count_Change : aliased Long := 0;
Last_Policy_Id : aliased QosPolicyId_T := INVALID_QOS_POLICY_ID;
Policies : aliased QosPolicyCount_Seq.Sequence;
end record with Convention => C;
pragma Compile_Time_Error (RequestedIncompatibleQosStatus'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_subscription_h.DDS_RequestedIncompatibleQosStatus'Size, "RequestedIncompatibleQosStatus size missmatch.");
type RequestedIncompatibleQosStatus_Access is access all RequestedIncompatibleQosStatus;
RequestedIncompatibleQosStatus_INITIALIZER : constant RequestedIncompatibleQosStatus := (others => <>);
type SampleLostStatusKind is new Unsigned_Long;
NOT_LOST : constant SampleLostStatusKind := 0;
LOST_BY_WRITER : constant SampleLostStatusKind := 1;
LOST_BY_INSTANCES_LIMIT : constant SampleLostStatusKind := 2;
LOST_BY_REMOTE_WRITERS_PER_INSTANCE_LIMIT : constant SampleLostStatusKind := 3;
LOST_BY_INCOMPLETE_COHERENT_SET : constant SampleLostStatusKind := 4;
LOST_BY_LARGE_COHERENT_SET : constant SampleLostStatusKind := 5;
LOST_BY_SAMPLES_PER_REMOTE_WRITER_LIMIT : constant SampleLostStatusKind := 6;
LOST_BY_VIRTUAL_WRITERS_LIMIT : constant SampleLostStatusKind := 7;
LOST_BY_REMOTE_WRITERS_PER_SAMPLE_LIMIT : constant SampleLostStatusKind := 8;
LOST_BY_AVAILABILITY_WAITING_TIME : constant SampleLostStatusKind := 9;
LOST_BY_REMOTE_WRITER_SAMPLES_PER_VIRTUAL_QUEUE_LIMIT : constant SampleLostStatusKind := 10;
LOST_BY_OUT_OF_MEMORY : constant SampleLostStatusKind := 11;
LOST_BY_UNKNOWN_INSTANCE : constant SampleLostStatusKind := 12;
type SampleLostStatus is record
Total_Count : aliased Long := 0;
Total_Count_Change : aliased Long := 0;
Last_Reason : aliased SampleLostStatusKind := NOT_LOST;
end record with Convention => C;
pragma Compile_Time_Error (SampleLostStatus'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_subscription_h.DDS_SampleLostStatus'Size, "SampleLostStatus size missmatch.");
SampleLostStatus_INITIALIZER : constant SampleLostStatus := (others => <>);
type SampleRejectedStatusKind is
(NOT_REJECTED,
REJECTED_BY_INSTANCES_LIMIT,
REJECTED_BY_SAMPLES_LIMIT,
REJECTED_BY_SAMPLES_PER_INSTANCE_LIMIT,
REJECTED_BY_SAMPLES_PER_REMOTE_WRITER_LIMIT,
REJECTED_BY_REMOTE_WRITER_SAMPLES_PER_VIRTUAL_QUEUE_LIMIT,
REJECTED_BY_DECODE_FAILURE);
pragma Convention (C, SampleRejectedStatusKind);
for SampleRejectedStatusKind use
(NOT_REJECTED => 0,
REJECTED_BY_INSTANCES_LIMIT => 1,
REJECTED_BY_SAMPLES_LIMIT => 2,
REJECTED_BY_SAMPLES_PER_INSTANCE_LIMIT => 3,
REJECTED_BY_SAMPLES_PER_REMOTE_WRITER_LIMIT => 6,
REJECTED_BY_REMOTE_WRITER_SAMPLES_PER_VIRTUAL_QUEUE_LIMIT => 9,
REJECTED_BY_DECODE_FAILURE => 10);
type SampleRejectedStatus is record
Total_Count : aliased Long := 0;
Total_Count_Change : aliased Long := 0;
Last_Reason : aliased SampleRejectedStatusKind := NOT_REJECTED;
Last_Instance_Handle : aliased InstanceHandle_T := Null_InstanceHandle_T;
end record with Convention => C;
pragma Compile_Time_Error (SampleRejectedStatus'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_subscription_h.DDS_SampleRejectedStatus'Size, "SampleRejectedStatus size missmatch.");
SampleRejectedStatus_INITIALIZER : constant SampleRejectedStatus := (others => <>);
type SubscriptionMatchedStatus is record
Total_Count : aliased Long := 0;
Total_Count_Change : aliased Long := 0;
Current_Count : aliased Long := 0;
Current_Count_Peak : aliased Long := 0;
Current_Count_Change : aliased Long := 0;
Last_Publication_Handle : aliased InstanceHandle_T := Null_InstanceHandle_T;
end record;
pragma Convention (C, SubscriptionMatchedStatus);
SubscriptionMatchedStatus_INITIALIZER : constant SubscriptionMatchedStatus := (others => <>);
type DataReaderCacheStatus is record
Sample_Count_Peak : aliased Long_Long := 0;
Sample_Count : aliased Long_Long := 0;
Old_Source_Timestamp_Dropped_Sample_Count : aliased Long_Long := 0;
Tolerance_Source_Timestamp_Dropped_Sample_Count : aliased Long_Long := 0;
Ownership_Dropped_Sample_Count : aliased Long_Long := 0;
Content_Filter_Dropped_Sample_Count : aliased Long_Long := 0;
Time_Based_Filter_Dropped_Sample_Count : aliased Long_Long := 0;
Expired_Dropped_Sample_Count : aliased Long_Long := 0;
Virtual_Duplicate_Dropped_Sample_Count : aliased Long_Long := 0;
Replaced_Dropped_Sample_Count : aliased Long_Long := 0;
Writer_Removed_Batch_Sample_Dropped_Sample_Count : aliased Long_Long := 0;
Total_Samples_Dropped_By_Instance_Replacement : aliased Long_Long := 0;
Alive_Instance_Count : aliased Long_Long := 0;
Alive_Instance_Count_Peak : aliased Long_Long := 0;
No_Writers_Instance_Count : aliased Long_Long := 0;
No_Writers_Instance_Count_Peak : aliased Long_Long := 0;
Disposed_Instance_Count : aliased Long_Long := 0;
Disposed_Instance_Count_Peak : aliased Long_Long := 0;
Detached_Instance_Count : aliased Long_Long := 0;
Detached_Instance_Count_Peak : aliased Long_Long := 0;
Compressed_Sample_Count : aliased Long_Long := 0;
end record with Convention => C;
pragma Compile_Time_Error (DataReaderCacheStatus'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_subscription_h.DDS_DataReaderCacheStatus'Size, "DataReaderCacheStatus size missmatch.");
DataReaderCacheStatus_INITIALIZER : constant DataReaderCacheStatus := (others => <>);
type DataReaderProtocolStatus is record
Received_Sample_Count : aliased Long_Long := 0;
Received_Sample_Count_Change : aliased Long_Long := 0;
Received_Sample_Bytes : aliased Long_Long := 0;
Received_Sample_Bytes_Change : aliased Long_Long := 0;
Duplicate_Sample_Count : aliased Long_Long := 0;
Duplicate_Sample_Count_Change : aliased Long_Long := 0;
Duplicate_Sample_Bytes : aliased Long_Long := 0;
Duplicate_Sample_Bytes_Change : aliased Long_Long := 0;
Filtered_Sample_Count : aliased Long_Long := 0;
Filtered_Sample_Count_Change : aliased Long_Long := 0;
Filtered_Sample_Bytes : aliased Long_Long := 0;
Filtered_Sample_Bytes_Change : aliased Long_Long := 0;
Received_Heartbeat_Count : aliased Long_Long := 0;
Received_Heartbeat_Count_Change : aliased Long_Long := 0;
Received_Heartbeat_Bytes : aliased Long_Long := 0;
Received_Heartbeat_Bytes_Change : aliased Long_Long := 0;
Sent_Ack_Count : aliased Long_Long := 0;
Sent_Ack_Count_Change : aliased Long_Long := 0;
Sent_Ack_Bytes : aliased Long_Long := 0;
Sent_Ack_Bytes_Change : aliased Long_Long := 0;
Sent_Nack_Count : aliased Long_Long := 0;
Sent_Nack_Count_Change : aliased Long_Long := 0;
Sent_Nack_Bytes : aliased Long_Long := 0;
Sent_Nack_Bytes_Change : aliased Long_Long := 0;
Received_Gap_Count : aliased Long_Long := 0;
Received_Gap_Count_Change : aliased Long_Long := 0;
Received_Gap_Bytes : aliased Long_Long := 0;
Received_Gap_Bytes_Change : aliased Long_Long := 0;
Rejected_Sample_Count : aliased Long_Long := 0;
Rejected_Sample_Count_Change : aliased Long_Long := 0;
First_Available_Sample_Sequence_Number : aliased SequenceNumber_T;
Last_Available_Sample_Sequence_Number : aliased SequenceNumber_T;
Last_Committed_Sample_Sequence_Number : aliased SequenceNumber_T;
Uncommitted_Sample_Count : aliased Long := 0;
Out_Of_Range_Rejected_Sample_Count : aliased Long_Long := 0;
Received_Fragment_Count : aliased Long_Long := 0;
Dropped_Fragment_Count : aliased Long_Long := 0;
Reassembled_Sample_Count : aliased Long_Long := 0;
Sent_Nack_Fragment_Count : aliased Long_Long := 0;
Sent_Nack_Fragment_Bytes : aliased Long_Long := 0;
end record;
pragma Convention (C_Pass_By_Copy, DataReaderProtocolStatus);
DataReaderProtocolStatus_INITIALIZER : constant DataReaderProtocolStatus :=
(Received_Sample_Count => 0,
Received_Sample_Count_Change => 0,
Received_Sample_Bytes => 0,
Received_Sample_Bytes_Change => 0,
Duplicate_Sample_Count => 0,
Duplicate_Sample_Count_Change => 0,
Duplicate_Sample_Bytes => 0,
Duplicate_Sample_Bytes_Change => 0,
Filtered_Sample_Count => 0,
Filtered_Sample_Count_Change => 0,
Filtered_Sample_Bytes => 0,
Filtered_Sample_Bytes_Change => 0,
Received_Heartbeat_Count => 0,
Received_Heartbeat_Count_Change => 0,
Received_Heartbeat_Bytes => 0,
Received_Heartbeat_Bytes_Change => 0,
Sent_Ack_Count => 0,
Sent_Ack_Count_Change => 0,
Sent_Ack_Bytes => 0,
Sent_Ack_Bytes_Change => 0,
Sent_Nack_Count => 0,
Sent_Nack_Count_Change => 0,
Sent_Nack_Bytes => 0,
Sent_Nack_Bytes_Change => 0,
Received_Gap_Count => 0,
Received_Gap_Count_Change => 0,
Received_Gap_Bytes => 0,
Received_Gap_Bytes_Change => 0,
Rejected_Sample_Count => 0,
Rejected_Sample_Count_Change => 0,
First_Available_Sample_Sequence_Number => SEQUENCE_NUMBER_UNKNOWN,
Last_Available_Sample_Sequence_Number => SEQUENCE_NUMBER_UNKNOWN,
Last_Committed_Sample_Sequence_Number => SEQUENCE_NUMBER_UNKNOWN,
Uncommitted_Sample_Count => 0,
Out_Of_Range_Rejected_Sample_Count => 0,
Received_Fragment_Count => 0,
Dropped_Fragment_Count => 0,
Reassembled_Sample_Count => 0,
Sent_Nack_Fragment_Count => 0,
Sent_Nack_Fragment_Bytes => 0);
type SampleStateKind is new Unsigned_Long;
READ_SAMPLE_STATE : constant SampleStateKind := 1;
NOT_READ_SAMPLE_STATE : constant SampleStateKind := 2;
subtype SampleStateMask is SampleStateKind;
ANY_SAMPLE_STATE : constant SampleStateMask := 16#FFFF#;
type SampleStateKind_Access is access constant SampleStateKind;
type ViewStateKind is new Unsigned_Long;
NEW_VIEW_STATE : constant ViewStateKind := 1;
NOT_NEW_VIEW_STATE : constant ViewStateKind := 2;
subtype ViewStateMask is ViewStateKind;
ANY_VIEW_STATE : constant ViewStateMask := 16#FFFF#;
type ViewStateKind_Access is access constant ViewStateKind;
type InstanceStateKind is new Unsigned_Long;
ALIVE_INSTANCE_STATE : constant InstanceStateKind := 1;
NOT_ALIVE_DISPOSED_INSTANCE_STATE : constant InstanceStateKind := 2;
NOT_ALIVE_NO_WRITERS_INSTANCE_STATE : constant InstanceStateKind := 4;
subtype InstanceStateMask is InstanceStateKind;
NOT_ALIVE_INSTANCE_STATE : constant InstanceStateMask := 6;
ANY_INSTANCE_STATE : constant InstanceStateMask := 16#FFFF#;
type InstanceStateKind_Access is access constant InstanceStateKind;
type SampleInfo is record
Sample_State : aliased SampleStateKind;
View_State : aliased ViewStateKind;
Instance_State : aliased InstanceStateKind;
Source_Timestamp : aliased Time_T;
Instance_Handle : aliased InstanceHandle_T;
Publication_Handle : aliased InstanceHandle_T;
Disposed_Generation_Count : aliased Long := 0;
No_Writers_Generation_Count : aliased Long := 0;
Sample_Rank : aliased Long := 0;
Generation_Rank : aliased Long := 0;
Absolute_Generation_Rank : aliased Long := 0;
Valid_Data : aliased DDS.Boolean := False;
Reception_Timestamp : aliased Time_T;
Publication_Sequence_Number : aliased SequenceNumber_T;
Reception_Sequence_Number : aliased SequenceNumber_T;
Publication_Virtual_Guid : aliased Guid_T;
Publication_Virtual_Sequence_Number : aliased SequenceNumber_T;
Original_Publication_Virtual_Guid : aliased Guid_T;
Original_Publication_Virtual_Sequence_Number : aliased SequenceNumber_T;
Related_Original_Publication_Virtual_Guid : aliased Guid_T;
Related_Original_Publication_Virtual_Sequence_Number : aliased SequenceNumber_T;
Flag : aliased SampleFlag;
Source_Guid : aliased Guid_T;
Related_Source_Guid : aliased Guid_T;
Related_Subscription_Guid : aliased Guid_T;
Topic_Query_Guid : aliased Guid_T;
Sample_Info_Hash : aliased RTIDDS.Low_Level.ndds_osapi_osapi_hash_h.RTIOsapiHash;
Sample_Signature : aliased access RTIDDS.Low_Level.ndds_pres_pres_common_impl_h.PRESSampleSignature;
Encapsulation_Id : aliased EncapsulationId_T;
Related_Epoch : aliased SequenceNumber_T;
Coherent_Set_Info : aliased access RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_CoherentSetInfo_t;
end record with Convention => C;
pragma Compile_Time_Error (SampleInfo'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_subscription_h.DDS_SampleInfo'Size, "SampleInfo size missmatch.");
type SampleInfo_Access is access all SampleInfo;
type SampleInfo_Array is array (Natural range <>) of aliased SampleInfo;
procedure Initialize (Self : in out SampleInfo);
procedure Finalize (Self : in out SampleInfo);
procedure Copy (Dst : in out SampleInfo; Src : in SampleInfo);
procedure Get_Sample_Identity (From : SampleInfo; Id : out SampleIdentity_T);
function Get_Sample_Identity (From : SampleInfo) return SampleIdentity_T;
procedure Get_Related_Sample_Identity (From : SampleInfo; Id : out SampleIdentity_T);
function Get_Related_Sample_Identity (From : SampleInfo) return SampleIdentity_T;
package SampleInfo_Seq is new DDS_Support.Sequences_Generic
(SampleInfo,
SampleInfo_Access,
DDS.Natural,
1,
SampleInfo_Array);
type DataReaderQoS is new Ada.Finalization.Limited_Controlled with record
Durability : aliased DurabilityQosPolicy;
Deadline : aliased DeadlineQosPolicy;
Latency_Budget : aliased LatencyBudgetQosPolicy;
Liveliness : aliased LivelinessQosPolicy;
Reliability : aliased ReliabilityQosPolicy;
Destination_Order : aliased DestinationOrderQosPolicy;
History : aliased HistoryQosPolicy;
Resource_Limits : aliased ResourceLimitsQosPolicy;
User_Data : aliased UserDataQosPolicy;
Ownership : aliased OwnershipQosPolicy;
Time_Based_Filter : aliased TimeBasedFilterQosPolicy;
Reader_Data_Lifecycle : aliased ReaderDataLifecycleQosPolicy;
Representation : aliased DataRepresentationQosPolicy;
Type_Consistency : aliased TypeConsistencyEnforcementQosPolicy;
Data_Tags : aliased DataTagQosPolicy;
Reader_Resource_Limits : aliased DataReaderResourceLimitsQosPolicy;
Protocol : aliased DataReaderProtocolQosPolicy;
Transport_Selection : aliased TransportSelectionQosPolicy;
Unicast : aliased TransportUnicastQosPolicy;
Multicast : aliased TransportMulticastQosPolicy;
Encapsulation : aliased TransportEncapsulationQosPolicy;
Property : aliased PropertyQosPolicy;
Service : aliased ServiceQosPolicy;
Availability : aliased AvailabilityQosPolicy;
Subscription_Name : aliased EntityNameQosPolicy;
Transport_Priority : aliased TransportPriorityQosPolicy;
Type_Support : aliased TypeSupportQosPolicy;
end record;
pragma Convention (C, DataReaderQoS);
procedure Initialize
(Self : in out DataReaderQoS);
procedure Finalize
(Self : in out DataReaderQoS);
procedure Copy
(Target : out DataReaderQoS;
Source : in DataReaderQoS);
type SubscriberQos is new Ada.Finalization.Limited_Controlled with record
Presentation : PresentationQosPolicy;
Partition : PartitionQosPolicy;
Group_Data : GroupDataQosPolicy;
Entity_Factory : EntityFactoryQosPolicy;
Exclusive_Area : ExclusiveAreaQosPolicy;
Protocol : aliased SubscriberProtocolQosPolicy;
Subscriber_Name : aliased EntityNameQosPolicy;
end record;
pragma Convention (C, SubscriberQos);
type SubscriberQos_Access is access SubscriberQos;
procedure Initialize
(Self : in out SubscriberQos);
procedure Finalize
(Self : in out SubscriberQos);
procedure Copy
(Target : out SubscriberQos;
Source : in SubscriberQos);
SQLFILTER_NAME : constant DDS.String := To_DDS_String ("DDSSQL");
STRINGMATCHFILTER_NAME : constant DDS.String := To_DDS_String ("DDSSTRINGMATCH");
type DomainParticipantQos is new Ada.Finalization.Limited_Controlled with record
User_Data : aliased UserDataQosPolicy;
Entity_Factory : aliased EntityFactoryQosPolicy;
Wire_Protocol : aliased WireProtocolQosPolicy;
Transport_Builtin : aliased TransportBuiltinQosPolicy;
Default_Unicast : aliased TransportUnicastQosPolicy;
Discovery : aliased DiscoveryQosPolicy;
Resource_Limits : aliased DomainParticipantResourceLimitsQosPolicy;
Event : aliased EventQosPolicy;
Receiver_Pool : aliased ReceiverPoolQosPolicy;
Database : aliased DatabaseQosPolicy;
Discovery_Config : aliased DiscoveryConfigQosPolicy;
Exclusive_Area : aliased ExclusiveAreaQosPolicy;
Property : aliased PropertyQosPolicy;
Participant_Name : aliased EntityNameQosPolicy;
Multicast_Mapping : aliased TransportMulticastMappingQosPolicy;
Service : aliased ServiceQosPolicy;
Partition : aliased PartitionQosPolicy;
User_Object : aliased UserObjectQosPolicy;
Protocol : aliased DomainParticipantProtocolQosPolicy;
Type_Support : aliased TypeSupportQosPolicy;
end record;
pragma Convention (C, DomainParticipantQos);
procedure Initialize
(Self : in out DomainParticipantQos);
procedure Finalize
(Self : in out DomainParticipantQos);
procedure Copy
(Target : out DomainParticipantQos;
Source : in DomainParticipantQos);
type LogCategory is private;
Category_PLATFORM : constant LogCategory;
Category_COMMUNICATION : constant LogCategory;
Category_DATABASE : constant LogCategory;
Category_ENTITIES : constant LogCategory;
Category_API : constant LogCategory;
Category_ALL : constant LogCategory;
type LogVerbosity is private;
function "+" (Left, Right : LogVerbosity) return LogVerbosity;
function Image (Item : LogVerbosity) return Standard.String;
VERBOSITY_SILENT : constant LogVerbosity;
VERBOSITY_ERROR : constant LogVerbosity;
VERBOSITY_WARNING : constant LogVerbosity;
VERBOSITY_STATUS_LOCAL : constant LogVerbosity;
VERBOSITY_STATUS_REMOTE : constant LogVerbosity;
VERBOSITY_ALL : constant LogVerbosity;
function Contains (Self : LogVerbosity; Verbosity : LogVerbosity) return Boolean;
type LogPrintFormat is private;
function "+" (Left, Right : LogPrintFormat) return LogPrintFormat;
PRINT_NONE : constant LogPrintFormat;
PRINT_BIT_NUMBER : constant LogPrintFormat;
PRINT_BIT_MESSAGE : constant LogPrintFormat;
PRINT_BIT_LOCATION_MODULE : constant LogPrintFormat;
PRINT_BIT_LOCATION_FILELINE : constant LogPrintFormat;
PRINT_BIT_LOCATION_METHOD : constant LogPrintFormat;
PRINT_BIT_TIMESTAMP : constant LogPrintFormat;
PRINT_BIT_THREAD_ID : constant LogPrintFormat;
PRINT_BIT_CONTEXT : constant LogPrintFormat;
PRINT_BIT_TWO_LINES : constant LogPrintFormat;
PRINT_FORMAT_DEFAULT : constant LogPrintFormat;
PRINT_FORMAT_TIMESTAMPED : constant LogPrintFormat;
PRINT_FORMAT_VERBOSE : constant LogPrintFormat;
PRINT_FORMAT_VERBOSE_TIMESTAMPED : constant LogPrintFormat;
PRINT_FORMAT_DEBUG : constant LogPrintFormat;
PRINT_FORMAT_MINIMAL : constant LogPrintFormat;
PRINT_FORMAT_MAXIMAL : constant LogPrintFormat;
type LoggingQosPolicy is record
Verbosity : LogVerbosity := VERBOSITY_SILENT;
Category : LogCategory := Category_PLATFORM;
Print_Format : LogPrintFormat := PRINT_NONE;
Output_File : String;
Output_File_Suffix : String;
Max_Bytes_Per_File : Long := -1;
Max_Files : Long := -1;
end record;
type SqlFilterAlignmentQos is record
Char_Alignment : aliased DDS.Unsigned_Short := 0;
Short_Alignment : aliased DDS.Unsigned_Short := 0;
Long_Alignment : aliased DDS.Unsigned_Short := 0;
Float_Alignment : aliased DDS.Unsigned_Short := 0;
Double_Alignment : aliased DDS.Unsigned_Short := 0;
Longlong_Alignment : aliased DDS.Unsigned_Short := 0;
Longdouble_Alignment : aliased DDS.Unsigned_Short := 0;
Pointer_Alignment : aliased DDS.Unsigned_Short := 0;
end record with Convention => C_Pass_By_Copy;
pragma Compile_Time_Error (SqlFilterAlignmentQos'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_sqlfilter_h.DDS_SqlFilterAlignmentQos'Size, "SqlFilterAlignmentQos size missmatch.");
type SqlFilterMemoryManagementQos is record
Buffer_Min_Size : aliased DDS.Long := 0;
Trim_Buffer : aliased DDS.Boolean := False;
end record with Convention => C_Pass_By_Copy;
pragma Compile_Time_Error (SqlFilterMemoryManagementQos'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_sqlfilter_h.DDS_SqlFilterMemoryManagementQos'Size, "SqlFilterMemoryManagementQos size missmatch.");
type SqlFilterGeneratorQos is new RTIDDS.Low_Level.ndds_dds_c_dds_c_sqlfilter_h.DDS_SqlFilterGeneratorQos;
type MonitoringDedicatedParticipantSettings is record
enable : aliased Boolean := False;
domain_id : aliased Integer := 0;
participant_qos_profile_name : aliased String;
collector_initial_peers : aliased String_Seq.Sequence;
end record
with Convention => C;
pragma Compile_Time_Error (MonitoringDedicatedParticipantSettings'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_MonitoringDedicatedParticipantSettings'Size, "MonitoringDedicatedParticipantSettings'size missmatch");
type MonitoringEventDistributionSettings is record
concurrency_level : aliased Unsigned_Long;
datawriter_qos_profile_name : aliased String;
thread : aliased ThreadSettings_T;
publication_period : aliased Duration_T;
end record
with Convention => C;
pragma Compile_Time_Error (MonitoringEventDistributionSettings'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_MonitoringEventDistributionSettings'Size, "MonitoringEventDistributionSettings'size missmatch");
type MonitoringPeriodicDistributionSettings is record
datawriter_qos_profile_name : aliased String;
thread : aliased ThreadSettings_T;
polling_period : aliased Duration_T;
end record
with Convention => C;
pragma Compile_Time_Error (MonitoringPeriodicDistributionSettings'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_MonitoringPeriodicDistributionSettings'Size, "MonitoringPeriodicDistributionSettings'size missmatch");
type MonitoringLoggingDistributionSettings is record
concurrency_level : aliased Unsigned_Long;
max_historical_logs : aliased Unsigned_Long;
datawriter_qos_profile_name : aliased String;
thread : aliased ThreadSettings_T;
publication_period : aliased Duration_T;
end record
with Convention => C;
pragma Compile_Time_Error (MonitoringLoggingDistributionSettings'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_MonitoringLoggingDistributionSettings'Size, "MonitoringLoggingDistributionSettings'size missmatch");
type MonitoringDistributionSettings is record
Dedicated_Participant : aliased MonitoringDedicatedParticipantSettings;
publisher_qos_profile_name : aliased String;
event_settings : aliased MonitoringEventDistributionSettings;
periodic_settings : aliased MonitoringPeriodicDistributionSettings;
logging_settings : aliased MonitoringLoggingDistributionSettings;
end record
with Convention => C;
pragma Compile_Time_Error (MonitoringDistributionSettings'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_MonitoringDistributionSettings'Size, "MonitoringDistributionSettings'size missmatch");
type MonitoringMetricSelection is record
resource_selection : aliased String;
enabled_metrics_selection : aliased String_Seq.Sequence;
disabled_metrics_selection : aliased String_Seq.Sequence;
end record
with Convention => C;
pragma Compile_Time_Error (MonitoringMetricSelection'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_MonitoringMetricSelection'Size, "MonitoringMetricSelection'size missmatch");
type MonitoringMetricSelection_Access is access all MonitoringMetricSelection;
type MonitoringMetricSelection_Array is array
(Natural range <>) of aliased MonitoringMetricSelection;
procedure Initialize (Self : in out MonitoringMetricSelection);
procedure Finalize (Self : in out MonitoringMetricSelection);
procedure Copy (Dst : in out MonitoringMetricSelection;
Src : in MonitoringMetricSelection);
package MonitoringMetricSelection_Seq is new DDS_Support.Sequences_Generic
(MonitoringMetricSelection,
MonitoringMetricSelection_Access,
DDS.Natural,
1,
MonitoringMetricSelection_Array);
type MonitoringLoggingForwardingSettings is record
middleware_forwarding_level : aliased RTIDDS.Low_Level.ndds_ndds_config_common_h.NDDS_Config_SyslogVerbosity := RTIDDS.Low_Level.ndds_ndds_config_common_h.NDDS_CONFIG_SYSLOG_VERBOSITY_WARNING;
security_forwarding_level : aliased RTIDDS.Low_Level.ndds_ndds_config_common_h.NDDS_Config_SyslogVerbosity := RTIDDS.Low_Level.ndds_ndds_config_common_h.NDDS_CONFIG_SYSLOG_VERBOSITY_WARNING;
service_forwarding_level : aliased RTIDDS.Low_Level.ndds_ndds_config_common_h.NDDS_Config_SyslogVerbosity := RTIDDS.Low_Level.ndds_ndds_config_common_h.NDDS_CONFIG_SYSLOG_VERBOSITY_WARNING;
user_forwarding_level : aliased RTIDDS.Low_Level.ndds_ndds_config_common_h.NDDS_Config_SyslogVerbosity := RTIDDS.Low_Level.ndds_ndds_config_common_h.NDDS_CONFIG_SYSLOG_VERBOSITY_WARNING;
end record
with Convention => C;
pragma Compile_Time_Error (MonitoringLoggingForwardingSettings'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_MonitoringLoggingForwardingSettings'Size, "MonitoringLoggingForwardingSettings'size missmatch");
type MonitoringTelemetryData is record
logs : aliased MonitoringMetricSelection_Seq.Sequence;
metrics : aliased MonitoringLoggingForwardingSettings;
end record
with Convention => C;
pragma Compile_Time_Error (MonitoringTelemetryData'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_MonitoringTelemetryData'Size, "MonitoringTelemetryData'size missmatch");
type MonitoringQosPolicy is record
enable : aliased Boolean;
application_name : aliased String;
distribution_settings : aliased MonitoringDistributionSettings;
telemetry_data : aliased MonitoringTelemetryData;
end record
with Convention => C;
pragma Compile_Time_Error (MonitoringQosPolicy'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_MonitoringQosPolicy'Size, "MonitoringQosPolicy'size missmatch");
type DomainParticipantFactoryQos is new Ada.Finalization.Limited_Controlled with record
Entity_Factory : aliased EntityFactoryQosPolicy;
Resource_Limits : aliased SystemResourceLimitsQosPolicy;
Profile : aliased ProfileQosPolicy;
Logging : aliased LoggingQosPolicy;
monitoring : aliased MonitoringQosPolicy;
end record;
pragma Convention (C, DomainParticipantFactoryQos);
type DomainParticipantFactoryQos_Access is access constant DomainParticipantFactoryQos;
procedure Copy
(Target : out DomainParticipantFactoryQos;
Source : in DomainParticipantFactoryQos);
procedure Initialize
(Self : in out DomainParticipantFactoryQos);
procedure Finalize
(Self : in out DomainParticipantFactoryQos);
DEFAULT_FLOW_CONTROLLER_NAME : constant DDS.String := To_DDS_String ("DDS_DEFAULT_FLOW_CONTROLLER_NAME");
FIXED_RATE_FLOW_CONTROLLER_NAME : constant DDS.String := To_DDS_String ("DDS_FIXED_RATE_FLOW_CONTROLLER_NAME");
ON_DEMAND_FLOW_CONTROLLER_NAME : constant DDS.String := To_DDS_String ("DDS_ON_DEMAND_FLOW_CONTROLLER_NAME");
type FlowControllerSchedulingPolicy is new Unsigned_Long;
RR_FLOW_CONTROLLER_SCHED_POLICY : constant FlowControllerSchedulingPolicy := 0;
EDF_FLOW_CONTROLLER_SCHED_POLICY : constant FlowControllerSchedulingPolicy := 1;
type FlowControllerTokenBucketProperty_T is record
Max_Tokens : aliased DDS.Long := 0;
Tokens_Added_Per_Period : aliased DDS.Long := 0;
Tokens_Leaked_Per_Period : aliased DDS.Long := 0;
Period : aliased Duration_T;
Bytes_Per_Token : aliased DDS.Long := 0;
end record;
pragma Convention (C, FlowControllerTokenBucketProperty_T);
type FlowControllerProperty_T is record
Scheduling_Policy : aliased DDS.FlowControllerSchedulingPolicy := EDF_FLOW_CONTROLLER_SCHED_POLICY;
Token_Bucket : aliased DDS.FlowControllerTokenBucketProperty_T := (-1, -1, 0, (1, 0), -1);
Is_Vendor_Specific : aliased DDS.Boolean := False;
end record;
pragma Convention (C, FlowControllerProperty_T);
FlowControllerProperty_T_INITIALIZER : constant FlowControllerProperty_T :=
(Scheduling_Policy => DDS.EDF_FLOW_CONTROLLER_SCHED_POLICY,
Token_Bucket => (-1, -1, 0, (1, 0), -1),
Is_Vendor_Specific => False);
procedure Copy (C_Out : not null access FlowControllerProperty_T;
C_In : not null access FlowControllerProperty_T);
type InvalidLocalIdentityAdvanceNoticeStatus is record
Expiration_Time : aliased Time_T;
end record with Convention => C;
pragma Compile_Time_Error (InvalidLocalIdentityAdvanceNoticeStatus'Size /= RTIDDS.Low_Level.ndds_dds_c_dds_c_domain_h.DDS_InvalidLocalIdentityAdvanceNoticeStatus'Size, "InvalidLocalIdentityAdvanceNoticeStatus'Size missmatch");
type ReferenceScope is
(SIMPLE_CONTENT_SCOPE,
REFERENCED_CONTENTS_SCOPE);
type ObjectScope is
(SIMPLE_OBJECT_SCOPE,
CONTAINED_OBJECTS_SCOPE,
RELATED_OBJECTS_SCOPE);
type DCPSState is
(INITIAL,
REGISTERED,
ENABLED);
type CacheUsage is
(READ_ONLY,
WRITE_ONLY,
READ_WRITE);
type ObjectSubState is new Interfaces.Unsigned_16;
OBJECT_NEW : constant ObjectSubState := 2#0000_0000_0000_0001#;
OBJECT_MODIFIED : constant ObjectSubState := 2#0000_0000_0000_0010#;
OBJECT_READ : constant ObjectSubState := 2#0000_0000_0000_0100#;
OBJECT_DELETED : constant ObjectSubState := 2#0000_0000_0000_1000#;
OBJECT_CREATED : constant ObjectSubState := 2#0000_0001_0000_0000#;
OBJECT_CHANGED : constant ObjectSubState := 2#0000_0010_0000_0000#;
OBJECT_WRITTEN : constant ObjectSubState := 2#0000_0100_0000_0000#;
OBJECT_DESTROYED : constant ObjectSubState := 2#0000_1000_0000_0000#;
type DLRLOid is record
Creator_Id : aliased Unsigned_Long;
Local_Id : aliased Unsigned_Long;
end record;
type TimeOutDuration is new Interfaces.Unsigned_32;
INFINITE_TIME_OUT : constant TimeOutDuration := -1;
subtype ClassName is DDS.String;
subtype CacheName is DDS.String;
subtype RelationName is DDS.String;
BadParameter : exception;
NotFound : exception;
ReadOnlyMode : exception;
WriteOnlyMode : exception;
AlreadyClonedInWriteMode : exception;
ExpiredTimeOut : exception;
type ObjectReference is record
Oid : DLRLOid;
Home_Index : Unsigned_Long;
end record;
type RelationKind is
(REF_RELATION,
LIST_RELATION,
INT_MAP_RELATION,
STR_MAP_RELATION);
type RelatedObjectDepth is new Short_Integer;
UNLIMITED_RELATED_OBJECTS : constant RelatedObjectDepth := -1;
type MembershipState is
(UNDEFINED_MEMBERSHIP,
ALREADY_MEMBER,
NOT_MEMBER);
Not_Implemented : exception;
function Octets_New
return Octets_Ptr;
function Octets_New_W_Size
(Size : Integer)
return Octets_Ptr;
procedure Octets_Delete
(Self : Octets_Ptr);
function KeyedString_New
return KeyedString_Ptr;
function KeyedString_New_W_Size
(Key_Size : Integer;
Size : Integer)
return KeyedString_Ptr;
procedure KeyedString_Delete
(Self : KeyedString_Ptr);
function KeyedOctets_New
return KeyedOctets_Ptr;
function KeyedOctets_New_W_Size
(Key_Size : Integer;
Size : Integer)
return KeyedOctets_Ptr;
procedure KeyedOctets_Delete
(Self : KeyedOctets_Ptr);
function Convert (Code : RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_ReturnCode_t) return DDS.ReturnCode_T;
procedure Ret_Code_To_Exception (Code : RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_ReturnCode_t;
Message : Standard.String := "");
procedure Ret_Code_To_Exception (Code : RTIDDS.Low_Level.ndds_dds_c_dds_c_common_h.DDS_Boolean;
Message : Standard.String := "");
private
type TypeObject is new RTIDDS.Low_Level.ndds_dds_c_dds_c_typeobject_h.DDS_Type;
type TypeCode is new RTIDDS.Low_Level.ndds_dds_c_dds_c_typecode_h.DDS_TypeCode;
type LogCategory is new RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_Config_LogCategory;
Category_PLATFORM : constant LogCategory := LogCategory (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_CATEGORY_PLATFORM);
Category_COMMUNICATION : constant LogCategory := LogCategory (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_CATEGORY_COMMUNICATION);
Category_DATABASE : constant LogCategory := LogCategory (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_CATEGORY_DATABASE);
Category_ENTITIES : constant LogCategory := LogCategory (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_CATEGORY_ENTITIES);
Category_API : constant LogCategory := LogCategory (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_CATEGORY_API);
Category_ALL : constant LogCategory := LogCategory (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_CATEGORY_ALL);
type LogVerbosity is new RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_Config_LogVerbosity;
VERBOSITY_SILENT : constant LogVerbosity := LogVerbosity (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_VERBOSITY_SILENT);
VERBOSITY_ERROR : constant LogVerbosity := LogVerbosity (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_VERBOSITY_ERROR);
VERBOSITY_WARNING : constant LogVerbosity := LogVerbosity (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_VERBOSITY_WARNING);
VERBOSITY_STATUS_LOCAL : constant LogVerbosity := LogVerbosity (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_VERBOSITY_STATUS_LOCAL);
VERBOSITY_STATUS_REMOTE : constant LogVerbosity := LogVerbosity (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_VERBOSITY_STATUS_REMOTE);
VERBOSITY_ALL : constant LogVerbosity := LogVerbosity (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_VERBOSITY_STATUS_ALL);
type LogPrintFormat is new RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_Config_LogPrintFormat;
PRINT_NONE : constant LogPrintFormat := LogPrintFormat (0);
PRINT_BIT_NUMBER : constant LogPrintFormat := LogPrintFormat (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_PRINT_BIT_NUMBER);
PRINT_BIT_MESSAGE : constant LogPrintFormat := LogPrintFormat (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_PRINT_BIT_MESSAGE);
PRINT_BIT_LOCATION_MODULE : constant LogPrintFormat := LogPrintFormat (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_PRINT_BIT_LOCATION_MODULE);
PRINT_BIT_LOCATION_FILELINE : constant LogPrintFormat := LogPrintFormat (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_PRINT_BIT_LOCATION_FILELINE);
PRINT_BIT_LOCATION_METHOD : constant LogPrintFormat := LogPrintFormat (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_PRINT_BIT_LOCATION_METHOD);
PRINT_BIT_TIMESTAMP : constant LogPrintFormat := LogPrintFormat (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_PRINT_BIT_TIMESTAMP);
PRINT_BIT_THREAD_ID : constant LogPrintFormat := LogPrintFormat (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_PRINT_BIT_THREAD_ID);
PRINT_BIT_CONTEXT : constant LogPrintFormat := LogPrintFormat (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_PRINT_BIT_ACTIVITY_CONTEXT);
PRINT_BIT_TWO_LINES : constant LogPrintFormat := LogPrintFormat (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_PRINT_BIT_TWO_LINES);
PRINT_FORMAT_DEFAULT : constant LogPrintFormat := LogPrintFormat (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_PRINT_FORMAT_DEFAULT);
PRINT_FORMAT_TIMESTAMPED : constant LogPrintFormat := LogPrintFormat (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_PRINT_FORMAT_TIMESTAMPED);
PRINT_FORMAT_VERBOSE : constant LogPrintFormat := LogPrintFormat (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_PRINT_FORMAT_VERBOSE);
PRINT_FORMAT_VERBOSE_TIMESTAMPED : constant LogPrintFormat := LogPrintFormat (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_PRINT_FORMAT_VERBOSE_TIMESTAMPED);
PRINT_FORMAT_DEBUG : constant LogPrintFormat := LogPrintFormat (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_PRINT_FORMAT_DEBUG);
PRINT_FORMAT_MINIMAL : constant LogPrintFormat := LogPrintFormat (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_PRINT_FORMAT_DEBUG);
PRINT_FORMAT_MAXIMAL : constant LogPrintFormat := LogPrintFormat (RTIDDS.Low_Level.ndds_ndds_config_c_h.NDDS_CONFIG_LOG_PRINT_FORMAT_MAXIMAL);
use Interfaces.C.Strings;
function GetInterface (P_Qos : TopicQos) return access RTIDDS.Low_Level.ndds_dds_c_dds_c_topic_h.DDS_TopicQos;
function GetInterface (P_Qos : DataWriterQos) return access RTIDDS.Low_Level.ndds_dds_c_dds_c_publication_h.DDS_DataWriterQos;
function GetInterface (P_Qos : PublisherQos) return access RTIDDS.Low_Level.ndds_dds_c_dds_c_publication_h.DDS_PublisherQos;
function GetInterface (P_Qos : DataReaderQoS) return access RTIDDS.Low_Level.ndds_dds_c_dds_c_subscription_h.DDS_DataReaderQos;
function GetInterface (P_Qos : SubscriberQos) return access RTIDDS.Low_Level.ndds_dds_c_dds_c_subscription_h.DDS_SubscriberQos;
function GetInterface (P_Qos : DomainParticipantQos) return access RTIDDS.Low_Level.ndds_dds_c_dds_c_domain_h.DDS_DomainParticipantQos;
function GetInterface (P_Qos : DomainParticipantFactoryQos) return access RTIDDS.Low_Level.ndds_dds_c_dds_c_domain_h.DDS_DomainParticipantFactoryQos;
function GetInterface (FC_P : FlowControllerProperty_T) return access RTIDDS.Low_Level.ndds_dds_c_dds_c_flowcontroller_h.DDS_FlowControllerProperty_t;
procedure Free is new Ada.Unchecked_Deallocation (PublisherQos, PublisherQos_Access);
procedure Free is new Ada.Unchecked_Deallocation (SubscriberQos, SubscriberQos_Access);
procedure Free is new Ada.Unchecked_Deallocation (TopicQos, TopicQos_Access);
procedure Validate_Library;
procedure Copy_Down (Dst : out RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_Time_t;
Source : DDS.Time_T);
procedure Copy_Down (Dst : out RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_WriteParams_t;
Source : DDS.WriteParams_T);
procedure Copy_Up (Dst : out DDS.Time_T;
Source : RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_Time_t);
procedure Copy_Down (Dst : out RTIDDS.Low_Level.ndds_pres_pres_participant_h.PRESInstanceHandle;
Source : DDS.InstanceHandle_T);
procedure Copy_Up (Dst : out DDS.InstanceHandle_T;
Source : RTIDDS.Low_Level.ndds_pres_pres_participant_h.PRESInstanceHandle);
procedure Copy_Down (Dst : out RTIDDS.Low_Level.ndds_dds_c_dds_c_common_h.DDS_Boolean;
Source : DDS.Boolean);
procedure Copy_Down (Dst : out RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_SampleIdentity_t;
Source : DDS.SampleIdentity_T);
procedure Copy_Down (Dst : out RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_GUID_t;
Source : DDS.Guid_T);
procedure Copy_Down (Dst : out RTIDDS.Low_Level.ndds_dds_c_dds_c_common_h.DDS_Long;
Source : DDS.Long);
procedure Copy_Down (Dst : out RTIDDS.Low_Level.ndds_dds_c_dds_c_common_h.DDS_Long;
Source : DDS.SampleFlag);
procedure Copy_Down (Dst : out RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_SequenceNumber_t;
Source : DDS.SequenceNumber_T);
procedure Copy_Down (Dst : out RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_OctetSeq;
Source : DDS.Octet_Seq.Sequence);
procedure Copy_Down (Dst : out RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_Cookie_t;
Source : DDS.Cookie_T);
procedure Copy_Down (Dst : out RTIDDS.Low_Level.ndds_dds_c_dds_c_common_h.DDS_UnsignedLong;
Source : DDS.Unsigned_Long);
Epoch : constant Ada.Calendar.Time := Ada.Calendar.Time_Of (1970, 01, 01);
function GetInterface (Item : String) return access Interfaces.C.Strings.chars_ptr;
function GetInterface (Item : String) return Interfaces.C.Strings.chars_ptr;
procedure Copy (To : in out String; From : Interfaces.C.Strings.chars_ptr);
procedure Debug_Trap;
end DDS;