Namespaces
	FilterExpressionGrammar

	GrammarUtils

	IDL

	TopicExpressionGrammar

	Transport

	Util

Classes
class	AbstractSamples

struct	AddDomainStatus

class	AddressCache

struct	AddressCacheEntry

struct	AddressCacheEntryProxy

class	AllocHeader

struct	AssociationData

class	AtomicBool

class	BasicQueue

class	BasicQueueVisitor

class	BestEffortSession

class	BestEffortSessionFactory

class	BitPubListenerImpl

class	BitSubscriber

struct	BudgetExceededStatus

class	BuildChainVisitor

struct	BuiltinTopicKey_tKeyLessThan

class	BuiltinTopicKeyLess

struct	BundlingCacheKey

class	Cached_Allocator_With_Overflow
	A fixed-size allocator that caches items for quicker access but if the pool is exhausted it will use the heap. More...

struct	CoherentChangeControl
	End Coherent Change message. More...

class	ComparatorBase

class	ConditionImpl

class	ConditionVariable

struct	ConnectionRecord

struct	ConstSequenceIterator

struct	ConstSequenceIterTraits

struct	ConstSharedRepoIdSet

class	container_supported_unique_ptr

class	ContentFilteredTopicImpl

struct	ContentFilterProperty_t

class	CopyChainVisitor

class	Data_Types_Register

class	DataCollector

class	DataDurabilityCache
	Underlying data cache for both OpenDDS `TRANSIENT` and `PERSISTENT` `DURABILITY` implementations.. More...

class	DataLink

class	DataLinkCleanupTask
	Active Object responsible for cleaning up DataLink resources. More...

class	DataLinkSet

struct	DataReaderAssociation

struct	DataReaderAssociationPeriodic

class	DataReaderCallbacks
	Defines the interface for Discovery callbacks into the DataReader. More...

interface	DataReaderEx

class	DataReaderImpl
	Implements the DDS::DataReader interface. More...

class	DataReaderImpl_T

interface	DataReaderListener

struct	DataReaderPeriodicReport

interface	DataReaderRemote

class	DataReaderRemoteImpl
	Implements the OpenDDS::DCPS::ReaderRemote interface that is used to add and remove associations. More...

struct	DataReaderReport

class	DataSampleElement

struct	DataSampleHeader

struct	DataWriterAssociation

struct	DataWriterAssociationPeriodic

class	DataWriterCallbacks
	Defines the interface for Discovery callbacks into the DataWriter. More...

class	DataWriterImpl
	Implements the OpenDDS::DCPS::DataWriterRemote interfaces and DDS::DataWriter interfaces. More...

class	DataWriterImpl_T

interface	DataWriterListener

struct	DataWriterPeriodicReport

interface	DataWriterRemote

class	DataWriterRemoteImpl
	Implements the OpenDDS::DCPS::DataWriterRemote interface. More...

struct	DataWriterReport

interface	DCPSInfo

class	DcpsUpcalls

struct	DDSTraits

struct	default_deleter

class	DefaultNetworkConfigMonitor

class	DirectPriorityMapper
	map TRANSPORT_PRIORITY values directly. More...

struct	DiscoveredReaderData

struct	DiscoveredWriterData

class	Discovery
	Discovery Strategy interface class. More...

class	DiscoveryListener
	Defines the interface that allows DataWriters (and lower levels) to inform discovery. More...

class	DisjointSequence

class	DispatchService

class	DomainParticipantFactoryImpl
	Implements the OpenDDS::DCPS::DomainParticipantFactory interfaces. More...

class	DomainParticipantImpl
	Implements the OpenDDS::DCPS::DomainParticipant interfaces. More...

struct	DomainParticipantReport

class	DPMonitorImpl

class	DRMonitorImpl

class	DRPeriodicMonitorImpl

class	DurabilityArray
	Array class that provides a means to reset the underlying `ACE_Allocator`. More...

class	DurabilityQueue
	Queue class that provides a means to reset the underlying `ACE_Allocator`. More...

class	DWMonitorImpl

class	DWPeriodicMonitorImpl

class	Dynamic_Cached_Allocator_With_Overflow
	A size-based allocator that caches blocks for quicker access, but if the pool is exhausted it will use the heap. More...

class	EnableContainerSupportedUniquePtr

class	EncapsulationHeader

class	Encoding

class	EndHistoricSamplesMissedSweeper

class	EndpointRegistry

struct	EntityId_t

struct	EntityId_tKeyLessThan

class	EntityImpl
	Implements the OpenDDS::DCPS::Entity interfaces. More...

class	EnumHelper

struct	EventBase

class	EventDispatcher

class	FailoverListener

class	FibonacciSequence

class	FieldComparator

class	FilterEvaluator

class	FirstTimeFastAllocator

struct	FragKey

class	FreeHeader

class	FreeIndex

class	FreeIndexNode

union	GenericReport

class	GroupRakeData

struct	GUID_t

struct	GUID_tKeyLessThan

class	GuidBuilder

class	GuidConverter
	Conversion processing and value testing utilities for RTPS GUID_t types. More...

struct	GuidCount

struct	HostnameInfo

struct	inc_count

struct	IncompatibleQosStatus

class	InfoRepoDiscovery
	Discovery Strategy class that implements InfoRepo discovery. More...

class	InfoRepoType

class	InstanceDataSampleList

class	InstanceHandleGenerator

class	InstanceState
	manage the states of a received data instance. More...

class	InternalDataReader

class	InternalDataReaderListener

class	InternalDataWriter

class	InternalEntity

struct	InternalMessageCountKey

class	InternalMessageCountValue

struct	InternalSampleInfo

struct	InternalThreadBuiltinTopicData

class	InternalTopic

struct	InternalTransportStatistics

exception	Invalid_Domain

exception	Invalid_Participant

exception	Invalid_Publication

exception	Invalid_Subscription

exception	Invalid_Topic

class	IRDiscoveryLoader

class	JobQueue

struct	keep_count

struct	KeyOnly

struct	LatencyStatistics
	Collection of latency statistics for a single association. More...

class	ListEnumHelper

class	ListMemberHelper

class	LivenessTimer

class	LocalObject

class	LocalObjectBase

struct	Locator_t

struct	LocatorCacheKey

class	LogAddr

struct	LogGuid

class	LogLevel

class	LogRestore

class	Marked_Default_Qos

struct	MarshalTraits

class	MemberHelper

class	MemoryPool

struct	Message_Block_Deleter

class	Message_Block_Shared_Ptr

class	MessageBlockHelper

struct	MessageCount

class	MessageHolder

class	MessageHolder_T

class	MessageTracker

class	MetaStruct

struct	MetaStructImpl

struct	MetaSubmessage

class	Monitor

class	MonitorFactory
	Null implementation of the MonitorFactory. More...

class	MonitorFactoryImpl
	Full implementation of the MonitorFactoryImpl. More...

struct	MonotonicTime_t

class	MulticastDataLink

class	MulticastInitializer

class	MulticastInst

class	MulticastLoader

class	MulticastManager

class	MulticastReceiveStrategy

class	MulticastSendStrategy

class	MulticastSession

class	MulticastSessionFactory

class	MulticastTransport

class	MulticastType

class	MultiTask

class	MultiTopicDataReader_T

class	MultiTopicDataReaderBase

class	MultiTopicImpl

struct	NameValuePair

struct	NestedKeyOnly

class	NetworkAddress

class	NetworkConfigMonitor

struct	NetworkInterfaceAddress

struct	NetworkInterfaceAddressKeyEqual

struct	NetworkResource
	Defines a wrapper around address info which is used for advertise. More...

class	NullSynch

class	NullSynchStrategy

struct	Objref_Servant_Pair
	This struct holds both object reference and the corresponding servant. More...

class	Observer

class	OwnershipManager

class	PacketRemoveVisitor

struct	ParticipantLocationBuiltinTopicData

class	PartitionName

class	PerConnectionSynch

class	PerConnectionSynchStrategy

class	PeriodicEvent

class	PeriodicTask

class	PmfEvent

class	PmfMultiTask

class	PmfNowEvent

class	PmfPeriodicTask

class	PmfSporadicTask

class	PoolAllocationBase

class	PoolSynch

class	PoolSynchStrategy

class	PrinterValueWriter
	Convert values to a readable format. More...

class	PriorityKey
	Encapsulate a priority value and internet address as a key. More...

class	PriorityMapper
	Encapsulate a TRANSPORT_PRIORITY value. More...

interface	ProcessMonitor

class	PublicationInstance
	Struct that has information about an instance and the instance sample list. More...

struct	PublicationLostStatus

class	PublisherImpl
	Implements the OpenDDS::DCPS::Publisher interfaces. More...

class	PublisherMonitorImpl

struct	PublisherReport

class	Qos_Helper
	This class implements methods that verify whether a qos is valid, consistent and changeable. More...

class	QOS_XML_File_Handler

class	QOS_XML_Handler

class	QOS_XML_Loader

class	QOS_XML_String_Handler

class	QueryConditionImpl

class	QueueRemoveVisitor

class	QueueTaskBase
	A simple ACE task that manages a queue of request. More...

struct	RakeData

class	RakeResults

class	RawDataSample

class	RcEventHandler

class	RcHandle

class	RcObject

class	ReactorInterceptor

class	ReactorSynch
	Send thread synchronization utilizing a reactor. More...

class	ReactorSynchStrategy
	strategy to construct ReactorSynch implementations of ThreadSynch. More...

class	ReactorTask

class	ReadConditionImpl

struct	ReaderAssociation

struct	ReaderProxy_t

class	ReceivedDataElement

class	ReceivedDataElementList

struct	ReceivedDataElementMemoryBlock

class	ReceivedDataElementWithType

class	ReceivedDataFilter

class	ReceivedDataOperation

class	ReceivedDataSample
	Holds a data sample received by the transport. More...

class	ReceivedDataStrategy

class	ReceiveListenerSet

class	ReceiveListenerSetMap

class	ReceptionDataStrategy

class	Recorder

class	RecorderImpl
	Implementation of Recorder functionality. More...

class	RecorderListener
	Listener for handling callbacks from the Recorder. More...

class	reference_wrapper

class	ReliableSession

class	ReliableSessionFactory

class	RemoveAllVisitor

class	Replayer
	Send raw data samples in the system. More...

class	ReplayerImpl
	Implementation of Replayer functionality. More...

class	ReplayerListener
	Listener for handling callbacks from the Replayer. More...

class	RepoIdBuilder

class	RepoIdConverter
	Conversion processing and value testing utilities for DCPS Information Repository identifiers. More...

class	RepoIdGenerator
	Create RepoId values for use within DDS. More...

class	RestoreOutputStreamState

struct	RoutedGuidPair

class	RtpsCustomizedElement

class	RtpsSampleHeader
	Adapt the TransportReceiveStrategy for RTPS's "sample" (submessage) Header. More...

struct	RtpsTransportHeader
	Adapt the TransportReceiveStrategy for RTPS's "transport" (message) Header. More...

class	RtpsUdpDataLink

class	RtpsUdpInitializer

class	RtpsUdpInst

class	RtpsUdpLoader

class	RtpsUdpReceiveStrategy

class	RtpsUdpSendStrategy

class	RtpsUdpTransport

class	RtpsUdpType

class	rv

class	SafeBool_T

class	SafeBool_T< void >

class	SafeBoolBase

class	Sample

class	Sample_T

struct	SampleRchCmp

class	ScheduleOutputHandler
	event handler used to enable and disable output processing. More...

class	SecurityDebug

struct	SendRequest

class	SendResponseListener
	Simple listener to discard response samples. More...

class	SendStateDataSampleList

struct	SendStateDataSampleListConstIterator
	`SendStateDataSampleList` STL-style const iterator implementation. More...

struct	SendStateDataSampleListIterator
	`SendStateDataSampleList` STL-style iterator implementation. More...

struct	SeqReaders

class	SequenceBackInsertIterator

struct	SequenceIterator

struct	SequenceIteratorBase

struct	SequenceIterTraits

class	SequenceNumber
	Sequence number abstraction. Only allows positive 64 bit values. More...

class	SerializedSizeBound

class	Serializer
	Class to serialize and deserialize data for DDS. More...

class	Service_Participant
	Service entrypoint. More...

class	ServiceEventDispatcher

struct	ServiceParticipantReport

struct	ShmemData

class	ShmemDataLink

class	ShmemInitializer

class	ShmemInst

class	ShmemLoader

class	ShmemReceiveStrategy

class	ShmemSendStrategy

class	ShmemTransport

class	ShmemType

class	ShutdownListener

class	SingleSendBuffer

class	SourceDataStrategy

class	SPMonitorImpl

class	SporadicEvent

class	SporadicTask

class	StaticDiscovery

class	StaticEndpointManager

class	StaticParticipant

struct	Statistics

class	Stats

class	StatusConditionImpl

class	StructComparator

class	SubscriberImpl

class	SubscriberMonitorImpl

struct	SubscriberReport

class	SubscriptionInstance
	Struct that has information about an instance and the instance sample list. More...

struct	SubscriptionLostStatus

class	Tcp_Initializer

class	TcpAcceptor

class	TcpConnection

class	TcpDataLink

class	TcpInst

class	TcpLoader

class	TcpReceiveStrategy

class	TcpSendStrategy

class	TcpSynchResource

class	TcpTransport

class	TcpType

class	ThreadPerConnectionSendTask
	Execute the requests of sending a sample or control message. More...

class	ThreadPerConRemoveVisitor

class	ThreadPool

class	ThreadStatusManager

class	ThreadSynch

class	ThreadSynchResource

class	ThreadSynchStrategy

class	ThreadSynchWorker

class	TimeDuration

class	TimePoint_T

class	TimeSource

class	TopicCallbacks
	Defines the interface for Discovery callbacks into the Topic. More...

class	TopicDescriptionImpl
	Implements the DDS::TopicDescription interface. More...

class	TopicDescriptionPtr

struct	TopicDetails

class	TopicImpl
	Implements the DDS::Topic interface. More...

class	TopicMonitorImpl

struct	TopicReport

class	TransactionalRtpsSendQueue

class	Transient_Kludge

class	TransportClient
	Mix-in class for DDS entities which directly use the transport layer. More...

class	TransportConfig

class	TransportControlElement

class	TransportCustomizedElement

class	TransportDebug

struct	TransportHeader
	Defines class that represents a transport packet header. More...

class	TransportImpl

class	TransportInst
	Base class to hold configuration settings for TransportImpls. More...

struct	TransportLocator

class	TransportMonitorImpl

class	TransportQueueElement
	Base wrapper class around a data/control sample to be sent. More...

class	TransportReassembly

struct	TransportReceiveConstants

class	TransportReceiveListener

class	TransportReceiveStrategy

class	TransportRegistry

class	TransportReplacedElement

struct	TransportReport

class	TransportRetainedElement

class	TransportSendBuffer

class	TransportSendControlElement

class	TransportSendElement

class	TransportSendListener

class	TransportSendStrategy

struct	TransportStatistics

class	TransportStrategy

class	TransportType
	Base class for concrete transports to provide new objects. More...

interface	TypeSupport

class	TypeSupportImpl

class	TypeSupportImpl_T

class	UdpDataLink

class	UdpInitializer

class	UdpInst

class	UdpLoader

class	UdpReceiveStrategy

class	UdpSendStrategy

class	UdpTransport

class	UdpType

class	unique_ptr

struct	Value

struct	ValueDispatcher

struct	ValueDispatcher_T

class	ValueReader

union	ValueUnion

class	ValueWriter

struct	VarLess

class	WeakObject

class	WeakRcHandle

class	WriteConnectionRecords

class	WriteDataContainer
	A container for instances sample data. More...

struct	WriterAssociation

struct	WriterCoherentSample

class	WriterDataSampleList

class	WriterInfo
	Keeps track of a DataWriter's liveliness for a DataReader. More...

class	WriterInfoListener

struct	WriterProxy_t

class	WriterStats
	Elements stored for managing statistical data. More...

Typedefs
typedef yard::TreeBuildingParser< char >::Node	AstNode

typedef DataReaderImpl_T< DDS::ParticipantBuiltinTopicData >	ParticipantBuiltinTopicDataDataReaderImpl

typedef DataReaderImpl_T< DDS::PublicationBuiltinTopicData >	PublicationBuiltinTopicDataDataReaderImpl

typedef DataReaderImpl_T< DDS::SubscriptionBuiltinTopicData >	SubscriptionBuiltinTopicDataDataReaderImpl

typedef DataReaderImpl_T< DDS::TopicBuiltinTopicData >	TopicBuiltinTopicDataDataReaderImpl

typedef DataReaderImpl_T< ParticipantLocationBuiltinTopicData >	ParticipantLocationBuiltinTopicDataDataReaderImpl

typedef DataReaderImpl_T< InternalThreadBuiltinTopicData >	InternalThreadBuiltinTopicDataDataReaderImpl

typedef DataReaderImpl_T< ConnectionRecord >	ConnectionRecordDataReaderImpl

typedef Cached_Allocator_With_Overflow< ACE_Message_Block, ACE_Thread_Mutex >	MessageBlockAllocator

typedef Cached_Allocator_With_Overflow< ACE_Data_Block, ACE_Thread_Mutex >	DataBlockAllocator

typedef std::pair< OPENDDS_STRING, ACE_Configuration_Section_Key >	SubsectionPair

typedef std::pair< bool, ConnectionRecord >	ActionConnectionRecord

typedef RcHandle< DataReaderCallbacks >	DataReaderCallbacks_rch

typedef WeakRcHandle< DataReaderCallbacks >	DataReaderCallbacks_wrch

typedef Cached_Allocator_With_Overflow< ReceivedDataElementMemoryBlock, ACE_Thread_Mutex >	ReceivedDataAllocator

typedef RcHandle< DataReaderImpl >	DataReaderImpl_rch

typedef Cached_Allocator_With_Overflow< DataSampleElement, ACE_Null_Mutex >	DataSampleElementAllocator

typedef RcHandle< PublicationInstance >	PublicationInstance_rch

typedef ACE_Message_Block	DataSample

typedef Cached_Allocator_With_Overflow< DataSampleHeader, ACE_Null_Mutex >	DataSampleHeaderAllocator

typedef RcHandle< DataWriterCallbacks >	DataWriterCallbacks_rch

typedef WeakRcHandle< DataWriterCallbacks >	DataWriterCallbacks_wrch

typedef RcHandle< DataWriterImpl >	DataWriterImpl_rch

typedef RcHandle< Discovery >	Discovery_rch

typedef RcHandle< DispatchService >	DispatchService_rch

typedef RcHandle< EventBase >	EventBase_rch

typedef RcHandle< EventDispatcher >	EventDispatcher_rch

typedef GuidSet	RepoIdSet

typedef unsigned char	MD5Result[16]

typedef RcHandle< InfoRepoDiscovery >	InfoRepoDiscovery_rch

typedef RcHandle< InstanceState >	InstanceState_rch

typedef WeakRcHandle< InternalEntity >	InternalEntity_wrch

typedef RcHandle< JobQueue >	JobQueue_rch

typedef WeakRcHandle< JobQueue >	JobQueue_wrch

typedef CORBA::LocalObject_ptr	LocalObject_ptr

typedef CORBA::LocalObject_var	LocalObject_var

typedef unique_ptr< ACE_Message_Block, Message_Block_Deleter >	Message_Block_Ptr

typedef RcHandle< NetworkConfigMonitor >	NetworkConfigMonitor_rch

typedef RcHandle< Observer >	Observer_rch

typedef std::string	String

typedef std::wstring	WString

typedef ACE_UINT16	CoherencyGroup

typedef RcHandle< ReactorInterceptor >	ReactorInterceptor_rch

typedef WeakRcHandle< ReactorInterceptor >	ReactorInterceptor_wrch

typedef RcHandle< ReactorTask >	ReactorTask_rch
	The type definition for the smart-pointer to the underlying type. More...

typedef RcHandle< RecorderListener >	RecorderListener_rch

typedef Recorder *	Recorder_ptr

typedef TAO_Objref_Var_T< Recorder >	Recorder_var

typedef RcHandle< ReplayerListener >	ReplayerListener_rch

typedef Replayer *	Replayer_ptr

typedef TAO_Objref_Var_T< Replayer >	Replayer_var

typedef ::CORBA::Long	ParticipantId

typedef RepoId	PublicationId

typedef RepoId	SubscriptionId

typedef ACE_Allocator	SafetyProfilePool

typedef RcHandle< Sample >	Sample_rch

typedef RcHandle< const Sample >	ConstSample_rch

typedef std::pair< SequenceNumber, SequenceNumber >	SequenceRange

typedef RcHandle< ServiceEventDispatcher >	ServiceEventDispatcher_rch

typedef RcHandle< StaticDiscovery >	StaticDiscovery_rch

typedef RcHandle< SubscriptionInstance >	SubscriptionInstance_rch

typedef WeakRcHandle< TransportSendListener >	TransportSendListener_wrch

typedef RcHandle< DataLink >	DataLink_rch
	The type definition for the smart-pointer to the underlying type. More...

typedef RcHandle< DataLinkSet >	DataLinkSet_rch
	The type definition for the smart-pointer to the underlying type. More...

typedef WeakRcHandle< TransportReceiveListener >	TransportReceiveListener_wrch

typedef RcHandle< ReceiveListenerSet >	ReceiveListenerSet_rch
	The type definition for the smart-pointer to the underlying type. More...

typedef RcHandle< ThreadSynchStrategy >	ThreadSynchStrategy_rch

typedef RcHandle< ThreadSynchWorker >	ThreadSynchWorker_rch

typedef RcHandle< TransportClient >	TransportClient_rch

typedef RcHandle< TransportConfig >	TransportConfig_rch

typedef ACE_UINT64	DataLinkIdType
	Identifier type for DataLink objects. More...

typedef Cached_Allocator_With_Overflow< ACE_Message_Block, RECEIVE_SYNCH >	TransportMessageBlockAllocator

typedef Cached_Allocator_With_Overflow< ACE_Data_Block, RECEIVE_SYNCH >	TransportDataBlockAllocator

typedef Cached_Allocator_With_Overflow< char[RECEIVE_DATA_BUFFER_SIZE], RECEIVE_SYNCH >	TransportDataAllocator

typedef ACE_CDR::Long	Priority

typedef size_t	ConnectionInfoFlags

typedef WeakRcHandle< TransportClient >	TransportClient_wrch

typedef RcHandle< TransportImpl >	TransportImpl_rch
	The type definition for the smart-pointer to the underlying type. More...

typedef RcHandle< TransportInst >	TransportInst_rch
	The type definition for the smart-pointer to the underlying type. More...

typedef std::pair< TransportQueueElement , TransportQueueElement >	TqePair

typedef RcHandle< TransportReassembly >	TransportReassembly_rch

typedef RcHandle< TransportReceiveListener >	TransportReceiveListener_rch

typedef RcHandle< TransportReceiveStrategy >	TransportReceiveStrategy_rch
	The type definition for the smart-pointer to the underlying type. More...

typedef Cached_Allocator_With_Overflow< TransportSendControlElement, ACE_SYNCH_NULL_MUTEX >	TransportSendControlElementAllocator

typedef RcHandle< TransportSendListener >	TransportSendListener_rch

typedef RcHandle< TransportSendStrategy >	TransportSendStrategy_rch
	The type definition for the smart-pointer to the underlying type. More...

typedef RcHandle< TransportStrategy >	TransportStrategy_rch

typedef RcHandle< TransportType >	TransportType_rch

typedef RcHandle< MulticastTransport >	MulticastTransport_rch

typedef RcHandle< MulticastDataLink >	MulticastDataLink_rch

typedef RcHandle< MulticastInst >	MulticastInst_rch

typedef RcHandle< MulticastReceiveStrategy >	MulticastReceiveStrategy_rch

typedef RcHandle< MulticastSendStrategy >	MulticastSendStrategy_rch

typedef RcHandle< MulticastSession >	MulticastSession_rch

typedef RcHandle< MulticastSessionFactory >	MulticastSessionFactory_rch

typedef ACE_INT64	MulticastPeer

typedef Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >	RtpsCustomizedElementAllocator

typedef RcHandle< RtpsUdpInst >	RtpsUdpInst_rch

typedef RcHandle< RtpsUdpTransport >	RtpsUdpTransport_rch

typedef AddressCache< LocatorCacheKey >	LocatorCache

typedef AddressCache< BundlingCacheKey >	BundlingCache

typedef RcHandle< RtpsUdpDataLink >	RtpsUdpDataLink_rch

typedef RcHandle< RtpsUdpReceiveStrategy >	RtpsUdpReceiveStrategy_rch

typedef RcHandle< RtpsUdpSendStrategy >	RtpsUdpSendStrategy_rch

typedef RcHandle< ShmemTransport >	ShmemTransport_rch

typedef ACE_Local_Memory_Pool	ShmemPool

typedef int	ShmemSharedSemaphore

typedef ACE_Malloc_T< ShmemPool, ACE_Process_Mutex, ACE_PI_Control_Block >	ShmemAllocator

typedef RcHandle< ShmemDataLink >	ShmemDataLink_rch

typedef RcHandle< ShmemInst >	ShmemInst_rch

typedef RcHandle< ShmemReceiveStrategy >	ShmemReceiveStrategy_rch

typedef RcHandle< ShmemSendStrategy >	ShmemSendStrategy_rch

typedef RcHandle< TcpConnection >	TcpConnection_rch

typedef RcHandle< TcpDataLink >	TcpDataLink_rch

typedef RcHandle< TcpInst >	TcpInst_rch

typedef RcHandle< TcpReceiveStrategy >	TcpReceiveStrategy_rch

typedef RcHandle< TcpSendStrategy >	TcpSendStrategy_rch

typedef RcHandle< TcpTransport >	TcpTransport_rch

typedef RcHandle< UdpTransport >	UdpTransport_rch

typedef RcHandle< UdpDataLink >	UdpDataLink_rch

typedef RcHandle< UdpInst >	UdpInst_rch

typedef RcHandle< UdpReceiveStrategy >	UdpReceiveStrategy_rch

typedef RcHandle< UdpSendStrategy >	UdpSendStrategy_rch

typedef RcHandle< WriterInfo >	WriterInfo_rch

typedef octet	GuidVendorId_t[2]

typedef octet	GuidPrefix_t[12]

typedef octet	EntityKey_t[3]

typedef sequence< GUID_t >	GUIDSeq

typedef GUID_t	RepoId

typedef DDS::OctetSeq	TransportBLOB

typedef sequence< TransportLocator >	TransportLocatorSeq

typedef sequence< RepoId >	WriterIdSeq

typedef sequence< RepoId >	ReaderIdSeq

typedef string< 256 >	String256

typedef PublicationLostStatus	PublicationDisconnectedStatus

typedef PublicationLostStatus	PublicationReconnectedStatus

typedef PublicationLostStatus	DisassociationStatus

typedef SubscriptionLostStatus	SubscriptionDisconnectedStatus

typedef SubscriptionLostStatus	SubscriptionReconnectedStatus

typedef sequence< LatencyStatistics >	LatencyStatisticsSeq

typedef sequence< NameValuePair >	NVPSeq

typedef sequence< DataWriterAssociation >	DWAssociations

typedef sequence< DataWriterAssociationPeriodic >	DWAssociationsPeriodic

typedef sequence< DataReaderAssociation >	DRAssociations

typedef sequence< DataReaderAssociationPeriodic >	DRAssociationsPeriodic

typedef unsigned long	ParticipantLocation

typedef sequence< Locator_t >	LocatorSeq

typedef long	MessageCountKind

typedef sequence< MessageCount >	MessageCountSequence

typedef sequence< GuidCount >	GuidCountSequence

typedef sequence< TransportStatistics >	TransportStatisticsSequence


typedef ACE_System_Time_Policy	SystemClock

typedef TimePoint_T< SystemClock >	SystemTimePoint


typedef SystemClock	MonotonicClock

typedef TimePoint_T< MonotonicClock >	MonotonicTimePoint

Enumerations
enum	CvStatus { CvStatus_NoTimeout, CvStatus_Timeout, CvStatus_Error }

enum	MarshalingType { FULL_MARSHALING, KEY_ONLY_MARSHALING }

enum	MessageId { SAMPLE_DATA, DATAWRITER_LIVELINESS, INSTANCE_REGISTRATION, UNREGISTER_INSTANCE, DISPOSE_INSTANCE, GRACEFUL_DISCONNECT, REQUEST_ACK, SAMPLE_ACK, END_COHERENT_CHANGES, TRANSPORT_CONTROL, DISPOSE_UNREGISTER_INSTANCE, END_HISTORIC_SAMPLES, MESSAGE_ID_MAX }
	One byte message id (<256) More...

enum	SubMessageId { SUBMESSAGE_NONE, MULTICAST_SYN, MULTICAST_SYNACK, MULTICAST_NAK, MULTICAST_NAKACK, SUBMESSAGE_ID_MAX }

enum	DataSampleHeaderFlag { BYTE_ORDER_FLAG, COHERENT_CHANGE_FLAG, HISTORIC_SAMPLE_FLAG, LIFESPAN_DURATION_FLAG, GROUP_COHERENT_FLAG, CONTENT_FILTER_FLAG, SEQUENCE_REPAIR_FLAG, MORE_FRAGMENTS_FLAG }

enum	DataSampleHeaderFlag2 { CDR_ENCAP_FLAG, KEY_ONLY_FLAG }

enum	EntityKind { KIND_UNKNOWN, KIND_PARTICIPANT, KIND_USER_WRITER, KIND_USER_READER, KIND_USER_TOPIC, KIND_BUILTIN_WRITER, KIND_BUILTIN_READER, KIND_BUILTIN_TOPIC, KIND_PUBLISHER, KIND_SUBSCRIBER, KIND_USER }

enum	InternalSampleInfoKind { ISIK_REGISTER, ISIK_SAMPLE, ISIK_UNREGISTER, ISIK_DISPOSE }

enum	Operation_t { DDS_OPERATION_READ, DDS_OPERATION_TAKE }

enum	Endianness { ENDIAN_BIG = 0, ENDIAN_LITTLE = 1, ENDIAN_NATIVE = ENDIAN_BIG, ENDIAN_NONNATIVE = ENDIAN_LITTLE }

enum	Extensibility { FINAL, APPENDABLE, MUTABLE }

enum	SendStrategyOpType { SEND_START, SEND, SEND_STOP, REMOVE_SAMPLE, REMOVE_ALL_CONTROL_SAMPLES }

enum	SendControlStatus { SEND_CONTROL_ERROR, SEND_CONTROL_OK }
	Return code type for send_control() operations. More...

enum	AttachStatus { ATTACH_BAD_TRANSPORT, ATTACH_ERROR, ATTACH_INCOMPATIBLE_QOS, ATTACH_OK }
	Return code type for attach_transport() operations. More...

enum	{ MAX_SEND_BLOCKS = 50 }
	Controls the maximum size of the iovec array used for a send packet. More...

enum	{ RECEIVE_DATA_BUFFER_SIZE = 65536 }
	Allocators used for transport receiving logic. More...

enum	{ DEFAULT_TRANSPORT_RECEIVE_BUFFERS = 16 }

enum	{ DEFAULT_CONFIG_QUEUE_MESSAGES_PER_POOL = 10, DEFAULT_CONFIG_QUEUE_INITIAL_POOLS = 5, DEFAULT_CONFIG_MAX_PACKET_SIZE = 2147481599, DEFAULT_CONFIG_MAX_SAMPLES_PER_PACKET = 10, DEFAULT_CONFIG_OPTIMUM_PACKET_SIZE = 4096 }
	Default TransportInst settings. More...

enum	RemoveResult { REMOVE_ERROR, REMOVE_NOT_FOUND, REMOVE_FOUND, REMOVE_RELEASED }
	used by DataLink::remove_sample(), TransportSendStrategy, *RemoveVisitor More...

enum	{ SHMEM_DATA_FREE = 0, SHMEM_DATA_IN_USE = 1, SHMEM_DATA_RECV_DONE = 2, SHMEM_DATA_END_OF_ALLOC = -1 }

enum	Coherent_State { NOT_COMPLETED_YET, COMPLETED, REJECTED }

enum	TopicStatus { CREATED, ENABLED, FOUND, NOT_FOUND, REMOVED, CONFLICTING_TYPENAME, PRECONDITION_NOT_MET, INTERNAL_ERROR, TOPIC_DISABLED }

enum	ValueEnumType { INTEGER_TYPE, DOUBLE_TYPE, STRING_TYPE, STATISTICS_TYPE, STRING_LIST_TYPE }

enum	ReportType { SERVICE_PARTICIPANT_REPORT_TYPE, DOMAIN_PARTICIPANT_REPORT_TYPE, TOPIC_REPORT_TYPE, PUBLISHER_REPORT_TYPE, SUBSCRIBER_REPORT_TYPE, DATA_WRITER_REPORT_TYPE, DATA_WRITER_PERIODIC_REPORT_TYPE, DATA_READER_REPORT_TYPE, DATA_READER_PERIODIC_REPORT_TYPE, TRANSPORT_REPORT_TYPE }

Functions
typedef	OPENDDS_SET_CMP (GUID_t, GUID_tKeyLessThan) GuidSet

void	reportErrors (yard::SimpleTextParser &parser, const char *input)
	called after parsing has failed, throws std::exception with details More...

OPENDDS_STRING	toString (yard::TreeBuildingParser< char >::Node *iter)

bool	topicIsBIT (const char name, const char type)

template<typename TopicType >
DDS::BuiltinTopicKey_t	keyFromSample (TopicType *sample)

template<class BIT_Reader_var , class BIT_DataSeq >
DDS::ReturnCode_t	instance_handle_to_bit_data (DomainParticipantImpl dp, const char bit_name, const DDS::InstanceHandle_t &handle, BIT_DataSeq &data)

template<>
DDS::BuiltinTopicKey_t	keyFromSample< DDS::ParticipantBuiltinTopicData > (DDS::ParticipantBuiltinTopicData *sample)

template<>
DDS::BuiltinTopicKey_t	keyFromSample< DDS::TopicBuiltinTopicData > (DDS::TopicBuiltinTopicData *sample)

template<>
DDS::BuiltinTopicKey_t	keyFromSample< DDS::SubscriptionBuiltinTopicData > (DDS::SubscriptionBuiltinTopicData *sample)

template<>
DDS::BuiltinTopicKey_t	keyFromSample< DDS::PublicationBuiltinTopicData > (DDS::PublicationBuiltinTopicData *sample)

ACE_CDR::Boolean	operator<< (Serializer &serializer, CoherentChangeControl &value)
	Marshal/Insertion into a buffer. More...

ACE_CDR::Boolean	operator>> (Serializer &serializer, CoherentChangeControl &value)

OpenDDS_Dcps_Export std::ostream &	operator<< (std::ostream &str, const CoherentChangeControl &value)
	Message header insertion onto an ostream. More...

typedef	OPENDDS_MAP_CMP (PublicationId, WriterCoherentSample, GUID_tKeyLessThan) GroupCoherentSamples

template<class Sample , class Field >
ComparatorBase::Ptr	make_field_cmp (Field Sample::*mp, ComparatorBase::Ptr next)

template<class Sample , class Field >
ComparatorBase::Ptr	make_struct_cmp (Field Sample::*mp, ComparatorBase::Ptr delegate, ComparatorBase::Ptr next)

int	pullValues (ACE_Configuration_Heap &cf, const ACE_Configuration_Section_Key &key, ValueMap &values)

int	processSections (ACE_Configuration_Heap &cf, const ACE_Configuration_Section_Key &key, KeyList &subsections)

typedef	OPENDDS_MAP (OPENDDS_STRING, OPENDDS_STRING) ValueMap
	Helper types and functions for config file parsing. More...

typedef	OPENDDS_LIST (SubsectionPair) KeyList

typedef	OPENDDS_VECTOR (ActionConnectionRecord) ConnectionRecords

template<typename DatumType >
std::ostream &	operator<< (std::ostream &str, const DataCollector< DatumType > &value)
	Insert collected data onto an ostream. More...

template<typename DatumType >
ACE_INLINE std::ostream &	operator<< (std::ostream &str, const DataCollector< DatumType > &value)
	Insert collected data onto an ostream. More...

bool	operator<< (ACE_Message_Block &, const DataSampleHeader &value)
	Marshal/Insertion into a buffer. More...

const char *	to_string (MessageId value)

const char *	to_string (SubMessageId value)

OPENDDS_STRING	to_string (const DataSampleHeader &value)

std::ostream &	operator<< (std::ostream &os, const MessageId value)
	Message Id enumeration insertion onto an ostream. More...

std::ostream &	operator<< (std::ostream &os, const SubMessageId value)
	Sub-Message Id enumeration insertion onto an ostream. More...

OpenDDS_Dcps_Export std::ostream &	operator<< (std::ostream &str, const DataSampleHeader &value)
	Message header insertion onto an ostream. More...

const char *	retcode_to_string (DDS::ReturnCode_t value)

const char *	topicstatus_to_string (TopicStatus value)

bool	is_wildcard (const char *str)

bool	matches_name (const DDS::PartitionQosPolicy &qos, const PartitionName &name)

bool	matches_default (const DDS::PartitionQosPolicy &qos)

bool	matching_partitions (const DDS::PartitionQosPolicy &pub, const DDS::PartitionQosPolicy &sub)

void	increment_incompatibility_count (OpenDDS::DCPS::IncompatibleQosStatus *status, DDS::QosPolicyId_t incompatible_policy)

bool	compatibleTransports (const OpenDDS::DCPS::TransportLocatorSeq &s1, const OpenDDS::DCPS::TransportLocatorSeq &s2)

bool	compatibleQOS (OpenDDS::DCPS::IncompatibleQosStatus writerStatus, OpenDDS::DCPS::IncompatibleQosStatus readerStatus, const OpenDDS::DCPS::TransportLocatorSeq &pubTLS, const OpenDDS::DCPS::TransportLocatorSeq &subTLS, DDS::DataWriterQos const const writerQos, DDS::DataReaderQos const const readerQos, DDS::PublisherQos const const pubQos, DDS::SubscriberQos const const subQos)

bool	compatibleQOS (const DDS::PublisherQos pubQos, const DDS::SubscriberQos subQos, OpenDDS::DCPS::IncompatibleQosStatus writerStatus, OpenDDS::DCPS::IncompatibleQosStatus readerStatus)

bool	compatibleQOS (const DDS::DataWriterQos writerQos, const DDS::DataReaderQos readerQos, OpenDDS::DCPS::IncompatibleQosStatus writerStatus, OpenDDS::DCPS::IncompatibleQosStatus readerStatus)

bool	should_check_association_upon_change (const DDS::DataReaderQos &qos1, const DDS::DataReaderQos &qos2)

bool	should_check_association_upon_change (const DDS::DataWriterQos &qos1, const DDS::DataWriterQos &qos2)

bool	should_check_association_upon_change (const DDS::SubscriberQos &qos1, const DDS::SubscriberQos &qos2)

bool	should_check_association_upon_change (const DDS::PublisherQos &qos1, const DDS::PublisherQos &qos2)

bool	should_check_association_upon_change (const DDS::TopicQos &, const DDS::TopicQos &)

bool	should_check_association_upon_change (const DDS::DomainParticipantQos &, const DDS::DomainParticipantQos &)

bool	repr_to_encoding_kind (DDS::DataRepresentationId_t repr, Encoding::Kind &kind)

DCPS::String	repr_to_string (const DDS::DataRepresentationId_t &repr)

DCPS::String	repr_seq_to_string (const DDS::DataRepresentationIdSeq &id_seq, bool is_data_writer)

void	set_writer_effective_data_rep_qos (DDS::DataRepresentationIdSeq &qos, bool cdr_encapsulated)

void	set_reader_effective_data_rep_qos (DDS::DataRepresentationIdSeq &qos)

OpenDDS_Dcps_Export LogLevel	log_level (LogLevel::Warning)

OpenDDS_Dcps_Export void	set_DCPS_debug_level (unsigned int lvl)

bool	operator>= (const LogLevel &ll, LogLevel::Value value)

template<typename T >
bool	operator== (const DisjointSequence::OrderedRanges< T > &a, const DisjointSequence::OrderedRanges< T > &b)

static size_t	arity (const FilterEvaluator::AstNodeWrapper &node)

static FilterEvaluator::AstNodeWrapper	child (const FilterEvaluator::AstNodeWrapper &node, size_t idx)

template<typename T >
const MetaStruct &	getMetaStruct ()

std::ostream &	operator<< (std::ostream &os, const GuidConverter &rhs)

OPENDDS_STRING	to_string (const EntityId_t &entityId)

OPENDDS_STRING	to_string (const GUID_t &guid)

void	intersect (const GuidSet &a, const GuidSet &b, GuidSet &result)

std::ostream &	operator<< (std::ostream &os, const GUID_t &rhs)

std::istream &	operator>> (std::istream &is, GUID_t &rhs)

bool	operator== (const GUID_t &lhs, const GUID_t &rhs)

bool	operator!= (const GUID_t &lhs, const GUID_t &rhs)

bool	operator< (const GUID_t &lhs, const GUID_t &rhs)

OpenDDS_Dcps_Export bool	equal_guid_prefixes (const GuidPrefix_t &lhs, const GuidPrefix_t &rhs)

OpenDDS_Dcps_Export bool	equal_guid_prefixes (const GUID_t &lhs, const GUID_t &rhs)

bool	operator== (const EntityId_t &lhs, const EntityId_t &rhs)

bool	operator!= (const EntityId_t &lhs, const EntityId_t &rhs)

void	assign (EntityId_t &dest, const EntityId_t &src)

void	assign (EntityKey_t &dest, unsigned src)

void	assign (GuidPrefix_t &dest, const GuidPrefix_t &src)

void	assign (GUID_t &dest, const GUID_t &src)

void	assign (DDS::OctetArray16 &dest, const GUID_t &src)

GUID_t	make_id (const GuidPrefix_t &prefix, const EntityId_t &entity)

GUID_t	make_id (const GUID_t &participant_id, const EntityId_t &entity)

OpenDDS_Dcps_Export GUID_t	make_part_guid (const GuidPrefix_t &prefix)

OpenDDS_Dcps_Export GUID_t	make_part_guid (const GUID_t &guid)

OpenDDS_Dcps_Export GUID_t	make_unknown_guid (const GuidPrefix_t &prefix)

OpenDDS_Dcps_Export GUID_t	make_unknown_guid (const GUID_t &guid)

OpenDDS_Dcps_Export DDS::BuiltinTopicKey_t	repo_id_to_bit_key (const GUID_t &guid)

OpenDDS_Dcps_Export GUID_t	bit_key_to_repo_id (const DDS::BuiltinTopicKey_t &key)

void	MD5Hash (MD5Result &result, const void *input, size_t size)

	ACE_FACTORY_DEFINE (OpenDDS_InfoRepoDiscovery, IRDiscoveryLoader)

const DDS::InstanceHandle_t	HANDLE_UNKNOWN (0)

typedef	OPENDDS_VECTOR (InternalSampleInfo) InternalSampleInfoSequence

void OpenDDS_Dcps_Export	log_progress (const char *activity, const GUID_t &local, const GUID_t &remote, const MonotonicTime_t &start_time, const GUID_t &reference)

bool	is_more_local (const NetworkAddress &current, const NetworkAddress &incoming)

typedef	OPENDDS_SET (NetworkAddress) AddrSet

bool	verify_hostname (const String &hostname, ACE_INET_Addr *addr_array, size_t addr_count, bool prefer_loopback, bool allow_ipv4_fallback)

String	get_fully_qualified_hostname (ACE_INET_Addr *addr)

void	get_interface_addrs (OPENDDS_VECTOR(ACE_INET_Addr)&addrs)

bool	set_socket_multicast_ttl (const ACE_SOCK_Dgram &socket, const unsigned char &ttl)

bool	open_appropriate_socket_type (ACE_SOCK_Dgram &socket, const ACE_INET_Addr &local_address, int *proto_family)

ACE_INET_Addr	choose_single_coherent_address (const ACE_INET_Addr &address, bool prefer_loopback)

ACE_INET_Addr	choose_single_coherent_address (const OPENDDS_VECTOR(ACE_INET_Addr)&addresses, bool prefer_loopback, const String &name)

ACE_INET_Addr	choose_single_coherent_address (const String &address, bool prefer_loopback, bool allow_ipv4_fallback)

int	locator_to_address (ACE_INET_Addr &dest, const DCPS::Locator_t &locator, bool map)

OpenDDS_Dcps_Export void	address_to_locator (Locator_t &locator, const ACE_INET_Addr &addr)

typedef	OPENDDS_VECTOR (HostnameInfo) HostnameInfoVector

void	assign (DDS::OctetArray16 &dest, ACE_CDR::ULong ipv4addr_be)

void	address_to_bytes (DDS::OctetArray16 &dest, const ACE_INET_Addr &addr)

void	vwrite (ValueWriter &vw, const Observer::Sample &sample)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::UserDataQosPolicy &qos1, const DDS::UserDataQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::TopicDataQosPolicy &qos1, const DDS::TopicDataQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::GroupDataQosPolicy &qos1, const DDS::GroupDataQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::TransportPriorityQosPolicy &qos1, const DDS::TransportPriorityQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::LifespanQosPolicy &qos1, const DDS::LifespanQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::DurabilityQosPolicy &qos1, const DDS::DurabilityQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::DurabilityServiceQosPolicy &qos1, const DDS::DurabilityServiceQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::PresentationQosPolicy &qos1, const DDS::PresentationQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::DeadlineQosPolicy &qos1, const DDS::DeadlineQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::LatencyBudgetQosPolicy &qos1, const DDS::LatencyBudgetQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::OwnershipQosPolicy &qos1, const DDS::OwnershipQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::OwnershipStrengthQosPolicy &qos1, const DDS::OwnershipStrengthQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::LivelinessQosPolicy &qos1, const DDS::LivelinessQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::TimeBasedFilterQosPolicy &qos1, const DDS::TimeBasedFilterQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::PartitionQosPolicy &qos1, const DDS::PartitionQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::ReliabilityQosPolicy &qos1, const DDS::ReliabilityQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::DestinationOrderQosPolicy &qos1, const DDS::DestinationOrderQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::HistoryQosPolicy &qos1, const DDS::HistoryQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::ResourceLimitsQosPolicy &qos1, const DDS::ResourceLimitsQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::EntityFactoryQosPolicy &qos1, const DDS::EntityFactoryQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::WriterDataLifecycleQosPolicy &qos1, const DDS::WriterDataLifecycleQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::ReaderDataLifecycleQosPolicy &qos1, const DDS::ReaderDataLifecycleQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::DomainParticipantQos &qos1, const DDS::DomainParticipantQos &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::TopicQos &qos1, const DDS::TopicQos &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::DataWriterQos &qos1, const DDS::DataWriterQos &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::PublisherQos &qos1, const DDS::PublisherQos &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::DataReaderQos &qos1, const DDS::DataReaderQos &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::SubscriberQos &qos1, const DDS::SubscriberQos &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::DomainParticipantFactoryQos &qos1, const DDS::DomainParticipantFactoryQos &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::DataRepresentationQosPolicy &qos1, const DDS::DataRepresentationQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::TypeConsistencyEnforcementQosPolicy &qos1, const DDS::TypeConsistencyEnforcementQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::UserDataQosPolicy &qos1, const DDS::UserDataQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::TopicDataQosPolicy &qos1, const DDS::TopicDataQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::GroupDataQosPolicy &qos1, const DDS::GroupDataQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::TransportPriorityQosPolicy &qos1, const DDS::TransportPriorityQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::LifespanQosPolicy &qos1, const DDS::LifespanQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::DurabilityQosPolicy &qos1, const DDS::DurabilityQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::DurabilityServiceQosPolicy &qos1, const DDS::DurabilityServiceQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::PresentationQosPolicy &qos1, const DDS::PresentationQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::DeadlineQosPolicy &qos1, const DDS::DeadlineQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::LatencyBudgetQosPolicy &qos1, const DDS::LatencyBudgetQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::OwnershipQosPolicy &qos1, const DDS::OwnershipQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::OwnershipStrengthQosPolicy &qos1, const DDS::OwnershipStrengthQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::LivelinessQosPolicy &qos1, const DDS::LivelinessQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::TimeBasedFilterQosPolicy &qos1, const DDS::TimeBasedFilterQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::PartitionQosPolicy &qos1, const DDS::PartitionQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::ReliabilityQosPolicy &qos1, const DDS::ReliabilityQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::DestinationOrderQosPolicy &qos1, const DDS::DestinationOrderQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::HistoryQosPolicy &qos1, const DDS::HistoryQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::ResourceLimitsQosPolicy &qos1, const DDS::ResourceLimitsQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::EntityFactoryQosPolicy &qos1, const DDS::EntityFactoryQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::WriterDataLifecycleQosPolicy &qos1, const DDS::WriterDataLifecycleQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::ReaderDataLifecycleQosPolicy &qos1, const DDS::ReaderDataLifecycleQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::PropertyQosPolicy &qos1, const DDS::PropertyQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::DomainParticipantQos &qos1, const DDS::DomainParticipantQos &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::TopicQos &qos1, const DDS::TopicQos &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::DataWriterQos &qos1, const DDS::DataWriterQos &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::PublisherQos &qos1, const DDS::PublisherQos &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::DataReaderQos &qos1, const DDS::DataReaderQos &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::SubscriberQos &qos1, const DDS::SubscriberQos &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::DomainParticipantFactoryQos &qos1, const DDS::DomainParticipantFactoryQos &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::DataRepresentationQosPolicy &qos1, const DDS::DataRepresentationQosPolicy &qos2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::TypeConsistencyEnforcementQosPolicy &qos1, const DDS::TypeConsistencyEnforcementQosPolicy &qos2)

template<typename T >
ACE_INLINE bool	operator== (const TAO::unbounded_value_sequence< T > &seq1, const TAO::unbounded_value_sequence< T > &seq2)

ACE_INLINE bool	operator== (const DDS::PropertyQosPolicy &qos1, const DDS::PropertyQosPolicy &qos2)

void	swap (RawDataSample &lhs, RawDataSample &rhs)

template<typename T >
void	swap (RcHandle< T > &lhs, RcHandle< T > &rhs)

template<typename T , typename U >
RcHandle< T >	static_rchandle_cast (const RcHandle< U > &h)

template<typename T , typename U >
RcHandle< T >	const_rchandle_cast (const RcHandle< U > &h)

template<typename T , typename U >
RcHandle< T >	dynamic_rchandle_cast (const RcHandle< U > &h)

template<typename T >
reference_wrapper< T >	ref (T &r)

template<typename T >
T const &	unwrap_reference (T const &t)

template<typename T >
T &	unwrap_reference (reference_wrapper< T > const &t)

template<typename T >
RcHandle< T >	make_rch ()

template<typename T , typename U >
RcHandle< T >	make_rch (U const &u)

template<typename T , typename U0 , typename U1 >
RcHandle< T >	make_rch (U0 const &u0, U1 const &u1)

template<typename T , typename U0 , typename U1 , typename U2 >
RcHandle< T >	make_rch (U0 const &u0, U1 const &u1, U2 const &u2)

template<typename T , typename U0 , typename U1 , typename U2 , typename U3 >
RcHandle< T >	make_rch (U0 const &u0, U1 const &u1, U2 const &u2, U3 const &u3)

template<typename T , typename U0 , typename U1 , typename U2 , typename U3 , typename U4 >
RcHandle< T >	make_rch (U0 const &u0, U1 const &u1, U2 const &u2, U3 const &u3, U4 const &u4)

template<typename T , typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 >
RcHandle< T >	make_rch (U0 const &u0, U1 const &u1, U2 const &u2, U3 const &u3, U4 const &u4, U5 const &u5)

template<typename T , typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 >
RcHandle< T >	make_rch (U0 const &u0, U1 const &u1, U2 const &u2, U3 const &u3, U4 const &u4, U5 const &u5, U6 const &u6)

template<typename T , typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 >
RcHandle< T >	make_rch (U0 const &u0, U1 const &u1, U2 const &u2, U3 const &u3, U4 const &u4, U5 const &u5, U6 const &u6, U7 const &u7)

template<typename T >
RcHandle< T >	rchandle_from (T *pointer)

typedef	OPENDDS_MAP (OPENDDS_STRING, TypeSupport_var) TypeSupportMap

typedef	OPENDDS_MAP (DDS::DomainParticipant_ptr, TypeSupportMap) ParticipantMap

typedef	OPENDDS_VECTOR (RawDataSample) RawDataSampleList

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeLookup_getTypes_In &stru)

bool	operator<< (Serializer &strm, const XTypes::TypeLookup_getTypes_In &stru)

bool	operator>> (Serializer &strm, XTypes::TypeLookup_getTypes_In &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeLookup_getTypes_Out &stru)

bool	operator<< (Serializer &strm, const XTypes::TypeLookup_getTypes_Out &stru)

bool	operator>> (Serializer &strm, XTypes::TypeLookup_getTypes_Out &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeLookup_getTypes_Result &uni)

bool	operator<< (Serializer &strm, const XTypes::TypeLookup_getTypes_Result &uni)

bool	operator>> (Serializer &strm, XTypes::TypeLookup_getTypes_Result &uni)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeLookup_getTypeDependencies_In &stru)

bool	operator<< (Serializer &strm, const XTypes::TypeLookup_getTypeDependencies_In &stru)

bool	operator>> (Serializer &strm, XTypes::TypeLookup_getTypeDependencies_In &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeLookup_getTypeDependencies_Out &stru)

bool	operator<< (Serializer &strm, const XTypes::TypeLookup_getTypeDependencies_Out &stru)

bool	operator>> (Serializer &strm, XTypes::TypeLookup_getTypeDependencies_Out &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeLookup_getTypeDependencies_Result &uni)

bool	operator<< (Serializer &strm, const XTypes::TypeLookup_getTypeDependencies_Result &uni)

bool	operator>> (Serializer &strm, XTypes::TypeLookup_getTypeDependencies_Result &uni)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeLookup_Call &uni)

bool	operator<< (Serializer &strm, const XTypes::TypeLookup_Call &uni)

bool	operator>> (Serializer &strm, XTypes::TypeLookup_Call &uni)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeLookup_Request &stru)

bool	operator<< (Serializer &strm, const XTypes::TypeLookup_Request &stru)

bool	operator>> (Serializer &strm, XTypes::TypeLookup_Request &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeLookup_Return &uni)

bool	operator<< (Serializer &strm, const XTypes::TypeLookup_Return &uni)

bool	operator>> (Serializer &strm, XTypes::TypeLookup_Return &uni)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeLookup_Reply &stru)

bool	operator<< (Serializer &strm, const XTypes::TypeLookup_Reply &stru)

bool	operator>> (Serializer &strm, XTypes::TypeLookup_Reply &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::OctetSeq32 &seq)

bool	operator<< (Serializer &strm, const XTypes::OctetSeq32 &seq)

bool	operator>> (Serializer &strm, XTypes::OctetSeq32 &seq)

template<typename X , typename Y >
bool	operator== (const SafeBool_T< X > &x, const SafeBool_T< Y > &)

template<typename X , typename Y >
bool	operator!= (const SafeBool_T< X > &x, const SafeBool_T< Y > &)

String	to_dds_string (unsigned short to_convert)

String	to_dds_string (int to_convert)

String	to_dds_string (unsigned int to_convert, bool as_hex)

String	to_dds_string (long to_convert)

String	to_dds_string (long long to_convert)

String	to_dds_string (unsigned long long to_convert, bool as_hex)

String	to_dds_string (unsigned long to_convert, bool as_hex)

String	to_dds_string (const unsigned char *array, size_t length)

static char	nibble_to_hex_char (char nibble)

String	to_dds_string (const String &to_convert)

template<typename T >
String	to_dds_string (const T *to_convert)
	Convert Pointer to String. More...

template<typename T >
bool	convertToInteger (const String &s, T &value)

template<typename T >
bool	convertToDouble (const String &s, T &value)

template<typename Sequence >
SequenceBackInsertIterator< Sequence >	back_inserter (Sequence &seq)

template<typename Sequence >
SequenceIterator< Sequence >	sequence_begin (Sequence &seq)

template<typename Sequence >
SequenceIterator< Sequence >	sequence_end (Sequence &seq)

template<typename Sequence >
ConstSequenceIterator< Sequence >	const_sequence_begin (Sequence &seq)

template<typename Sequence >
ConstSequenceIterator< Sequence >	const_sequence_end (Sequence &seq)

const SequenceRange	unknown_sequence_range (SequenceNumber::SEQUENCENUMBER_UNKNOWN(), SequenceNumber::SEQUENCENUMBER_UNKNOWN())

ACE_CDR::Boolean	operator<< (Serializer &s, const SequenceNumber &x)

ACE_CDR::Boolean	operator>> (Serializer &s, SequenceNumber &x)

SequenceNumber	operator+ (const SequenceNumber &lhs, int rhs)

SequenceNumber	operator+= (SequenceNumber &lhs, int rhs)

SequenceNumber	operator+ (int lhs, const SequenceNumber &rhs)

void	serialized_size (const Encoding &encoding, size_t &size, const SequenceNumber &)

String	endianness_to_string (Endianness endianness)

bool	operator>> (Serializer &s, EncapsulationHeader &value)

bool	operator<< (Serializer &s, const EncapsulationHeader &value)

OpenDDS_Dcps_Export void	align (size_t &value, size_t by)
	Align "value" by "by" if it's not already. More...

template<typename T >
size_t	serialized_size (const Encoding &encoding, const T &value)

template<typename Type >
void	set_default (Type &)

template<typename Type , typename Tag >
void	set_default (IDL::DistinctType< Type, Tag >)

OpenDDS_Dcps_Export bool	primitive_serialized_size (const Encoding &encoding, size_t &size, const ACE_CDR::Short &value, size_t count=1)

OpenDDS_Dcps_Export bool	primitive_serialized_size (const Encoding &encoding, size_t &size, const ACE_CDR::UShort &value, size_t count=1)

OpenDDS_Dcps_Export bool	primitive_serialized_size (const Encoding &encoding, size_t &size, const ACE_CDR::Long &value, size_t count=1)

OpenDDS_Dcps_Export bool	primitive_serialized_size (const Encoding &encoding, size_t &size, const ACE_CDR::ULong &value, size_t count=1)

OpenDDS_Dcps_Export bool	primitive_serialized_size (const Encoding &encoding, size_t &size, const ACE_CDR::LongLong &value, size_t count=1)

OpenDDS_Dcps_Export bool	primitive_serialized_size (const Encoding &encoding, size_t &size, const ACE_CDR::ULongLong &value, size_t count=1)

OpenDDS_Dcps_Export bool	primitive_serialized_size (const Encoding &encoding, size_t &size, const ACE_CDR::Float &value, size_t count=1)

OpenDDS_Dcps_Export bool	primitive_serialized_size (const Encoding &encoding, size_t &size, const ACE_CDR::Double &value, size_t count=1)

OpenDDS_Dcps_Export bool	primitive_serialized_size (const Encoding &encoding, size_t &size, const ACE_CDR::LongDouble &value, size_t count=1)

OpenDDS_Dcps_Export bool	primitive_serialized_size (const Encoding &encoding, size_t &size, const ACE_OutputCDR::from_boolean value, size_t count=1)

OpenDDS_Dcps_Export bool	primitive_serialized_size (const Encoding &encoding, size_t &size, const ACE_OutputCDR::from_char value, size_t count=1)

OpenDDS_Dcps_Export bool	primitive_serialized_size (const Encoding &encoding, size_t &size, const ACE_OutputCDR::from_wchar value, size_t count=1)

OpenDDS_Dcps_Export bool	primitive_serialized_size (const Encoding &encoding, size_t &size, const ACE_OutputCDR::from_octet value, size_t count=1)

OpenDDS_Dcps_Export void	primitive_serialized_size_boolean (const Encoding &encoding, size_t &size, size_t count=1)

OpenDDS_Dcps_Export void	primitive_serialized_size_char (const Encoding &encoding, size_t &size, size_t count=1)

OpenDDS_Dcps_Export void	primitive_serialized_size_wchar (const Encoding &encoding, size_t &size, size_t count=1)

OpenDDS_Dcps_Export void	primitive_serialized_size_octet (const Encoding &encoding, size_t &size, size_t count=1)

OpenDDS_Dcps_Export void	primitive_serialized_size_ulong (const Encoding &encoding, size_t &size, size_t count=1)

OpenDDS_Dcps_Export void	serialized_size_delimiter (const Encoding &encoding, size_t &size)
	Add delimiter to the size of a serialized size if the encoding has them. More...

OpenDDS_Dcps_Export void	serialized_size_parameter_id (const Encoding &encoding, size_t &size, size_t &running_size)

OpenDDS_Dcps_Export void	serialized_size_list_end_parameter_id (const Encoding &encoding, size_t &size, size_t &running_size)

ACE_INLINE bool	serialized_size (const Encoding &, size_t &size, const EncapsulationHeader &)

ACE_INLINE bool	operator<< (Serializer &s, ACE_CDR::Char x)

ACE_INLINE bool	operator<< (Serializer &s, ACE_CDR::Short x)

ACE_INLINE bool	operator<< (Serializer &s, ACE_CDR::UShort x)

ACE_INLINE bool	operator<< (Serializer &s, ACE_CDR::Long x)

ACE_INLINE bool	operator<< (Serializer &s, ACE_CDR::ULong x)

ACE_INLINE bool	operator<< (Serializer &s, ACE_CDR::LongLong x)

ACE_INLINE bool	operator<< (Serializer &s, ACE_CDR::ULongLong x)

ACE_INLINE bool	operator<< (Serializer &s, ACE_CDR::Float x)

ACE_INLINE bool	operator<< (Serializer &s, ACE_CDR::Double x)

ACE_INLINE bool	operator<< (Serializer &s, ACE_CDR::LongDouble x)

ACE_INLINE bool	operator<< (Serializer &s, const ACE_CDR::Char *x)

ACE_INLINE bool	operator<< (Serializer &s, const ACE_CDR::WChar *x)

ACE_INLINE bool	operator<< (Serializer &s, ACE_OutputCDR::from_boolean x)

ACE_INLINE bool	operator<< (Serializer &s, ACE_OutputCDR::from_char x)

ACE_INLINE bool	operator<< (Serializer &s, ACE_OutputCDR::from_wchar x)

ACE_INLINE bool	operator<< (Serializer &s, const String &x)

ACE_INLINE bool	operator<< (Serializer &s, Serializer::FromBoundedString< char > x)

ACE_INLINE bool	operator<< (Serializer &s, ACE_OutputCDR::from_octet x)

ACE_INLINE bool	operator<< (Serializer &s, ACE_OutputCDR::from_string x)

ACE_INLINE bool	operator<< (Serializer &s, ACE_OutputCDR::from_wstring x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_CDR::Char &x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_CDR::Short &x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_CDR::UShort &x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_CDR::Long &x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_CDR::ULong &x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_CDR::LongLong &x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_CDR::ULongLong &x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_CDR::Float &x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_CDR::Double &x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_CDR::LongDouble &x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_CDR::Char *&x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_CDR::WChar *&x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_InputCDR::to_boolean x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_InputCDR::to_char x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_InputCDR::to_wchar x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_InputCDR::to_octet x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_InputCDR::to_string x)

ACE_INLINE bool	operator>> (Serializer &s, ACE_InputCDR::to_wstring x)

ACE_INLINE bool	operator>> (Serializer &s, String &x)

ACE_INLINE bool	operator>> (Serializer &s, Serializer::ToBoundedString< char > x)

ACE_INLINE OpenDDS_Dcps_Export ACE_Time_Value	time_to_time_value (const DDS::Time_t &t)

ACE_INLINE OpenDDS_Dcps_Export DDS::Time_t	time_value_to_time (const ACE_Time_Value &tv)

ACE_INLINE OpenDDS_Dcps_Export MonotonicTime_t	time_value_to_monotonic_time (const ACE_Time_Value &tv)

ACE_INLINE OpenDDS_Dcps_Export ACE_Time_Value	duration_to_time_value (const DDS::Duration_t &t)

ACE_INLINE OpenDDS_Dcps_Export ACE_Time_Value	duration_to_absolute_time_value (const DDS::Duration_t &t, const ACE_Time_Value &now)

ACE_INLINE OpenDDS_Dcps_Export DDS::Duration_t	time_value_to_duration (const ACE_Time_Value &tv)

ACE_INLINE OpenDDS_Dcps_Export DDS::Duration_t	time_to_duration (const DDS::Time_t &t)

ACE_INLINE OpenDDS_Dcps_Export bool	valid_duration (DDS::Duration_t const &t)

ACE_INLINE OpenDDS_Dcps_Export bool	non_negative_duration (const DDS::Duration_t &t)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::Duration_t &t1, const DDS::Duration_t &t2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::Duration_t &t1, const DDS::Duration_t &t2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator< (const DDS::Duration_t &t1, const DDS::Duration_t &t2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator<= (const DDS::Duration_t &t1, const DDS::Duration_t &t2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator> (const DDS::Duration_t &t1, const DDS::Duration_t &t2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator>= (const DDS::Duration_t &t1, const DDS::Duration_t &t2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator! (const DDS::Time_t &t)

ACE_INLINE OpenDDS_Dcps_Export bool	operator== (const DDS::Time_t &t1, const DDS::Time_t &t2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator!= (const DDS::Time_t &t1, const DDS::Time_t &t2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator< (const DDS::Time_t &t1, const DDS::Time_t &t2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator<= (const DDS::Time_t &t1, const DDS::Time_t &t2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator> (const DDS::Time_t &t1, const DDS::Time_t &t2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator>= (const DDS::Time_t &t1, const DDS::Time_t &t2)

ACE_INLINE OpenDDS_Dcps_Export DDS::Duration_t	operator- (const DDS::Time_t &t1, const DDS::Time_t &t2)

ACE_INLINE OpenDDS_Dcps_Export DDS::Time_t	operator- (const DDS::Time_t &t1, const DDS::Duration_t &t2)

ACE_INLINE OpenDDS_Dcps_Export DDS::Duration_t	operator- (const MonotonicTime_t &t1, const MonotonicTime_t &t2)

ACE_INLINE OpenDDS_Dcps_Export bool	operator< (const MonotonicTime_t &t1, const MonotonicTime_t &t2)

ACE_INLINE OpenDDS_Dcps_Export ACE_UINT32	uint32_fractional_seconds_to_nanoseconds (ACE_UINT32 fraction)

ACE_INLINE OpenDDS_Dcps_Export ACE_UINT32	nanoseconds_to_uint32_fractional_seconds (ACE_UINT32 fraction)

ACE_INLINE OpenDDS_Dcps_Export ACE_UINT32	uint32_fractional_seconds_to_microseconds (ACE_UINT32 fraction)

ACE_INLINE OpenDDS_Dcps_Export ACE_UINT32	microseconds_to_uint32_fractional_seconds (ACE_UINT32 fraction)

ACE_INLINE OpenDDS_Dcps_Export bool	is_infinite (const DDS::Duration_t &value)

ACE_INLINE OpenDDS_Dcps_Export const MonotonicTime_t &	monotonic_time_zero ()

OpenDDS_Dcps_Export TimeDuration	operator+ (const TimeDuration &x, const TimeDuration &y)

OpenDDS_Dcps_Export TimeDuration	operator- (const TimeDuration &x, const TimeDuration &y)

OpenDDS_Dcps_Export TimeDuration	operator- (const TimeDuration &x)

OpenDDS_Dcps_Export TimeDuration	operator* (double x, const TimeDuration &y)

OpenDDS_Dcps_Export TimeDuration	operator* (const TimeDuration &x, double y)

OpenDDS_Dcps_Export TimeDuration	operator/ (const TimeDuration &x, double y)

OpenDDS_Dcps_Export double	operator/ (const TimeDuration &x, const TimeDuration &y)

OpenDDS_Dcps_Export bool	operator< (const TimeDuration &x, const TimeDuration &y)

OpenDDS_Dcps_Export bool	operator> (const TimeDuration &x, const TimeDuration &y)

OpenDDS_Dcps_Export bool	operator<= (const TimeDuration &x, const TimeDuration &y)

OpenDDS_Dcps_Export bool	operator>= (const TimeDuration &x, const TimeDuration &y)

OpenDDS_Dcps_Export bool	operator== (const TimeDuration &x, const TimeDuration &y)

OpenDDS_Dcps_Export bool	operator!= (const TimeDuration &x, const TimeDuration &y)

template<typename AceClock >
TimePoint_T< AceClock >	operator+ (const TimeDuration &x, const TimePoint_T< AceClock > &y)

template<typename AceClock >
TimePoint_T< AceClock >	operator+ (const TimePoint_T< AceClock > &x, const TimeDuration &y)

template<typename AceClock >
TimeDuration	operator- (const TimePoint_T< AceClock > &x, const TimePoint_T< AceClock > &y)

template<typename AceClock >
TimePoint_T< AceClock >	operator- (const TimePoint_T< AceClock > &x, const TimeDuration &y)

template<typename AceClock >
bool	operator< (const TimePoint_T< AceClock > &x, const TimePoint_T< AceClock > &y)

template<typename AceClock >
bool	operator> (const TimePoint_T< AceClock > &x, const TimePoint_T< AceClock > &y)

template<typename AceClock >
bool	operator<= (const TimePoint_T< AceClock > &x, const TimePoint_T< AceClock > &y)

template<typename AceClock >
bool	operator>= (const TimePoint_T< AceClock > &x, const TimePoint_T< AceClock > &y)

template<typename AceClock >
bool	operator== (const TimePoint_T< AceClock > &x, const TimePoint_T< AceClock > &y)

template<typename AceClock >
bool	operator!= (const TimePoint_T< AceClock > &x, const TimePoint_T< AceClock > &y)

template<typename AceClock >
ACE_INLINE TimePoint_T< AceClock >	operator+ (const TimeDuration &x, const TimePoint_T< AceClock > &y)

template<typename AceClock >
ACE_INLINE TimePoint_T< AceClock >	operator+ (const TimePoint_T< AceClock > &x, const TimeDuration &y)

template<typename AceClock >
ACE_INLINE TimeDuration	operator- (const TimePoint_T< AceClock > &x, const TimePoint_T< AceClock > &y)

template<typename AceClock >
ACE_INLINE TimePoint_T< AceClock >	operator- (const TimePoint_T< AceClock > &x, const TimeDuration &y)

template<typename AceClock >
ACE_INLINE bool	operator< (const TimePoint_T< AceClock > &x, const TimePoint_T< AceClock > &y)

template<typename AceClock >
ACE_INLINE bool	operator> (const TimePoint_T< AceClock > &x, const TimePoint_T< AceClock > &y)

template<typename AceClock >
ACE_INLINE bool	operator<= (const TimePoint_T< AceClock > &x, const TimePoint_T< AceClock > &y)

template<typename AceClock >
ACE_INLINE bool	operator>= (const TimePoint_T< AceClock > &x, const TimePoint_T< AceClock > &y)

template<typename AceClock >
ACE_INLINE bool	operator== (const TimePoint_T< AceClock > &x, const TimePoint_T< AceClock > &y)

template<typename AceClock >
ACE_INLINE bool	operator!= (const TimePoint_T< AceClock > &x, const TimePoint_T< AceClock > &y)

typedef	OPENDDS_MAP (String, TopicDetails) TopicDetailsMap

template<typename Seq >
void	set_to_seq (const RepoIdSet &rids, Seq &seq)

std::ostream &	operator<< (std::ostream &str, const DataLink &value)

typedef	OPENDDS_MAP_CMP (RepoId, DataLinkSet_rch, GUID_tKeyLessThan) DataLinkSetMap

bool	operator<< (ACE_Message_Block &buffer, const TransportHeader &value)

static const ACE_UINT32	TRANSPORT_HDR_SERIALIZED_SZ (28)

typedef	OPENDDS_VECTOR (TransportQueueElement *) TqeVector

void	append (TransportStatisticsSequence &seq, const InternalTransportStatistics &istats)

static bool	get_remote_reliability (const TransportImpl::RemoteTransport &remote)

size_t	dedup (MetaSubmessageVec &vec)

typedef	OPENDDS_VECTOR (MetaSubmessage) MetaSubmessageVec

typedef	OPENDDS_MAP_CMP (RepoId, SeqReaders, GUID_tKeyLessThan) WriterToSeqReadersMap

	ACE_FACTORY_DEFINE (OpenDDS_Rtps_Udp, RtpsUdpLoader)

	ACE_FACTORY_DEFINE (OpenDDS_Shmem, ShmemLoader)

	ACE_FACTORY_DEFINE (OpenDDS_Udp, UdpLoader)

const char *	kind_to_string (const XTypes::EquivalenceKind ek)

template<typename T >
T::rv_reference	move (T &p)

template<typename T , typename Deleter >
void	swap (unique_ptr< T, Deleter > &a, unique_ptr< T, Deleter > &b)

template<typename T >
void	swap (container_supported_unique_ptr< T > &lhs, container_supported_unique_ptr< T > &rhs)

template<typename T >
unique_ptr< T >::rv_reference	move (container_supported_unique_ptr< T > &ptr)

template<typename Container , typename FirstType , typename SecondType >
int	bind (Container &c, const FirstType &first, const SecondType &second)

template<typename Container >
int	unbind (Container &c, const typename Container::key_type &k, typename Container::mapped_type &v)

template<typename Container >
int	unbind (Container &c, const typename Container::key_type &k)

template<typename Container , typename Key >
int	find (Container &c, const Key &key, typename Container::mapped_type *&value)

template<typename Container , typename Key >
int	find (const Container &c, const Key &key, typename Container::mapped_type &value)

template<typename Container , typename ValueType >
int	insert (Container &c, const ValueType &v)

template<typename Container , typename ValueType >
int	remove (Container &c, const ValueType &v)

template<typename Seq >
void	push_back (Seq &seq, const typename Seq::value_type &val)
	std::vector-style push_back() for CORBA Sequences More...

template<typename Seq >
Seq::size_type	grow (Seq &seq)

template<typename InputIteratorA , typename InputIteratorB , typename OutputIterator >
OutputIterator	intersect_sorted_ranges (InputIteratorA a, InputIteratorA aEnd, InputIteratorB b, InputIteratorB bEnd, OutputIterator intersect)

template<typename InputIteratorA , typename InputIteratorB , typename OutputIterator , typename LessThan >
OutputIterator	intersect_sorted_ranges (InputIteratorA a, InputIteratorA aEnd, InputIteratorB b, InputIteratorB bEnd, OutputIterator intersect, LessThan lessThan)

template<typename SetA , typename SortedB , typename LessThan >
bool	set_intersect (SetA &sA, const SortedB &sB, LessThan lessThan)

template<typename Type , size_t count>
size_t	array_count (Type(&)[count])

template<typename IntType >
std::ostream &	signed_int_helper (std::ostream &o, IntType value, IntType min)

ostream &	operator<< (ostream &os, const ACE_CDR::LongDouble &val)

std::ostream &	hex_value (std::ostream &o, unsigned value, size_t bytes)

template<typename CharType >
unsigned	char_value (CharType value)

template<typename CharType >
std::ostream &	char_helper (std::ostream &o, CharType value)

template<typename CharType >
std::ostream &	string_helper (std::ostream &o, const CharType *value)

template<typename CharType >
std::ostream &	string_helper (std::ostream &o, const CharType *value, size_t length)

bool	resend_data_expired (const DataSampleElement &element, const DDS::LifespanQosPolicy &lifespan)

typedef	OPENDDS_MAP (DDS::InstanceHandle_t, PublicationInstance_rch) PublicationInstanceMapType

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeIdentifier &uni)

bool	operator<< (Serializer &strm, const XTypes::TypeIdentifier &uni)

bool	operator>> (Serializer &strm, XTypes::TypeIdentifier &uni)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::LBoundSeq &seq)

bool	operator<< (Serializer &strm, const XTypes::LBoundSeq &seq)

bool	operator>> (Serializer &strm, XTypes::LBoundSeq &seq)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::SBoundSeq &seq)

bool	operator<< (Serializer &strm, const XTypes::SBoundSeq &seq)

bool	operator>> (Serializer &strm, XTypes::SBoundSeq &seq)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::UnionCaseLabelSeq &seq)

bool	operator<< (Serializer &strm, const XTypes::UnionCaseLabelSeq &seq)

bool	operator>> (Serializer &strm, XTypes::UnionCaseLabelSeq &seq)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::ExtendedAnnotationParameterValue &)

bool	operator<< (Serializer &strm, const XTypes::ExtendedAnnotationParameterValue &)

bool	operator>> (Serializer &strm, XTypes::ExtendedAnnotationParameterValue &)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::NameHash_forany &)

bool	operator<< (Serializer &strm, const XTypes::NameHash_forany &arr)

bool	operator>> (Serializer &strm, XTypes::NameHash_forany &arr)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::EquivalenceHash_forany &)

bool	operator<< (Serializer &strm, const XTypes::EquivalenceHash_forany &arr)

bool	operator>> (Serializer &strm, XTypes::EquivalenceHash_forany &arr)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteTypeDetail &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteTypeDetail &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteTypeDetail &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteStructHeader &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteStructHeader &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteStructHeader &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalStructHeader &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalStructHeader &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalStructHeader &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteStructType &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteStructType &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteStructType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalStructType &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalStructType &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalStructType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteUnionType &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteUnionType &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteUnionType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalUnionType &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalUnionType &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalUnionType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteAnnotationType &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteAnnotationType &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteAnnotationType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalAnnotationType &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalAnnotationType &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalAnnotationType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteAliasType &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteAliasType &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteAliasType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalAliasType &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalAliasType &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalAliasType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteSequenceType &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteSequenceType &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteSequenceType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalSequenceType &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalSequenceType &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalSequenceType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteArrayType &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteArrayType &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteArrayType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalArrayType &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalArrayType &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalArrayType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteMapType &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteMapType &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteMapType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalMapType &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalMapType &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalMapType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteEnumeratedHeader &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteEnumeratedHeader &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteEnumeratedHeader &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalEnumeratedHeader &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalEnumeratedHeader &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalEnumeratedHeader &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteEnumeratedType &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteEnumeratedType &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteEnumeratedType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalEnumeratedType &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalEnumeratedType &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalEnumeratedType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteBitmaskType &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteBitmaskType &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteBitmaskType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalBitmaskType &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalBitmaskType &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalBitmaskType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteBitsetType &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteBitsetType &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteBitsetType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalBitsetType &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalBitsetType &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalBitsetType &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteExtendedType &)

bool	operator<< (Serializer &strm, const XTypes::CompleteExtendedType &)

bool	operator>> (Serializer &strm, XTypes::CompleteExtendedType &)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeIdentifierWithSize &stru)

bool	operator<< (Serializer &strm, const XTypes::TypeIdentifierWithSize &stru)

bool	operator>> (Serializer &strm, XTypes::TypeIdentifierWithSize &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeIdentifierWithDependencies &stru)

bool	operator<< (Serializer &strm, const XTypes::TypeIdentifierWithDependencies &stru)

bool	operator>> (Serializer &strm, XTypes::TypeIdentifierWithDependencies &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::AppliedAnnotation &stru)

bool	operator<< (Serializer &strm, const XTypes::AppliedAnnotation &stru)

bool	operator>> (Serializer &strm, XTypes::AppliedAnnotation &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::AppliedBuiltinTypeAnnotations &stru)

bool	operator<< (Serializer &strm, const XTypes::AppliedBuiltinTypeAnnotations &stru)

bool	operator>> (Serializer &strm, XTypes::AppliedBuiltinTypeAnnotations &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteAliasBody &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteAliasBody &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteAliasBody &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteAliasHeader &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteAliasHeader &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteAliasHeader &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteAnnotationHeader &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteAnnotationHeader &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteAnnotationHeader &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteAnnotationParameter &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteAnnotationParameter &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteAnnotationParameter &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteArrayHeader &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteArrayHeader &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteArrayHeader &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteBitfield &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteBitfield &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteBitfield &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteBitflag &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteBitflag &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteBitflag &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteBitsetHeader &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteBitsetHeader &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteBitsetHeader &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteCollectionElement &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteCollectionElement &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteCollectionElement &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteCollectionHeader &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteCollectionHeader &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteCollectionHeader &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteDiscriminatorMember &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteDiscriminatorMember &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteDiscriminatorMember &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteEnumeratedLiteral &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteEnumeratedLiteral &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteEnumeratedLiteral &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteStructMember &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteStructMember &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteStructMember &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteUnionHeader &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteUnionHeader &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteUnionHeader &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteUnionMember &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteUnionMember &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteUnionMember &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalAliasBody &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalAliasBody &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalAliasBody &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalAliasHeader &)

bool	operator<< (Serializer &strm, const XTypes::MinimalAliasHeader &)

bool	operator>> (Serializer &strm, XTypes::MinimalAliasHeader &)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalAnnotationHeader &)

bool	operator<< (Serializer &strm, const XTypes::MinimalAnnotationHeader &)

bool	operator>> (Serializer &strm, XTypes::MinimalAnnotationHeader &)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalAnnotationParameter &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalAnnotationParameter &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalAnnotationParameter &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalArrayHeader &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalArrayHeader &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalArrayHeader &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalBitfield &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalBitfield &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalBitfield &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalBitflag &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalBitflag &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalBitflag &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalBitsetHeader &)

bool	operator<< (Serializer &strm, const XTypes::MinimalBitsetHeader &)

bool	operator>> (Serializer &strm, XTypes::MinimalBitsetHeader &)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalCollectionElement &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalCollectionElement &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalCollectionElement &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalCollectionHeader &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalCollectionHeader &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalCollectionHeader &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalDiscriminatorMember &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalDiscriminatorMember &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalDiscriminatorMember &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalEnumeratedLiteral &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalEnumeratedLiteral &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalEnumeratedLiteral &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalStructMember &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalStructMember &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalStructMember &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalUnionHeader &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalUnionHeader &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalUnionHeader &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalUnionMember &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalUnionMember &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalUnionMember &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::AnnotationParameterValue &uni)

bool	operator<< (Serializer &strm, const XTypes::AnnotationParameterValue &uni)

bool	operator>> (Serializer &strm, XTypes::AnnotationParameterValue &uni)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::AppliedAnnotationParameter &stru)

bool	operator<< (Serializer &strm, const XTypes::AppliedAnnotationParameter &stru)

bool	operator>> (Serializer &strm, XTypes::AppliedAnnotationParameter &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::AppliedBuiltinMemberAnnotations &stru)

bool	operator<< (Serializer &strm, const XTypes::AppliedBuiltinMemberAnnotations &stru)

bool	operator>> (Serializer &strm, XTypes::AppliedBuiltinMemberAnnotations &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::AppliedVerbatimAnnotation &stru)

bool	operator<< (Serializer &strm, const XTypes::AppliedVerbatimAnnotation &stru)

bool	operator>> (Serializer &strm, XTypes::AppliedVerbatimAnnotation &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CommonAliasBody &stru)

bool	operator<< (Serializer &strm, const XTypes::CommonAliasBody &stru)

bool	operator>> (Serializer &strm, XTypes::CommonAliasBody &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CommonAnnotationParameter &stru)

bool	operator<< (Serializer &strm, const XTypes::CommonAnnotationParameter &stru)

bool	operator>> (Serializer &strm, XTypes::CommonAnnotationParameter &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CommonArrayHeader &stru)

bool	operator<< (Serializer &strm, const XTypes::CommonArrayHeader &stru)

bool	operator>> (Serializer &strm, XTypes::CommonArrayHeader &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CommonBitfield &stru)

bool	operator<< (Serializer &strm, const XTypes::CommonBitfield &stru)

bool	operator>> (Serializer &strm, XTypes::CommonBitfield &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CommonBitflag &stru)

bool	operator<< (Serializer &strm, const XTypes::CommonBitflag &stru)

bool	operator>> (Serializer &strm, XTypes::CommonBitflag &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CommonCollectionElement &stru)

bool	operator<< (Serializer &strm, const XTypes::CommonCollectionElement &stru)

bool	operator>> (Serializer &strm, XTypes::CommonCollectionElement &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CommonCollectionHeader &stru)

bool	operator<< (Serializer &strm, const XTypes::CommonCollectionHeader &stru)

bool	operator>> (Serializer &strm, XTypes::CommonCollectionHeader &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CommonDiscriminatorMember &stru)

bool	operator<< (Serializer &strm, const XTypes::CommonDiscriminatorMember &stru)

bool	operator>> (Serializer &strm, XTypes::CommonDiscriminatorMember &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CommonEnumeratedHeader &stru)

bool	operator<< (Serializer &strm, const XTypes::CommonEnumeratedHeader &stru)

bool	operator>> (Serializer &strm, XTypes::CommonEnumeratedHeader &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CommonEnumeratedLiteral &stru)

bool	operator<< (Serializer &strm, const XTypes::CommonEnumeratedLiteral &stru)

bool	operator>> (Serializer &strm, XTypes::CommonEnumeratedLiteral &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CommonStructMember &stru)

bool	operator<< (Serializer &strm, const XTypes::CommonStructMember &stru)

bool	operator>> (Serializer &strm, XTypes::CommonStructMember &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CommonUnionMember &stru)

bool	operator<< (Serializer &strm, const XTypes::CommonUnionMember &stru)

bool	operator>> (Serializer &strm, XTypes::CommonUnionMember &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteElementDetail &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteElementDetail &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteElementDetail &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteMemberDetail &stru)

bool	operator<< (Serializer &strm, const XTypes::CompleteMemberDetail &stru)

bool	operator>> (Serializer &strm, XTypes::CompleteMemberDetail &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalMemberDetail &stru)

bool	operator<< (Serializer &strm, const XTypes::MinimalMemberDetail &stru)

bool	operator>> (Serializer &strm, XTypes::MinimalMemberDetail &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::ExtendedTypeDefn &)

bool	operator<< (Serializer &strm, const XTypes::ExtendedTypeDefn &)

bool	operator>> (Serializer &strm, XTypes::ExtendedTypeDefn &)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::PlainArrayLElemDefn &stru)

bool	operator<< (Serializer &strm, const XTypes::PlainArrayLElemDefn &stru)

bool	operator>> (Serializer &strm, XTypes::PlainArrayLElemDefn &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::PlainArraySElemDefn &stru)

bool	operator<< (Serializer &strm, const XTypes::PlainArraySElemDefn &stru)

bool	operator>> (Serializer &strm, XTypes::PlainArraySElemDefn &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::PlainMapLTypeDefn &stru)

bool	operator<< (Serializer &strm, const XTypes::PlainMapLTypeDefn &stru)

bool	operator>> (Serializer &strm, XTypes::PlainMapLTypeDefn &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::PlainMapSTypeDefn &stru)

bool	operator<< (Serializer &strm, const XTypes::PlainMapSTypeDefn &stru)

bool	operator>> (Serializer &strm, XTypes::PlainMapSTypeDefn &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::PlainSequenceLElemDefn &stru)

bool	operator<< (Serializer &strm, const XTypes::PlainSequenceLElemDefn &stru)

bool	operator>> (Serializer &strm, XTypes::PlainSequenceLElemDefn &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::PlainSequenceSElemDefn &stru)

bool	operator<< (Serializer &strm, const XTypes::PlainSequenceSElemDefn &stru)

bool	operator>> (Serializer &strm, XTypes::PlainSequenceSElemDefn &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::StringLTypeDefn &stru)

bool	operator<< (Serializer &strm, const XTypes::StringLTypeDefn &stru)

bool	operator>> (Serializer &strm, XTypes::StringLTypeDefn &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::StringSTypeDefn &stru)

bool	operator<< (Serializer &strm, const XTypes::StringSTypeDefn &stru)

bool	operator>> (Serializer &strm, XTypes::StringSTypeDefn &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::StronglyConnectedComponentId &stru)

bool	operator<< (Serializer &strm, const XTypes::StronglyConnectedComponentId &stru)

bool	operator>> (Serializer &strm, XTypes::StronglyConnectedComponentId &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::PlainCollectionHeader &stru)

bool	operator<< (Serializer &strm, const XTypes::PlainCollectionHeader &stru)

bool	operator>> (Serializer &strm, XTypes::PlainCollectionHeader &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeObjectHashId &uni)

bool	operator<< (Serializer &strm, const XTypes::TypeObjectHashId &uni)

bool	operator>> (Serializer &strm, XTypes::TypeObjectHashId &uni)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::CompleteTypeObject &type_object)

bool	operator<< (Serializer &ser, const XTypes::CompleteTypeObject &type_object)

bool	operator>> (Serializer &ser, XTypes::CompleteTypeObject &type_object)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalTypeObject &type_object)

bool	operator<< (Serializer &ser, const XTypes::MinimalTypeObject &type_object)

bool	operator>> (Serializer &ser, XTypes::MinimalTypeObject &type_object)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeObject &type_object)

bool	operator<< (Serializer &ser, const XTypes::TypeObject &type_object)

bool	operator>> (Serializer &ser, XTypes::TypeObject &type_object)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::MinimalExtendedType &)

bool	operator<< (Serializer &strm, const XTypes::MinimalExtendedType &)

bool	operator>> (Serializer &strm, XTypes::MinimalExtendedType &)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeInformation &stru)

bool	operator<< (Serializer &strm, const XTypes::TypeInformation &stru)

bool	operator>> (Serializer &strm, XTypes::TypeInformation &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeIdentifierTypeObjectPair &stru)

bool	operator<< (Serializer &strm, const XTypes::TypeIdentifierTypeObjectPair &stru)

bool	operator>> (Serializer &strm, XTypes::TypeIdentifierTypeObjectPair &stru)

void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::TypeIdentifierPair &stru)

bool	operator<< (Serializer &strm, const XTypes::TypeIdentifierPair &stru)

bool	operator>> (Serializer &strm, XTypes::TypeIdentifierPair &stru)

bool	to_type_object (const unsigned char *buffer, size_t size, XTypes::TypeObject &to)

template<typename T >
const XTypes::TypeIdentifier &	getMinimalTypeIdentifier ()

template<typename T >
const XTypes::TypeMap &	getMinimalTypeMap ()

template<typename T >
const XTypes::TypeIdentifier &	getCompleteTypeIdentifier ()

template<typename T >
const XTypes::TypeMap &	getCompleteTypeMap ()

template<typename T >
void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::Optional< T > &opt)

template<typename T >
bool	operator<< (Serializer &strm, const XTypes::Optional< T > &opt)

template<typename T >
bool	operator>> (Serializer &strm, XTypes::Optional< T > &opt)

template<typename T >
void	serialized_size (const Encoding &encoding, size_t &size, const XTypes::Sequence< T > &seq)

template<typename T >
bool	operator<< (Serializer &strm, const XTypes::Sequence< T > &seq)

template<typename T >
bool	operator>> (Serializer &strm, XTypes::Sequence< T > &seq)

void	serialized_size (const Encoding &, size_t &, const XTypes::MinimalTypeDetail &)

bool	operator<< (Serializer &, const XTypes::MinimalTypeDetail &)

bool	operator>> (Serializer &, XTypes::MinimalTypeDetail &)

bool	operator>> (Serializer &ser, const XTypes::MinimalAnnotationType &stru)

bool	operator<< (Serializer &ser, XTypes::MinimalAnnotationType &stru)

bool	operator>> (Serializer &ser, const XTypes::CompleteAliasType &stru)

bool	operator<< (Serializer &ser, XTypes::CompleteAliasType &stru)

bool	operator>> (Serializer &ser, const XTypes::MinimalAliasType &stru)

bool	operator<< (Serializer &ser, XTypes::MinimalAliasType &stru)


String	to_hex_dds_string (const unsigned char *data, const size_t size, const char delim, const size_t delim_every)

String	to_hex_dds_string (const char *data, size_t size, const char delim, const size_t delim_every)

Variables
const char *const	BUILT_IN_PARTICIPANT_TOPIC = "DCPSParticipant"

const char *const	BUILT_IN_PARTICIPANT_TOPIC_TYPE = "PARTICIPANT_BUILT_IN_TOPIC_TYPE"

const char *const	BUILT_IN_TOPIC_TOPIC = "DCPSTopic"

const char *const	BUILT_IN_TOPIC_TOPIC_TYPE = "TOPIC_BUILT_IN_TOPIC_TYPE"

const char *const	BUILT_IN_SUBSCRIPTION_TOPIC = "DCPSSubscription"

const char *const	BUILT_IN_SUBSCRIPTION_TOPIC_TYPE = "SUBSCRIPTION_BUILT_IN_TOPIC_TYPE"

const char *const	BUILT_IN_PUBLICATION_TOPIC = "DCPSPublication"

const char *const	BUILT_IN_PUBLICATION_TOPIC_TYPE = "PUBLICATION_BUILT_IN_TOPIC_TYPE"

const char *const	BUILT_IN_PARTICIPANT_LOCATION_TOPIC = "OpenDDSParticipantLocation"

const char *const	BUILT_IN_PARTICIPANT_LOCATION_TOPIC_TYPE = "PARTICIPANT_LOCATION_BUILT_IN_TOPIC_TYPE"

const char *const	BUILT_IN_CONNECTION_RECORD_TOPIC = "OpenDDSConnectionRecord"

const char *const	BUILT_IN_CONNECTION_RECORD_TOPIC_TYPE = "CONNECTION_RECORD_BUILT_IN_TOPIC_TYPE"

const char *const	BUILT_IN_INTERNAL_THREAD_TOPIC = "OpenDDSInternalThread"

const char *const	BUILT_IN_INTERNAL_THREAD_TOPIC_TYPE = "INTERNAL_THREAD_BUILT_IN_TOPIC_TYPE"

const size_t	NUMBER_OF_BUILT_IN_TOPICS = 7

const CORBA::ULong	MAX_READERS_PER_ELEM = 5

OpenDDS_Dcps_Export unsigned int	Transport_debug_level = 0
	Transport Logging verbosity level. More...

OpenDDS_Dcps_Export TransportDebug	transport_debug

OpenDDS_Dcps_Export unsigned int	DCPS_debug_level = 0

OpenDDS_Dcps_Export SecurityDebug	security_debug

OpenDDS_Dcps_Export LogLevel	log_level

const size_t	AceTimestampSize = 27

const size_t	AddrToStringSize = 256
	Size of TCHAR buffer for use with addr_to_string. More...

const GuidVendorId_t	VENDORID_OCI = { 0x01, 0x03 }
	Vendor Id value specified for OCI is used for OpenDDS. More...

const GuidPrefix_t	GUIDPREFIX_UNKNOWN = { 0 }
	Nil value for the GUID prefix (participant identifier). More...

const GUID_t	GUID_UNKNOWN = { { 0 }, { { 0 }, 0 } }
	Nil value for GUID. More...

const size_t	guid_cdr_size = 16

static InfoRepoDiscovery::StaticInitializer	initialize_inforepodisco

bool	log_bits = false

int const	INVALID_ENUM_VALUE = 999

static const int	OpenDDS_Requires_MonitorFactory_Initializer

const int	MAX_READERS_TO_RESEND = 5

OpenDDS_Dcps_Export const SequenceRange	unknown_sequence_range

const size_t	boolean_cdr_size = 1

const size_t	byte_cdr_size = 1

const size_t	int8_cdr_size = 1

const size_t	uint8_cdr_size = 1

const size_t	int16_cdr_size = 2

const size_t	uint16_cdr_size = 2

const size_t	int32_cdr_size = 4

const size_t	uint32_cdr_size = 4

const size_t	int64_cdr_size = 8

const size_t	uint64_cdr_size = 8

const size_t	float32_cdr_size = 4

const size_t	float64_cdr_size = 8

const size_t	float128_cdr_size = 16

const size_t	char8_cdr_size = 1

const size_t	char16_cdr_size = 2

const size_t	xcdr1_pid_alignment = 4

const size_t	DEFAULT_NUM_CHUNKS = 20

const size_t	DEFAULT_CHUNK_MULTIPLIER = 10

const int	DEFAULT_FEDERATION_RECOVERY_DURATION = 900

const int	DEFAULT_FEDERATION_INITIAL_BACKOFF_SECONDS = 1

const int	DEFAULT_FEDERATION_BACKOFF_MULTIPLIER = 2

const int	DEFAULT_FEDERATION_LIVELINESS = 60

const int	BIT_LOOKUP_DURATION_MSEC = 2000

static ACE_TString	config_fname (ACE_TEXT(""))

static const ACE_TCHAR	DEFAULT_REPO_IOR [] = ACE_TEXT("file://repo.ior")

static const char	DEFAULT_PERSISTENT_DATA_DIR [] = "OpenDDS-durable-data-dir"

static const ACE_TCHAR	COMMON_SECTION_NAME [] = ACE_TEXT("common")

static const ACE_TCHAR	DOMAIN_SECTION_NAME [] = ACE_TEXT("domain")

static const ACE_TCHAR	DOMAIN_RANGE_SECTION_NAME [] = ACE_TEXT("DomainRange")

static const ACE_TCHAR	REPO_SECTION_NAME [] = ACE_TEXT("repository")

static const ACE_TCHAR	RTPS_SECTION_NAME [] = ACE_TEXT("rtps_discovery")

static bool	got_debug_level = false

static bool	got_use_rti_serialization = false

static bool	got_info = false

static bool	got_chunks = false

static bool	got_chunk_association_multiplier = false

static bool	got_liveliness_factor = false

static bool	got_bit_transport_port = false

static bool	got_bit_transport_ip = false

static bool	got_bit_lookup_duration_msec = false

static bool	got_global_transport_config = false

static bool	got_bit_flag = false

static bool	got_security_flag = false

static bool	got_security_debug = false

static bool	got_security_fake_encryption = false

static bool	got_publisher_content_filter = false

static bool	got_transport_debug_level = false

static bool	got_pending_timeout = false

static bool	got_persistent_data_dir = false

static bool	got_default_discovery = false

static bool	got_log_fname = false

static bool	got_log_verbose = false

static bool	got_default_address = false

static bool	got_bidir_giop = false

static bool	got_thread_status_interval = false

static bool	got_monitor = false

static bool	got_type_object_encoding = false

static bool	got_log_level = false

const char	DEFAULT_ORB_NAME [] = "OpenDDS_DCPS"

static const ACE_TCHAR	TRANSPORT_SECTION_NAME [] = ACE_TEXT("transport")

static const ACE_TCHAR	TRANSPORT_TEMPLATE_SECTION_NAME [] = ACE_TEXT("transport_template")

static const ACE_TCHAR	CONFIG_SECTION_NAME [] = ACE_TEXT("config")

static const ACE_TCHAR	CUSTOMIZATION_SECTION_NAME [] = ACE_TEXT("Customization")

static const ConnectionInfoFlags	CONNINFO_UNICAST = (1 << 0)

static const ConnectionInfoFlags	CONNINFO_MULTICAST = (1 << 1)

static const ConnectionInfoFlags	CONNINFO_ALL = static_cast<ConnectionInfoFlags>(-1)

const TqePair	null_tqe_pair

static MulticastInitializer	multicast_init

static RtpsUdpInitializer	rtps_udp_init

const size_t	ONE_SAMPLE_PER_PACKET = 1

const size_t	initial_bundle_size = 32

static ShmemInitializer	shmem_init

static Tcp_Initializer	tcp_initializer

static UdpInitializer	udp_init

const DDS::DataRepresentationId_t	UNALIGNED_CDR_DATA_REPRESENTATION = -12140

const octet	ENTITYKIND_BUILTIN_UNKNOWN = 0xc0

const octet	ENTITYKIND_BUILTIN_PARTICIPANT = 0xc1

const octet	ENTITYKIND_BUILTIN_WRITER_WITH_KEY = 0xc2

const octet	ENTITYKIND_BUILTIN_WRITER_NO_KEY = 0xc3

const octet	ENTITYKIND_BUILTIN_READER_NO_KEY = 0xc4

const octet	ENTITYKIND_BUILTIN_READER_WITH_KEY = 0xc7

const octet	ENTITYKIND_BUILTIN_TOPIC = 0xc5

const octet	ENTITYKIND_USER_UNKNOWN = 0x00

const octet	ENTITYKIND_USER_WRITER_WITH_KEY = 0x02

const octet	ENTITYKIND_USER_WRITER_NO_KEY = 0x03

const octet	ENTITYKIND_USER_READER_NO_KEY = 0x04

const octet	ENTITYKIND_USER_READER_WITH_KEY = 0x07

const octet	ENTITYKIND_OPENDDS_SUBSCRIBER = 0x41

const octet	ENTITYKIND_OPENDDS_PUBLISHER = 0x42

const octet	ENTITYKIND_OPENDDS_TOPIC = 0x45

const octet	ENTITYKIND_OPENDDS_USER = 0x4a

const octet	ENTITYKIND_OPENDDS_NIL_WRITER = 0x4e

const DDS::StatusMask	ALL_STATUS_MASK = 0xffffffff

const DDS::StatusMask	NO_STATUS_MASK = 0x00000000

const DDS::StatusMask	DEFAULT_STATUS_MASK = ALL_STATUS_MASK

const long	MONITOR_DOMAIN_ID = -999

const long	MONITOR_TRANSPORT_ID = 999

const string	SERVICE_PARTICIPANT_MONITOR_TOPIC = "Service Participant Monitor"

const string	DOMAIN_PARTICIPANT_MONITOR_TOPIC = "Domain Participant Monitor"

const string	TOPIC_MONITOR_TOPIC = "Topic Monitor"

const string	PUBLISHER_MONITOR_TOPIC = "Publisher Monitor"

const string	SUBSCRIBER_MONITOR_TOPIC = "Subscriber Monitor"

const string	DATA_WRITER_MONITOR_TOPIC = "Data Writer Monitor"

const string	DATA_WRITER_PERIODIC_MONITOR_TOPIC = "Data Writer Periodic Monitor"

const string	DATA_READER_MONITOR_TOPIC = "Data Reader Monitor"

const string	DATA_READER_PERIODIC_MONITOR_TOPIC = "Data Reader Periodic Monitor"

const string	TRANSPORT_MONITOR_TOPIC = "Transport Monitor"

static int	OpenDDS_Requires_MonitorFactoryImpl_Initializer

const ParticipantLocation	LOCATION_LOCAL = 0x0001 << 0

const ParticipantLocation	LOCATION_ICE = 0x0001 << 1

const ParticipantLocation	LOCATION_RELAY = 0x0001 << 2

const ParticipantLocation	LOCATION_LOCAL6 = 0x0001 << 3

const ParticipantLocation	LOCATION_ICE6 = 0x0001 << 4

const ParticipantLocation	LOCATION_RELAY6 = 0x0001 << 5

const string	RTPS_RELAY_STUN_PROTOCOL = "RtpsRelay:STUN"

const long	LOCATOR_KIND_INVALID = -1

const long	LOCATOR_KIND_RESERVED = 0

const long	LOCATOR_KIND_UDPv4 = 1

const long	LOCATOR_KIND_UDPv6 = 2

const unsigned long	LOCATOR_PORT_INVALID = 0

const MessageCountKind	MCK_RTPS = 0

const MessageCountKind	MCK_STUN = 1


const EntityId_t	ENTITYID_UNKNOWN = { {0x00,0x00,0x00}, 0x00}

const EntityId_t	ENTITYID_PARTICIPANT = { {0x00,0x00,0x01}, 0xc1}

const EntityId_t	ENTITYID_SEDP_BUILTIN_TOPIC_WRITER = { {0x00,0x00,0x02}, 0xc2}

const EntityId_t	ENTITYID_SEDP_BUILTIN_TOPIC_READER = { {0x00,0x00,0x02}, 0xc7}

const EntityId_t	ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER = { {0x00,0x00,0x03}, 0xc2}

const EntityId_t	ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER = { {0x00,0x00,0x03}, 0xc7}

const EntityId_t	ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER = { {0x00,0x00,0x04}, 0xc2}

const EntityId_t	ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_READER = { {0x00,0x00,0x04}, 0xc7}

const EntityId_t	ENTITYID_SPDP_BUILTIN_PARTICIPANT_WRITER = { {0x00,0x01,0x00}, 0xc2}

const EntityId_t	ENTITYID_SPDP_BUILTIN_PARTICIPANT_READER = { {0x00,0x01,0x00}, 0xc7}

const EntityId_t	ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_WRITER = { {0x00,0x02,0x00}, 0xc2}

const EntityId_t	ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_READER = { {0x00,0x02,0x00}, 0xc7}


const EntityId_t	ENTITYID_TL_SVC_REQ_WRITER = { {0x00,0x03,0x00}, 0xc3}

const EntityId_t	ENTITYID_TL_SVC_REQ_READER = { {0x00,0x03,0x00}, 0xc4}

const EntityId_t	ENTITYID_TL_SVC_REPLY_WRITER = { {0x00,0x03,0x01}, 0xc3}

const EntityId_t	ENTITYID_TL_SVC_REPLY_READER = { {0x00,0x03,0x01}, 0xc4}

Typedef Documentation

◆ ActionConnectionRecord

typedef std::pair<bool, ConnectionRecord> OpenDDS::DCPS::ActionConnectionRecord

Definition at line 22 of file ConnectionRecords.h.

◆ AstNode

typedef yard::TreeBuildingParser<char>::Node OpenDDS::DCPS::AstNode

Definition at line 24 of file AstNodeWrapper.h.

◆ BundlingCache

typedef AddressCache<BundlingCacheKey> OpenDDS::DCPS::BundlingCache

Definition at line 87 of file RtpsUdpDataLink.h.

◆ CoherencyGroup

typedef ACE_UINT16 OpenDDS::DCPS::CoherencyGroup

Definition at line 29 of file PublicationInstance.h.

◆ ConnectionInfoFlags

typedef size_t OpenDDS::DCPS::ConnectionInfoFlags

Definition at line 256 of file TransportDefs.h.

◆ ConnectionRecordDataReaderImpl

typedef DataReaderImpl_T<ConnectionRecord> OpenDDS::DCPS::ConnectionRecordDataReaderImpl

Definition at line 20 of file BuiltInTopicDataReaderImpls.h.

◆ ConstSample_rch

typedef RcHandle<const Sample> OpenDDS::DCPS::ConstSample_rch

Definition at line 24 of file Sample.h.

◆ DataBlockAllocator

typedef Cached_Allocator_With_Overflow<ACE_Data_Block, ACE_Thread_Mutex> OpenDDS::DCPS::DataBlockAllocator

Definition at line 171 of file Cached_Allocator_With_Overflow_T.h.

◆ DataLink_rch

typedef RcHandle<DataLink> OpenDDS::DCPS::DataLink_rch

The type definition for the smart-pointer to the underlying type.

Definition at line 34 of file DataLink_rch.h.

◆ DataLinkIdType

typedef ACE_UINT64 OpenDDS::DCPS::DataLinkIdType

Identifier type for DataLink objects.

Definition at line 192 of file TransportDefs.h.

◆ DataLinkSet_rch

typedef RcHandle< DataLinkSet > OpenDDS::DCPS::DataLinkSet_rch

The type definition for the smart-pointer to the underlying type.

Definition at line 27 of file DataLinkSet.h.

◆ DataReaderCallbacks_rch

typedef RcHandle<DataReaderCallbacks> OpenDDS::DCPS::DataReaderCallbacks_rch

Definition at line 70 of file DataReaderCallbacks.h.

◆ DataReaderCallbacks_wrch

typedef WeakRcHandle<DataReaderCallbacks> OpenDDS::DCPS::DataReaderCallbacks_wrch

Definition at line 71 of file DataReaderCallbacks.h.

◆ DataReaderImpl_rch

typedef RcHandle<DataReaderImpl> OpenDDS::DCPS::DataReaderImpl_rch

Definition at line 1112 of file DataReaderImpl.h.

◆ DataSample

typedef ACE_Message_Block OpenDDS::DCPS::DataSample

Currently we contain entire messages in a single ACE_Message_Block chain.

Definition at line 40 of file DataSampleElement.h.

◆ DataSampleElementAllocator

typedef Cached_Allocator_With_Overflow<DataSampleElement, ACE_Null_Mutex> OpenDDS::DCPS::DataSampleElementAllocator

Definition at line 28 of file DataSampleElement.h.

◆ DataSampleHeaderAllocator

typedef Cached_Allocator_With_Overflow<DataSampleHeader, ACE_Null_Mutex> OpenDDS::DCPS::DataSampleHeaderAllocator

Definition at line 294 of file DataSampleHeader.h.

◆ DataWriterCallbacks_rch

typedef RcHandle<DataWriterCallbacks> OpenDDS::DCPS::DataWriterCallbacks_rch

Definition at line 70 of file DataWriterCallbacks.h.

◆ DataWriterCallbacks_wrch

typedef WeakRcHandle<DataWriterCallbacks> OpenDDS::DCPS::DataWriterCallbacks_wrch

Definition at line 71 of file DataWriterCallbacks.h.

◆ DataWriterImpl_rch

typedef RcHandle<DataWriterImpl> OpenDDS::DCPS::DataWriterImpl_rch

Definition at line 872 of file DataWriterImpl.h.

◆ DisassociationStatus

typedef PublicationLostStatus OpenDDS::DCPS::DisassociationStatus

Definition at line 183 of file DdsDcpsPublication.idl.

◆ Discovery_rch

typedef RcHandle<Discovery> OpenDDS::DCPS::Discovery_rch

Definition at line 270 of file Discovery.h.

◆ DispatchService_rch

typedef RcHandle<DispatchService> OpenDDS::DCPS::DispatchService_rch

Definition at line 146 of file DispatchService.h.

◆ DRAssociations

typedef sequence<DataReaderAssociation> OpenDDS::DCPS::DRAssociations

Definition at line 150 of file monitor.idl.

◆ DRAssociationsPeriodic

typedef sequence<DataReaderAssociationPeriodic> OpenDDS::DCPS::DRAssociationsPeriodic

Definition at line 174 of file monitor.idl.

◆ DWAssociations

typedef sequence<DataWriterAssociation> OpenDDS::DCPS::DWAssociations

Definition at line 110 of file monitor.idl.

◆ DWAssociationsPeriodic

typedef sequence<DataWriterAssociationPeriodic> OpenDDS::DCPS::DWAssociationsPeriodic

Definition at line 133 of file monitor.idl.

◆ EntityKey_t

typedef octet OpenDDS::DCPS::EntityKey_t[3]

Definition at line 22 of file DdsDcpsGuid.idl.

◆ EventBase_rch

typedef RcHandle<EventBase> OpenDDS::DCPS::EventBase_rch

Definition at line 42 of file EventDispatcher.h.

◆ EventDispatcher_rch

typedef RcHandle<EventDispatcher> OpenDDS::DCPS::EventDispatcher_rch

Definition at line 142 of file EventDispatcher.h.

◆ GuidCountSequence

typedef sequence<GuidCount> OpenDDS::DCPS::GuidCountSequence

Definition at line 117 of file OpenddsDcpsExt.idl.

◆ GuidPrefix_t

typedef octet OpenDDS::DCPS::GuidPrefix_t[12]

Definition at line 19 of file DdsDcpsGuid.idl.

◆ GUIDSeq

typedef sequence<GUID_t> OpenDDS::DCPS::GUIDSeq

Definition at line 62 of file DdsDcpsGuid.idl.

◆ GuidVendorId_t

typedef octet OpenDDS::DCPS::GuidVendorId_t[2]

Definition at line 16 of file DdsDcpsGuid.idl.

◆ InfoRepoDiscovery_rch

typedef RcHandle<InfoRepoDiscovery> OpenDDS::DCPS::InfoRepoDiscovery_rch

Definition at line 288 of file InfoRepoDiscovery.h.

◆ InstanceState_rch

typedef RcHandle<InstanceState> OpenDDS::DCPS::InstanceState_rch

Definition at line 33 of file InstanceState.h.

◆ InternalEntity_wrch

typedef WeakRcHandle<InternalEntity> OpenDDS::DCPS::InternalEntity_wrch

Definition at line 29 of file InternalDataReader.h.

◆ InternalThreadBuiltinTopicDataDataReaderImpl

typedef DataReaderImpl_T<InternalThreadBuiltinTopicData> OpenDDS::DCPS::InternalThreadBuiltinTopicDataDataReaderImpl

Definition at line 19 of file BuiltInTopicDataReaderImpls.h.

◆ JobQueue_rch

typedef RcHandle<JobQueue> OpenDDS::DCPS::JobQueue_rch

Definition at line 54 of file JobQueue.h.

◆ JobQueue_wrch

typedef WeakRcHandle<JobQueue> OpenDDS::DCPS::JobQueue_wrch

Definition at line 55 of file JobQueue.h.

◆ LatencyStatisticsSeq

typedef sequence<LatencyStatistics> OpenDDS::DCPS::LatencyStatisticsSeq

Definition at line 75 of file DdsDcpsSubscriptionExt.idl.

◆ LocalObject_ptr

typedef CORBA::LocalObject_ptr OpenDDS::DCPS::LocalObject_ptr

Definition at line 22 of file LocalObject.h.

◆ LocalObject_var

typedef CORBA::LocalObject_var OpenDDS::DCPS::LocalObject_var

Definition at line 23 of file LocalObject.h.

◆ LocatorCache

typedef AddressCache<LocatorCacheKey> OpenDDS::DCPS::LocatorCache

Definition at line 86 of file RtpsUdpDataLink.h.

◆ LocatorSeq

typedef sequence<Locator_t> OpenDDS::DCPS::LocatorSeq

Definition at line 92 of file OpenddsDcpsExt.idl.

◆ MD5Result

typedef unsigned char OpenDDS::DCPS::MD5Result[16]

Definition at line 21 of file Hash.h.

◆ Message_Block_Ptr

typedef unique_ptr<ACE_Message_Block, Message_Block_Deleter> OpenDDS::DCPS::Message_Block_Ptr

Definition at line 31 of file Message_Block_Ptr.h.

◆ MessageBlockAllocator

typedef Cached_Allocator_With_Overflow<ACE_Message_Block, ACE_Thread_Mutex> OpenDDS::DCPS::MessageBlockAllocator

Definition at line 170 of file Cached_Allocator_With_Overflow_T.h.

◆ MessageCountKind

typedef long OpenDDS::DCPS::MessageCountKind

Definition at line 94 of file OpenddsDcpsExt.idl.

◆ MessageCountSequence

typedef sequence<MessageCount> OpenDDS::DCPS::MessageCountSequence

Definition at line 116 of file OpenddsDcpsExt.idl.

◆ MonotonicClock

typedef SystemClock OpenDDS::DCPS::MonotonicClock

ACE_Time_Policy that OpenDDS uses for internal timing.

ACE_Monotonic_Time_Policy protects OpenDDS from being effected by changes to the system clock to a certain degree.

Definition at line 49 of file TimeTypes.h.

◆ MonotonicTimePoint

typedef TimePoint_T<MonotonicClock> OpenDDS::DCPS::MonotonicTimePoint

ACE_Time_Policy that OpenDDS uses for internal timing.

ACE_Monotonic_Time_Policy protects OpenDDS from being effected by changes to the system clock to a certain degree.

Definition at line 51 of file TimeTypes.h.

◆ MulticastDataLink_rch

typedef RcHandle< MulticastDataLink > OpenDDS::DCPS::MulticastDataLink_rch

Definition at line 18 of file MulticastDataLink_rch.h.

◆ MulticastInst_rch

typedef RcHandle<MulticastInst> OpenDDS::DCPS::MulticastInst_rch

Definition at line 18 of file MulticastInst_rch.h.

◆ MulticastPeer

typedef ACE_INT64 OpenDDS::DCPS::MulticastPeer

Definition at line 19 of file MulticastTypes.h.

◆ MulticastReceiveStrategy_rch

typedef RcHandle<MulticastReceiveStrategy> OpenDDS::DCPS::MulticastReceiveStrategy_rch

Definition at line 18 of file MulticastReceiveStrategy_rch.h.

◆ MulticastSendStrategy_rch

typedef RcHandle<MulticastSendStrategy> OpenDDS::DCPS::MulticastSendStrategy_rch

Definition at line 18 of file MulticastSendStrategy_rch.h.

◆ MulticastSession_rch

typedef RcHandle< MulticastSession > OpenDDS::DCPS::MulticastSession_rch

Definition at line 18 of file MulticastSession_rch.h.

◆ MulticastSessionFactory_rch

typedef RcHandle<MulticastSessionFactory> OpenDDS::DCPS::MulticastSessionFactory_rch

Definition at line 18 of file MulticastSessionFactory_rch.h.

◆ MulticastTransport_rch

typedef RcHandle<MulticastTransport> OpenDDS::DCPS::MulticastTransport_rch

Definition at line 39 of file MulticastDataLink.h.

◆ NetworkConfigMonitor_rch

typedef RcHandle<NetworkConfigMonitor> OpenDDS::DCPS::NetworkConfigMonitor_rch

Definition at line 106 of file NetworkConfigMonitor.h.

◆ NVPSeq

typedef sequence<NameValuePair> OpenDDS::DCPS::NVPSeq

Definition at line 47 of file monitor.idl.

◆ Observer_rch

typedef RcHandle<Observer> OpenDDS::DCPS::Observer_rch

Definition at line 101 of file Observer.h.

◆ ParticipantBuiltinTopicDataDataReaderImpl

typedef DataReaderImpl_T<DDS::ParticipantBuiltinTopicData> OpenDDS::DCPS::ParticipantBuiltinTopicDataDataReaderImpl

Definition at line 14 of file BuiltInTopicDataReaderImpls.h.

◆ ParticipantId

typedef ::CORBA::Long OpenDDS::DCPS::ParticipantId

Definition at line 28 of file RepoIdConverter.h.

◆ ParticipantLocation

typedef unsigned long OpenDDS::DCPS::ParticipantLocation

Definition at line 32 of file OpenddsDcpsExt.idl.

◆ ParticipantLocationBuiltinTopicDataDataReaderImpl

typedef DataReaderImpl_T<ParticipantLocationBuiltinTopicData> OpenDDS::DCPS::ParticipantLocationBuiltinTopicDataDataReaderImpl

Definition at line 18 of file BuiltInTopicDataReaderImpls.h.

◆ Priority

typedef ACE_CDR::Long OpenDDS::DCPS::Priority

Definition at line 254 of file TransportDefs.h.

◆ PublicationBuiltinTopicDataDataReaderImpl

typedef DataReaderImpl_T<DDS::PublicationBuiltinTopicData> OpenDDS::DCPS::PublicationBuiltinTopicDataDataReaderImpl

Definition at line 15 of file BuiltInTopicDataReaderImpls.h.

◆ PublicationDisconnectedStatus

typedef PublicationLostStatus OpenDDS::DCPS::PublicationDisconnectedStatus

Definition at line 181 of file DdsDcpsPublication.idl.

◆ PublicationId

typedef RepoId OpenDDS::DCPS::PublicationId

Definition at line 22 of file RepoIdTypes.h.

◆ PublicationInstance_rch

typedef RcHandle< PublicationInstance > OpenDDS::DCPS::PublicationInstance_rch

Definition at line 33 of file DataSampleElement.h.

◆ PublicationReconnectedStatus

typedef PublicationLostStatus OpenDDS::DCPS::PublicationReconnectedStatus

Definition at line 182 of file DdsDcpsPublication.idl.

◆ ReactorInterceptor_rch

typedef RcHandle<ReactorInterceptor> OpenDDS::DCPS::ReactorInterceptor_rch

Definition at line 80 of file ReactorInterceptor.h.

◆ ReactorInterceptor_wrch

typedef WeakRcHandle<ReactorInterceptor> OpenDDS::DCPS::ReactorInterceptor_wrch

Definition at line 81 of file ReactorInterceptor.h.

◆ ReactorTask_rch

typedef RcHandle<ReactorTask> OpenDDS::DCPS::ReactorTask_rch

The type definition for the smart-pointer to the underlying type.

Definition at line 34 of file ReactorTask_rch.h.

◆ ReaderIdSeq

typedef sequence<RepoId> OpenDDS::DCPS::ReaderIdSeq

Definition at line 92 of file DdsDcpsInfoUtils.idl.

◆ ReceivedDataAllocator

typedef Cached_Allocator_With_Overflow<ReceivedDataElementMemoryBlock, ACE_Thread_Mutex> OpenDDS::DCPS::ReceivedDataAllocator

Definition at line 73 of file DataReaderImpl.h.

◆ ReceiveListenerSet_rch

typedef RcHandle<ReceiveListenerSet> OpenDDS::DCPS::ReceiveListenerSet_rch

The type definition for the smart-pointer to the underlying type.

Definition at line 34 of file ReceiveListenerSet_rch.h.

◆ Recorder_ptr

typedef Recorder* OpenDDS::DCPS::Recorder_ptr

Definition at line 58 of file Recorder.h.

◆ Recorder_var

typedef TAO_Objref_Var_T<Recorder> OpenDDS::DCPS::Recorder_var

Definition at line 59 of file Recorder.h.

◆ RecorderListener_rch

typedef RcHandle<RecorderListener> OpenDDS::DCPS::RecorderListener_rch

Definition at line 56 of file Recorder.h.

◆ Replayer_ptr

typedef Replayer* OpenDDS::DCPS::Replayer_ptr

Definition at line 49 of file Replayer.h.

◆ Replayer_var

typedef TAO_Objref_Var_T<Replayer> OpenDDS::DCPS::Replayer_var

Definition at line 50 of file Replayer.h.

◆ ReplayerListener_rch

typedef RcHandle<ReplayerListener> OpenDDS::DCPS::ReplayerListener_rch

Definition at line 45 of file Replayer.h.

◆ RepoId

typedef GUID_t OpenDDS::DCPS::RepoId

Definition at line 20 of file DdsDcpsInfoUtils.idl.

◆ RepoIdSet

typedef GuidSet OpenDDS::DCPS::RepoIdSet

Definition at line 126 of file GuidUtils.h.

◆ RtpsCustomizedElementAllocator

typedef Dynamic_Cached_Allocator_With_Overflow<ACE_Thread_Mutex> OpenDDS::DCPS::RtpsCustomizedElementAllocator

Definition at line 43 of file RtpsCustomizedElement.h.

◆ RtpsUdpDataLink_rch

typedef RcHandle< RtpsUdpDataLink > OpenDDS::DCPS::RtpsUdpDataLink_rch

Definition at line 18 of file RtpsUdpDataLink_rch.h.

◆ RtpsUdpInst_rch

typedef RcHandle< RtpsUdpInst > OpenDDS::DCPS::RtpsUdpInst_rch

Definition at line 75 of file RtpsUdpDataLink.h.

◆ RtpsUdpReceiveStrategy_rch

typedef RcHandle<RtpsUdpReceiveStrategy> OpenDDS::DCPS::RtpsUdpReceiveStrategy_rch

Definition at line 18 of file RtpsUdpReceiveStrategy_rch.h.

◆ RtpsUdpSendStrategy_rch

typedef RcHandle<RtpsUdpSendStrategy> OpenDDS::DCPS::RtpsUdpSendStrategy_rch

Definition at line 18 of file RtpsUdpSendStrategy_rch.h.

◆ RtpsUdpTransport_rch

typedef RcHandle<RtpsUdpTransport> OpenDDS::DCPS::RtpsUdpTransport_rch

Definition at line 77 of file RtpsUdpDataLink.h.

◆ SafetyProfilePool

typedef ACE_Allocator OpenDDS::DCPS::SafetyProfilePool

Definition at line 104 of file SafetyProfilePool.h.

◆ Sample_rch

typedef RcHandle<Sample> OpenDDS::DCPS::Sample_rch

Definition at line 22 of file Sample.h.

◆ SequenceRange

typedef std::pair<SequenceNumber, SequenceNumber> OpenDDS::DCPS::SequenceRange

Definition at line 203 of file SequenceNumber.h.

◆ ServiceEventDispatcher_rch

typedef RcHandle<ServiceEventDispatcher> OpenDDS::DCPS::ServiceEventDispatcher_rch

Definition at line 41 of file ServiceEventDispatcher.h.

◆ ShmemAllocator

typedef ACE_Malloc_T<ShmemPool, ACE_Process_Mutex, ACE_PI_Control_Block> OpenDDS::DCPS::ShmemAllocator

Definition at line 64 of file ShmemDataLink.h.

◆ ShmemDataLink_rch

typedef RcHandle<ShmemDataLink> OpenDDS::DCPS::ShmemDataLink_rch

Definition at line 18 of file ShmemDataLink_rch.h.

◆ ShmemInst_rch

typedef RcHandle< ShmemInst > OpenDDS::DCPS::ShmemInst_rch

Definition at line 18 of file ShmemInst_rch.h.

◆ ShmemPool

typedef ACE_Local_Memory_Pool OpenDDS::DCPS::ShmemPool

Definition at line 59 of file ShmemDataLink.h.

◆ ShmemReceiveStrategy_rch

typedef RcHandle<ShmemReceiveStrategy> OpenDDS::DCPS::ShmemReceiveStrategy_rch

Definition at line 18 of file ShmemReceiveStrategy_rch.h.

◆ ShmemSendStrategy_rch

typedef RcHandle<ShmemSendStrategy> OpenDDS::DCPS::ShmemSendStrategy_rch

Definition at line 18 of file ShmemSendStrategy_rch.h.

◆ ShmemSharedSemaphore

typedef int OpenDDS::DCPS::ShmemSharedSemaphore

Definition at line 60 of file ShmemDataLink.h.

◆ ShmemTransport_rch

typedef RcHandle<ShmemTransport> OpenDDS::DCPS::ShmemTransport_rch

Definition at line 35 of file ShmemDataLink.h.

◆ StaticDiscovery_rch

typedef RcHandle<StaticDiscovery> OpenDDS::DCPS::StaticDiscovery_rch

Definition at line 30 of file StaticDiscovery.h.

◆ String

typedef std::string OpenDDS::DCPS::String

Definition at line 163 of file PoolAllocator.h.

◆ String256

typedef string<256> OpenDDS::DCPS::String256

Definition at line 94 of file DdsDcpsInfoUtils.idl.

◆ SubscriptionBuiltinTopicDataDataReaderImpl

typedef DataReaderImpl_T<DDS::SubscriptionBuiltinTopicData> OpenDDS::DCPS::SubscriptionBuiltinTopicDataDataReaderImpl

Definition at line 16 of file BuiltInTopicDataReaderImpls.h.

◆ SubscriptionDisconnectedStatus

typedef SubscriptionLostStatus OpenDDS::DCPS::SubscriptionDisconnectedStatus

Definition at line 26 of file DdsDcpsSubscriptionExt.idl.

◆ SubscriptionId

typedef RepoId OpenDDS::DCPS::SubscriptionId

Definition at line 23 of file RepoIdTypes.h.

◆ SubscriptionInstance_rch

typedef RcHandle<SubscriptionInstance> OpenDDS::DCPS::SubscriptionInstance_rch

Definition at line 78 of file SubscriptionInstance.h.

◆ SubscriptionReconnectedStatus

typedef SubscriptionLostStatus OpenDDS::DCPS::SubscriptionReconnectedStatus

Definition at line 27 of file DdsDcpsSubscriptionExt.idl.

◆ SubsectionPair

typedef std::pair<OPENDDS_STRING, ACE_Configuration_Section_Key> OpenDDS::DCPS::SubsectionPair

Definition at line 22 of file ConfigUtils.h.

◆ SystemClock

typedef ACE_System_Time_Policy OpenDDS::DCPS::SystemClock

ACE_Time_Policy that OpenDDS uses to define the system clock for external interactions.

Definition at line 31 of file TimeTypes.h.

◆ SystemTimePoint

typedef TimePoint_T<SystemClock> OpenDDS::DCPS::SystemTimePoint

ACE_Time_Policy that OpenDDS uses to define the system clock for external interactions.

Definition at line 32 of file TimeTypes.h.

◆ TcpConnection_rch

typedef RcHandle<TcpConnection> OpenDDS::DCPS::TcpConnection_rch

Definition at line 18 of file TcpConnection_rch.h.

◆ TcpDataLink_rch

typedef RcHandle<TcpDataLink> OpenDDS::DCPS::TcpDataLink_rch

Definition at line 19 of file TcpDataLink_rch.h.

◆ TcpInst_rch

typedef RcHandle<TcpInst> OpenDDS::DCPS::TcpInst_rch

Definition at line 18 of file TcpInst_rch.h.

◆ TcpReceiveStrategy_rch

typedef RcHandle<TcpReceiveStrategy> OpenDDS::DCPS::TcpReceiveStrategy_rch

Definition at line 20 of file TcpReceiveStrategy_rch.h.

◆ TcpSendStrategy_rch

typedef RcHandle<TcpSendStrategy> OpenDDS::DCPS::TcpSendStrategy_rch

Definition at line 19 of file TcpSendStrategy_rch.h.

◆ TcpTransport_rch

typedef RcHandle<TcpTransport> OpenDDS::DCPS::TcpTransport_rch

Definition at line 18 of file TcpTransport_rch.h.

◆ ThreadSynchStrategy_rch

typedef RcHandle<ThreadSynchStrategy> OpenDDS::DCPS::ThreadSynchStrategy_rch

Definition at line 18 of file ThreadSynchStrategy_rch.h.

◆ ThreadSynchWorker_rch

typedef RcHandle<ThreadSynchWorker> OpenDDS::DCPS::ThreadSynchWorker_rch

Definition at line 53 of file ThreadSynchWorker.h.

◆ TopicBuiltinTopicDataDataReaderImpl

typedef DataReaderImpl_T<DDS::TopicBuiltinTopicData> OpenDDS::DCPS::TopicBuiltinTopicDataDataReaderImpl

Definition at line 17 of file BuiltInTopicDataReaderImpls.h.

◆ TqePair

typedef std::pair<TransportQueueElement*, TransportQueueElement*> OpenDDS::DCPS::TqePair

Definition at line 34 of file TransportQueueElement.h.

◆ TransportBLOB

typedef DDS::OctetSeq OpenDDS::DCPS::TransportBLOB

Definition at line 27 of file DdsDcpsInfoUtils.idl.

◆ TransportClient_rch

typedef RcHandle< TransportClient > OpenDDS::DCPS::TransportClient_rch

Definition at line 354 of file TransportClient.h.

◆ TransportClient_wrch

typedef WeakRcHandle<TransportClient> OpenDDS::DCPS::TransportClient_wrch

Definition at line 44 of file TransportImpl.h.

◆ TransportConfig_rch

typedef RcHandle<TransportConfig> OpenDDS::DCPS::TransportConfig_rch

Definition at line 24 of file TransportConfig_rch.h.

◆ TransportDataAllocator

typedef Cached_Allocator_With_Overflow<char[RECEIVE_DATA_BUFFER_SIZE], RECEIVE_SYNCH> OpenDDS::DCPS::TransportDataAllocator

Definition at line 238 of file TransportDefs.h.

◆ TransportDataBlockAllocator

typedef Cached_Allocator_With_Overflow<ACE_Data_Block, RECEIVE_SYNCH> OpenDDS::DCPS::TransportDataBlockAllocator

Definition at line 234 of file TransportDefs.h.

◆ TransportImpl_rch

typedef RcHandle<TransportImpl> OpenDDS::DCPS::TransportImpl_rch

The type definition for the smart-pointer to the underlying type.

Definition at line 34 of file TransportImpl_rch.h.

◆ TransportInst_rch

typedef RcHandle< TransportInst > OpenDDS::DCPS::TransportInst_rch

The type definition for the smart-pointer to the underlying type.

Definition at line 34 of file TransportInst_rch.h.

◆ TransportLocatorSeq

typedef sequence<TransportLocator> OpenDDS::DCPS::TransportLocatorSeq

Definition at line 37 of file DdsDcpsInfoUtils.idl.

◆ TransportMessageBlockAllocator

typedef Cached_Allocator_With_Overflow<ACE_Message_Block, RECEIVE_SYNCH> OpenDDS::DCPS::TransportMessageBlockAllocator

Definition at line 231 of file TransportDefs.h.

◆ TransportReassembly_rch

typedef RcHandle<TransportReassembly> OpenDDS::DCPS::TransportReassembly_rch

Definition at line 193 of file TransportReassembly.h.

◆ TransportReceiveListener_rch

typedef RcHandle< TransportReceiveListener > OpenDDS::DCPS::TransportReceiveListener_rch

Definition at line 44 of file TransportReceiveListener.h.

◆ TransportReceiveListener_wrch

typedef WeakRcHandle<TransportReceiveListener> OpenDDS::DCPS::TransportReceiveListener_wrch

Definition at line 24 of file ReceiveListenerSet.h.

◆ TransportReceiveStrategy_rch

typedef RcHandle<TransportReceiveStrategy> OpenDDS::DCPS::TransportReceiveStrategy_rch

The type definition for the smart-pointer to the underlying type.

Definition at line 34 of file TransportReceiveStrategy_rch.h.

◆ TransportSendControlElementAllocator

typedef Cached_Allocator_With_Overflow<TransportSendControlElement, ACE_SYNCH_NULL_MUTEX> OpenDDS::DCPS::TransportSendControlElementAllocator

Definition at line 29 of file TransportSendControlElement.h.

◆ TransportSendListener_rch

typedef RcHandle<TransportSendListener> OpenDDS::DCPS::TransportSendListener_rch

Definition at line 85 of file TransportSendListener.h.

◆ TransportSendListener_wrch

typedef WeakRcHandle<TransportSendListener> OpenDDS::DCPS::TransportSendListener_wrch

Definition at line 61 of file DataLink.h.

◆ TransportSendStrategy_rch

typedef RcHandle<TransportSendStrategy> OpenDDS::DCPS::TransportSendStrategy_rch

The type definition for the smart-pointer to the underlying type.

Definition at line 34 of file TransportSendStrategy_rch.h.

◆ TransportStatisticsSequence

typedef sequence<TransportStatistics> OpenDDS::DCPS::TransportStatisticsSequence

Definition at line 126 of file OpenddsDcpsExt.idl.

◆ TransportStrategy_rch

typedef RcHandle<TransportStrategy> OpenDDS::DCPS::TransportStrategy_rch

Definition at line 18 of file TransportStrategy_rch.h.

◆ TransportType_rch

typedef RcHandle<TransportType> OpenDDS::DCPS::TransportType_rch

Definition at line 23 of file TransportType_rch.h.

◆ UdpDataLink_rch

typedef RcHandle< UdpDataLink > OpenDDS::DCPS::UdpDataLink_rch

Definition at line 18 of file UdpDataLink_rch.h.

◆ UdpInst_rch

typedef RcHandle<UdpInst> OpenDDS::DCPS::UdpInst_rch

Definition at line 18 of file UdpInst_rch.h.

◆ UdpReceiveStrategy_rch

typedef RcHandle<UdpReceiveStrategy> OpenDDS::DCPS::UdpReceiveStrategy_rch

Definition at line 18 of file UdpReceiveStrategy_rch.h.

◆ UdpSendStrategy_rch

typedef RcHandle<UdpSendStrategy> OpenDDS::DCPS::UdpSendStrategy_rch

Definition at line 18 of file UdpSendStrategy_rch.h.

◆ UdpTransport_rch

typedef RcHandle<UdpTransport> OpenDDS::DCPS::UdpTransport_rch

Definition at line 32 of file UdpDataLink.h.

◆ WriterIdSeq

typedef sequence<RepoId> OpenDDS::DCPS::WriterIdSeq

Definition at line 90 of file DdsDcpsInfoUtils.idl.

◆ WriterInfo_rch

typedef RcHandle<WriterInfo> OpenDDS::DCPS::WriterInfo_rch

Definition at line 280 of file WriterInfo.h.

◆ WString

typedef std::wstring OpenDDS::DCPS::WString

Definition at line 164 of file PoolAllocator.h.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Controls the maximum size of the iovec array used for a send packet.

Enumerator
MAX_SEND_BLOCKS

Definition at line 220 of file TransportDefs.h.

220 { MAX_SEND_BLOCKS = 50 };

OpenDDS::DCPS::MAX_SEND_BLOCKS

Definition: TransportDefs.h:220

◆ anonymous enum

anonymous enum

Allocators used for transport receiving logic.

Enumerator
RECEIVE_DATA_BUFFER_SIZE

Definition at line 227 of file TransportDefs.h.

227 { RECEIVE_DATA_BUFFER_SIZE = 65536 };

OpenDDS::DCPS::RECEIVE_DATA_BUFFER_SIZE

Definition: TransportDefs.h:227

◆ anonymous enum

anonymous enum

Enumerator
DEFAULT_TRANSPORT_RECEIVE_BUFFERS

Definition at line 228 of file TransportDefs.h.

228 { DEFAULT_TRANSPORT_RECEIVE_BUFFERS = 16 };

OpenDDS::DCPS::DEFAULT_TRANSPORT_RECEIVE_BUFFERS

Definition: TransportDefs.h:228

◆ anonymous enum

anonymous enum

Default TransportInst settings.

Enumerator
DEFAULT_CONFIG_QUEUE_MESSAGES_PER_POOL
DEFAULT_CONFIG_QUEUE_INITIAL_POOLS
DEFAULT_CONFIG_MAX_PACKET_SIZE
DEFAULT_CONFIG_MAX_SAMPLES_PER_PACKET
DEFAULT_CONFIG_OPTIMUM_PACKET_SIZE

Definition at line 241 of file TransportDefs.h.

      {
   DEFAULT_CONFIG_QUEUE_MESSAGES_PER_POOL = 10,
   DEFAULT_CONFIG_QUEUE_INITIAL_POOLS     = 5,
   DEFAULT_CONFIG_MAX_PACKET_SIZE         = 2147481599,
   DEFAULT_CONFIG_MAX_SAMPLES_PER_PACKET  = 10,
   DEFAULT_CONFIG_OPTIMUM_PACKET_SIZE     = 4096
 };

◆ anonymous enum

anonymous enum

values for ShmemData::status_

Enumerator
SHMEM_DATA_FREE
SHMEM_DATA_IN_USE
SHMEM_DATA_RECV_DONE
SHMEM_DATA_END_OF_ALLOC

Definition at line 75 of file ShmemDataLink.h.

      {
   SHMEM_DATA_FREE = 0,
   SHMEM_DATA_IN_USE = 1,
   SHMEM_DATA_RECV_DONE = 2,
   SHMEM_DATA_END_OF_ALLOC = -1
 };

◆ AttachStatus

enum OpenDDS::DCPS::AttachStatus

Return code type for attach_transport() operations.

Enumerator
ATTACH_BAD_TRANSPORT
ATTACH_ERROR
ATTACH_INCOMPATIBLE_QOS
ATTACH_OK

Definition at line 201 of file TransportDefs.h.

                   {
   ATTACH_BAD_TRANSPORT,
   ATTACH_ERROR,
   ATTACH_INCOMPATIBLE_QOS,
   ATTACH_OK
 };

◆ Coherent_State

enum OpenDDS::DCPS::Coherent_State

Enumerator
NOT_COMPLETED_YET
COMPLETED
REJECTED

Definition at line 76 of file WriterInfo.h.

                     {
   NOT_COMPLETED_YET,
   COMPLETED,
   REJECTED
 };

◆ CvStatus

enum OpenDDS::DCPS::CvStatus

This is the return type of ConditionVariable::wait* functions.

Enumerator
CvStatus_NoTimeout	The wait has returned because it was woken up.
CvStatus_Timeout	The wait has returned because of a timeout.
CvStatus_Error	The wait has returned because of an error. The errno-given reason was logged.

Definition at line 26 of file ConditionVariable.h.

               {
   CvStatus_NoTimeout, ///< The wait has returned because it was woken up
   CvStatus_Timeout, ///< The wait has returned because of a timeout
   CvStatus_Error /**<
     * The wait has returned because of an error.
     * The errno-given reason was logged.
     */
 };

◆ DataSampleHeaderFlag

enum OpenDDS::DCPS::DataSampleHeaderFlag

Enumerator
BYTE_ORDER_FLAG
COHERENT_CHANGE_FLAG
HISTORIC_SAMPLE_FLAG
LIFESPAN_DURATION_FLAG
GROUP_COHERENT_FLAG
CONTENT_FILTER_FLAG
SEQUENCE_REPAIR_FLAG
MORE_FRAGMENTS_FLAG

Definition at line 61 of file DataSampleHeader.h.

                           {
   BYTE_ORDER_FLAG,
   COHERENT_CHANGE_FLAG,
   HISTORIC_SAMPLE_FLAG,
   LIFESPAN_DURATION_FLAG,
   GROUP_COHERENT_FLAG,
   CONTENT_FILTER_FLAG,
   SEQUENCE_REPAIR_FLAG,
   MORE_FRAGMENTS_FLAG
 };

◆ DataSampleHeaderFlag2

enum OpenDDS::DCPS::DataSampleHeaderFlag2

Enumerator
CDR_ENCAP_FLAG
KEY_ONLY_FLAG

Definition at line 72 of file DataSampleHeader.h.

                            {
   CDR_ENCAP_FLAG,
   KEY_ONLY_FLAG
 };

◆ Endianness

enum OpenDDS::DCPS::Endianness

Enumerator
ENDIAN_BIG
ENDIAN_LITTLE
ENDIAN_NATIVE
ENDIAN_NONNATIVE

Definition at line 54 of file Serializer.h.

                 {
   ENDIAN_BIG = 0,
   ENDIAN_LITTLE = 1,
 #ifdef ACE_LITTLE_ENDIAN
   ENDIAN_NATIVE = ENDIAN_LITTLE,
   ENDIAN_NONNATIVE = ENDIAN_BIG
 #else
   ENDIAN_NATIVE = ENDIAN_BIG,
   ENDIAN_NONNATIVE = ENDIAN_LITTLE
 #endif
 };

◆ EntityKind

enum OpenDDS::DCPS::EntityKind

Summary kinds of entities within the service.

See dds/DdsDcpsGuid.idl for the values these map to.

Enumerator
KIND_UNKNOWN	Represents ENTITYKIND_USER_UNKNOWN and ENTITYKIND_BUILTIN_UNKNOWN.
KIND_PARTICIPANT	Represents ENTITYKIND_BUILTIN_PARTICIPANT.
KIND_USER_WRITER	Represents ENTITYKIND_USER_WRITER_WITH_KEY and ENTITYKIND_USER_WRITER_NO_KEY.
KIND_USER_READER	Represents ENTITYKIND_USER_READER_WITH_KEY and ENTITYKIND_USER_READER_NO_KEY.
KIND_USER_TOPIC	Represents ENTITYKIND_OPENDDS_TOPIC.
KIND_BUILTIN_WRITER	Represents ENTITYKIND_BUILTIN_WRITER_WITH_KEY and ENTITYKIND_USER_WRITER_NO_KEY.
KIND_BUILTIN_READER	Represents ENTITYKIND_BUILTIN_READER_WITH_KEY and ENTITYKIND_USER_READER_NO_KEY.
KIND_BUILTIN_TOPIC	Represents ENTITYKIND_BUILTIN_TOPIC.
KIND_PUBLISHER	OpenDDS specific Publisher Guid values.
KIND_SUBSCRIBER	OpenDDS specific Subscriber Guid values.
KIND_USER	OpenDDS specific other Guid values.

Definition at line 67 of file GuidUtils.h.

                 {     // EntityId_t.entityKind value(s)
 
   /// Represents ENTITYKIND_USER_UNKNOWN and ENTITYKIND_BUILTIN_UNKNOWN
   KIND_UNKNOWN,
 
   /// Represents ENTITYKIND_BUILTIN_PARTICIPANT
   KIND_PARTICIPANT,
 
   /// Represents ENTITYKIND_USER_WRITER_WITH_KEY and ENTITYKIND_USER_WRITER_NO_KEY
   KIND_USER_WRITER,
   /// Represents ENTITYKIND_USER_READER_WITH_KEY and ENTITYKIND_USER_READER_NO_KEY
   KIND_USER_READER,
 
   /// Represents ENTITYKIND_OPENDDS_TOPIC
   KIND_USER_TOPIC,
 
   /// Represents ENTITYKIND_BUILTIN_WRITER_WITH_KEY and ENTITYKIND_USER_WRITER_NO_KEY
   KIND_BUILTIN_WRITER,
   /// Represents ENTITYKIND_BUILTIN_READER_WITH_KEY and ENTITYKIND_USER_READER_NO_KEY
   KIND_BUILTIN_READER,
   /// Represents ENTITYKIND_BUILTIN_TOPIC
   KIND_BUILTIN_TOPIC,
 
   /// OpenDDS specific Publisher Guid values
   KIND_PUBLISHER,
   /// OpenDDS specific Subscriber Guid values
   KIND_SUBSCRIBER,
   /// OpenDDS specific other Guid values
   KIND_USER
 };

◆ Extensibility

enum OpenDDS::DCPS::Extensibility

Enumerator
FINAL
APPENDABLE
MUTABLE

Definition at line 69 of file Serializer.h.

                    {
   FINAL,
   APPENDABLE,
   MUTABLE
 };

◆ InternalSampleInfoKind

enum OpenDDS::DCPS::InternalSampleInfoKind

Enumerator
ISIK_REGISTER
ISIK_SAMPLE
ISIK_UNREGISTER
ISIK_DISPOSE

Definition at line 31 of file InternalDataReader.h.

                             {
   ISIK_REGISTER,
   ISIK_SAMPLE,
   ISIK_UNREGISTER,
   ISIK_DISPOSE
 };

◆ MarshalingType

enum OpenDDS::DCPS::MarshalingType

Enumerator
FULL_MARSHALING
KEY_ONLY_MARSHALING

Definition at line 78 of file DataReaderImpl.h.

                     {
   FULL_MARSHALING,
   KEY_ONLY_MARSHALING
 };

◆ MessageId

enum OpenDDS::DCPS::MessageId

One byte message id (<256)

Enumerator
SAMPLE_DATA
DATAWRITER_LIVELINESS
INSTANCE_REGISTRATION
UNREGISTER_INSTANCE
DISPOSE_INSTANCE
GRACEFUL_DISCONNECT
REQUEST_ACK
SAMPLE_ACK
END_COHERENT_CHANGES
TRANSPORT_CONTROL
DISPOSE_UNREGISTER_INSTANCE
END_HISTORIC_SAMPLES
MESSAGE_ID_MAX

Definition at line 36 of file DataSampleHeader.h.

                {
   SAMPLE_DATA,
   DATAWRITER_LIVELINESS,
   INSTANCE_REGISTRATION,
   UNREGISTER_INSTANCE,
   DISPOSE_INSTANCE,
   GRACEFUL_DISCONNECT,
   REQUEST_ACK,
   SAMPLE_ACK,
   END_COHERENT_CHANGES,
   TRANSPORT_CONTROL,
   DISPOSE_UNREGISTER_INSTANCE,
   END_HISTORIC_SAMPLES,
   MESSAGE_ID_MAX // must be the last enumerator
 };

◆ Operation_t

enum OpenDDS::DCPS::Operation_t

Enumerator
DDS_OPERATION_READ
DDS_OPERATION_TAKE

Definition at line 27 of file RakeResults_T.h.

27 { DDS_OPERATION_READ, DDS_OPERATION_TAKE };

OpenDDS::DCPS::DDS_OPERATION_TAKE

Definition: RakeResults_T.h:27

OpenDDS::DCPS::DDS_OPERATION_READ

Definition: RakeResults_T.h:27

◆ RemoveResult

enum OpenDDS::DCPS::RemoveResult

used by DataLink::remove_sample(), TransportSendStrategy, *RemoveVisitor

Enumerator
REMOVE_ERROR
REMOVE_NOT_FOUND
REMOVE_FOUND
REMOVE_RELEASED

Definition at line 250 of file TransportDefs.h.

                   {
   REMOVE_ERROR, REMOVE_NOT_FOUND, REMOVE_FOUND, REMOVE_RELEASED
 };

◆ ReportType

enum OpenDDS::DCPS::ReportType

Enumerator
SERVICE_PARTICIPANT_REPORT_TYPE
DOMAIN_PARTICIPANT_REPORT_TYPE
TOPIC_REPORT_TYPE
PUBLISHER_REPORT_TYPE
SUBSCRIBER_REPORT_TYPE
DATA_WRITER_REPORT_TYPE
DATA_WRITER_PERIODIC_REPORT_TYPE
DATA_READER_REPORT_TYPE
DATA_READER_PERIODIC_REPORT_TYPE
TRANSPORT_REPORT_TYPE

Definition at line 192 of file monitor.idl.

                     {
       SERVICE_PARTICIPANT_REPORT_TYPE,
       DOMAIN_PARTICIPANT_REPORT_TYPE,
       TOPIC_REPORT_TYPE,
       PUBLISHER_REPORT_TYPE,
       SUBSCRIBER_REPORT_TYPE,
       DATA_WRITER_REPORT_TYPE,
       DATA_WRITER_PERIODIC_REPORT_TYPE,
       DATA_READER_REPORT_TYPE,
       DATA_READER_PERIODIC_REPORT_TYPE,
       TRANSPORT_REPORT_TYPE
     };

◆ SendControlStatus

enum OpenDDS::DCPS::SendControlStatus

Return code type for send_control() operations.

Enumerator
SEND_CONTROL_ERROR
SEND_CONTROL_OK

Definition at line 195 of file TransportDefs.h.

                        {
   SEND_CONTROL_ERROR,
   SEND_CONTROL_OK
 };

◆ SendStrategyOpType

enum OpenDDS::DCPS::SendStrategyOpType

Enumerator
SEND_START
SEND
SEND_STOP
REMOVE_SAMPLE
REMOVE_ALL_CONTROL_SAMPLES

Definition at line 36 of file ThreadPerConnectionSendTask.h.

                         {
   SEND_START,
   SEND,
   SEND_STOP,
   REMOVE_SAMPLE,
   REMOVE_ALL_CONTROL_SAMPLES
 };

◆ SubMessageId

enum OpenDDS::DCPS::SubMessageId

Enumerator
SUBMESSAGE_NONE
MULTICAST_SYN
MULTICAST_SYNACK
MULTICAST_NAK
MULTICAST_NAKACK
SUBMESSAGE_ID_MAX

Definition at line 52 of file DataSampleHeader.h.

                   {
   SUBMESSAGE_NONE,
   MULTICAST_SYN,
   MULTICAST_SYNACK,
   MULTICAST_NAK,
   MULTICAST_NAKACK,
   SUBMESSAGE_ID_MAX // must be the last enumerator
 };

◆ TopicStatus

enum OpenDDS::DCPS::TopicStatus

Enumerator
CREATED
ENABLED
FOUND
NOT_FOUND
REMOVED
CONFLICTING_TYPENAME
PRECONDITION_NOT_MET
INTERNAL_ERROR
TOPIC_DISABLED

Definition at line 53 of file DdsDcpsInfoUtils.idl.

                      {
       CREATED,
       ENABLED,
       FOUND,
       NOT_FOUND,
       REMOVED,
       CONFLICTING_TYPENAME,
       PRECONDITION_NOT_MET,
       INTERNAL_ERROR,
       TOPIC_DISABLED
     };

◆ ValueEnumType

enum OpenDDS::DCPS::ValueEnumType

Enumerator
INTEGER_TYPE
DOUBLE_TYPE
STRING_TYPE
STATISTICS_TYPE
STRING_LIST_TYPE

Definition at line 34 of file monitor.idl.

34 { INTEGER_TYPE, DOUBLE_TYPE, STRING_TYPE,

35 STATISTICS_TYPE, STRING_LIST_TYPE };

OpenDDS::DCPS::STATISTICS_TYPE

Definition: monitor.idl:35

OpenDDS::DCPS::STRING_TYPE

Definition: monitor.idl:34

OpenDDS::DCPS::INTEGER_TYPE

Definition: monitor.idl:34

OpenDDS::DCPS::DOUBLE_TYPE

Definition: monitor.idl:34

OpenDDS::DCPS::STRING_LIST_TYPE

Definition: monitor.idl:35

Function Documentation

◆ ACE_FACTORY_DEFINE() [1/4]

OpenDDS::DCPS::ACE_FACTORY_DEFINE	(	OpenDDS_Udp	,
		UdpLoader
	)

Referenced by OpenDDS::DCPS::UdpLoader::init().

◆ ACE_FACTORY_DEFINE() [2/4]

OpenDDS::DCPS::ACE_FACTORY_DEFINE	(	OpenDDS_Shmem	,
		ShmemLoader
	)

Referenced by OpenDDS::DCPS::ShmemLoader::init().

◆ ACE_FACTORY_DEFINE() [3/4]

OpenDDS::DCPS::ACE_FACTORY_DEFINE	(	OpenDDS_Rtps_Udp	,
		RtpsUdpLoader
	)

Referenced by OpenDDS::DCPS::RtpsUdpLoader::load().

◆ ACE_FACTORY_DEFINE() [4/4]

OpenDDS::DCPS::ACE_FACTORY_DEFINE	(	OpenDDS_InfoRepoDiscovery	,
		IRDiscoveryLoader
	)

Referenced by OpenDDS::DCPS::MulticastLoader::init(), OpenDDS::DCPS::TcpLoader::init(), UpdateManagerSvc_Loader::init(), PersistenceUpdaterSvc_Loader::init(), OpenDDS::DCPS::IRDiscoveryLoader::init(), OpenDDS::DCPS::MonitorFactoryImpl::service_initialize(), and OpenDDS::DCPS::MonitorFactory::service_initialize().

◆ address_to_bytes()

void OpenDDS::DCPS::address_to_bytes	(	DDS::OctetArray16 &	dest,
		const ACE_INET_Addr &	addr
	)

inline

Definition at line 117 of file NetworkResource.h.

References ACE_BEGIN_VERSIONED_NAMESPACE_DECL, ACE_END_VERSIONED_NAMESPACE_DECL, address_to_locator(), ACE_INET_Addr::get_addr(), ACE_Addr::get_type(), locator_to_address(), OpenDDS_Dcps_Export, OPENDDS_END_VERSIONED_NAMESPACE_DECL, operator<<(), operator>>(), and value.

Referenced by OpenDDS::STUN::operator<<().

 {
   const void* raw = addr.get_addr();
 #ifdef ACE_HAS_IPV6
   if (addr.get_type() == AF_INET6) {
     const sockaddr_in6* in = static_cast<const sockaddr_in6*>(raw);
     std::memcpy(&dest[0], &in->sin6_addr, 16);
   } else {
 #else
   {
 #endif
     const sockaddr_in* in = static_cast<const sockaddr_in*>(raw);
     std::memset(&dest[0], 0, 12);
     std::memcpy(&dest[12], &in->sin_addr, 4);
   }
 }

◆ address_to_locator()

OpenDDS_Dcps_Export void OpenDDS::DCPS::address_to_locator	(	Locator_t &	locator,
		const ACE_INET_Addr &	addr
	)

Definition at line 895 of file NetworkResource.cpp.

References OpenDDS::DCPS::Locator_t::address, AF_INET, ACE_INET_Addr::get_addr(), ACE_INET_Addr::get_port_number(), ACE_Addr::get_type(), OpenDDS::DCPS::Locator_t::kind, LOCATOR_KIND_INVALID, LOCATOR_KIND_UDPv4, LOCATOR_KIND_UDPv6, and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

Referenced by address_to_bytes(), append(), OpenDDS::DCPS::RtpsUdpTransport::get_last_recv_locator(), OpenDDS::RTPS::Spdp::get_last_recv_locator(), OpenDDS::DCPS::RtpsUdpInst::populate_locator(), OpenDDS::DCPS::RtpsUdpReceiveStrategy::MessageReceiver::reset(), and OpenDDS::RTPS::ParameterListConverter::to_param_list().

 {
   const void* raw = addr.get_addr();
   switch (addr.get_type()) {
   case AF_INET:
     {
       locator.kind = LOCATOR_KIND_UDPv4;
       const sockaddr_in* in = static_cast<const sockaddr_in*>(raw);
       std::memset(&locator.address[0], 0, 12);
       std::memcpy(&locator.address[12], &in->sin_addr, 4);
     }
     break;
 #ifdef ACE_HAS_IPV6
   case AF_INET6:
     {
       locator.kind = LOCATOR_KIND_UDPv6;
       const sockaddr_in6* in = static_cast<const sockaddr_in6*>(raw);
       std::memcpy(&locator.address[0], &in->sin6_addr, 16);
     }
     break;
 #endif
   default:
     locator.kind = LOCATOR_KIND_INVALID;
     std::memset(&locator.address[0], 0, 16);
     break;
   }
   locator.port = addr.get_port_number();
 }

◆ align()

ACE_INLINE void OpenDDS::DCPS::align	(	size_t &	value,
		size_t	by
	)

Align "value" by "by" if it's not already.

Definition at line 23 of file Serializer.inl.

References ACE_INLINE.

Referenced by OpenDDS::DCPS::Encoding::align(), OpenDDS::Security::CryptoBuiltInImpl::encode_rtps_message(), OpenDDS::Security::CryptoBuiltInImpl::encode_submessage(), marshal_generator::gen_enum(), OpenDDS::DCPS::Serializer::reset_alignment(), and OpenDDS::DCPS::RtpsUdpReceiveStrategy::sec_submsg_to_octets().

 {
   value = (value + by - 1) & ~(by - 1);
 }

◆ append()

void OpenDDS::DCPS::append	(	TransportStatisticsSequence &	seq,
		const InternalTransportStatistics &	istats
	)

inline

Definition at line 107 of file TransportStatistics.h.

References OpenDDS::DCPS::Locator_t::address, address_to_locator(), grow(), OpenDDS::DCPS::MessageCount::kind, OpenDDS::DCPS::MessageCount::locator, OpenDDS::DCPS::InternalTransportStatistics::message_count, OpenDDS::DCPS::TransportStatistics::message_count, OPENDDS_END_VERSIONED_NAMESPACE_DECL, push_back(), OpenDDS::DCPS::InternalTransportStatistics::reader_nack_count, OpenDDS::DCPS::TransportStatistics::reader_nack_count, OpenDDS::DCPS::MessageCount::recv_bytes, OpenDDS::DCPS::MessageCount::recv_count, OpenDDS::DCPS::MessageCount::relay, OpenDDS::DCPS::MessageCount::send_bytes, OpenDDS::DCPS::MessageCount::send_count, OpenDDS::DCPS::MessageCount::send_fail_bytes, OpenDDS::DCPS::MessageCount::send_fail_count, OpenDDS::DCPS::InternalTransportStatistics::transport, OpenDDS::DCPS::TransportStatistics::transport, OpenDDS::DCPS::InternalTransportStatistics::writer_resend_count, and OpenDDS::DCPS::TransportStatistics::writer_resend_count.

Referenced by OpenDDS::DCPS::RtpsUdpTransport::append_transport_statistics(), OpenDDS::RTPS::Spdp::append_transport_statistics(), and OpenDDS::DCPS::ReceivedDataSample::clear().

 {
   const ACE_CDR::ULong idx = grow(seq) - 1;
   TransportStatistics& stats = seq[idx];
   stats.transport = istats.transport.c_str();
   for (InternalTransportStatistics::MessageCountMap::const_iterator pos = istats.message_count.begin(),
          limit = istats.message_count.end(); pos != limit; ++pos) {
     MessageCount mc;
     address_to_locator(mc.locator, pos->first.address.to_addr());
     mc.kind = pos->first.kind;
     mc.relay = pos->first.relay;
     mc.send_count = static_cast<ACE_CDR::ULong>(pos->second.send_count());
     mc.send_bytes = static_cast<ACE_CDR::ULong>(pos->second.send_bytes());
     mc.send_fail_count = static_cast<ACE_CDR::ULong>(pos->second.send_fail_count());
     mc.send_fail_bytes = static_cast<ACE_CDR::ULong>(pos->second.send_fail_bytes());
     mc.recv_count = static_cast<ACE_CDR::ULong>(pos->second.recv_count());
     mc.recv_bytes = static_cast<ACE_CDR::ULong>(pos->second.recv_bytes());
     push_back(stats.message_count, mc);
   }
   for (InternalTransportStatistics::GuidCountMap::const_iterator pos = istats.writer_resend_count.begin(),
          limit = istats.writer_resend_count.end(); pos != limit; ++pos) {
     const GuidCount gc = { pos->first, pos->second };
     push_back(stats.writer_resend_count, gc);
   }
   for (InternalTransportStatistics::GuidCountMap::const_iterator pos = istats.reader_nack_count.begin(),
          limit = istats.reader_nack_count.end(); pos != limit; ++pos) {
     const GuidCount gc = { pos->first, pos->second };
     push_back(stats.reader_nack_count, gc);
   }
 }

◆ arity()

static size_t OpenDDS::DCPS::arity ( const FilterEvaluator::AstNodeWrapper & node )

static

Definition at line 463 of file FilterEvaluator.cpp.

Referenced by OpenDDS::DCPS::FilterEvaluator::walkAst(), and OpenDDS::DCPS::FilterEvaluator::walkOperand().

 {
   size_t a = 0;
   for (AstNode* iter = node->GetFirstChild(); iter; iter = iter->GetSibling()) {
     ++a;
   }
   return a;
 }

◆ array_count()

template<typename Type , size_t count>

size_t OpenDDS::DCPS::array_count ( Type(&) [count] )

Definition at line 219 of file Util.h.

References OPENDDS_END_VERSIONED_NAMESPACE_DECL.

Referenced by OpenDDS::RTPS::Sedp::disassociate(), marshal_generator::gen_enum(), marshal_generator::gen_union(), OpenDDS::DCPS::LogLevel::get_as_string(), and OpenDDS::DCPS::LogLevel::set_from_string().

 {
   return count;
 }

◆ assign() [1/6]

void OpenDDS::DCPS::assign	(	DDS::OctetArray16 &	dest,
		ACE_CDR::ULong	ipv4addr_be
	)

inline

Definition at line 106 of file NetworkResource.h.

 {
   std::memset(&dest[0], 0, 12);
   dest[12] = ipv4addr_be >> 24;
   dest[13] = ipv4addr_be >> 16;
   dest[14] = ipv4addr_be >> 8;
   dest[15] = ipv4addr_be;
 }

◆ assign() [2/6]

void OpenDDS::DCPS::assign	(	EntityId_t &	dest,
		const EntityId_t &	src
	)

inline

Definition at line 176 of file GuidUtils.h.

 {
   std::memcpy(&dest, &src, sizeof(EntityId_t));
 }

◆ assign() [3/6]

void OpenDDS::DCPS::assign	(	EntityKey_t &	dest,
		unsigned	src
	)

inline

Definition at line 181 of file GuidUtils.h.

References OpenDDS_Dcps_Export, OPENDDS_STRING, operator<<(), operator>>(), and to_string().

 {
   dest[0] = static_cast<CORBA::Octet>(src);
   dest[1] = static_cast<CORBA::Octet>(src >> 8);
   dest[2] = static_cast<CORBA::Octet>(src >> 16);
 }

◆ assign() [4/6]

void OpenDDS::DCPS::assign	(	GuidPrefix_t &	dest,
		const GuidPrefix_t &	src
	)

inline

Definition at line 204 of file GuidUtils.h.

 {
   std::memcpy(&dest[0], &src[0], sizeof(GuidPrefix_t));
 }

◆ assign() [5/6]

void OpenDDS::DCPS::assign	(	GUID_t &	dest,
		const GUID_t &	src
	)

inline

Definition at line 209 of file GuidUtils.h.

 {
   std::memcpy(&dest, &src, sizeof(GUID_t));
 }

◆ assign() [6/6]

void OpenDDS::DCPS::assign	(	DDS::OctetArray16 &	dest,
		const GUID_t &	src
	)

inline

Definition at line 214 of file GuidUtils.h.

 {
   std::memcpy(&dest[0], &src, sizeof(src));
 }

◆ back_inserter()

template<typename Sequence >

SequenceBackInsertIterator<Sequence> OpenDDS::DCPS::back_inserter ( Sequence & seq )

inline

Definition at line 49 of file SequenceIterator.h.

Referenced by OpenDDS::DCPS::BasicQueue< TransportQueueElement >::accept_remove_visitor(), OpenDDS::DCPS::ReceivedDataSample::append(), OpenDDS::DCPS::TransportClient::associate(), OpenDDS::DCPS::DisjointSequence::insert_filtered(), and OpenDDS::Security::SSL::Certificate::subject_name_to_str().

 {
   return SequenceBackInsertIterator<Sequence>(seq);
 }

◆ bind()

template<typename Container , typename FirstType , typename SecondType >

int OpenDDS::DCPS::bind	(	Container &	c,
		const FirstType &	first,
		const SecondType &	second
	)

Definition at line 18 of file Util.h.

Referenced by OpenDDS::DCPS::ReplayerImpl::association_complete_i(), OpenDDS::DCPS::DataWriterImpl::association_complete_i(), OpenDDS::DCPS::DataLinkSet::insert_link(), OpenDDS::DCPS::WriteDataContainer::register_instance(), OpenDDS::DCPS::DataLinkSet::select_links(), OpenDDS::DCPS::DataLinkSet::send_start(), and OpenDDS::DCPS::OwnershipManager::set_instance_map().

 {
   if (c.find(first) == c.end()) {
     typedef typename Container::value_type container_value_type;
 
     if (c.insert(container_value_type(first, second)).second) {
       return 0;
     }
 
     return -1;
   }
 
   return 1;
 }

◆ bit_key_to_repo_id()

OpenDDS_Dcps_Export GUID_t OpenDDS::DCPS::bit_key_to_repo_id ( const DDS::BuiltinTopicKey_t & key )

inline

Definition at line 270 of file GuidUtils.h.

References OpenDDS_Dcps_Export, OPENDDS_END_VERSIONED_NAMESPACE_DECL, and DDS::BuiltinTopicKey_t::value.

Referenced by OpenDDS::DCPS::DataReaderImpl::get_next_handle(), OpenDDS::DCPS::BitPubListenerImpl::on_data_available(), DCPS_IR_Domain::publish_participant_bit(), DCPS_IR_Domain::publish_publication_bit(), DCPS_IR_Domain::publish_subscription_bit(), and DCPS_IR_Domain::publish_topic_bit().

 {
   GUID_t id;
   std::memcpy(&id, key.value, sizeof(id));
   return id;
 }

◆ char_helper()

template<typename CharType >

std::ostream& OpenDDS::DCPS::char_helper	(	std::ostream &	o,
		CharType	value
	)

Definition at line 77 of file ValueHelper.h.

References char_value(), hex_value(), and value.

Referenced by OpenDDS::DCPS::PrinterValueWriter::write_char16(), and OpenDDS::DCPS::PrinterValueWriter::write_char8().

 {
   switch (value) {
   case '\'':
   case '\"':
   case '\\':
   case '\?':
     return o << '\\' << static_cast<char>(value);
   case '\n':
     return o << "\\n";
   case '\t':
     return o << "\\t";
   case '\v':
     return o << "\\v";
   case '\b':
     return o << "\\b";
   case '\r':
     return o << "\\r";
   case '\f':
     return o << "\\f";
   case '\a':
     return o << "\\a";
   }
   const unsigned cvalue = char_value(value);
   if (cvalue <= UCHAR_MAX && isprint(cvalue)) {
     return o << static_cast<char>(value);
   }
   return hex_value(o << "\\x", cvalue, sizeof(CharType) == 1 ? 1 : 2);
 }

◆ char_value()

template<typename CharType >

unsigned OpenDDS::DCPS::char_value ( CharType value )

Definition at line 58 of file ValueHelper.h.

References value.

Referenced by OpenDDS::XTypes::AnnotationParameterValue::activate(), and char_helper().

 {
   return value;
 }

◆ child()

static FilterEvaluator::AstNodeWrapper OpenDDS::DCPS::child	(	const FilterEvaluator::AstNodeWrapper &	node,
		size_t	idx
	)

static

Definition at line 472 of file FilterEvaluator.cpp.

Referenced by OpenDDS::DCPS::FilterEvaluator::EvalNode::deleteChild(), OpenDDS::DCPS::FilterEvaluator::EvalNode::has_non_key_fields(), TopicKeys::Iterator::operator++(), OpenDDS::DCPS::FilterEvaluator::walkAst(), and OpenDDS::DCPS::FilterEvaluator::walkOperand().

 {
   AstNode* iter = 0;
   for (iter = node->GetFirstChild(); idx != 0; iter = iter->GetSibling(), --idx) {}
   return iter;
 }

◆ choose_single_coherent_address() [1/3]

OpenDDS_Dcps_Export ACE_INET_Addr OpenDDS::DCPS::choose_single_coherent_address	(	const ACE_INET_Addr &	address,
		bool	prefer_loopback
	)

Definition at line 523 of file NetworkResource.cpp.

References OpenDDS::DCPS::LogAddr::c_str(), copy(), ACE_INET_Addr::get_addr(), ACE_INET_Addr::get_addr_size(), OpenDDS::DCPS::LogAddr::host(), OpenDDS::DCPS::LogAddr::IpPortHost, LM_DEBUG, name, ACE_INET_Addr::next(), OPENDDS_VECTOR(), ACE_INET_Addr::set_addr(), and VDBG.

Referenced by choose_single_coherent_address(), OpenDDS::DCPS::UdpInst::local_address(), OpenDDS::DCPS::TcpInst::local_address(), OpenDDS::DCPS::NetworkResource::to_addr(), and verify_hostname().

 {
 // Check that ACE_INET_Addr supports next()
 #if !(ACE_MAJOR_VERSION < 6 || (ACE_MAJOR_VERSION == 6 && (ACE_MINOR_VERSION < 3 || (ACE_MINOR_VERSION == 3 && ACE_MICRO_VERSION < 1))))
   ACE_INET_Addr copy(address);
   OPENDDS_VECTOR(ACE_INET_Addr) addresses;
   do {
     ACE_INET_Addr temp;
     temp.set_addr(copy.get_addr(), copy.get_addr_size());
     addresses.push_back(temp);
   } while (copy.next());
   return choose_single_coherent_address(addresses, prefer_loopback);
 #else
   ACE_UNUSED_ARG(prefer_loopback);
   return address;
 #endif // !(ACE_MAJOR_VERSION < 6 || (ACE_MAJOR_VERSION == 6 && (ACE_MINOR_VERSION < 3 || (ACE_MINOR_VERSION == 3 && ACE_MICRO_VERSION < 1))))
 }

◆ choose_single_coherent_address() [2/3]

OpenDDS_Dcps_Export ACE_INET_Addr OpenDDS::DCPS::choose_single_coherent_address	(	const OPENDDS_VECTOR(ACE_INET_Addr)&	addresses,
		bool	prefer_loopback,
		const String &	name
	)

Definition at line 561 of file NetworkResource.cpp.

References AF_INET, OpenDDS::DCPS::LogAddr::c_str(), LM_DEBUG, OPENDDS_SET(), OPENDDS_VECTOR(), and VDBG.

 {
 #ifdef ACE_HAS_IPV6
   OPENDDS_SET(ACE_INET_Addr) set6_loopback;
   OPENDDS_SET(ACE_INET_Addr) set6_linklocal;
   OPENDDS_SET(ACE_INET_Addr) set6_mapped_v4;
   OPENDDS_SET(ACE_INET_Addr) set6;
 #endif // ACE_HAS_IPV6
   OPENDDS_SET(ACE_INET_Addr) set4_loopback;
   OPENDDS_SET(ACE_INET_Addr) set4;
 
   for (OPENDDS_VECTOR(ACE_INET_Addr)::const_iterator it = addresses.begin(); it != addresses.end(); ++it) {
 #ifdef ACE_HAS_IPV6
     if (it->get_type() == AF_INET6 && !it->is_multicast()) {
       if (it->is_loopback()) {
         VDBG((LM_DEBUG, "(%P|%t) choose_single_coherent_address(list) - "
           "Considering Address %C - ADDING TO IPv6 LOOPBACK LIST\n", LogAddr(*it).c_str()));
         set6_loopback.insert(*it);
       } else if (it->is_ipv4_mapped_ipv6() || it->is_ipv4_compat_ipv6()) {
 #ifndef IPV6_V6ONLY
         VDBG((LM_DEBUG, "(%P|%t) choose_single_coherent_address(list) - "
           "Considering Address %C - ADDING TO IPv6 MAPPED / COMPATIBLE IPv4 LIST\n", LogAddr(*it).c_str()));
         set6_mapped_v4.insert(*it);
 #endif  // ! IPV6_V6ONLY
       } else if (it->is_linklocal()) {
         VDBG((LM_DEBUG, "(%P|%t) choose_single_coherent_address(list) - "
           "Considering Address %C - ADDING TO IPv6 LINK-LOCAL LIST\n", LogAddr(*it).c_str()));
         set6_linklocal.insert(*it);
       } else {
         VDBG((LM_DEBUG, "(%P|%t) choose_single_coherent_address(list) - "
           "Considering Address %C - ADDING TO IPv6 NORMAL LIST\n", LogAddr(*it).c_str()));
         set6.insert(*it);
       }
     }
 #endif // ACE_HAS_IPV6
     if (it->get_type() == AF_INET && !it->is_multicast()) {
       if (it->is_loopback()) {
         VDBG((LM_DEBUG, "(%P|%t) choose_single_coherent_address(list) - "
           "Considering Address %C - ADDING TO IPv4 LOOPBACK LIST\n", LogAddr(*it).c_str()));
         set4_loopback.insert(*it);
       } else {
         VDBG((LM_DEBUG, "(%P|%t) choose_single_coherent_address(list) - "
           "Considering Address %C - ADDING TO IPv4 NORMAL LIST\n", LogAddr(*it).c_str()));
         set4.insert(*it);
       }
     }
   }
 
 #ifdef ACE_HAS_IPV6
   if (prefer_loopback && !set6_loopback.empty()) {
     return tie_breaker(set6_loopback, name);
   }
 #endif // ACE_HAS_IPV6
 
   if (prefer_loopback && !set4_loopback.empty()) {
     return tie_breaker(set4_loopback, name);
   }
 
 #ifdef ACE_HAS_IPV6
   if (prefer_loopback && !set6_linklocal.empty()) {
     return tie_breaker(set6_linklocal, name);
   }
   if (!set6.empty()) {
     return tie_breaker(set6, name);
   }
   if (!set6_mapped_v4.empty()) {
     return tie_breaker(set6_mapped_v4, name);
   }
 #endif // ACE_HAS_IPV6
 
   if (!set4.empty()) {
     return tie_breaker(set4, name);
   }
 
 #ifdef ACE_HAS_IPV6
   if (!set6_linklocal.empty()) {
     return tie_breaker(set6_linklocal, name);
   }
   if (!set6_loopback.empty()) {
     return tie_breaker(set6_loopback, name);
   }
 #endif // ACE_HAS_IPV6
 
   if (!set4_loopback.empty()) {
     return tie_breaker(set4_loopback, name);
   }
 
   if (!addresses.empty()) {
     return tie_breaker(addresses, name);
   }
 
   return ACE_INET_Addr();
 }

◆ choose_single_coherent_address() [3/3]

OpenDDS_Dcps_Export ACE_INET_Addr OpenDDS::DCPS::choose_single_coherent_address	(	const String &	address,
		bool	prefer_loopback,
		bool	allow_ipv4_fallback
	)

Definition at line 655 of file NetworkResource.cpp.

References ACE_NTOHS, AF_INET, AF_UNSPEC, AI_V4MAPPED, choose_single_coherent_address(), ACE_OS::freeaddrinfo(), ACE_OS::getaddrinfo(), inet_addr(), ACE_OS::inet_pton(), ACE::ipv6_enabled(), LM_WARNING, OpenDDS::DCPS::TimePoint_T< SystemClock >::now(), OPENDDS_MAP(), OPENDDS_SET(), OPENDDS_VECTOR(), ACE_Guard< ACE_LOCK >::release(), ACE_INET_Addr::set_addr(), ACE_INET_Addr::set_port_number(), SOCK_STREAM, and VDBG.

 {
   ACE_INET_Addr result;
 
   if (address.empty()) {
     return ACE_INET_Addr();
   }
 
   String host_name_str;
   unsigned short port_number = 0;
 
 #ifdef ACE_HAS_IPV6
   const String::size_type openb = address.find_first_of('[');
   const String::size_type closeb = address.find_first_of(']', openb);
   const String::size_type last_double = address.rfind("::", closeb);
   const String::size_type port_div = closeb != String::npos ?
                                        address.find_first_of(':', closeb + 1u) :
                                        (last_double != String::npos ?
                                          address.find_first_of(':', last_double + 2u) :
                                          address.find_last_of(':'));
 #else
   const String::size_type port_div = address.find_last_of(':');
 #endif
 
   if (port_div != String::npos) {
 #ifdef ACE_HAS_IPV6
     if (openb != String::npos && closeb != String::npos) {
       host_name_str = address.substr(openb + 1u, closeb - 1u - openb);
     } else
 #endif /* ACE_HAS_IPV6 */
     {
       host_name_str = address.substr(0, port_div);
     }
     port_number = static_cast<unsigned short>(std::strtoul(address.substr(port_div + 1u).c_str(), 0, 10));
   } else {
 #ifdef ACE_HAS_IPV6
     if (openb != String::npos && closeb != String::npos) {
       host_name_str = address.substr(openb + 1u, closeb - 1u - openb);
     } else
 #endif /* ACE_HAS_IPV6 */
     {
       host_name_str = address;
     }
   }
 
   if (host_name_str.empty()) {
     return ACE_INET_Addr();
   }
 
   const char* host_name = host_name_str.c_str();
 
   union ip46
   {
     sockaddr_in  in4_;
 #ifdef ACE_HAS_IPV6
     sockaddr_in6 in6_;
 #endif /* ACE_HAS_IPV6 */
   } inet_addr;
   std::memset(&inet_addr, 0, sizeof inet_addr);
 
   int address_family = AF_UNSPEC;
 
 #if defined ACE_HAS_IPV6 && defined ACE_USES_IPV4_IPV6_MIGRATION
   if (address_family == AF_UNSPEC && !ACE::ipv6_enabled()) {
     address_family = AF_INET;
   }
 #endif /* ACE_HAS_IPV6 && ACE_USES_IPV4_IPV6_MIGRATION */
 
 #ifdef ACE_HAS_IPV6
   if (address_family == AF_UNSPEC && ACE::ipv6_enabled() && !allow_ipv4_fallback) {
     address_family = AF_INET6;
   }
 
   if (address_family != AF_INET && ACE_OS::inet_pton(AF_INET6, host_name, &inet_addr.in6_.sin6_addr) == 1) {
 #ifdef ACE_HAS_SOCKADDR_IN6_SIN6_LEN
     inet_addr.in6_.sin6_len = sizeof inet_addr.in6_;
 #endif /* ACE_HAS_SOCKADDR_IN6_SIN6_LEN */
     inet_addr.in6_.sin6_family = AF_INET6;
     result.set_addr(&inet_addr, sizeof inet_addr);
     result.set_port_number(port_number, 1 /*encode*/);
     return result;
   }
 #else
   ACE_UNUSED_ARG(allow_ipv4_fallback);
   address_family = AF_INET;
 #endif /* ACE_HAS_IPV6 */
 
   if (ACE_OS::inet_pton(AF_INET, host_name, &inet_addr.in4_.sin_addr) == 1) {
 #ifdef ACE_HAS_SOCKADDR_IN_SIN_LEN
     inet_addr.in4_.sin_len = sizeof inet_addr.in4_;
 #endif /* ACE_HAS_SOCKADDR_IN_SIN_LEN */
     inet_addr.in4_.sin_family = AF_INET;
     result.set_addr(&inet_addr, sizeof inet_addr);
     result.set_port_number(port_number, 1 /*encode*/);
     return result;
   }
 
   addrinfo hints;
   std::memset(&hints, 0, sizeof hints);
   hints.ai_family = address_family;
 
   // The ai_flags used to contain AI_ADDRCONFIG as well but that prevented
   // lookups from completing if there is no, or only a loopback, IPv6
   // interface configured. See Bugzilla 4211 for more info.
 
 #if defined ACE_HAS_IPV6 && !defined IPV6_V6ONLY
   hints.ai_flags |= AI_V4MAPPED;
 #endif
 
 #if defined ACE_HAS_IPV6 && defined AI_ALL
   // Without AI_ALL, Windows machines exhibit inconsistent behaviors on
   // difference machines we have tested.
   hints.ai_flags |= AI_ALL;
 #endif
 
   // Note - specify the socktype here to avoid getting multiple entries
   // returned with the same address for different socket types or
   // protocols. If this causes a problem for some reason (an address that's
   // available for TCP but not UDP, or vice-versa) this will need to change
   // back to unrestricted hints and weed out the duplicate addresses by
   // searching this->inet_addrs_ which would slow things down.
   hints.ai_socktype = SOCK_STREAM;
 
   addrinfo *res = 0;
   const int error = ACE_OS::getaddrinfo(host_name, 0, &hints, &res);
 
   if (error) {
     VDBG((LM_WARNING, "(%P|%t) WARNING: choose_single_coherent_address: Call to getaddrinfo for hostname %C returned error: %d\n", host_name, error));
     return ACE_INET_Addr();
   }
 
   struct AddrInfoGuard {
     AddrInfoGuard(addrinfo* ptr) : ptr_(ptr) {}
     ~AddrInfoGuard() {
       ACE_OS::freeaddrinfo(ptr_);
     }
     addrinfo* const ptr_;
   } guard(res);
 
   OPENDDS_VECTOR(ACE_INET_Addr) addresses;
 
 #ifdef ACE_WIN32
   static ACE_Thread_Mutex addr_cache_map_mutex_;
   typedef std::pair<SystemTimePoint, OPENDDS_SET(ACE_INET_Addr)> AddrCachePair;
   typedef OPENDDS_MAP(String, AddrCachePair) AddrCacheMap;
   static AddrCacheMap addr_cache_map_;
   ACE_Guard<ACE_Thread_Mutex> g(addr_cache_map_mutex_);
   const SystemTimePoint now = SystemTimePoint::now();
   for (AddrCacheMap::iterator it = addr_cache_map_.begin(); it != addr_cache_map_.end(); /* inc in loop */) {
     if (it->second.first + TimeDuration(3, 0) < now) {
       addr_cache_map_.erase(it++);
     } else {
       ++it;
     }
   }
   AddrCacheMap::iterator it = addr_cache_map_.find(host_name);
   if (it != addr_cache_map_.end()) {
     addresses.insert(addresses.end(), it->second.second.begin(), it->second.second.end());
     it->second.first = now;
   }
 #endif /* ACE_WIN32 */
 
   for (addrinfo* curr = res; curr; curr = curr->ai_next) {
     if (curr->ai_family != AF_INET && curr->ai_family != AF_INET6) {
       continue;
     }
     ip46 addr;
     std::memset(&addr, 0, sizeof addr);
     std::memcpy(&addr, curr->ai_addr, curr->ai_addrlen);
 #ifdef ACE_HAS_IPV6
     if (curr->ai_family == AF_INET6) {
       addr.in6_.sin6_port = ACE_NTOHS(port_number);
     } else {
 #endif /* ACE_HAS_IPV6 */
       addr.in4_.sin_port = ACE_NTOHS(port_number);;
 #ifdef ACE_HAS_IPV6
     }
 #endif /* ACE_HAS_IPV6 */
 
     ACE_INET_Addr temp;
     temp.set_addr(&addr, sizeof addr);
     addresses.push_back(temp);
 #ifdef ACE_WIN32
     if (it != addr_cache_map_.end()) {
       it->second.second.insert(temp);
     } else {
       OPENDDS_SET(ACE_INET_Addr) my_set;
       my_set.insert(temp);
       addr_cache_map_[host_name] = make_pair(now, my_set);
     }
 #endif /* ACE_WIN32 */
   }
 
 #ifdef ACE_WIN32
   g.release();
 #endif /* ACE_WIN32 */
 
   result = choose_single_coherent_address(addresses, prefer_loopback, host_name);
   result.set_port_number(port_number, 1 /*encode*/);
   return result;
 }

◆ compatibleQOS() [1/3]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::compatibleQOS	(	OpenDDS::DCPS::IncompatibleQosStatus *	writerStatus,
		OpenDDS::DCPS::IncompatibleQosStatus *	readerStatus,
		const OpenDDS::DCPS::TransportLocatorSeq &	pubTLS,
		const OpenDDS::DCPS::TransportLocatorSeq &	subTLS,
		DDS::DataWriterQos const *const	writerQos,
		DDS::DataReaderQos const *const	readerQos,
		DDS::PublisherQos const *const	pubQos,
		DDS::SubscriberQos const *const	subQos
	)

Compares whether a publication and subscription are compatible by comparing their constituent parts.

Definition at line 237 of file DCPS_Utils.cpp.

References compatibleTransports(), increment_incompatibility_count(), matching_partitions(), DDS::PublisherQos::partition, DDS::SubscriberQos::partition, and OpenDDS::TRANSPORTTYPE_QOS_POLICY_ID.

Referenced by OpenDDS::DCPS::EndpointRegistry::match(), OpenDDS::DCPS::StaticEndpointManager::match_continue(), OpenDDS::RTPS::Sedp::match_continue(), DCPS_IR_Subscription::reevaluate_association(), DCPS_IR_Publication::reevaluate_association(), and DCPS_IR_Topic_Description::try_associate().

 {
   bool compatible = true;
 
   // Check transport-type compatibility
   if (!compatibleTransports(pubTLS, subTLS)) {
     compatible = false;
     increment_incompatibility_count(writerStatus,
                                     OpenDDS::TRANSPORTTYPE_QOS_POLICY_ID);
     increment_incompatibility_count(readerStatus,
                                     OpenDDS::TRANSPORTTYPE_QOS_POLICY_ID);
   }
 
   // Verify compatibility of DataWriterQos and DataReaderQos
   compatible = compatible && compatibleQOS(writerQos, readerQos,
                                            writerStatus, readerStatus);
 
   // Verify compatibility of PublisherQos and SubscriberQos
   compatible = compatible && compatibleQOS(pubQos, subQos,
                                            writerStatus, readerStatus);
 
   // Verify publisher and subscriber are in a matching partition.
   //
   // According to the DDS spec:
   //
   //   Failure to match partitions is not considered an incompatible
   //   QoS and does not trigger any listeners nor conditions.
   //
   // Don't increment the incompatibity count.
   compatible = compatible && matching_partitions(pubQos->partition,
                                                  subQos->partition);
 
   return compatible;
 }

◆ compatibleQOS() [2/3]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::compatibleQOS	(	const DDS::PublisherQos *	pubQos,
		const DDS::SubscriberQos *	subQos,
		OpenDDS::DCPS::IncompatibleQosStatus *	writerStatus,
		OpenDDS::DCPS::IncompatibleQosStatus *	readerStatus
	)

Definition at line 280 of file DCPS_Utils.cpp.

References DDS::PresentationQosPolicy::access_scope, DDS::PresentationQosPolicy::coherent_access, increment_incompatibility_count(), DDS::PresentationQosPolicy::ordered_access, DDS::PublisherQos::presentation, DDS::SubscriberQos::presentation, and DDS::PRESENTATION_QOS_POLICY_ID.

 {
   bool compatible = true;
 
   // PARTITION, GROUP_DATA, and ENTITY_FACTORY are RxO==no.
 
   // Check the PRESENTATION_QOS_POLICY_ID
   if ((pubQos->presentation.access_scope < subQos->presentation.access_scope)
       || (!pubQos->presentation.coherent_access && subQos->presentation.coherent_access)
       || (!pubQos->presentation.ordered_access && subQos->presentation.ordered_access)) {
     compatible = false;
 
     increment_incompatibility_count(writerStatus,
                                     DDS::PRESENTATION_QOS_POLICY_ID);
     increment_incompatibility_count(readerStatus,
                                     DDS::PRESENTATION_QOS_POLICY_ID);
   }
 
   return compatible;
 }

◆ compatibleQOS() [3/3]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::compatibleQOS	(	const DDS::DataWriterQos *	writerQos,
		const DDS::DataReaderQos *	readerQos,
		OpenDDS::DCPS::IncompatibleQosStatus *	writerStatus,
		OpenDDS::DCPS::IncompatibleQosStatus *	readerStatus
	)

Definition at line 305 of file DCPS_Utils.cpp.

References DDS::DATA_REPRESENTATION_QOS_POLICY_ID, DDS::DataWriterQos::deadline, DDS::DataReaderQos::deadline, DDS::DEADLINE_QOS_POLICY_ID, DDS::DataWriterQos::durability, DDS::DataReaderQos::durability, DDS::DURABILITY_QOS_POLICY_ID, DDS::LatencyBudgetQosPolicy::duration, increment_incompatibility_count(), DDS::DurabilityQosPolicy::kind, DDS::LivelinessQosPolicy::kind, DDS::ReliabilityQosPolicy::kind, DDS::OwnershipQosPolicy::kind, DDS::DataWriterQos::latency_budget, DDS::DataReaderQos::latency_budget, DDS::LATENCYBUDGET_QOS_POLICY_ID, DDS::LivelinessQosPolicy::lease_duration, DDS::DataWriterQos::liveliness, DDS::DataReaderQos::liveliness, DDS::LIVELINESS_QOS_POLICY_ID, DDS::DataWriterQos::ownership, DDS::DataReaderQos::ownership, DDS::OWNERSHIP_QOS_POLICY_ID, DDS::DeadlineQosPolicy::period, DDS::DataWriterQos::reliability, DDS::DataReaderQos::reliability, DDS::RELIABILITY_QOS_POLICY_ID, DDS::DataWriterQos::representation, DDS::DataReaderQos::representation, and DDS::DataRepresentationQosPolicy::value.

 {
   bool compatible = true;
 
   // Check the RELIABILITY_QOS_POLICY_ID
   if (writerQos->reliability.kind < readerQos->reliability.kind) {
     compatible = false;
 
     increment_incompatibility_count(writerStatus,
                                     DDS::RELIABILITY_QOS_POLICY_ID);
     increment_incompatibility_count(readerStatus,
                                     DDS::RELIABILITY_QOS_POLICY_ID);
   }
 
   // Check the DURABILITY_QOS_POLICY_ID
   if (writerQos->durability.kind < readerQos->durability.kind) {
     compatible = false;
 
     increment_incompatibility_count(writerStatus,
                                     DDS::DURABILITY_QOS_POLICY_ID);
     increment_incompatibility_count(readerStatus,
                                     DDS::DURABILITY_QOS_POLICY_ID);
   }
 
   // Check the LIVELINESS_QOS_POLICY_ID
   // invalid if offered kind is less than requested kind OR
   //         if offered liveliness duration greater than requested
   //         liveliness duration
   using OpenDDS::DCPS::operator>;
   if (writerQos->liveliness.kind < readerQos->liveliness.kind
       || writerQos->liveliness.lease_duration
       > readerQos->liveliness.lease_duration) {
 
     compatible = false;
 
     increment_incompatibility_count(writerStatus,
                                     DDS::LIVELINESS_QOS_POLICY_ID);
     increment_incompatibility_count(readerStatus,
                                     DDS::LIVELINESS_QOS_POLICY_ID);
   }
 
   // Check the DEADLINE_QOS_POLICY_ID
   //   Offered deadline must be less than or equal to the requested
   //   deadline.
   if (writerQos->deadline.period > readerQos->deadline.period) {
 
     compatible = false;
 
     increment_incompatibility_count(writerStatus,
                                     DDS::DEADLINE_QOS_POLICY_ID);
     increment_incompatibility_count(readerStatus,
                                     DDS::DEADLINE_QOS_POLICY_ID);
   }
 
   // Check the LATENCY_BUDGET
   //   The reader's duration must be greater than or equal to the writer's
   using OpenDDS::DCPS::operator<;
   if (readerQos->latency_budget.duration < writerQos->latency_budget.duration) {
 
     compatible = false;
 
     increment_incompatibility_count(writerStatus,
                                     DDS::LATENCYBUDGET_QOS_POLICY_ID);
     increment_incompatibility_count(readerStatus,
                                     DDS::LATENCYBUDGET_QOS_POLICY_ID);
   }
 
   // The value of the OWNERSHIP kind offered must exactly match the one
   // requested or else they are considered incompatible.
   if (writerQos->ownership.kind != readerQos->ownership.kind) {
     compatible = false;
 
     increment_incompatibility_count(writerStatus,
                                     DDS::OWNERSHIP_QOS_POLICY_ID);
     increment_incompatibility_count(readerStatus,
                                     DDS::OWNERSHIP_QOS_POLICY_ID);
   }
 
   {
     // Find a common data representation
     bool found = false;
     const CORBA::ULong reader_count = readerQos->representation.value.length();
     const CORBA::ULong writer_count = writerQos->representation.value.length();
     for (CORBA::ULong wi = 0; !found && wi < writer_count; ++wi) {
       for (CORBA::ULong ri = 0; !found && ri < reader_count; ++ri) {
         if (readerQos->representation.value[ri] == writerQos->representation.value[wi]) {
           found = true;
           break;
         }
       }
     }
 
     if (!found) {
       increment_incompatibility_count(writerStatus,
         DDS::DATA_REPRESENTATION_QOS_POLICY_ID);
       increment_incompatibility_count(readerStatus,
         DDS::DATA_REPRESENTATION_QOS_POLICY_ID);
       compatible = false;
     }
   }
 
   return compatible;
 }

◆ compatibleTransports()

bool OpenDDS::DCPS::compatibleTransports	(	const OpenDDS::DCPS::TransportLocatorSeq &	s1,
		const OpenDDS::DCPS::TransportLocatorSeq &	s2
	)

Definition at line 223 of file DCPS_Utils.cpp.

Referenced by compatibleQOS().

 {
   for (CORBA::ULong i = 0; i < s1.length(); ++i) {
     for (CORBA::ULong j = 0; j < s2.length(); ++j) {
       if (0 == std::strcmp(s1[i].transport_type, s2[j].transport_type)) {
         return true;
       }
     }
   }
   return false;
 }

◆ const_rchandle_cast()

template<typename T , typename U >

RcHandle<T> OpenDDS::DCPS::const_rchandle_cast ( const RcHandle< U > & h )

Definition at line 208 of file RcHandle_T.h.

References OpenDDS::DCPS::RcHandle< T >::in().

 {
   return RcHandle<T>(const_cast<T*>(h.in()), inc_count());
 }

◆ const_sequence_begin()

template<typename Sequence >

ConstSequenceIterator<Sequence> OpenDDS::DCPS::const_sequence_begin ( Sequence & seq )

inline

Definition at line 262 of file SequenceIterator.h.

References OpenDDS::DCPS::SequenceIteratorBase< ConstSequenceIterator< Sequence >, ConstSequenceIterTraits< Sequence > >::begin().

Referenced by OpenDDS::Security::TokenReader::get_bin_property_value(), and OpenDDS::Security::TokenReader::get_property_value().

 {
   return ConstSequenceIterator<Sequence>::Base::begin(seq);
 }

◆ const_sequence_end()

template<typename Sequence >

ConstSequenceIterator<Sequence> OpenDDS::DCPS::const_sequence_end ( Sequence & seq )

inline

Definition at line 268 of file SequenceIterator.h.

References OpenDDS::DCPS::SequenceIteratorBase< ConstSequenceIterator< Sequence >, ConstSequenceIterTraits< Sequence > >::end(), and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

Referenced by OpenDDS::Security::TokenReader::get_bin_property_value(), and OpenDDS::Security::TokenReader::get_property_value().

 {
   return ConstSequenceIterator<Sequence>::Base::end(seq);
 }

◆ convertToDouble()

template<typename T >

bool OpenDDS::DCPS::convertToDouble	(	const String &	s,
		T &	value
	)

Convert string s to value of double type T.

Returns true for success, false for error

Definition at line 90 of file SafetyProfileStreams.h.

References OPENDDS_END_VERSIONED_NAMESPACE_DECL.

Referenced by OpenDDS::RTPS::RtpsDiscovery::Config::discovery_config().

 {
 #ifdef OPENDDS_SAFETY_PROFILE
   char* end;
   const double conv = std::strtod(s.c_str(), &end);
   if (end == s.c_str()) return false;
   value = static_cast<T>(conv);
 #else
   std::stringstream istr(s.c_str());
   if (!(istr >> value) || (istr.peek() != EOF)) return false;
 #endif
   return true;
 }

◆ convertToInteger()

template<typename T >

bool OpenDDS::DCPS::convertToInteger	(	const String &	s,
		T &	value
	)

Convert string s to value of integral type T.

Returns true for success, false for error

Definition at line 70 of file SafetyProfileStreams.h.

Referenced by OpenDDS::DCPS::InfoRepoDiscovery::Config::discovery_config(), OpenDDS::RTPS::RtpsDiscovery::Config::discovery_config(), OpenDDS::DCPS::Service_Participant::load_domain_configuration(), OpenDDS::DCPS::TransportRegistry::load_transport_configuration(), OpenDDS::DCPS::Service_Participant::parse_domain_range(), OpenDDS::DCPS::StaticDiscovery::parse_endpoints(), OpenDDS::DCPS::TransportRegistry::process_customizations(), and OpenDDS::DCPS::Service_Participant::process_customizations().

 {
 #ifdef OPENDDS_SAFETY_PROFILE
   char* end;
   const long conv = std::strtol(s.c_str(), &end, 10);
   if (end == s.c_str()) return false;
   value = static_cast<T>(conv);
 #else
   std::stringstream istr(s.c_str());
   if (!(istr >> value) || (istr.peek() != EOF)) return false;
 #endif
   return true;
 }

◆ dedup()

OpenDDS_Rtps_Udp_Export size_t OpenDDS::DCPS::dedup ( MetaSubmessageVec & vec )

Mark submessages that are superseded as ignored. Returns the number of messages that are marked as ignored.

Definition at line 51 of file MetaSubmessage.cpp.

References OpenDDS::RTPS::ACKNACK, OpenDDS::RTPS::HEARTBEAT, and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

Referenced by OpenDDS::DCPS::RtpsUdpDataLink::flush_send_queue_i().

 {
   size_t count = 0;
 
   if (vec.empty()) {
     return count;
   }
 
   std::sort(vec.begin(), vec.end(), SortPredicate());
   MetaSubmessageVec::iterator pos = vec.begin();
   MetaSubmessageVec::iterator next = pos;
   std::advance(next, 1);
   const MetaSubmessageVec::iterator limit = vec.end();
   EqualPredicate eq;
   for (; next != limit; ++pos, ++next) {
     if ((pos->sm_._d() == RTPS::HEARTBEAT || pos->sm_._d() == RTPS::ACKNACK) && eq(*pos, *next)) {
       next->ignore_ = true;
       ++count;
     }
   }
 
   return count;
 }

◆ duration_to_absolute_time_value()

ACE_INLINE ACE_Time_Value OpenDDS::DCPS::duration_to_absolute_time_value	(	const DDS::Duration_t &	t,
		const ACE_Time_Value &	now
	)

Definition at line 213 of file Time_Helper.inl.

References ACE_INLINE, ACE_ONE_SECOND_IN_USECS, ACE_Time_Value::max_time, DDS::Duration_t::nanosec, ACE_Time_Value::sec(), DDS::Duration_t::sec, and ACE_Time_Value::usec().

 {
   CORBA::LongLong sec
     = t.sec + now.sec() + (t.nanosec/1000 + now.usec())/ACE_ONE_SECOND_IN_USECS;
   CORBA::ULong usec = (t.nanosec/1000 + now.usec()) % ACE_ONE_SECOND_IN_USECS;
 
   if (sec > ACE_Time_Value::max_time.sec()) {
     return ACE_Time_Value::max_time;
   }
   else {
     return ACE_Time_Value(ACE_Utils::truncate_cast<time_t>(sec), usec);
   }
 }

◆ duration_to_time_value()

ACE_INLINE ACE_Time_Value OpenDDS::DCPS::duration_to_time_value ( const DDS::Duration_t & t )

Definition at line 195 of file Time_Helper.inl.

References ACE_INLINE, ACE_ONE_SECOND_IN_USECS, is_infinite(), ACE_Time_Value::max_time, DDS::Duration_t::nanosec, and DDS::Duration_t::sec.

Referenced by log_progress().

 {
   if (is_infinite(t)) {
     return ACE_Time_Value::max_time;
   }
 
   CORBA::LongLong sec = t.sec + t.nanosec/1000/ACE_ONE_SECOND_IN_USECS;
   CORBA::ULong usec = t.nanosec/1000 % ACE_ONE_SECOND_IN_USECS;
 
   if (sec > ACE_Time_Value::max_time.sec()) {
     return ACE_Time_Value::max_time;
   }
   else {
     return ACE_Time_Value(ACE_Utils::truncate_cast<time_t>(sec), usec);
   }
 }

◆ dynamic_rchandle_cast()

template<typename T , typename U >

RcHandle<T> OpenDDS::DCPS::dynamic_rchandle_cast ( const RcHandle< U > & h )

Definition at line 214 of file RcHandle_T.h.

References OpenDDS::DCPS::RcHandle< T >::in().

Referenced by OpenDDS::DCPS::Sample_T< NativeType >::copy(), OpenDDS::DCPS::DataWriterImpl_T< MessageType >::get_key_value(), TAO_DDS_DCPSInfo_i::init_transport(), OpenDDS::DCPS::RtpsUdpDataLink::receive_strategy(), OpenDDS::DCPS::RtpsUdpDataLink::send_strategy(), and OpenDDS::DCPS::DataReaderImpl_T< MessageType >::store_instance_data().

 {
   return RcHandle<T>(dynamic_cast<T*>(h.in()), inc_count());
 }

◆ endianness_to_string()

OpenDDS_Dcps_Export String OpenDDS::DCPS::endianness_to_string ( Endianness endianness )

Definition at line 57 of file Serializer.cpp.

References ENDIAN_BIG, and ENDIAN_LITTLE.

Referenced by OpenDDS::DCPS::Encoding::to_string().

 {
   switch (endianness) {
   case ENDIAN_BIG:
     return "big-endian ("
 #ifdef ACE_LITTLE_ENDIAN
       "non-"
 #endif
       "native)";
   case ENDIAN_LITTLE:
     return "little-endian ("
 #ifndef ACE_LITTLE_ENDIAN
       "non-"
 #endif
       "native)";
   default:
     return "invalid endianness";
   }
 }

◆ equal_guid_prefixes() [1/2]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::equal_guid_prefixes	(	const GuidPrefix_t &	lhs,
		const GuidPrefix_t &	rhs
	)

inline

Definition at line 151 of file GuidUtils.h.

References OpenDDS_Dcps_Export.

Referenced by OpenDDS::RTPS::Sedp::cleanup_reader_association(), OpenDDS::RTPS::Sedp::cleanup_writer_association(), equal_guid_prefixes(), OpenDDS::Security::HandleRegistry::get_all_remote_datareaders(), OpenDDS::Security::HandleRegistry::get_all_remote_datawriters(), OpenDDS::DCPS::StaticEndpointManager::init_bit(), OpenDDS::DCPS::RtpsUdpTransport::make_datalink(), OpenDDS::DCPS::StaticEndpointManager::match_endpoints(), OpenDDS::RTPS::Sedp::match_endpoints(), OpenDDS::RTPS::Sedp::notify_liveliness(), OpenDDS::DCPS::RtpsUdpReceiveStrategy::receive_bytes(), OpenDDS::DCPS::RtpsUdpTransport::relay_stun_task(), OpenDDS::RTPS::Sedp::resend_user_crypto_tokens(), OpenDDS::DCPS::RecorderImpl::signal_liveliness(), and OpenDDS::DCPS::DataReaderImpl::signal_liveliness().

 {
   return std::memcmp(&lhs, &rhs, sizeof(GuidPrefix_t)) == 0;
 }

◆ equal_guid_prefixes() [2/2]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::equal_guid_prefixes	(	const GUID_t &	lhs,
		const GUID_t &	rhs
	)

inline

Definition at line 157 of file GuidUtils.h.

References equal_guid_prefixes(), and OpenDDS::DCPS::GUID_t::guidPrefix.

 {
   return equal_guid_prefixes(lhs.guidPrefix, rhs.guidPrefix);
 }

◆ find() [1/2]

template<typename Container , typename Key >

int OpenDDS::DCPS::find	(	Container &	c,
		const Key &	key,
		typename Container::mapped_type *&	value
	)

Definition at line 69 of file Util.h.

Referenced by OpenDDS::DCPS::WriteDataContainer::dispose(), OpenDDS::DCPS::ReceiveListenerSet::exist(), OpenDDS::DCPS::ReceiveListenerSetMap::find(), OpenDDS::DCPS::WriteDataContainer::get_handle_instance(), OpenDDS::DCPS::OwnershipManager::get_instance_map(), OpenDDS::DCPS::TransportRegistry::load_transport_lib_i(), OpenDDS::DCPS::DomainParticipantFactoryImpl::lookup_participant(), OpenDDS::DCPS::WriteDataContainer::num_samples(), OpenDDS::DCPS::UdpTransport::passive_connection(), OpenDDS::DCPS::MulticastTransport::passive_connection(), OpenDDS::DCPS::WriteDataContainer::register_instance(), OpenDDS::DCPS::ReceiveListenerSetMap::release_subscriber(), OpenDDS::DCPS::ReceiveListenerSetMap::remove(), and OpenDDS::DCPS::OwnershipManager::unregister_reader().

 {
   typename Container::iterator iter =
     c.find(key);
 
   if (iter == c.end()) {
     return -1;
   }
 
   value = &iter->second;
   return 0;
 }

◆ find() [2/2]

template<typename Container , typename Key >

int OpenDDS::DCPS::find	(	const Container &	c,
		const Key &	key,
		typename Container::mapped_type &	value
	)

Definition at line 86 of file Util.h.

 {
   typename Container::const_iterator iter =
     c.find(key);
 
   if (iter == c.end()) {
     return -1;
   }
 
   value = iter->second;
   return 0;
 }

◆ get_fully_qualified_hostname()

OpenDDS_Dcps_Export String OpenDDS::DCPS::get_fully_qualified_hostname ( ACE_INET_Addr * addr = 0 )

Helper function to get the fully qualified hostname. It attempts to discover the FQDN by the network interface addresses, however the result is impacted by the network configuration, so it returns name in the order whoever is found first - FQDN, short hostname, name resolved from loopback address. In the case using short hostname or name resolved from loopback, a warning is logged. If there is no any name discovered from network interfaces, an error is logged. If ACE_HAS_IPV6, will give priority to IPV6 interfaces

Definition at line 81 of file NetworkResource.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_TEXT(), ACE::get_fqdn(), ACE_INET_Addr::get_host_addr(), ACE::get_ip_interfaces(), hostname(), OpenDDS::DCPS::HostnameInfo::hostname_, OpenDDS::DCPS::HostnameInfo::index_, OpenDDS::DCPS::LogAddr::ip(), ACE_INET_Addr::is_loopback(), LM_DEBUG, LM_ERROR, LM_WARNING, MAXHOSTNAMELEN, ACE_INET_Addr::set_address(), ACE_OS::strchr(), ACE_OS::strncmp(), swap(), VDBG_LVL, and verify_hostname().

Referenced by OpenDDS::DCPS::TcpTransport::configure_i(), OpenDDS::DCPS::UdpDataLink::open(), and OpenDDS::DCPS::UdpInst::populate_locator().

 {
   // cache the determined fully qualified hostname and its
   // address to be used on subsequent calls
   static String fullname;
   static ACE_INET_Addr selected_address;
 
   if (fullname.length() == 0) {
     size_t addr_count;
     ACE_INET_Addr *addr_array = 0;
     OpenDDS::DCPS::HostnameInfoVector nonFQDN;
 
     const int result = ACE::get_ip_interfaces(addr_count, addr_array);
 
     struct Array_Guard {
       Array_Guard(ACE_INET_Addr *ptr) : ptr_(ptr) {}
       ~Array_Guard() {
         delete [] ptr_;
       }
       ACE_INET_Addr* const ptr_;
     } guardObject(addr_array);
 
     if (result != 0 || addr_count < 1) {
       ACE_ERROR((LM_ERROR,
                  ACE_TEXT("(%P|%t) ERROR: get_fully_qualified_hostname: Unable to probe network. %p\n"),
                  ACE_TEXT("ACE::get_ip_interfaces")));
 
     } else {
       for (size_t i = 0; i < addr_count; i++) {
         VDBG_LVL((LM_DEBUG, "(%P|%t) get_fully_qualified_hostname: Found IP interface %C\n", LogAddr::ip(addr_array[i]).c_str()), 4);
       }
 
 #ifdef ACE_HAS_IPV6
       // Front load IPV6 addresses to give preference to IPV6 interfaces
       size_t index_last_non_ipv6 = 0;
       for (size_t i = 0; i < addr_count; i++) {
         if (addr_array[i].get_type() == AF_INET6) {
           if (i == index_last_non_ipv6) {
             ++index_last_non_ipv6;
           } else {
             std::swap(addr_array[i], addr_array[index_last_non_ipv6]);
             ++index_last_non_ipv6;
           }
         }
       }
 #endif
       for (size_t i = 0; i < addr_count; i++) {
         char hostname[MAXHOSTNAMELEN+1] = "";
 
         // Discover the fully qualified hostname
         if (ACE::get_fqdn(addr_array[i], hostname, MAXHOSTNAMELEN+1) == 0) {
           VDBG_LVL((LM_DEBUG, "(%P|%t) get_fully_qualified_hostname: Considering fqdn %C\n", hostname), 4);
           // Find the first FQDN that resolves to an IP interface address.
           if (!addr_array[i].is_loopback() && ACE_OS::strchr(hostname, '.') != 0 &&
               verify_hostname(hostname, addr_array, addr_count, false, false)) {
             VDBG_LVL((LM_DEBUG, "(%P|%t) get_fully_qualified_hostname: Found fqdn %C from %C\n", hostname, LogAddr(addr_array[i]).c_str()), 2);
             selected_address = addr_array[i];
             fullname = hostname;
             if (addr) {
               *addr = selected_address;
             }
             return fullname;
           } else {
             VDBG_LVL((LM_DEBUG, "(%P|%t) get_fully_qualified_hostname: IP interface %C maps to hostname %C\n",
                       LogAddr(addr_array[i]).c_str(), hostname), 2);
 
             if (ACE_OS::strncmp(hostname, "localhost", 9) == 0) {
               addr_array[i].get_host_addr(hostname, MAXHOSTNAMELEN);
             }
 
             if (verify_hostname(hostname, addr_array, addr_count, false, true)) {
               OpenDDS::DCPS::HostnameInfo info;
               info.index_ = i;
               info.hostname_ = hostname;
               nonFQDN.push_back(info);
             }
           }
         }
       }
     }
 
     OpenDDS::DCPS::HostnameInfoVector::iterator itBegin = nonFQDN.begin();
     OpenDDS::DCPS::HostnameInfoVector::iterator itEnd = nonFQDN.end();
 
     for (OpenDDS::DCPS::HostnameInfoVector::iterator it = itBegin; it != itEnd; ++it) {
       if (!addr_array[it->index_].is_loopback()) {
         ACE_DEBUG((LM_WARNING, "(%P|%t) WARNING: get_fully_qualified_hostname: Could not find FQDN. Using "
                    "\"%C\" as fully qualified hostname, please "
                    "correct system configuration.\n", it->hostname_.c_str()));
         selected_address = addr_array[it->index_];
         fullname = it->hostname_;
         if (addr) {
           *addr = selected_address;
         }
         return fullname;
       }
     }
 
     // If no non-loopback IP is found from the above step, return a non-loopback
     // address from the IP interfaces list.
     for (size_t i = 0; i < addr_count; ++i) {
       if (!addr_array[i].is_loopback()) {
         char addr_str[MAXHOSTNAMELEN+1] = "";
         addr_array[i].get_host_addr(addr_str, MAXHOSTNAMELEN);
         ACE_DEBUG((LM_WARNING, "(%P|%t) WARNING: get_fully_qualified_hostname: Could not find FQDN. Using "
                    "\"%C\" as fully qualified hostname, please "
                    "correct system configuration.\n", addr_str));
         selected_address = addr_array[i];
         fullname = addr_str;
         if (addr) {
           *addr = selected_address;
         }
         return fullname;
       }
     }
 
     // As a last resort, return the first loopback address from the non-FQDNs list if not empty.
     if (itBegin != itEnd) {
       ACE_DEBUG((LM_WARNING, "(%P|%t) WARNING: get_fully_qualified_hostname: Could not find FQDN. Using "
                  "\"%C\" as fully qualified hostname, please "
                  "correct system configuration.\n", itBegin->hostname_.c_str()));
       selected_address = addr_array[itBegin->index_];
       fullname = itBegin->hostname_;
       if (addr) {
         *addr = selected_address;
       }
       return fullname;
     }
 
 #ifdef OPENDDS_SAFETY_PROFILE
     // address resolution may not be available due to safety profile,
     // return an address that should work for running tests
     if (addr) {
       static const char local[] = {1, 0, 0, 127};
       addr->set_address(local, sizeof local);
     }
     return "localhost";
 #else
     ACE_ERROR((LM_ERROR,
                "(%P|%t) ERROR: get_fully_qualified_hostname: Failed to discover the fully qualified hostname\n"));
 #endif
   }
 
   if (addr) {
     *addr = selected_address;
   }
   return fullname;
 }

◆ get_interface_addrs()

OpenDDS_Dcps_Export void OpenDDS::DCPS::get_interface_addrs ( OPENDDS_VECTOR(ACE_INET_Addr)& addrs )

Helper function to get the vector of addresses which should be advertised to peers

Definition at line 230 of file NetworkResource.cpp.

References ACE_ERROR, ACE_TEXT(), AF_INET, ACE::get_ip_interfaces(), ACE_Addr::get_type(), LM_DEBUG, LM_ERROR, ACE_INET_Addr::set_address(), swap(), and VDBG_LVL.

Referenced by OpenDDS::DCPS::RtpsUdpTransport::IceEndpoint::host_addresses(), OpenDDS::RTPS::Spdp::SpdpTransport::host_addresses(), and OpenDDS::DCPS::RtpsUdpInst::populate_locator().

 {
   ACE_INET_Addr *if_addrs = 0;
   size_t if_cnt = 0;
   size_t endpoint_count = 0;
 
   int result =
 #ifdef OPENDDS_SAFETY_PROFILE
     -1;
 #else
     ACE::get_ip_interfaces(if_cnt, if_addrs);
 #endif
 
   struct Array_Guard {
     Array_Guard(ACE_INET_Addr *ptr) : ptr_(ptr) {}
     ~Array_Guard() {
       delete[] ptr_;
     }
     ACE_INET_Addr* const ptr_;
   } guardObject(if_addrs);
 
   if (!result) {
     size_t lo_cnt = 0;  // Loopback interface count
 #if defined (ACE_HAS_IPV6)
     size_t ipv4_cnt = 0;
     size_t ipv4_lo_cnt = 0;
     size_t ipv6_ll = 0;
     bool ipv6_non_ll = false;
 #endif
     for (size_t j = 0; j < if_cnt; ++j) {
       // Scan for the loopback interface since it shouldn't be included in
       // the list of cached hostnames unless it is the only interface.
       if (if_addrs[j].is_loopback())
         ++lo_cnt;
 #if defined (ACE_HAS_IPV6)
       // Scan for IPv4 interfaces since these should not be included
       // when IPv6-only is selected.
       if (if_addrs[j].get_type() != AF_INET6 ||
           if_addrs[j].is_ipv4_mapped_ipv6()) {
         ++ipv4_cnt;
         if (if_addrs[j].is_loopback())
           ++ipv4_lo_cnt;  // keep track of IPv4 loopback ifs
       } else if (!if_addrs[j].is_linklocal() &&
                  !if_addrs[j].is_loopback()) {
         ipv6_non_ll = true; // we have at least 1 non-local IPv6 if
       } else if (if_addrs[j].is_linklocal()) {
         ++ipv6_ll;  // count link local addrs to exclude them afterwards
       }
 #endif /* ACE_HAS_IPV6 */
     }
 
     bool ipv4_only = ACE_INET_Addr().get_type() == AF_INET;
 
 #if defined (ACE_HAS_IPV6)
 
     // If the loopback interface is the only interface then include it
     // in the list of interfaces to query for a hostname, otherwise
     // exclude it from the list.
     bool ignore_lo;
     if (ipv4_only) {
       ignore_lo = ipv4_cnt != ipv4_lo_cnt;
     } else {
       ignore_lo = if_cnt != lo_cnt;
     }
 
     // Adjust counts for IPv4 only if required
     size_t if_ok_cnt = if_cnt;
     if (ipv4_only) {
       if_ok_cnt = ipv4_cnt;
       lo_cnt = ipv4_lo_cnt;
       ipv6_ll = 0;
     }
 
     // In case there are no non-local IPv6 ifs in the list only exclude
     // IPv4 loopback.
     // IPv6 loopback will be needed to successfully connect IPv6 clients
     // in a localhost environment.
     if (!ipv4_only && !ipv6_non_ll)
       lo_cnt = ipv4_lo_cnt;
 
     if (!ignore_lo)
       endpoint_count = if_ok_cnt - ipv6_ll;
     else
       endpoint_count = if_ok_cnt - ipv6_ll - lo_cnt;
 #else /* end ACE_HAS_IPV6 begin !ACE_HAS_IPV6*/
     // If the loopback interface is the only interface then include it
     // in the list of interfaces to query for a hostname, otherwise
     // exclude it from the list.
     bool ignore_lo;
     ignore_lo = if_cnt != lo_cnt;
     if (!ignore_lo)
       endpoint_count = if_cnt;
     else
       endpoint_count = if_cnt - lo_cnt;
 #endif /* !ACE_HAS_IPV6 */
     if (endpoint_count == 0) {
       VDBG_LVL((LM_DEBUG,
         ACE_TEXT("(%P|%t) get_interface_addrs() - ")
         ACE_TEXT("found no usable addresses\n")), 2);
     }
 
     for (size_t i = 0; i < if_cnt; ++i) {
       // Ignore any non-IPv4 interfaces when so required.
       if (ipv4_only && (if_addrs[i].get_type() != AF_INET))
         continue;
 #if defined (ACE_HAS_IPV6)
       // Ignore any loopback interface if there are other
       // non-loopback interfaces.
       if (ignore_lo &&
           if_addrs[i].is_loopback() &&
           (ipv4_only ||
           ipv6_non_ll ||
           if_addrs[i].get_type() != AF_INET6))
         continue;
 
       // Ignore all IPv6 link local interfaces when so required.
       if (ipv6_non_ll && if_addrs[i].is_linklocal())
         continue;
 #else /* ACE_HAS_IPV6 */
       // Ignore any loopback interface if there are other
       // non-loopback interfaces.
       if (ignore_lo && if_addrs[i].is_loopback())
         continue;
 #endif /* !ACE_HAS_IPV6 */
       addrs.push_back(if_addrs[i]);
     }
   }
 #ifdef ACE_HAS_IPV6
   //front load IPV6 addresses to give preference to IPV6 interfaces
   size_t index_last_non_ipv6 = 0;
   for (size_t i = 0; i < addrs.size(); i++) {
     if (addrs.at(i).get_type() == AF_INET6) {
       if (i == index_last_non_ipv6) {
         ++index_last_non_ipv6;
       }
       else {
         std::swap(addrs.at(i), addrs.at(index_last_non_ipv6));
         ++index_last_non_ipv6;
       }
     }
   }
 #endif
 #ifdef OPENDDS_SAFETY_PROFILE
   // address resolution may not be available due to safety profile,
   // return an address that should work for running tests
   if (addrs.empty()) {
     ACE_INET_Addr addr;
     static const char local[] = { 1, 0, 0, 127 };
     addr.set_address(local, sizeof local);
     addrs.push_back(addr);
   }
 #else
   if (addrs.empty()) {
     ACE_ERROR((LM_ERROR,
       "(%P|%t) ERROR: failed to find usable interface address\n"));
   }
 #endif
 }

◆ get_remote_reliability()

static bool OpenDDS::DCPS::get_remote_reliability ( const TransportImpl::RemoteTransport & remote )

static

Definition at line 131 of file MulticastTransport.cpp.

References OpenDDS::DCPS::TransportImpl::RemoteTransport::blob_.

Referenced by OpenDDS::DCPS::MulticastTransport::accept_datalink(), and OpenDDS::DCPS::MulticastTransport::connect_datalink().

 {
   NetworkResource network_resource;
   ACE_CDR::Boolean reliable;
 
   const size_t len = remote.blob_.length();
   const char* buffer = reinterpret_cast<const char*>(remote.blob_.get_buffer());
 
   ACE_InputCDR cdr(buffer, len);
   cdr >> network_resource;
   cdr >> ACE_InputCDR::to_boolean(reliable);
 
   return reliable;
 }

◆ getCompleteTypeIdentifier()

template<typename T >

const XTypes::TypeIdentifier& OpenDDS::DCPS::getCompleteTypeIdentifier ( )

Referenced by OpenDDS::DCPS::TypeSupportImpl::has_dcps_key(), and OpenDDS::XTypes::TypeMapBuilder::operator TypeMap &().

◆ getCompleteTypeMap()

template<typename T >

const XTypes::TypeMap& OpenDDS::DCPS::getCompleteTypeMap ( )

Referenced by OpenDDS::DCPS::TypeSupportImpl::has_dcps_key(), and OpenDDS::XTypes::TypeMapBuilder::operator TypeMap &().

◆ getMetaStruct()

template<typename T >

const MetaStruct& OpenDDS::DCPS::getMetaStruct ( )

◆ getMinimalTypeIdentifier()

template<typename T >

const XTypes::TypeIdentifier& OpenDDS::DCPS::getMinimalTypeIdentifier ( )

Referenced by OpenDDS::DCPS::TypeSupportImpl::has_dcps_key(), and OpenDDS::XTypes::TypeMapBuilder::operator TypeMap &().

◆ getMinimalTypeMap()

template<typename T >

const XTypes::TypeMap& OpenDDS::DCPS::getMinimalTypeMap ( )

Referenced by OpenDDS::DCPS::TypeSupportImpl::has_dcps_key(), and OpenDDS::XTypes::TypeMapBuilder::operator TypeMap &().

◆ grow()

template<typename Seq >

Seq::size_type OpenDDS::DCPS::grow ( Seq & seq )

Definition at line 149 of file Util.h.

Referenced by OpenDDS::DCPS::RtpsUdpDataLink::RtpsWriter::add_gap_submsg_i(), append(), TAO::DCPS::ZeroCopyDataSeq< Sample_T, DEF_MAX >::length(), OpenDDS::DCPS::RtpsSampleHeader::payload_byte_order(), OpenDDS::DCPS::TransportClient::populate_connection_info(), OpenDDS::DCPS::RtpsSampleHeader::populate_data_control_submessages(), OpenDDS::DCPS::RtpsSampleHeader::populate_data_sample_submessages(), OpenDDS::DCPS::RtpsSampleHeader::populate_inline_qos(), OpenDDS::DCPS::RtpsUdpInst::populate_locator(), and OpenDDS::DCPS::TransportConfig::populate_locators().

 {
   const ACE_CDR::ULong len = seq.length();
   // Grow by factor of 2 when length is a power of 2 in order to prevent every call to length(+1)
   // allocating a new buffer & copying previous results. The maximum is kept when length is reduced.
   if (len && !(len & (len - 1))) {
     seq.length(2 * len);
   }
   seq.length(len + 1);
   return len + 1;
 }

◆ HANDLE_UNKNOWN()

const DDS::InstanceHandle_t OpenDDS::DCPS::HANDLE_UNKNOWN ( 0 )

◆ hex_value()

std::ostream& OpenDDS::DCPS::hex_value	(	std::ostream &	o,
		unsigned	value,
		size_t	bytes
	)

inline

Definition at line 50 of file ValueHelper.h.

References value.

Referenced by char_helper(), and operator<<().

 {
   OpenDDS::DCPS::RestoreOutputStreamState ross(o);
   o << std::hex << std::setw(bytes * 2) << std::setfill('0') << value;
   return o;
 }

◆ increment_incompatibility_count()

OpenDDS_Dcps_Export void OpenDDS::DCPS::increment_incompatibility_count	(	OpenDDS::DCPS::IncompatibleQosStatus *	status,
		DDS::QosPolicyId_t	incompatible_policy
	)

Increments the count of occurrences of the incompatible policy for the status

Definition at line 194 of file DCPS_Utils.cpp.

References DDS::QosPolicyCount::count, OpenDDS::DCPS::IncompatibleQosStatus::count_since_last_send, OpenDDS::DCPS::IncompatibleQosStatus::last_policy_id, OpenDDS::DCPS::IncompatibleQosStatus::policies, DDS::QosPolicyCount::policy_id, and OpenDDS::DCPS::IncompatibleQosStatus::total_count.

Referenced by compatibleQOS().

 {
   if (!status) return;
 
   ++status->total_count;
   ++status->count_since_last_send;
   status->last_policy_id = incompatible_policy;
   CORBA::ULong const size = status->policies.length();
   CORBA::ULong count = 0;
   bool updated = false;
 
   for (; !updated && count < size; ++count) {
     if (status->policies[count].policy_id == incompatible_policy) {
       ++status->policies[count].count;
       updated = true;
     }
   }
 
   if (!updated) {
     DDS::QosPolicyCount policy;
     policy.policy_id = incompatible_policy;
     policy.count = 1;
     status->policies.length(count + 1);
     status->policies[count] = policy;
   }
 }

◆ insert()

template<typename Container , typename ValueType >

int OpenDDS::DCPS::insert	(	Container &	c,
		const ValueType &	v
	)

Definition at line 103 of file Util.h.

Referenced by OpenDDS::DCPS::ReplayerImpl::association_complete_i(), OpenDDS::DCPS::DataWriterImpl::association_complete_i(), OpenDDS::DCPS::DomainParticipantImpl::create_publisher(), OpenDDS::DCPS::DomainParticipantImpl::create_subscriber(), Intro::insert(), OpenDDS::DCPS::RtpsUdpDataLink::MultiSendBuffer::MultiSendBuffer(), OpenDDS::DCPS::RtpsUdpDataLink::send_heartbeats(), and OpenDDS::DCPS::RtpsUdpDataLink::RtpsWriter::update_remote_guids_cache_i().

 {
   if (c.find(v) == c.end()) {
     if (c.insert(v).second) {
       return 0;
     }
 
     return -1;
   }
 
   return 1;
 }

◆ instance_handle_to_bit_data()

template<class BIT_Reader_var , class BIT_DataSeq >

DDS::ReturnCode_t OpenDDS::DCPS::instance_handle_to_bit_data	(	DomainParticipantImpl *	dp,
		const char *	bit_name,
		const DDS::InstanceHandle_t &	handle,
		BIT_DataSeq &	data
	)

Definition at line 104 of file BuiltInTopicUtils.h.

References ACE_DEBUG, ACE_ERROR, DDS::ANY_INSTANCE_STATE, DDS::ANY_SAMPLE_STATE, DDS::ANY_VIEW_STATE, DCPS_debug_level, OpenDDS::DCPS::TimeDuration::from_msec(), OpenDDS::DCPS::DomainParticipantImpl::get_builtin_subscriber(), DDS::LENGTH_UNLIMITED, LM_DEBUG, LM_NOTICE, log_level, OpenDDS::DCPS::LogLevel::Notice, OpenDDS::DCPS::TimePoint_T< MonotonicClock >::now(), DDS::RETCODE_BAD_PARAMETER, DDS::RETCODE_NO_DATA, DDS::RETCODE_OK, DDS::RETCODE_TIMEOUT, retcode_to_string(), ACE_OS::sleep(), TheServiceParticipant, and value.

 {
   DDS::Subscriber_var bit_subscriber = dp->get_builtin_subscriber();
   if (!bit_subscriber) {
     if (log_level >= LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: instance_handle_to_bit_data: "
         "Could not get BIT subscriber, might be in middle of shutdown\n"));
     }
     return DDS::RETCODE_BAD_PARAMETER;
   }
 
   DDS::DataReader_var reader = bit_subscriber->lookup_datareader(bit_name);
   typedef typename BIT_Reader_var::_obj_type BIT_Reader;
   BIT_Reader_var bit_reader = BIT_Reader::_narrow(reader.in());
   if (!bit_reader) {
     if (log_level >= LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: instance_handle_to_bit_data: "
         "Could not get BIT reader \"%C\", might be in middle of shutdown\n", bit_name));
     }
     return DDS::RETCODE_BAD_PARAMETER;
   }
 
   const MonotonicTimePoint due(MonotonicTimePoint::now() +
     TimeDuration::from_msec(TheServiceParticipant->bit_lookup_duration_msec()));
 
   // Look for the data from builtin topic datareader until we get results or
   // timeout.
   // This is to resolve the problem of lookup return nothing. This could happen
   // when the add_association is called before the builtin topic datareader got
   // the published data.
   while (true) {
     DDS::SampleInfoSeq the_info;
     BIT_DataSeq the_data;
     const DDS::ReturnCode_t ret =
       bit_reader->read_instance(the_data,
                                 the_info,
                                 DDS::LENGTH_UNLIMITED,
                                 handle,
                                 DDS::ANY_SAMPLE_STATE,
                                 DDS::ANY_VIEW_STATE,
                                 DDS::ANY_INSTANCE_STATE);
 
     if (ret == DDS::RETCODE_OK) {
       data.length(1);
       data[0] = the_data[0];
       return ret;
     }
 
     if (ret != DDS::RETCODE_BAD_PARAMETER && ret != DDS::RETCODE_NO_DATA) {
       if (log_level >= LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: instance_handle_to_bit_data: "
           "read_instance %C 0x%x error: %C\n",
           bit_name, handle, retcode_to_string(ret)));
       }
       return ret;
     }
 
     const MonotonicTimePoint now = MonotonicTimePoint::now();
     if (now < due) {
       if (DCPS_debug_level >= 10) {
         ACE_DEBUG((LM_DEBUG, "(%P|%t) instance_handle_to_bit_data: "
                    "BIT reader read_instance returned \"%C\" - trying again...\n",
                    retcode_to_string(ret)));
       }
       ACE_OS::sleep(std::min(due - now, TimeDuration(0, 100000)).value());
 
     } else {
       if (log_level >= LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: instance_handle_to_bit_data: "
           "read_instance %C 0x%x timed out\n",
           bit_name, handle));
       }
       return DDS::RETCODE_TIMEOUT;
     }
   }
 }

◆ intersect()

OpenDDS_Dcps_Export void OpenDDS::DCPS::intersect	(	const GuidSet &	a,
		const GuidSet &	b,
		GuidSet &	result
	)

Definition at line 60 of file GuidUtils.cpp.

References intersect_sorted_ranges().

Referenced by intersect_sorted_ranges(), and make_unknown_guid().

 {
   result.clear();
   intersect_sorted_ranges(a.begin(), a.end(), b.begin(), b.end(),
                           std::inserter(result, result.end()), GUID_tKeyLessThan());
 }

◆ intersect_sorted_ranges() [1/2]

template<typename InputIteratorA , typename InputIteratorB , typename OutputIterator >

OutputIterator OpenDDS::DCPS::intersect_sorted_ranges	(	InputIteratorA	a,
		InputIteratorA	aEnd,
		InputIteratorB	b,
		InputIteratorB	bEnd,
		OutputIterator	intersect
	)

Definition at line 164 of file Util.h.

References intersect().

Referenced by intersect().

 {
   while (a != aEnd && b != bEnd) {
     if (*a < *b) { ++a; }
     else if (*b < *a) { ++b; }
     else { *intersect++ = *a++; ++b; }
   }
   return intersect;
 }

◆ intersect_sorted_ranges() [2/2]

template<typename InputIteratorA , typename InputIteratorB , typename OutputIterator , typename LessThan >

OutputIterator OpenDDS::DCPS::intersect_sorted_ranges	(	InputIteratorA	a,
		InputIteratorA	aEnd,
		InputIteratorB	b,
		InputIteratorB	bEnd,
		OutputIterator	intersect,
		LessThan	lessThan
	)

Definition at line 179 of file Util.h.

References intersect().

 {
   while (a != aEnd && b != bEnd) {
     if (lessThan(*a, *b)) { ++a; }
     else if (lessThan(*b, *a)) { ++b; }
     else { *intersect++ = *a++; ++b; }
   }
   return intersect;
 }

◆ is_infinite()

bool OpenDDS::DCPS::is_infinite ( const DDS::Duration_t & value )

Definition at line 289 of file Time_Helper.inl.

References ACE_INLINE, DDS::DURATION_INFINITE_NSEC, DDS::DURATION_INFINITE_SEC, DDS::Duration_t::nanosec, OpenDDS_Dcps_Export, and DDS::Duration_t::sec.

Referenced by duration_to_time_value(), operator<(), valid_duration(), and DDS::WaitSet::wait().

 {
   return value.sec == DDS::DURATION_INFINITE_SEC &&
     value.nanosec == DDS::DURATION_INFINITE_NSEC;
 }

◆ is_more_local()

OpenDDS_Dcps_Export bool OpenDDS::DCPS::is_more_local	(	const NetworkAddress &	current,
		const NetworkAddress &	incoming
	)

Definition at line 297 of file NetworkAddress.cpp.

References AF_INET, OpenDDS::DCPS::NetworkAddress::get_type(), OpenDDS::DCPS::NetworkAddress::is_linklocal(), OpenDDS::DCPS::NetworkAddress::is_loopback(), OpenDDS::DCPS::NetworkAddress::is_private(), OpenDDS::DCPS::NetworkAddress::is_sitelocal(), OpenDDS::DCPS::NetworkAddress::is_uniquelocal(), and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

Referenced by OpenDDS::DCPS::RtpsUdpDataLink::update_last_recv_addr(), and OpenDDS::DCPS::RtpsUdpTransport::use_datalink().

 {
   // The question to answer here: "Is the incoming address 'more local' than the current address?"
 
   if (!current) {
     return true;
   }
 
 #ifdef ACE_HAS_IPV6
   if (current.get_type() == AF_INET) {
     if (incoming.get_type() == AF_INET6) {
       return true;
     }
 #endif /* ACE_HAS_IPV6 */
     if (current.is_loopback()) {
       return false;
     } else if (incoming.is_loopback()) {
       return true;
     }
 
     if (current.is_private()) {
       return false;
     } else if (incoming.is_private()) {
       return true;
     }
 #ifdef ACE_HAS_IPV6
   } else if (current.get_type() == AF_INET6) {
     if (incoming.get_type() == AF_INET) {
       return false;
     }
 
     if (current.is_loopback()) {
       return false;
     } else if (incoming.is_loopback()) {
       return true;
     }
 
     if (current.is_linklocal()) {
       return false;
     } else if (incoming.is_linklocal()) {
       return true;
     }
 
     if (current.is_uniquelocal()) {
       return false;
     } else if (incoming.is_uniquelocal()) {
       return true;
     }
 
     if (current.is_sitelocal()) {
       return false;
     } else if (incoming.is_sitelocal()) {
       return true;
     }
   }
 #endif /* ACE_HAS_IPV6 */
   return false;
 }

◆ is_wildcard()

OpenDDS_Dcps_Export bool OpenDDS::DCPS::is_wildcard ( const char * str )

Definition at line 100 of file DCPS_Utils.cpp.

References ACE_OS::strcspn().

 {
   static const char wild[] = "?*[";
 
   while (*str) {
     size_t i = ACE_OS::strcspn(str, wild);
 
     if (!str[i]) return false; // no wildcard
 
     if (i > 0 && str[i-1] == '\\') str += i + 1; // escaped wildcard
 
     else return true;
   }
 
   return false;
 }

◆ keyFromSample()

template<typename TopicType >

DDS::BuiltinTopicKey_t OpenDDS::DCPS::keyFromSample ( TopicType * sample )

Definition at line 235 of file BuiltInTopicUtils.h.

References DDS::BuiltinTopicKey_t::value.

Referenced by OpenDDS::DCPS::DataReaderImpl_T< MessageType >::store_instance_data().

 {
   DDS::BuiltinTopicKey_t key;
   std::memset(key.value, 0, sizeof(key.value));
   return key;
 }

◆ keyFromSample< DDS::ParticipantBuiltinTopicData >()

template<>

DDS::BuiltinTopicKey_t OpenDDS::DCPS::keyFromSample< DDS::ParticipantBuiltinTopicData > ( DDS::ParticipantBuiltinTopicData * sample )

inline

Definition at line 199 of file BuiltInTopicUtils.h.

 {
   return sample->key;
 }

◆ keyFromSample< DDS::PublicationBuiltinTopicData >()

template<>

DDS::BuiltinTopicKey_t OpenDDS::DCPS::keyFromSample< DDS::PublicationBuiltinTopicData > ( DDS::PublicationBuiltinTopicData * sample )

inline

Definition at line 226 of file BuiltInTopicUtils.h.

 {
   return sample->key;
 }

◆ keyFromSample< DDS::SubscriptionBuiltinTopicData >()

template<>

DDS::BuiltinTopicKey_t OpenDDS::DCPS::keyFromSample< DDS::SubscriptionBuiltinTopicData > ( DDS::SubscriptionBuiltinTopicData * sample )

inline

Definition at line 217 of file BuiltInTopicUtils.h.

 {
   return sample->key;
 }

◆ keyFromSample< DDS::TopicBuiltinTopicData >()

template<>

DDS::BuiltinTopicKey_t OpenDDS::DCPS::keyFromSample< DDS::TopicBuiltinTopicData > ( DDS::TopicBuiltinTopicData * sample )

inline

Definition at line 208 of file BuiltInTopicUtils.h.

 {
   return sample->key;
 }

◆ kind_to_string()

const char * OpenDDS::DCPS::kind_to_string ( const XTypes::EquivalenceKind ek )

Definition at line 166 of file TypeSupportImpl.cpp.

References OpenDDS::XTypes::EK_MINIMAL, and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

Referenced by OpenDDS::DCPS::TypeSupportImpl_T< NativeType >::key_only_serialized_size_bound(), OpenDDS::DCPS::TypeSupportImpl::populate_dependencies_i(), and OpenDDS::DCPS::TypeSupportImpl::to_type_info_i().

 {
   return ek == XTypes::EK_MINIMAL ? "minimal" : "complete";
 }

◆ locator_to_address()

OpenDDS_Dcps_Export int OpenDDS::DCPS::locator_to_address	(	ACE_INET_Addr &	dest,
		const DCPS::Locator_t &	locator,
		bool	map
	)

Definition at line 857 of file NetworkResource.cpp.

References OpenDDS::DCPS::Locator_t::address, AF_INET, OpenDDS::DCPS::Locator_t::kind, LOCATOR_KIND_UDPv4, LOCATOR_KIND_UDPv6, OpenDDS_Dcps_Export, ACE_INET_Addr::set_address(), ACE_INET_Addr::set_port_number(), and ACE_Addr::set_type().

Referenced by address_to_bytes(), OpenDDS::RTPS::ParameterListConverter::from_param_list(), OpenDDS::DCPS::RtpsUdpTransport::get_connection_addrs(), and OpenDDS::RTPS::print_locator().

 {
   switch (locator.kind) {
 #ifdef ACE_HAS_IPV6
   case LOCATOR_KIND_UDPv6:
     dest.set_type(AF_INET6);
     if (dest.set_address(reinterpret_cast<const char*>(locator.address),
                          16, 0 /*encode*/) == -1) {
       return -1;
     }
     dest.set_port_number(locator.port);
     return 0;
 #endif
   case LOCATOR_KIND_UDPv4:
 #if !defined (ACE_HAS_IPV6) || !defined (IPV6_V6ONLY)
     ACE_UNUSED_ARG(map);
 #endif
     dest.set_type(AF_INET);
     if (dest.set_address(reinterpret_cast<const char*>(locator.address)
                          + 12, 4, 0 /*network order*/
 #if defined (ACE_HAS_IPV6) && defined (IPV6_V6ONLY)
                          , map ? 1 : 0 /*map IPV4 to IPV6 addr*/
 #endif
     ) == -1) {
       return -1;
     }
     dest.set_port_number(locator.port);
     return 0;
   default:
     return -1;  // Unknown kind
   }
 
   return -1;
 }

◆ log_level()

OpenDDS_Dcps_Export LogLevel OpenDDS::DCPS::log_level ( LogLevel::Warning )

◆ log_progress()

void OpenDDS_Dcps_Export OpenDDS::DCPS::log_progress	(	const char *	activity,
		const GUID_t &	local,
		const GUID_t &	remote,
		const MonotonicTime_t &	start_time,
		const GUID_t &	reference
	)

Definition at line 20 of file Logging.cpp.

References ACE_DEBUG, duration_to_time_value(), LM_INFO, OpenDDS::DCPS::TimePoint_T< MonotonicClock >::now(), and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

Referenced by OpenDDS::DCPS::RtpsUdpDataLink::associated(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsWriter::end_historic_samples_i(), OpenDDS::RTPS::Spdp::handle_participant_crypto_tokens(), OpenDDS::RTPS::Spdp::handle_participant_data(), OpenDDS::RTPS::Spdp::match_authenticated(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsWriter::process_acknack(), OpenDDS::RTPS::Sedp::process_discovered_reader_data(), OpenDDS::RTPS::Sedp::process_discovered_writer_data(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsReader::process_heartbeat_i(), OpenDDS::RTPS::Sedp::TypeLookupReplyReader::process_type_lookup_reply(), and OpenDDS::RTPS::Sedp::TypeLookupRequestWriter::send_type_lookup_request().

 {
   ACE_DEBUG((LM_INFO, "(%P|%t) {transport_debug.log_progress} local: %C remote: %C reference: %C time(ms): %Lu activity: %C\n",
              DCPS::LogGuid(local).c_str(), DCPS::LogGuid(remote).c_str(), DCPS::LogGuid(reference).c_str(),
              duration_to_time_value(MonotonicTimePoint::now().to_monotonic_time() - start_time).msec(),
              activity));
 }

◆ make_field_cmp()

template<class Sample , class Field >

ComparatorBase::Ptr OpenDDS::DCPS::make_field_cmp	(	Field Sample::*	mp,
		ComparatorBase::Ptr	next
	)

Definition at line 79 of file Comparator_T.h.

 {
   return make_rch<FieldComparator<Sample, Field> >(mp, next);
 }

◆ make_id() [1/2]

GUID_t OpenDDS::DCPS::make_id	(	const GuidPrefix_t &	prefix,
		const EntityId_t &	entity
	)

inline

Definition at line 219 of file GuidUtils.h.

References assign().

 {
   GUID_t id;
   assign(id.guidPrefix, prefix);
   id.entityId = entity;
   return id;
 }

◆ make_id() [2/2]

GUID_t OpenDDS::DCPS::make_id	(	const GUID_t &	participant_id,
		const EntityId_t &	entity
	)

inline

Definition at line 227 of file GuidUtils.h.

References OpenDDS::DCPS::GUID_t::entityId, and OpenDDS_Dcps_Export.

 {
   GUID_t id = participant_id;
   id.entityId = entity;
   return id;
 }

◆ make_part_guid() [1/2]

OpenDDS_Dcps_Export GUID_t OpenDDS::DCPS::make_part_guid ( const GuidPrefix_t & prefix )

inline

Definition at line 235 of file GuidUtils.h.

References make_id(), and OpenDDS_Dcps_Export.

Referenced by OpenDDS::RTPS::Spdp::data_received(), OpenDDS::RTPS::Sedp::data_received(), OpenDDS::RTPS::Sedp::DiscoveryReader::data_received_i(), OpenDDS::RTPS::DiscoveredParticipant::DiscoveredParticipant(), OpenDDS::RTPS::Spdp::get_participant_data(), OpenDDS::RTPS::Spdp::get_participant_discovered_at(), OpenDDS::RTPS::Spdp::handle_participant_data(), make_part_guid(), OpenDDS::RTPS::Sedp::notify_liveliness(), OpenDDS::RTPS::Sedp::process_discovered_writer_data(), OpenDDS::RTPS::Sedp::received_participant_message_data_secure(), and OpenDDS::RTPS::ParameterListConverter::to_param_list().

 {
   return make_id(prefix, ENTITYID_PARTICIPANT);
 }

◆ make_part_guid() [2/2]

OpenDDS_Dcps_Export GUID_t OpenDDS::DCPS::make_part_guid ( const GUID_t & guid )

inline

Definition at line 241 of file GuidUtils.h.

References OpenDDS::DCPS::GUID_t::guidPrefix, make_part_guid(), and OpenDDS_Dcps_Export.

 {
   return make_part_guid(guid.guidPrefix);
 }

◆ make_rch() [1/9]

template<typename T >

RcHandle<T> OpenDDS::DCPS::make_rch ( )

Definition at line 256 of file RcHandle_T.h.

 {
   return RcHandle<T>(new T(), keep_count());
 }

◆ make_rch() [2/9]

template<typename T , typename U >

RcHandle<T> OpenDDS::DCPS::make_rch ( U const & u )

Definition at line 262 of file RcHandle_T.h.

References unwrap_reference().

 {
   return RcHandle<T>(new T(unwrap_reference(u)), keep_count());
 }

◆ make_rch() [3/9]

template<typename T , typename U0 , typename U1 >

RcHandle<T> OpenDDS::DCPS::make_rch	(	U0 const &	u0,
		U1 const &	u1
	)

Definition at line 268 of file RcHandle_T.h.

References unwrap_reference().

 {
   return RcHandle<T>(new T(unwrap_reference(u0), unwrap_reference(u1)), keep_count());
 }

◆ make_rch() [4/9]

template<typename T , typename U0 , typename U1 , typename U2 >

RcHandle<T> OpenDDS::DCPS::make_rch	(	U0 const &	u0,
		U1 const &	u1,
		U2 const &	u2
	)

Definition at line 274 of file RcHandle_T.h.

References unwrap_reference().

 {
   return RcHandle<T>(new T(unwrap_reference(u0), unwrap_reference(u1), unwrap_reference(u2)), keep_count());
 }

◆ make_rch() [5/9]

template<typename T , typename U0 , typename U1 , typename U2 , typename U3 >

RcHandle<T> OpenDDS::DCPS::make_rch	(	U0 const &	u0,
		U1 const &	u1,
		U2 const &	u2,
		U3 const &	u3
	)

Definition at line 280 of file RcHandle_T.h.

References unwrap_reference().

 {
   return RcHandle<T>(new T(unwrap_reference(u0), unwrap_reference(u1), unwrap_reference(u2), unwrap_reference(u3)), keep_count());
 }

◆ make_rch() [6/9]

template<typename T , typename U0 , typename U1 , typename U2 , typename U3 , typename U4 >

RcHandle<T> OpenDDS::DCPS::make_rch	(	U0 const &	u0,
		U1 const &	u1,
		U2 const &	u2,
		U3 const &	u3,
		U4 const &	u4
	)

Definition at line 286 of file RcHandle_T.h.

References unwrap_reference().

 {
   return RcHandle<T>(new T(unwrap_reference(u0), unwrap_reference(u1), unwrap_reference(u2), unwrap_reference(u3), unwrap_reference(u4)), keep_count());
 }

◆ make_rch() [7/9]

template<typename T , typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 >

RcHandle<T> OpenDDS::DCPS::make_rch	(	U0 const &	u0,
		U1 const &	u1,
		U2 const &	u2,
		U3 const &	u3,
		U4 const &	u4,
		U5 const &	u5
	)

Definition at line 292 of file RcHandle_T.h.

References unwrap_reference().

 {
   return RcHandle<T>(new T(unwrap_reference(u0), unwrap_reference(u1), unwrap_reference(u2), unwrap_reference(u3), unwrap_reference(u4), unwrap_reference(u5)), keep_count());
 }

◆ make_rch() [8/9]

template<typename T , typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 >

RcHandle<T> OpenDDS::DCPS::make_rch	(	U0 const &	u0,
		U1 const &	u1,
		U2 const &	u2,
		U3 const &	u3,
		U4 const &	u4,
		U5 const &	u5,
		U6 const &	u6
	)

Definition at line 298 of file RcHandle_T.h.

References unwrap_reference().

 {
   return RcHandle<T>(new T(unwrap_reference(u0), unwrap_reference(u1), unwrap_reference(u2), unwrap_reference(u3), unwrap_reference(u4), unwrap_reference(u5), unwrap_reference(u6)), keep_count());
 }

◆ make_rch() [9/9]

template<typename T , typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 >

RcHandle<T> OpenDDS::DCPS::make_rch	(	U0 const &	u0,
		U1 const &	u1,
		U2 const &	u2,
		U3 const &	u3,
		U4 const &	u4,
		U5 const &	u5,
		U6 const &	u6,
		U7 const &	u7
	)

Definition at line 304 of file RcHandle_T.h.

References unwrap_reference().

 {
   return RcHandle<T>(new T(unwrap_reference(u0), unwrap_reference(u1), unwrap_reference(u2), unwrap_reference(u3), unwrap_reference(u4), unwrap_reference(u5), unwrap_reference(u6), unwrap_reference(u7)), keep_count());
 }

◆ make_struct_cmp()

template<class Sample , class Field >

ComparatorBase::Ptr OpenDDS::DCPS::make_struct_cmp	(	Field Sample::*	mp,
		ComparatorBase::Ptr	delegate,
		ComparatorBase::Ptr	next
	)

Definition at line 121 of file Comparator_T.h.

References OPENDDS_END_VERSIONED_NAMESPACE_DECL.

 {
   return make_rch<StructComparator<Sample, Field> >(mp, delegate, next);
 }

◆ make_unknown_guid() [1/2]

OpenDDS_Dcps_Export GUID_t OpenDDS::DCPS::make_unknown_guid ( const GuidPrefix_t & prefix )

inline

Definition at line 247 of file GuidUtils.h.

References make_id(), and OpenDDS_Dcps_Export.

Referenced by OpenDDS::DCPS::RtpsUdpDataLink::build_meta_submessage_map(), OpenDDS::DCPS::RtpsUdpDataLink::bundle_and_send_submessages(), OpenDDS::RTPS::Sedp::disassociate(), make_unknown_guid(), and OpenDDS::RTPS::Sedp::notify_liveliness().

 {
   return make_id(prefix, ENTITYID_UNKNOWN);
 }

◆ make_unknown_guid() [2/2]

OpenDDS_Dcps_Export GUID_t OpenDDS::DCPS::make_unknown_guid ( const GUID_t & guid )

inline

Definition at line 253 of file GuidUtils.h.

References OpenDDS::DCPS::GUID_t::guidPrefix, intersect(), make_unknown_guid(), and OpenDDS_Dcps_Export.

 {
   return make_unknown_guid(guid.guidPrefix);
 }

◆ matches_default()

bool OpenDDS::DCPS::matches_default ( const DDS::PartitionQosPolicy & qos )

Definition at line 156 of file DCPS_Utils.cpp.

References DDS::PartitionQosPolicy::name.

Referenced by matching_partitions().

 {
   if (qos.name.length() == 0)
     return true; // default
 
   for (CORBA::ULong i = 0; i < qos.name.length(); ++i) {
     if (*qos.name[i] == 0)
       return true; // default (empty string)
   }
 
   return false;
 }

◆ matches_name()

bool OpenDDS::DCPS::matches_name	(	const DDS::PartitionQosPolicy &	qos,
		const PartitionName &	name
	)

Definition at line 143 of file DCPS_Utils.cpp.

References OpenDDS::DCPS::PartitionName::matches(), and DDS::PartitionQosPolicy::name.

Referenced by matching_partitions().

 {
   for (CORBA::ULong i = 0; i < qos.name.length(); ++i) {
     PartitionName qos_name(qos.name[i]);
 
     if (qos_name.matches(name))
       return true;
   }
 
   return false;
 }

◆ matching_partitions()

OpenDDS_Dcps_Export bool OpenDDS::DCPS::matching_partitions	(	const DDS::PartitionQosPolicy &	pub,
		const DDS::PartitionQosPolicy &	sub
	)

Definition at line 170 of file DCPS_Utils.cpp.

References matches_default(), matches_name(), name, and DDS::PartitionQosPolicy::name.

Referenced by compatibleQOS().

 {
   if (matches_default(pub)) {
     if (matches_default(sub))
       return true;
 
     // Zero-length sequences should be treated the same as a
     // sequence of length 1 that contains an empty string:
     if (pub.name.length() == 0)
       return matches_name(sub, "");
   }
 
   for (CORBA::ULong i = 0; i < pub.name.length(); ++i) {
     const char* name = pub.name[i];
 
     if (matches_name(sub, name))
       return true;
   }
 
   return false;
 }

◆ MD5Hash()

OpenDDS_Dcps_Export void OpenDDS::DCPS::MD5Hash	(	MD5Result &	result,
		const void *	input,
		size_t	size
	)

Definition at line 323 of file Hash.cpp.

References OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL::MD5_Final(), OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL::MD5_Init(), OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL::MD5_Update(), and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

Referenced by OpenDDS::XTypes::hash_member_name(), OpenDDS::XTypes::hash_member_name_to_id(), OpenDDS::XTypes::makeTypeIdentifier(), OpenDDS::RTPS::marshal_key_hash(), OpenDDS::XTypes::MinimalMemberDetail::MinimalMemberDetail(), and typeobject_generator::strong_connect().

 {
   MD5_CTX ctx;
   MD5_Init(&ctx);
   MD5_Update(&ctx, input, static_cast<unsigned long>(size));
   MD5_Final(result, &ctx);
 }

◆ microseconds_to_uint32_fractional_seconds()

ACE_INLINE OpenDDS_Dcps_Export ACE_UINT32 OpenDDS::DCPS::microseconds_to_uint32_fractional_seconds ( ACE_UINT32 fraction )

Definition at line 284 of file Time_Helper.inl.

 {
   return static_cast<ACE_UINT32>((static_cast<ACE_UINT64>(usec) << 32) / 1000000);
 }

◆ monotonic_time_zero()

ACE_INLINE OpenDDS_Dcps_Export const MonotonicTime_t & OpenDDS::DCPS::monotonic_time_zero ( )

Definition at line 296 of file Time_Helper.inl.

References OPENDDS_END_VERSIONED_NAMESPACE_DECL.

 {
   static const MonotonicTime_t zero = { 0, 0 };
   return zero;
 }

◆ move() [1/2]

template<typename T >

T::rv_reference OpenDDS::DCPS::move ( T & p )

Definition at line 146 of file unique_ptr.h.

 {
   return static_cast<typename T::rv_reference>(p);
 }

◆ move() [2/2]

template<typename T >

unique_ptr<T>::rv_reference OpenDDS::DCPS::move ( container_supported_unique_ptr< T > & ptr )

Definition at line 338 of file unique_ptr.h.

References OPENDDS_ASSERT, and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

 {
   OPENDDS_ASSERT(ptr->ref_count() == 1);
   return reinterpret_cast<typename unique_ptr<T>::rv_reference>(ptr);
 }

◆ nanoseconds_to_uint32_fractional_seconds()

ACE_INLINE OpenDDS_Dcps_Export ACE_UINT32 OpenDDS::DCPS::nanoseconds_to_uint32_fractional_seconds ( ACE_UINT32 fraction )

Definition at line 272 of file Time_Helper.inl.

References ACE_INLINE, and OpenDDS_Dcps_Export.

Referenced by OpenDDS::DCPS::RtpsSampleHeader::payload_byte_order().

 {
   return static_cast<ACE_UINT32>((static_cast<ACE_UINT64>(nsec) << 32) / 1000000000);
 }

◆ nibble_to_hex_char()

static char OpenDDS::DCPS::nibble_to_hex_char ( char nibble )

inlinestatic

Definition at line 125 of file SafetyProfileStreams.cpp.

Referenced by to_hex_dds_string().

 {
   nibble &= 0x0F;
   return ((nibble < 0xA) ? '0' : ('a' - 0xA)) + nibble;
 }

◆ non_negative_duration()

ACE_INLINE bool OpenDDS::DCPS::non_negative_duration ( const DDS::Duration_t & t )

Check if given duration is either infinite or greater than or equal to zero.

Definition at line 257 of file Time_Helper.inl.

References ACE_INLINE, DDS::DURATION_ZERO_NSEC, DDS::DURATION_ZERO_SEC, DDS::Duration_t::nanosec, OpenDDS_Dcps_Export, DDS::Duration_t::sec, and valid_duration().

Referenced by OpenDDS::DCPS::Qos_Helper::valid(), and DDS::WaitSet::wait().

 {
   return
     (t.sec == DDS::DURATION_ZERO_SEC  // Allow zero duration.
      && t.nanosec == DDS::DURATION_ZERO_NSEC)
     || valid_duration(t);
 }

◆ open_appropriate_socket_type()

OpenDDS_Dcps_Export bool OpenDDS::DCPS::open_appropriate_socket_type	(	ACE_SOCK_Dgram &	socket,
		const ACE_INET_Addr &	local_address,
		int *	proto_family = `0`
	)

Helper function to create dual stack socket to support IPV4 and IPV6, for IPV6 builds allows for setting IPV6_V6ONLY socket option to 0 before binding Otherwise defaults to opening a socket based on the type of local_address

Definition at line 438 of file NetworkResource.cpp.

References ACE_ERROR_RETURN, ACE_PROTOCOL_FAMILY_INET, ACE_TEXT(), ACE_OS::bind(), ACE::bind_port(), ACE_SOCK::close(), ACE_INET_Addr::get_addr(), ACE_IPC_SAP::get_handle(), ACE_Addr::get_size(), ACE_Addr::get_type(), INADDR_ANY, ACE::ipv6_enabled(), LM_WARNING, ACE_SOCK_Dgram::open(), PF_INET, PF_UNIX, PF_UNSPEC, ACE_Addr::sap_any, ACE_IPC_SAP::set_handle(), ACE_SOCK::set_option(), ACE_OS::setsockopt(), SO_REUSEADDR, SOCK_DGRAM, ACE_OS::socket(), SOL_SOCKET, and VDBG_LVL.

Referenced by OpenDDS::DCPS::UdpDataLink::open().

 {
 #if defined (ACE_HAS_IPV6) && defined (IPV6_V6ONLY)
   int protocol_family = ACE_PROTOCOL_FAMILY_INET;
   int protocol = 0;
   int reuse_addr = 0;
   if (static_cast<ACE_Addr>(local_address) != ACE_Addr::sap_any) {
     protocol_family = local_address.get_type();
   } else if (protocol_family == PF_UNSPEC) {
     protocol_family = ACE::ipv6_enabled() ? PF_INET6 : PF_INET;
   }
 
   int one = 1;
   socket.set_handle(ACE_OS::socket(protocol_family,
     SOCK_DGRAM,
     protocol));
 
   if (socket.get_handle() == ACE_INVALID_HANDLE) {
     ACE_ERROR_RETURN((LM_WARNING,
       ACE_TEXT("(%P|%t) WARNING:")
       ACE_TEXT("open_appropriate_socket_type: ")
       ACE_TEXT("failed to set socket handle\n")),
       false);
   } else if (protocol_family != PF_UNIX &&
              reuse_addr &&
              socket.set_option(SOL_SOCKET,
                                SO_REUSEADDR,
                                &one,
                                sizeof one) == -1) {
     socket.close();
     ACE_ERROR_RETURN((LM_WARNING,
       ACE_TEXT("(%P|%t) WARNING: ")
       ACE_TEXT("open_appropriate_socket_type: ")
       ACE_TEXT("failed to set socket SO_REUSEADDR option\n")),
       false);
   }
   ACE_HANDLE handle = socket.get_handle();
   int ipv6_only = 0;
   if (protocol_family == PF_INET6 &&
       0 != ACE_OS::setsockopt(handle,
                               IPPROTO_IPV6,
                               IPV6_V6ONLY,
                               (char*)&ipv6_only,
                               sizeof(ipv6_only))) {
     ACE_ERROR_RETURN((LM_WARNING,
       ACE_TEXT("(%P|%t) WARNING: ")
       ACE_TEXT("open_appropriate_socket_type: ")
       ACE_TEXT("failed to set IPV6_V6ONLY to 0: %p\n"),
       ACE_TEXT("ACE_OS::setsockopt(IPV6_V6ONLY)")),
       false);
   }
   bool error = false;
 
   if (static_cast<ACE_Addr>(local_address) == ACE_Addr::sap_any) {
     if (protocol_family == PF_INET || protocol_family == PF_INET6) {
       if (ACE::bind_port(socket.get_handle(),
                          INADDR_ANY,
                          protocol_family) == -1) {
         error = true;
       }
     }
   } else if (ACE_OS::bind(socket.get_handle(),
                           reinterpret_cast<sockaddr *> (local_address.get_addr()),
                           local_address.get_size()) == -1) {
     error = true;
   }
 
   if (error) {
     socket.close();
     VDBG_LVL((LM_WARNING, "(%P|%t) WARNING: open_appropriate_socket_type: "
                           "failed to bind address to socket\n"), 2);
     return false;
   }
   if (proto_family) {
     *proto_family = protocol_family;
   }
   return true;
 #else
   if (proto_family) {
     *proto_family = PF_INET;
   }
   return socket.open(local_address) == 0;
 #endif
 }

◆ OPENDDS_LIST()

typedef OpenDDS::DCPS::OPENDDS_LIST ( SubsectionPair )

Referenced by OpenDDS::DCPS::TransportRegistry::load_transport_configuration().

◆ OPENDDS_MAP() [1/5]

typedef OpenDDS::DCPS::OPENDDS_MAP	(	OPENDDS_STRING	,
		OPENDDS_STRING
	)

Helper types and functions for config file parsing.

Referenced by choose_single_coherent_address(), OpenDDS::DCPS::RakeResults< SampleSeq >::copy_into(), OpenDDS::DCPS::Service_Participant::default_address(), OpenDDS::DCPS::DataReaderImpl::deliver_historic(), OpenDDS::DCPS::DataReaderImpl::get_priority_value(), OpenDDS::DCPS::FilterEvaluator::SerializedForEval::lookup(), OpenDDS::DCPS::StaticEndpointManager::MatchingPair::operator<(), OpenDDS::DCPS::Service_Participant::printer_value_writer_indent(), OpenDDS::DCPS::WriterInfo::publisher_id(), OpenDDS::DCPS::DataReaderImpl::resume_sample_processing(), and OpenDDS::DCPS::PublisherImpl::wait_for_acknowledgments().

◆ OPENDDS_MAP() [2/5]

typedef OpenDDS::DCPS::OPENDDS_MAP	(	OPENDDS_STRING	,
		TypeSupport_var
	)

◆ OPENDDS_MAP() [3/5]

typedef OpenDDS::DCPS::OPENDDS_MAP	(	DDS::DomainParticipant_ptr	,
		TypeSupportMap
	)

◆ OPENDDS_MAP() [4/5]

typedef OpenDDS::DCPS::OPENDDS_MAP	(	DDS::InstanceHandle_t	,
		PublicationInstance_rch
	)

◆ OPENDDS_MAP() [5/5]

typedef OpenDDS::DCPS::OPENDDS_MAP	(	String	,
		TopicDetails
	)

◆ OPENDDS_MAP_CMP() [1/3]

typedef OpenDDS::DCPS::OPENDDS_MAP_CMP	(	PublicationId	,
		WriterCoherentSample	,
		GUID_tKeyLessThan
	)

Referenced by OpenDDS::DCPS::PublisherImpl::get_pi_lock(), OpenDDS::DCPS::StaticEndpointManager::DiscoveredSubscription::get_type_name(), OpenDDS::DCPS::StaticEndpointManager::DiscoveredPublication::get_type_name(), OpenDDS::DCPS::EndpointRegistry::Reader::Reader(), and OpenDDS::DCPS::EndpointRegistry::Writer::Writer().

◆ OPENDDS_MAP_CMP() [2/3]

typedef OpenDDS::DCPS::OPENDDS_MAP_CMP	(	RepoId	,
		DataLinkSet_rch	,
		GUID_tKeyLessThan
	)

◆ OPENDDS_MAP_CMP() [3/3]

typedef OpenDDS::DCPS::OPENDDS_MAP_CMP	(	RepoId	,
		SeqReaders	,
		GUID_tKeyLessThan
	)

◆ OPENDDS_SET()

typedef OpenDDS::DCPS::OPENDDS_SET ( NetworkAddress )

Referenced by choose_single_coherent_address(), OpenDDS::DCPS::RakeResults< SampleSeq >::copy_into(), and OpenDDS::DCPS::TypeSupportImpl::populate_dependencies_i().

◆ OPENDDS_SET_CMP()

typedef OpenDDS::DCPS::OPENDDS_SET_CMP	(	GUID_t	,
		GUID_tKeyLessThan
	)

Referenced by OpenDDS::DCPS::BuiltinTopicKey_tKeyLessThan::operator()(), and DDS::WaitSet::~WaitSet().

◆ OPENDDS_VECTOR() [1/6]

typedef OpenDDS::DCPS::OPENDDS_VECTOR ( ActionConnectionRecord )

Referenced by choose_single_coherent_address(), OpenDDS::DCPS::DataWriterImpl::data_allocator(), OpenDDS::DCPS::ReceiveListenerSet::data_received(), OpenDDS::DCPS::ReliableSession::deliver_held_data(), OpenDDS::DCPS::DataReaderImpl_T< MessageType >::filter_delayed(), OpenDDS::DCPS::DataReaderImpl::get_n_chunks(), OpenDDS::DCPS::PublisherImpl::get_pi_lock(), OpenDDS::DCPS::DataDurabilityCache::init(), OpenDDS::DCPS::DataDurabilityCache::insert(), OpenDDS::DCPS::StaticParticipant::DiscoveredParticipant::LocationUpdate::LocationUpdate(), OpenDDS::DCPS::TransportConfig::name(), OpenDDS::DCPS::InternalSampleInfo::operator==(), OpenDDS::DCPS::DataReaderImpl::ownership_manager(), OpenDDS::DCPS::RtpsUdpInst::populate_locator(), OpenDDS::DCPS::DataLinkSet::send_start(), and OpenDDS::DCPS::ThreadPerConnectionSendTask::svc().

◆ OPENDDS_VECTOR() [2/6]

typedef OpenDDS::DCPS::OPENDDS_VECTOR ( MetaSubmessage )

◆ OPENDDS_VECTOR() [3/6]

typedef OpenDDS::DCPS::OPENDDS_VECTOR ( HostnameInfo )

◆ OPENDDS_VECTOR() [4/6]

typedef OpenDDS::DCPS::OPENDDS_VECTOR ( TransportQueueElement * )

◆ OPENDDS_VECTOR() [5/6]

typedef OpenDDS::DCPS::OPENDDS_VECTOR ( RawDataSample )

◆ OPENDDS_VECTOR() [6/6]

typedef OpenDDS::DCPS::OPENDDS_VECTOR ( InternalSampleInfo )

◆ operator!()

ACE_INLINE bool OpenDDS::DCPS::operator! ( const DDS::Time_t & t )

Definition at line 77 of file Time_Helper.inl.

References ACE_INLINE, DDS::Time_t::nanosec, DDS::Time_t::sec, DDS::TIME_INVALID_NSEC, and DDS::TIME_INVALID_SEC.

 {
   return t.sec == DDS::TIME_INVALID_SEC
          || t.nanosec == DDS::TIME_INVALID_NSEC;
 }

◆ operator!=() [1/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::Duration_t &	t1,
		const DDS::Duration_t &	t2
	)

Definition at line 28 of file Time_Helper.inl.

References ACE_INLINE.

 {
   return !(t1 == t2);
 }

◆ operator!=() [2/40]

template<typename X , typename Y >

bool OpenDDS::DCPS::operator!=	(	const SafeBool_T< X > &	x,
		const SafeBool_T< Y > &
	)

Definition at line 82 of file SafeBool_T.h.

References OPENDDS_END_VERSIONED_NAMESPACE_DECL, and OpenDDS::DCPS::SafeBoolBase::this_type_does_not_support_comparisons().

 {
   x.this_type_does_not_support_comparisons();
   return false;
 }

◆ operator!=() [3/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::Time_t &	t1,
		const DDS::Time_t &	t2
	)

Definition at line 91 of file Time_Helper.inl.

References ACE_INLINE.

 {
   return !(t1 == t2);
 }

◆ operator!=() [4/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const TimeDuration &	x,
		const TimeDuration &	y
	)

Definition at line 225 of file TimeDuration.inl.

References OPENDDS_END_VERSIONED_NAMESPACE_DECL, and OpenDDS::DCPS::TimeDuration::value().

 {
   return x.value() != y.value();
 }

◆ operator!=() [5/40]

bool OpenDDS::DCPS::operator!=	(	const GUID_t &	lhs,
		const GUID_t &	rhs
	)

inline

Definition at line 138 of file GuidUtils.h.

Referenced by OpenDDS::SafetyProfile::Sequence< T, Bounds, Elts >::end(), and OpenDDS::STUN::TransactionId::TransactionId().

 {
   return !(lhs == rhs);
 }

◆ operator!=() [6/40]

template<typename AceClock >

bool OpenDDS::DCPS::operator!=	(	const TimePoint_T< AceClock > &	x,
		const TimePoint_T< AceClock > &	y
	)

Definition at line 195 of file TimePoint_T.inl.

References OPENDDS_END_VERSIONED_NAMESPACE_DECL, and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return x.value() != y.value();
 }

◆ operator!=() [7/40]

bool OpenDDS::DCPS::operator!=	(	const EntityId_t &	lhs,
		const EntityId_t &	rhs
	)

inline

Definition at line 170 of file GuidUtils.h.

 {
   return !(lhs == rhs);
 }

◆ operator!=() [8/40]

template<typename AceClock >

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const TimePoint_T< AceClock > &	x,
		const TimePoint_T< AceClock > &	y
	)

Definition at line 195 of file TimePoint_T.inl.

References OPENDDS_END_VERSIONED_NAMESPACE_DECL, and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return x.value() != y.value();
 }

◆ operator!=() [9/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::UserDataQosPolicy &	qos1,
		const DDS::UserDataQosPolicy &	qos2
	)

Definition at line 368 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [10/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::TopicDataQosPolicy &	qos1,
		const DDS::TopicDataQosPolicy &	qos2
	)

Definition at line 375 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [11/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::GroupDataQosPolicy &	qos1,
		const DDS::GroupDataQosPolicy &	qos2
	)

Definition at line 382 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [12/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::TransportPriorityQosPolicy &	qos1,
		const DDS::TransportPriorityQosPolicy &	qos2
	)

Definition at line 389 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [13/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::LifespanQosPolicy &	qos1,
		const DDS::LifespanQosPolicy &	qos2
	)

Definition at line 396 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [14/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::DurabilityQosPolicy &	qos1,
		const DDS::DurabilityQosPolicy &	qos2
	)

Definition at line 404 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [15/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::DurabilityServiceQosPolicy &	qos1,
		const DDS::DurabilityServiceQosPolicy &	qos2
	)

Definition at line 412 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [16/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::PresentationQosPolicy &	qos1,
		const DDS::PresentationQosPolicy &	qos2
	)

Definition at line 419 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [17/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::DeadlineQosPolicy &	qos1,
		const DDS::DeadlineQosPolicy &	qos2
	)

Definition at line 426 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [18/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::LatencyBudgetQosPolicy &	qos1,
		const DDS::LatencyBudgetQosPolicy &	qos2
	)

Definition at line 433 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [19/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::OwnershipQosPolicy &	qos1,
		const DDS::OwnershipQosPolicy &	qos2
	)

Definition at line 440 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [20/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::OwnershipStrengthQosPolicy &	qos1,
		const DDS::OwnershipStrengthQosPolicy &	qos2
	)

Definition at line 447 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [21/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::LivelinessQosPolicy &	qos1,
		const DDS::LivelinessQosPolicy &	qos2
	)

Definition at line 454 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [22/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::TimeBasedFilterQosPolicy &	qos1,
		const DDS::TimeBasedFilterQosPolicy &	qos2
	)

Definition at line 461 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [23/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::PartitionQosPolicy &	qos1,
		const DDS::PartitionQosPolicy &	qos2
	)

Definition at line 468 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [24/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::ReliabilityQosPolicy &	qos1,
		const DDS::ReliabilityQosPolicy &	qos2
	)

Definition at line 475 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [25/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::DestinationOrderQosPolicy &	qos1,
		const DDS::DestinationOrderQosPolicy &	qos2
	)

Definition at line 482 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [26/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::HistoryQosPolicy &	qos1,
		const DDS::HistoryQosPolicy &	qos2
	)

Definition at line 489 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [27/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::ResourceLimitsQosPolicy &	qos1,
		const DDS::ResourceLimitsQosPolicy &	qos2
	)

Definition at line 496 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [28/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::EntityFactoryQosPolicy &	qos1,
		const DDS::EntityFactoryQosPolicy &	qos2
	)

Definition at line 503 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [29/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::WriterDataLifecycleQosPolicy &	qos1,
		const DDS::WriterDataLifecycleQosPolicy &	qos2
	)

Definition at line 510 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [30/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::ReaderDataLifecycleQosPolicy &	qos1,
		const DDS::ReaderDataLifecycleQosPolicy &	qos2
	)

Definition at line 517 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [31/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::PropertyQosPolicy &	qos1,
		const DDS::PropertyQosPolicy &	qos2
	)

Definition at line 524 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [32/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::DomainParticipantQos &	qos1,
		const DDS::DomainParticipantQos &	qos2
	)

Definition at line 531 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [33/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::TopicQos &	qos1,
		const DDS::TopicQos &	qos2
	)

Definition at line 538 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [34/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::DataWriterQos &	qos1,
		const DDS::DataWriterQos &	qos2
	)

Definition at line 545 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [35/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::PublisherQos &	qos1,
		const DDS::PublisherQos &	qos2
	)

Definition at line 552 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [36/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::DataReaderQos &	qos1,
		const DDS::DataReaderQos &	qos2
	)

Definition at line 559 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [37/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::SubscriberQos &	qos1,
		const DDS::SubscriberQos &	qos2
	)

Definition at line 566 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [38/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::DomainParticipantFactoryQos &	qos1,
		const DDS::DomainParticipantFactoryQos &	qos2
	)

Definition at line 573 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [39/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::DataRepresentationQosPolicy &	qos1,
		const DDS::DataRepresentationQosPolicy &	qos2
	)

Definition at line 580 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator!=() [40/40]

ACE_INLINE bool OpenDDS::DCPS::operator!=	(	const DDS::TypeConsistencyEnforcementQosPolicy &	qos1,
		const DDS::TypeConsistencyEnforcementQosPolicy &	qos2
	)

Definition at line 587 of file Qos_Helper.inl.

References ACE_INLINE.

 {
   return !(qos1 == qos2);
 }

◆ operator*() [1/2]

ACE_INLINE TimeDuration OpenDDS::DCPS::operator*	(	double	x,
		const TimeDuration &	y
	)

Definition at line 163 of file TimeDuration.inl.

References ACE_INLINE, OpenDDS::DCPS::TimeDuration::TimeDuration(), and OpenDDS::DCPS::TimeDuration::value().

Referenced by OpenDDS::DCPS::SendStateDataSampleListConstIterator::SendStateDataSampleListConstIterator(), and OpenDDS::DCPS::SendStateDataSampleListIterator::SendStateDataSampleListIterator().

 {
   return TimeDuration(x * y.value());
 }

◆ operator*() [2/2]

ACE_INLINE TimeDuration OpenDDS::DCPS::operator*	(	const TimeDuration &	x,
		double	y
	)

Definition at line 170 of file TimeDuration.inl.

References ACE_INLINE, OpenDDS::DCPS::TimeDuration::TimeDuration(), and OpenDDS::DCPS::TimeDuration::value().

 {
   return TimeDuration(x.value() * y);
 }

◆ operator+() [1/7]

ACE_INLINE TimeDuration OpenDDS::DCPS::operator+	(	const TimeDuration &	x,
		const TimeDuration &	y
	)

Definition at line 142 of file TimeDuration.inl.

References ACE_INLINE, OpenDDS::DCPS::TimeDuration::TimeDuration(), and OpenDDS::DCPS::TimeDuration::value().

 {
   return TimeDuration(x.value() + y.value());
 }

◆ operator+() [2/7]

template<typename AceClock >

TimePoint_T<AceClock> OpenDDS::DCPS::operator+	(	const TimeDuration &	x,
		const TimePoint_T< AceClock > &	y
	)

Definition at line 123 of file TimePoint_T.inl.

References ACE_INLINE, OpenDDS::DCPS::TimeDuration::value(), and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return TimePoint_T<AceClock>(x.value() + y.value());
 }

◆ operator+() [3/7]

template<typename AceClock >

ACE_INLINE TimePoint_T<AceClock> OpenDDS::DCPS::operator+	(	const TimeDuration &	x,
		const TimePoint_T< AceClock > &	y
	)

Definition at line 123 of file TimePoint_T.inl.

References ACE_INLINE, OpenDDS::DCPS::TimeDuration::value(), and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return TimePoint_T<AceClock>(x.value() + y.value());
 }

◆ operator+() [4/7]

template<typename AceClock >

TimePoint_T<AceClock> OpenDDS::DCPS::operator+	(	const TimePoint_T< AceClock > &	x,
		const TimeDuration &	y
	)

Definition at line 131 of file TimePoint_T.inl.

References ACE_INLINE, OpenDDS::DCPS::TimeDuration::value(), and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return TimePoint_T<AceClock>(x.value() + y.value());
 }

◆ operator+() [5/7]

template<typename AceClock >

ACE_INLINE TimePoint_T<AceClock> OpenDDS::DCPS::operator+	(	const TimePoint_T< AceClock > &	x,
		const TimeDuration &	y
	)

Definition at line 131 of file TimePoint_T.inl.

References ACE_INLINE, OpenDDS::DCPS::TimeDuration::value(), and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return TimePoint_T<AceClock>(x.value() + y.value());
 }

◆ operator+() [6/7]

SequenceNumber OpenDDS::DCPS::operator+	(	const SequenceNumber &	lhs,
		int	rhs
	)

inline

Definition at line 178 of file SequenceNumber.h.

References OpenDDS::DCPS::SequenceNumber::getValue().

 {
   return SequenceNumber(lhs.getValue() + rhs);
 }

◆ operator+() [7/7]

SequenceNumber OpenDDS::DCPS::operator+	(	int	lhs,
		const SequenceNumber &	rhs
	)

inline

Definition at line 191 of file SequenceNumber.h.

 {
   return rhs + lhs;
 }

◆ operator+=()

SequenceNumber OpenDDS::DCPS::operator+=	(	SequenceNumber &	lhs,
		int	rhs
	)

inline

Definition at line 184 of file SequenceNumber.h.

References OpenDDS::DCPS::SequenceNumber::getValue(), and OpenDDS::DCPS::SequenceNumber::setValue().

Referenced by OpenDDS::DCPS::TimeDuration::sec_str().

 {
   lhs.setValue(lhs.getValue() + rhs);
   return lhs;
 }

◆ operator-() [1/9]

ACE_INLINE DDS::Duration_t OpenDDS::DCPS::operator-	(	const DDS::Time_t &	t1,
		const DDS::Time_t &	t2
	)

Definition at line 125 of file Time_Helper.inl.

References ACE_INLINE, ACE_ONE_SECOND_IN_NSECS, DDS::Duration_t::nanosec, DDS::Time_t::nanosec, DDS::Duration_t::sec, and DDS::Time_t::sec.

 {
   DDS::Duration_t t = { t1.sec - t2.sec, t1.nanosec - t2.nanosec };
 
   if (t2.nanosec > t1.nanosec) {
       t.nanosec = (t1.nanosec + ACE_ONE_SECOND_IN_NSECS) - t2.nanosec;
       t.sec = (t1.sec - 1) - t2.sec;
     }
 
   return t;
 }

◆ operator-() [2/9]

ACE_INLINE DDS::Time_t OpenDDS::DCPS::operator-	(	const DDS::Time_t &	t1,
		const DDS::Duration_t &	t2
	)

Definition at line 138 of file Time_Helper.inl.

References ACE_INLINE, ACE_ONE_SECOND_IN_NSECS, DDS::Duration_t::nanosec, DDS::Time_t::nanosec, DDS::Duration_t::sec, and DDS::Time_t::sec.

 {
   DDS::Time_t t = { t1.sec - t2.sec, t1.nanosec - t2.nanosec };
 
   if (t2.nanosec > t1.nanosec) {
       t.nanosec = (t1.nanosec + ACE_ONE_SECOND_IN_NSECS) - t2.nanosec;
       t.sec = (t1.sec - 1) - t2.sec;
     }
 
   return t;
 }

◆ operator-() [3/9]

ACE_INLINE DDS::Duration_t OpenDDS::DCPS::operator-	(	const MonotonicTime_t &	t1,
		const MonotonicTime_t &	t2
	)

Definition at line 151 of file Time_Helper.inl.

References ACE_INLINE, ACE_ONE_SECOND_IN_NSECS, OpenDDS::DCPS::MonotonicTime_t::nanosec, DDS::Duration_t::nanosec, OpenDDS::DCPS::MonotonicTime_t::sec, and DDS::Duration_t::sec.

 {
   DDS::Duration_t t = { t1.sec - t2.sec, t1.nanosec - t2.nanosec };
 
   if (t2.nanosec > t1.nanosec) {
       t.nanosec = (t1.nanosec + ACE_ONE_SECOND_IN_NSECS) - t2.nanosec;
       t.sec = (t1.sec - 1) - t2.sec;
     }
 
   return t;
 }

◆ operator-() [4/9]

ACE_INLINE TimeDuration OpenDDS::DCPS::operator-	(	const TimeDuration &	x,
		const TimeDuration &	y
	)

Definition at line 149 of file TimeDuration.inl.

References ACE_INLINE, OpenDDS::DCPS::TimeDuration::TimeDuration(), and OpenDDS::DCPS::TimeDuration::value().

 {
   return TimeDuration(x.value() - y.value());
 }

◆ operator-() [5/9]

ACE_INLINE TimeDuration OpenDDS::DCPS::operator- ( const TimeDuration & x )

Definition at line 156 of file TimeDuration.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimeDuration::zero_value.

 {
   return TimeDuration::zero_value - x;
 }

◆ operator-() [6/9]

template<typename AceClock >

TimeDuration OpenDDS::DCPS::operator-	(	const TimePoint_T< AceClock > &	x,
		const TimePoint_T< AceClock > &	y
	)

Definition at line 139 of file TimePoint_T.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return TimeDuration(x.value() - y.value());
 }

◆ operator-() [7/9]

template<typename AceClock >

TimePoint_T<AceClock> OpenDDS::DCPS::operator-	(	const TimePoint_T< AceClock > &	x,
		const TimeDuration &	y
	)

Definition at line 147 of file TimePoint_T.inl.

References ACE_INLINE, OpenDDS::DCPS::TimeDuration::value(), and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return TimePoint_T<AceClock>(x.value() - y.value());
 }

◆ operator-() [8/9]

template<typename AceClock >

ACE_INLINE TimeDuration OpenDDS::DCPS::operator-	(	const TimePoint_T< AceClock > &	x,
		const TimePoint_T< AceClock > &	y
	)

Definition at line 139 of file TimePoint_T.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return TimeDuration(x.value() - y.value());
 }

◆ operator-() [9/9]

template<typename AceClock >

ACE_INLINE TimePoint_T<AceClock> OpenDDS::DCPS::operator-	(	const TimePoint_T< AceClock > &	x,
		const TimeDuration &	y
	)

Definition at line 147 of file TimePoint_T.inl.

References ACE_INLINE, OpenDDS::DCPS::TimeDuration::value(), and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return TimePoint_T<AceClock>(x.value() - y.value());
 }

◆ operator/() [1/2]

ACE_INLINE TimeDuration OpenDDS::DCPS::operator/	(	const TimeDuration &	x,
		double	y
	)

Definition at line 176 of file TimeDuration.inl.

References ACE_INLINE, OpenDDS::DCPS::TimeDuration::TimeDuration(), and OpenDDS::DCPS::TimeDuration::value().

 {
   return TimeDuration(x.value() * (1.0 / y));
 }

◆ operator/() [2/2]

ACE_INLINE double OpenDDS::DCPS::operator/	(	const TimeDuration &	x,
		const TimeDuration &	y
	)

Definition at line 182 of file TimeDuration.inl.

References ACE_INLINE, ACE_Time_Value::sec(), ACE_Time_Value::usec(), and OpenDDS::DCPS::TimeDuration::value().

 {
   return (double(x.value().sec()) * 1000000 + x.value().usec()) /
          (double(y.value().sec()) * 1000000 + y.value().usec());
 }

◆ operator<() [1/7]

ACE_INLINE bool OpenDDS::DCPS::operator<	(	const DDS::Duration_t &	t1,
		const DDS::Duration_t &	t2
	)

Definition at line 35 of file Time_Helper.inl.

References ACE_INLINE, is_infinite(), DDS::Duration_t::nanosec, and DDS::Duration_t::sec.

 {
   // @note We wouldn't have to handle the case for INFINITY explicitly
   //       if both the Duration_t sec and nanosec fields were the
   //       maximum values for their corresponding types.
   //       Unfortunately, the OMG DDS specification defines the
   //       infinite nanosec value to be somewhere in the middle.
 
   // We assume that either both the DDS::Duration_t::sec and
   // DDS::Duration_t::nanosec fields are INFINITY or neither of them
   // are.  It doesn't make sense for only one of the fields to be
   // INFINITY.
   return
     !is_infinite(t1)
     && (is_infinite(t2)
         || t1.sec < t2.sec
         || (t1.sec == t2.sec && t1.nanosec < t2.nanosec));
 }

◆ operator<() [2/7]

ACE_INLINE bool OpenDDS::DCPS::operator<	(	const DDS::Time_t &	t1,
		const DDS::Time_t &	t2
	)

Definition at line 98 of file Time_Helper.inl.

References ACE_INLINE, DDS::Time_t::nanosec, and DDS::Time_t::sec.

 {
   if (!t1 || !t2) return false;
 
   return t1.sec < t2.sec
          || (t1.sec == t2.sec && t1.nanosec < t2.nanosec);
 }

◆ operator<() [3/7]

ACE_INLINE bool OpenDDS::DCPS::operator<	(	const MonotonicTime_t &	t1,
		const MonotonicTime_t &	t2
	)

Definition at line 164 of file Time_Helper.inl.

References ACE_INLINE, OpenDDS::DCPS::MonotonicTime_t::nanosec, and OpenDDS::DCPS::MonotonicTime_t::sec.

 {
   return t1.sec < t2.sec || (t1.sec == t2.sec && t1.nanosec < t2.nanosec);
 }

◆ operator<() [4/7]

ACE_INLINE bool OpenDDS::DCPS::operator<	(	const TimeDuration &	x,
		const TimeDuration &	y
	)

Definition at line 190 of file TimeDuration.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimeDuration::value().

 {
   return x.value() < y.value();
 }

◆ operator<() [5/7]

template<typename AceClock >

bool OpenDDS::DCPS::operator<	(	const TimePoint_T< AceClock > &	x,
		const TimePoint_T< AceClock > &	y
	)

Definition at line 155 of file TimePoint_T.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return x.value() < y.value();
 }

◆ operator<() [6/7]

bool OpenDDS::DCPS::operator<	(	const GUID_t &	lhs,
		const GUID_t &	rhs
	)

inline

Definition at line 145 of file GuidUtils.h.

References OpenDDS_Dcps_Export.

Referenced by OpenDDS::XTypes::PlainArrayLElemDefn::PlainArrayLElemDefn(), OpenDDS::XTypes::PlainArraySElemDefn::PlainArraySElemDefn(), OpenDDS::XTypes::PlainMapLTypeDefn::PlainMapLTypeDefn(), OpenDDS::XTypes::PlainMapSTypeDefn::PlainMapSTypeDefn(), OpenDDS::XTypes::PlainSequenceLElemDefn::PlainSequenceLElemDefn(), OpenDDS::XTypes::PlainSequenceSElemDefn::PlainSequenceSElemDefn(), OpenDDS::RTPS::Spdp::process_location_updates_i(), and OpenDDS::STUN::TransactionId::TransactionId().

 {
   return GUID_tKeyLessThan()(lhs, rhs);
 }

◆ operator<() [7/7]

template<typename AceClock >

ACE_INLINE bool OpenDDS::DCPS::operator<	(	const TimePoint_T< AceClock > &	x,
		const TimePoint_T< AceClock > &	y
	)

Definition at line 155 of file TimePoint_T.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return x.value() < y.value();
 }

◆ operator<<() [1/157]

template<typename DatumType >

ACE_INLINE std::ostream& OpenDDS::DCPS::operator<<	(	std::ostream &	str,
		const DataCollector< DatumType > &	value
	)

Insert collected data onto an ostream.

Definition at line 16 of file DataCollector_T.inl.

References ACE_INLINE.

 {
   return value.insert(str);
 }

◆ operator<<() [2/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::TypeLookup_getTypes_In &	stru
	)

Definition at line 25 of file TypeLookup.cpp.

References OpenDDS::STUN::encoding(), OpenDDS::DCPS::Serializer::encoding(), serialized_size(), OpenDDS::XTypes::TypeLookup_getTypes_In::type_ids, OpenDDS::DCPS::Serializer::write_delimiter(), and OpenDDS::DCPS::Serializer::write_parameter_id().

 {
   const Encoding& encoding = strm.encoding();
   size_t total_size = 0;
   serialized_size(encoding, total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   size_t size = 0;
 
   serialized_size(encoding, size, stru.type_ids);
   if (!strm.write_parameter_id(206790757, size)) {
     return false;
   }
 
   return strm << stru.type_ids;
 }

◆ operator<<() [3/157]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator<<	(	ACE_Message_Block &	buffer,
		const TransportHeader &	value
	)

Definition at line 28 of file TransportHeader.cpp.

 {
   Serializer writer(&buffer, Encoding::KIND_UNALIGNED_CDR);
 
   if (!writer.write_octet_array(value.protocol_, sizeof(value.protocol_)))
     return false;
 
   const ACE_CDR::Octet flags =
     (value.byte_order_ << TransportHeader::BYTE_ORDER_FLAG) |
     (value.first_fragment_ << TransportHeader::FIRST_FRAGMENT_FLAG) |
     (value.last_fragment_ << TransportHeader::LAST_FRAGMENT_FLAG);
 
   return (writer << ACE_OutputCDR::from_octet(flags)) &&
          (writer << ACE_OutputCDR::from_octet(value.reserved_)) &&
          (writer << value.length_) &&
          (writer << value.sequence_) &&
          (writer << value.source_);
 }

◆ operator<<() [4/157]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator<<	(	Serializer &	serializer,
		CoherentChangeControl &	value
	)

Marshal/Insertion into a buffer.

Definition at line 36 of file CoherentChangeControl.cpp.

References OpenDDS::DCPS::CoherentChangeControl::coherent_samples_, OpenDDS::DCPS::Serializer::good_bit(), OpenDDS::DCPS::CoherentChangeControl::group_coherent_, OpenDDS::DCPS::CoherentChangeControl::group_coherent_samples_, OpenDDS::DCPS::WriterCoherentSample::last_sample_, OpenDDS::DCPS::WriterCoherentSample::num_samples_, and OpenDDS::DCPS::CoherentChangeControl::publisher_id_.

Referenced by address_to_bytes(), assign(), OpenDDS::DCPS::Serializer::current(), operator<<(), and OpenDDS::DCPS::TransportHeader::sequence().

 {
   if (!(serializer << value.coherent_samples_.num_samples_) ||
       !(serializer << value.coherent_samples_.last_sample_) ||
       !(serializer << ACE_OutputCDR::from_boolean(value.group_coherent_))) {
     return false;
   }
 
   if (value.group_coherent_) {
     if (!(serializer << value.publisher_id_) ||
         !(serializer << static_cast<ACE_UINT32>(value.group_coherent_samples_.size()))) {
       return false;
     }
     GroupCoherentSamples::iterator itEnd = value.group_coherent_samples_.end();
     for (GroupCoherentSamples::iterator it =
            value.group_coherent_samples_.begin(); it != itEnd; ++it) {
       if (!(serializer << it->first) ||
           !(serializer << it->second.num_samples_) ||
           !(serializer << it->second.last_sample_)) {
         return false;
       }
     }
   }
 
   return serializer.good_bit();
 }

◆ operator<<() [5/157]

ostream& OpenDDS::DCPS::operator<<	(	ostream &	os,
		const ACE_CDR::LongDouble &	val
	)

inline

Definition at line 42 of file ValueHelper.h.

 {
   os << ACE_CDR::LongDouble::NativeImpl(val);
   return os;
 }

◆ operator<<() [6/157]

OpenDDS_Dcps_Export std::ostream & OpenDDS::DCPS::operator<<	(	std::ostream &	os,
		const GUID_t &	rhs
	)

Definition at line 69 of file GuidUtils.cpp.

References OpenDDS::DCPS::GUID_t::entityId, OpenDDS::DCPS::EntityId_t::entityKey, OpenDDS::DCPS::EntityId_t::entityKind, and OpenDDS::DCPS::GUID_t::guidPrefix.

 {
   RestoreOutputStreamState os_state(os);
 
   std::size_t len = sizeof(rhs.guidPrefix);
 
   os << std::hex;
 
   for (std::size_t i = 0; i < len; ++i) {
     os << setopts << unsigned(rhs.guidPrefix[i]);
 
     if ((i + 1) % 4 == 0) os << sep;
   }
 
   len = sizeof(rhs.entityId.entityKey);
 
   for (std::size_t i = 0; i < len; ++i) {
     os << setopts << unsigned(rhs.entityId.entityKey[i]);
   }
 
   os << setopts << unsigned(rhs.entityId.entityKind);
 
   // Reset, because hex is "sticky"
   os << std::dec;
 
   return os;
 }

◆ operator<<() [7/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::TypeLookup_getTypes_Out &	stru
	)

Definition at line 102 of file TypeLookup.cpp.

References OpenDDS::XTypes::TypeLookup_getTypes_Out::complete_to_minimal, OpenDDS::STUN::encoding(), OpenDDS::DCPS::Serializer::encoding(), serialized_size(), OpenDDS::XTypes::TypeLookup_getTypes_Out::types, OpenDDS::DCPS::Serializer::write_delimiter(), and OpenDDS::DCPS::Serializer::write_parameter_id().

 {
   const Encoding& encoding = strm.encoding();
   size_t total_size = 0;
   serialized_size(encoding, total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   size_t size = 0;
   serialized_size(encoding, size, stru.types);
   if (!strm.write_parameter_id(41962193, size)) {
     return false;
   }
   if (!(strm << stru.types)) {
     return false;
   }
 
   size = 0;
   serialized_size(encoding, size, stru.complete_to_minimal);
   if (!strm.write_parameter_id(193881463, size)) {
     return false;
   }
   return strm << stru.complete_to_minimal;
 }

◆ operator<<() [8/157]

OpenDDS_Dcps_Export std::ostream & OpenDDS::DCPS::operator<<	(	std::ostream &	str,
		const CoherentChangeControl &	value
	)

Message header insertion onto an ostream.

Definition at line 104 of file CoherentChangeControl.cpp.

References OpenDDS::DCPS::LogGuid::c_str(), OpenDDS::DCPS::CoherentChangeControl::coherent_samples_, OpenDDS::DCPS::SequenceNumber::getValue(), OpenDDS::DCPS::CoherentChangeControl::group_coherent_, OpenDDS::DCPS::CoherentChangeControl::group_coherent_samples_, OpenDDS::DCPS::WriterCoherentSample::last_sample_, OpenDDS::DCPS::WriterCoherentSample::num_samples_, OPENDDS_END_VERSIONED_NAMESPACE_DECL, and OpenDDS::DCPS::CoherentChangeControl::publisher_id_.

 {
   RestoreOutputStreamState stream_state(str);
 
   str << "num_samples: " << std::dec << value.coherent_samples_.num_samples_
       << ", last_sample: " << value.coherent_samples_.last_sample_.getValue()
       << ", ";
   if (value.group_coherent_) {
     str << "publisher: " << std::dec << LogGuid(value.publisher_id_).c_str() << ", ";
     str << "group size: " << std::dec << value.group_coherent_samples_.size()
         << ", ";
     GroupCoherentSamples::const_iterator itEnd =
       value.group_coherent_samples_.end();
     for (GroupCoherentSamples::const_iterator it =
            value.group_coherent_samples_.begin(); it != itEnd; ++it) {
       str << "writer: " << LogGuid(it->first).c_str() << ", "
           << "num_samples: " << it->second.num_samples_ << ", "
           << "last_sample: " << it->second.last_sample_.getValue()  << std::endl;
     }
   }
   return str;
 }

◆ operator<<() [9/157]

template<typename DatumType >

std::ostream& OpenDDS::DCPS::operator<<	(	std::ostream &	str,
		const DataCollector< DatumType > &	value
	)

Insert collected data onto an ostream.

Definition at line 16 of file DataCollector_T.inl.

References ACE_INLINE.

 {
   return value.insert(str);
 }

◆ operator<<() [10/157]

ACE_CDR::Boolean OpenDDS::DCPS::operator<<	(	Serializer &	s,
		const SequenceNumber &	x
	)

inline

Definition at line 157 of file SequenceNumber.h.

References OpenDDS::DCPS::SequenceNumber::getHigh(), OpenDDS::DCPS::SequenceNumber::getLow(), and OpenDDS::DCPS::Serializer::good_bit().

                                                    {
   s << x.getHigh();
   s << x.getLow();
   return s.good_bit();
 }

◆ operator<<() [11/157]

OpenDDS_Dcps_Export std::ostream & OpenDDS::DCPS::operator<<	(	std::ostream &	os,
		const GuidConverter &	rhs
	)

Definition at line 177 of file GuidConverter.cpp.

References OPENDDS_STRING, and operator<<().

 {
   return os << OPENDDS_STRING(rhs);
 }

◆ operator<<() [12/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::TypeLookup_getTypes_Result &	uni
	)

Definition at line 188 of file TypeLookup.cpp.

References OpenDDS::STUN::encoding(), OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::TypeLookup_getTypes_Result::result, OpenDDS::XTypes::TypeLookup_getTypes_Result::return_code, serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   const Encoding& encoding = strm.encoding();
   size_t total_size = 0;
   serialized_size(encoding, total_size, uni);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   if (!(strm << uni.return_code)) {
     return false;
   }
 
   switch (uni.return_code) {
   case 0:
     return strm << uni.result;
   }
 
   return true;
 }

◆ operator<<() [13/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::TypeLookup_getTypeDependencies_In &	stru
	)

Definition at line 244 of file TypeLookup.cpp.

References OpenDDS::XTypes::TypeLookup_getTypeDependencies_In::continuation_point, OpenDDS::STUN::encoding(), OpenDDS::DCPS::Serializer::encoding(), serialized_size(), OpenDDS::XTypes::TypeLookup_getTypeDependencies_In::type_ids, OpenDDS::DCPS::Serializer::write_delimiter(), and OpenDDS::DCPS::Serializer::write_parameter_id().

 {
   const Encoding& encoding = strm.encoding();
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   size_t size = 0;
   serialized_size(encoding, size, stru.type_ids);
   if (!strm.write_parameter_id(206790757, size)) {
     return false;
   }
   if (!(strm << stru.type_ids)) {
     return false;
   }
 
   size = 0;
   serialized_size(encoding, size, stru.continuation_point);
   if (!strm.write_parameter_id(84468690, size)) {
     return false;
   }
   return strm << stru.continuation_point;
 }

◆ operator<<() [14/157]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator<<	(	ACE_Message_Block &	buffer,
		const DataSampleHeader &	value
	)

Marshal/Insertion into a buffer.

Definition at line 280 of file DataSampleHeader.cpp.

 {
   Serializer writer(&buffer, encoding_kind, value.byte_order_ ? ENDIAN_LITTLE : ENDIAN_BIG);
 
   writer << value.message_id_;
   writer << value.submessage_id_;
 
   // Write the flags as a single byte.
   ACE_CDR::Octet flags = (value.byte_order_           << BYTE_ORDER_FLAG)
                          | (value.coherent_change_    << COHERENT_CHANGE_FLAG)
                          | (value.historic_sample_    << HISTORIC_SAMPLE_FLAG)
                          | (value.lifespan_duration_  << LIFESPAN_DURATION_FLAG)
                          | (value.group_coherent_     << GROUP_COHERENT_FLAG)
                          | (value.content_filter_     << CONTENT_FILTER_FLAG)
                          | (value.sequence_repair_    << SEQUENCE_REPAIR_FLAG)
                          | (value.more_fragments_     << MORE_FRAGMENTS_FLAG)
                          ;
   writer << ACE_OutputCDR::from_octet(flags);
 
   flags = (value.cdr_encapsulation_ << CDR_ENCAP_FLAG)
         | (value.key_fields_only_   << KEY_ONLY_FLAG)
         ;
   writer << ACE_OutputCDR::from_octet(flags);
 
   writer << value.message_length_;
   writer << value.sequence_;
   writer << value.source_timestamp_sec_;
   writer << value.source_timestamp_nanosec_;
 
   if (value.lifespan_duration_) {
     writer << value.lifespan_duration_sec_;
     writer << value.lifespan_duration_nanosec_;
   }
 
   writer << value.publication_id_;
 
 #ifndef OPENDDS_NO_OBJECT_MODEL_PROFILE
   if (value.group_coherent_) {
     writer << value.publisher_id_;
   }
 #endif
 
   // content_filter_entries_ is deliberately not marshaled here.
   // It's variable sized, so it won't fit into our pre-allocated data block.
   // It may be customized per-datalink so it will be handled later with a
   // a chained (continuation) ACE_Message_Block.
 
   return writer.good_bit();
 }

◆ operator<<() [15/157]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		const EncapsulationHeader &	value
	)

Definition at line 310 of file Serializer.cpp.

References OpenDDS::DCPS::EncapsulationHeader::is_good(), OpenDDS::DCPS::EncapsulationHeader::kind(), OpenDDS::DCPS::EncapsulationHeader::options(), OpenDDS::DCPS::Serializer::reset_alignment(), OpenDDS::DCPS::EncapsulationHeader::serialized_size, and OpenDDS::DCPS::Serializer::write_octet_array().

 {
   if (!value.is_good()) {
     return false;
   }
   ACE_CDR::Octet data[EncapsulationHeader::serialized_size];
   data[0] = (value.kind() >> 8) & 0xff;
   data[1] = value.kind() & 0xff;
   data[2] = (value.options() >> 8) & 0xff;
   data[3] = value.options() & 0xff;
   const bool ok = s.write_octet_array(&data[0],
     EncapsulationHeader::serialized_size);
   s.reset_alignment();
   return ok;
 }

◆ operator<<() [16/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::TypeLookup_getTypeDependencies_Out &	stru
	)

Definition at line 332 of file TypeLookup.cpp.

References OpenDDS::XTypes::TypeLookup_getTypeDependencies_Out::continuation_point, OpenDDS::XTypes::TypeLookup_getTypeDependencies_Out::dependent_typeids, OpenDDS::STUN::encoding(), OpenDDS::DCPS::Serializer::encoding(), serialized_size(), OpenDDS::DCPS::Serializer::write_delimiter(), and OpenDDS::DCPS::Serializer::write_parameter_id().

 {
   const Encoding& encoding = strm.encoding();
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   size_t size = 0;
   serialized_size(encoding, size, stru.dependent_typeids);
   if (!strm.write_parameter_id(195354569, size)) {
     return false;
   }
   if (!(strm << stru.dependent_typeids)) {
     return false;
   }
 
   size = 0;
   serialized_size(encoding, size, stru.continuation_point);
   if (!strm.write_parameter_id(84468690, size)) {
     return false;
   }
   return strm << stru.continuation_point;
 }

◆ operator<<() [17/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::TypeLookup_getTypeDependencies_Result &	uni
	)

Definition at line 419 of file TypeLookup.cpp.

References OpenDDS::STUN::encoding(), OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::TypeLookup_getTypeDependencies_Result::result, OpenDDS::XTypes::TypeLookup_getTypeDependencies_Result::return_code, serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   const Encoding& encoding = strm.encoding();
   size_t total_size = 0;
   serialized_size(encoding, total_size, uni);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   if (!(strm << uni.return_code)) {
     return false;
   }
 
   switch (uni.return_code) {
   case 0:
     return strm << uni.result;
   }
 
   return true;
 }

◆ operator<<() [18/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::TypeLookup_Call &	uni
	)

Definition at line 475 of file TypeLookup.cpp.

References OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::TypeLookup_Call::getTypeDependencies, OpenDDS::XTypes::TypeLookup_Call::getTypes, OpenDDS::XTypes::TypeLookup_Call::kind, serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, uni);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   if (!(strm << uni.kind)) {
     return false;
   }
 
   switch (uni.kind) {
   case 25318099:
     return strm << uni.getTypes;
   case 95091505:
     return strm << uni.getTypeDependencies;
   }
 
   return true;
 }

◆ operator<<() [19/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::TypeLookup_Request &	stru
	)

Definition at line 526 of file TypeLookup.cpp.

References OpenDDS::XTypes::TypeLookup_Request::data, and OpenDDS::XTypes::TypeLookup_Request::header.

 {
   return (strm << stru.header)
     && (strm << stru.data);
 }

◆ operator<<() [20/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::TypeLookup_Return &	uni
	)

Definition at line 555 of file TypeLookup.cpp.

References OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::TypeLookup_Return::getType, OpenDDS::XTypes::TypeLookup_Return::getTypeDependencies, OpenDDS::XTypes::TypeLookup_Return::kind, serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, uni);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   if (!(strm << uni.kind)) {
     return false;
   }
 
   switch (uni.kind) {
   case 25318099:
     return strm << uni.getType;
   case 95091505:
     return strm << uni.getTypeDependencies;
   }
 
   return true;
 }

◆ operator<<() [21/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::TypeLookup_Reply &	stru
	)

Definition at line 606 of file TypeLookup.cpp.

References OpenDDS::XTypes::TypeLookup_Reply::_cxx_return, and OpenDDS::XTypes::TypeLookup_Reply::header.

 {
   return (strm << stru.header)
     && (strm << stru._cxx_return);
 }

◆ operator<<() [22/157]

OpenDDS_Dcps_Export std::ostream & OpenDDS::DCPS::operator<<	(	std::ostream &	os,
		const MessageId	value
	)

Message Id enumeration insertion onto an ostream.

Definition at line 609 of file DataSampleHeader.cpp.

References to_string().

 {
   os << to_string(value);
   return os;
 }

◆ operator<<() [23/157]

OpenDDS_Dcps_Export std::ostream & OpenDDS::DCPS::operator<<	(	std::ostream &	os,
		const SubMessageId	value
	)

Sub-Message Id enumeration insertion onto an ostream.

Definition at line 616 of file DataSampleHeader.cpp.

References OpenDDS_Dcps_Export, and to_string().

 {
   os << to_string(value);
   return os;
 }

◆ operator<<() [24/157]

OpenDDS_Dcps_Export std::ostream & OpenDDS::DCPS::operator<<	(	std::ostream &	str,
		const DataSampleHeader &	value
	)

Message header insertion onto an ostream.

Definition at line 624 of file DataSampleHeader.cpp.

 {
   RestoreOutputStreamState stream_state(str);
 
   if (value.submessage_id_ != SUBMESSAGE_NONE) {
     str << SubMessageId(value.submessage_id_)
       << " (0x" << std::hex << std::setw(2) << std::setfill('0')
       << unsigned(value.submessage_id_) << "), ";
 
   } else {
     str << MessageId(value.message_id_)
         << " (0x" << std::hex << std::setw(2) << std::setfill('0')
         << unsigned(value.message_id_) << "), ";
   }
 
   str << "Length: " << std::dec << value.message_length_ << ", ";
 
   str << "Byte order: " << (value.byte_order_ == 1 ? "Little" : "Big")
       << " Endian";
 
   if (value.message_id_ != TRANSPORT_CONTROL) {
     str << ", ";
 
     if (value.coherent_change_ == 1) str << "Coherent, ";
     if (value.historic_sample_ == 1) str << "Historic, ";
     if (value.lifespan_duration_ == 1) str << "Lifespan, ";
 #ifndef OPENDDS_NO_OBJECT_MODEL_PROFILE
     if (value.group_coherent_ == 1) str << "Group-Coherent, ";
 #endif
     if (value.content_filter_ == 1) str << "Content-Filtered, ";
     if (value.sequence_repair_ == 1) str << "Sequence Repair, ";
     if (value.more_fragments_ == 1) str << "More Fragments, ";
     if (value.cdr_encapsulation_ == 1) str << "CDR Encapsulation, ";
     if (value.key_fields_only_ == 1) str << "Key Fields Only, ";
 
     str << "Sequence: 0x" << std::hex << std::setw(4) << std::setfill('0')
         << value.sequence_.getValue() << ", ";
 
     str << "Timestamp: " << std::dec << value.source_timestamp_sec_ << "."
         << std::dec << value.source_timestamp_nanosec_ << ", ";
 
     if (value.lifespan_duration_) {
       str << "Lifespan: " << std::dec << value.lifespan_duration_sec_ << "."
           << std::dec << value.lifespan_duration_nanosec_ << ", ";
     }
 
     str << "Publication: " << GuidConverter(value.publication_id_);
 #ifndef OPENDDS_NO_OBJECT_MODEL_PROFILE
     if (value.group_coherent_) {
       str << ", Publisher: " << GuidConverter(value.publisher_id_);
     }
 #endif
 
     if (value.content_filter_) {
       const CORBA::ULong len = value.content_filter_entries_.length();
       str << ", Content-Filter Entries (" << len << "): [";
       for (CORBA::ULong i(0); i < len; ++i) {
         str << GuidConverter(value.content_filter_entries_[i]) << ' ';
       }
       str << ']';
     }
   }
 
   return str;
 }

◆ operator<<() [25/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::OctetSeq32 &	seq
	)

Definition at line 629 of file TypeLookup.cpp.

References OpenDDS::XTypes::Sequence< T >::get_buffer(), OpenDDS::XTypes::Sequence< T >::length(), and OpenDDS::DCPS::Serializer::write_octet_array().

 {
   const CORBA::ULong length = seq.length();
   if (length > 32) {
     return false;
   }
   if (!(strm << length)) {
     return false;
   }
   if (length == 0) {
     return true;
   }
   return strm.write_octet_array(seq.get_buffer(), length);
 }

◆ operator<<() [26/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		ACE_CDR::Char	x
	)

Definition at line 951 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::buffer_write(), char8_cdr_size, OpenDDS::DCPS::Serializer::good_bit(), and OpenDDS::DCPS::Serializer::swap_bytes().

 {
   s.buffer_write(reinterpret_cast<char*>(&x), char8_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<<() [27/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		ACE_CDR::Short	x
	)

Definition at line 958 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_w(), OpenDDS::DCPS::Serializer::buffer_write(), OpenDDS::DCPS::Serializer::good_bit(), int16_cdr_size, and OpenDDS::DCPS::Serializer::swap_bytes().

 {
   if (!s.align_w(int16_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), int16_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<<() [28/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		ACE_CDR::UShort	x
	)

Definition at line 968 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_w(), OpenDDS::DCPS::Serializer::buffer_write(), OpenDDS::DCPS::Serializer::good_bit(), OpenDDS::DCPS::Serializer::swap_bytes(), and uint16_cdr_size.

 {
   if (!s.align_w(uint16_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), uint16_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<<() [29/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		ACE_CDR::Long	x
	)

Definition at line 978 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_w(), OpenDDS::DCPS::Serializer::buffer_write(), OpenDDS::DCPS::Serializer::good_bit(), int32_cdr_size, and OpenDDS::DCPS::Serializer::swap_bytes().

 {
   if (!s.align_w(int32_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), int32_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<<() [30/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		ACE_CDR::ULong	x
	)

Definition at line 988 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_w(), OpenDDS::DCPS::Serializer::buffer_write(), OpenDDS::DCPS::Serializer::good_bit(), OpenDDS::DCPS::Serializer::swap_bytes(), and uint32_cdr_size.

 {
   if (!s.align_w(uint32_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), uint32_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<<() [31/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		ACE_CDR::LongLong	x
	)

Definition at line 998 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_w(), OpenDDS::DCPS::Serializer::buffer_write(), OpenDDS::DCPS::Serializer::good_bit(), int64_cdr_size, and OpenDDS::DCPS::Serializer::swap_bytes().

 {
   if (!s.align_w(int64_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), int64_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<<() [32/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		ACE_CDR::ULongLong	x
	)

Definition at line 1008 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_w(), OpenDDS::DCPS::Serializer::buffer_write(), OpenDDS::DCPS::Serializer::good_bit(), OpenDDS::DCPS::Serializer::swap_bytes(), and uint64_cdr_size.

 {
   if (!s.align_w(uint64_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), uint64_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<<() [33/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		ACE_CDR::Float	x
	)

Definition at line 1018 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_w(), OpenDDS::DCPS::Serializer::buffer_write(), float32_cdr_size, OpenDDS::DCPS::Serializer::good_bit(), and OpenDDS::DCPS::Serializer::swap_bytes().

 {
   if (!s.align_w(float32_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), float32_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<<() [34/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		ACE_CDR::Double	x
	)

Definition at line 1028 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_w(), OpenDDS::DCPS::Serializer::buffer_write(), float64_cdr_size, OpenDDS::DCPS::Serializer::good_bit(), and OpenDDS::DCPS::Serializer::swap_bytes().

 {
   if (!s.align_w(float64_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), float64_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<<() [35/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		ACE_CDR::LongDouble	x
	)

Definition at line 1038 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_w(), OpenDDS::DCPS::Serializer::buffer_write(), float128_cdr_size, OpenDDS::DCPS::Serializer::good_bit(), and OpenDDS::DCPS::Serializer::swap_bytes().

 {
   if (!s.align_w(float128_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), float128_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<<() [36/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		const ACE_CDR::Char *	x
	)

Definition at line 1048 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::buffer_write(), and OpenDDS::DCPS::Serializer::good_bit().

 {
   if (x != 0) {
     // Include the null termination in the serialized data.
     const ACE_CDR::ULong stringlen =
       1 + static_cast<ACE_CDR::ULong>(std::strlen(x));
     s << stringlen;
     s.buffer_write(reinterpret_cast<const char*>(x), stringlen, false);
 
   } else {
     s << ACE_CDR::ULong(0);
   }
 
   return s.good_bit();
 }

◆ operator<<() [37/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		const ACE_CDR::WChar *	x
	)

Definition at line 1065 of file Serializer.inl.

References ACE_CDR_LONG_DOUBLE_ASSIGNMENT, ACE_INLINE, OpenDDS::DCPS::Serializer::align_w(), OpenDDS::DCPS::Serializer::buffer_write(), char16_cdr_size, float128_cdr_size, OpenDDS::DCPS::Serializer::good_bit(), OpenDDS::DCPS::Serializer::good_bit_, operator<<(), ACE_OS::strlen(), OpenDDS::DCPS::Serializer::swap_bytes(), and OpenDDS::DCPS::Serializer::write_array().

 {
   if (x != 0) {
     // Do not include the null terminatator in the serialized data.
     const ACE_CDR::ULong length = static_cast<ACE_CDR::ULong>(ACE_OS::strlen(x));
     s << ACE_CDR::ULong(length * char16_cdr_size);
 
 #if ACE_SIZEOF_WCHAR == 2
     s.write_array(reinterpret_cast<const char*>(x), char16_cdr_size, length,
       s.swap_bytes());
 #else
     for (size_t i = 0; i < length && s.good_bit(); ++i) {
       const ACE_UINT16 as_utf16 = static_cast<ACE_UINT16>(x[i]);
       if (as_utf16 != x[i]) { // not currently handling surrogates
         s.good_bit_ = false;
         break;
       }
       s.buffer_write(reinterpret_cast<const char*>(&as_utf16), char16_cdr_size,
         s.swap_bytes());
     }
 #endif
   } else {
     s << ACE_CDR::ULong(0);
   }
 
   return s.good_bit();
 }

◆ operator<<() [38/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		ACE_OutputCDR::from_boolean	x
	)

Definition at line 1107 of file Serializer.inl.

References ACE_INLINE, boolean_cdr_size, OpenDDS::DCPS::Serializer::buffer_write(), OpenDDS::DCPS::Serializer::good_bit(), and ACE_OutputCDR::from_boolean::val_.

 {
   s.buffer_write(reinterpret_cast<char*>(&x.val_), boolean_cdr_size, false);
   return s.good_bit();
 }

◆ operator<<() [39/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		ACE_OutputCDR::from_char	x
	)

Definition at line 1114 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::buffer_write(), char8_cdr_size, OpenDDS::DCPS::Serializer::good_bit(), and ACE_OutputCDR::from_char::val_.

 {
   s.buffer_write(reinterpret_cast<char*>(&x.val_), char8_cdr_size, false);
   return s.good_bit();
 }

◆ operator<<() [40/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		ACE_OutputCDR::from_wchar	x
	)

Definition at line 1121 of file Serializer.inl.

References ACE_ERROR, ACE_INLINE, ACE_TEXT(), OpenDDS::DCPS::Serializer::align_w(), OpenDDS::DCPS::Serializer::buffer_write(), char16_cdr_size, DCPS_debug_level, OpenDDS::DCPS::Serializer::good_bit(), OpenDDS::DCPS::Serializer::good_bit_, LM_ERROR, OpenDDS::DCPS::Serializer::swap_bytes(), and ACE_OutputCDR::from_wchar::val_.

 {
   if (!s.align_w(char16_cdr_size)) {
     return false;
   }
 #if ACE_SIZEOF_WCHAR == 2
   s.buffer_write(reinterpret_cast<char*>(&x.val_), char16_cdr_size, s.swap_bytes());
 #else
   const ACE_UINT16 as_utf16 = static_cast<ACE_UINT16>(x.val_);
   if (as_utf16 != x.val_) { // not currently handling surrogates
     if (DCPS_debug_level) {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ")
         ACE_TEXT("operator<<(Serializer&, ACE_OutputCDR::from_wchar): ")
         ACE_TEXT("failure to convert UTF-32 to UTF-16.\n")));
     }
     s.good_bit_ = false;
   } else {
     s.buffer_write(reinterpret_cast<const char*>(&as_utf16), char16_cdr_size,
       s.swap_bytes());
   }
 #endif
   return s.good_bit();
 }

◆ operator<<() [41/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		const String &	x
	)

Definition at line 1146 of file Serializer.inl.

References ACE_INLINE.

 {
   return s << x.c_str();
 }

◆ operator<<() [42/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		Serializer::FromBoundedString< char >	x
	)

Definition at line 1152 of file Serializer.inl.

 {
   return (x.bound_ == 0 || x.str_.size() <= x.bound_) && s << x.str_;
 }

◆ operator<<() [43/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		ACE_OutputCDR::from_octet	x
	)

Definition at line 1172 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::buffer_write(), byte_cdr_size, OpenDDS::DCPS::Serializer::good_bit(), and ACE_OutputCDR::from_octet::val_.

 {
   s.buffer_write(reinterpret_cast<char*>(&x.val_), byte_cdr_size, false);
   return s.good_bit();
 }

◆ operator<<() [44/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		ACE_OutputCDR::from_string	x
	)

Definition at line 1179 of file Serializer.inl.

References ACE_INLINE, ACE_OutputCDR::from_string::bound_, OpenDDS::DCPS::Serializer::buffer_write(), OpenDDS::DCPS::Serializer::good_bit(), ACE_OS::strlen(), and ACE_OutputCDR::from_string::val_.

 {
   // Include the null termination in the serialized data.
   ACE_CDR::ULong stringlen = 0;
   if (x.val_ != 0) {
     stringlen = 1 + static_cast<ACE_CDR::ULong>(ACE_OS::strlen(x.val_));
     s << stringlen;
     s.buffer_write(reinterpret_cast<char*>(x.val_), stringlen, false);
   } else {
     s << ACE_CDR::ULong(0);
   }
   return s.good_bit() && ((x.bound_ == 0) || (stringlen - 1 <= x.bound_));
 }

◆ operator<<() [45/157]

ACE_INLINE bool OpenDDS::DCPS::operator<<	(	Serializer &	s,
		ACE_OutputCDR::from_wstring	x
	)

Definition at line 1194 of file Serializer.inl.

References ACE_INLINE, ACE_OutputCDR::from_wstring::bound_, OpenDDS::DCPS::Serializer::buffer_write(), OpenDDS::DCPS::Serializer::good_bit(), int8_cdr_size, operator<<(), ACE_OS::strlen(), uint8_cdr_size, ACE_OutputCDR::from_uint8::val_, ACE_OutputCDR::from_int8::val_, and ACE_OutputCDR::from_wstring::val_.

 {
   s << x.val_;
   const ACE_CDR::ULong stringlen =
     x.bound_ ? static_cast<ACE_CDR::ULong>(ACE_OS::strlen(x.val_)) : 0;
   return s.good_bit() && ((x.bound_ == 0) || (stringlen <= x.bound_));
 }

◆ operator<<() [46/157]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::TypeIdentifier &	uni
	)

Definition at line 1196 of file TypeObject.cpp.

 {
   if (!(strm << ACE_OutputCDR::from_octet(uni.kind()))) {
     return false;
   }
 
   switch (uni.kind()) {
   case XTypes::TI_STRING8_SMALL:
   case XTypes::TI_STRING16_SMALL:
     return (strm << uni.string_sdefn());
   case XTypes::TI_STRING8_LARGE:
   case XTypes::TI_STRING16_LARGE:
     return (strm << uni.string_ldefn());
   case XTypes::TI_PLAIN_SEQUENCE_SMALL:
     return (strm << uni.seq_sdefn());
   case XTypes::TI_PLAIN_SEQUENCE_LARGE:
     return (strm << uni.seq_ldefn());
   case XTypes::TI_PLAIN_ARRAY_SMALL:
     return (strm << uni.array_sdefn());
   case XTypes::TI_PLAIN_ARRAY_LARGE:
     return (strm << uni.array_ldefn());
   case XTypes::TI_PLAIN_MAP_SMALL:
     return (strm << uni.map_sdefn());
   case XTypes::TI_PLAIN_MAP_LARGE:
     return (strm << uni.map_ldefn());
   case XTypes::TI_STRONGLY_CONNECTED_COMPONENT:
     return (strm << uni.sc_component_id());
   case XTypes::EK_COMPLETE:
   case XTypes::EK_MINIMAL:
     {
       XTypes::EquivalenceHash_forany uni_equivalence_hash(const_cast<XTypes::EquivalenceHash_slice*>(uni.equivalence_hash()));
       return (strm << uni_equivalence_hash);
     }
   case XTypes::TK_NONE:
   case XTypes::TK_BOOLEAN:
   case XTypes::TK_BYTE:
   case XTypes::TK_INT16:
   case XTypes::TK_INT32:
   case XTypes::TK_INT64:
   case XTypes::TK_UINT16:
   case XTypes::TK_UINT32:
   case XTypes::TK_UINT64:
   case XTypes::TK_FLOAT32:
   case XTypes::TK_FLOAT64:
   case XTypes::TK_FLOAT128:
   case XTypes::TK_INT8:
   case XTypes::TK_UINT8:
   case XTypes::TK_CHAR8:
   case XTypes::TK_CHAR16:
     return true; // no-op, no member selected
   default:
     return (strm << uni.extended_defn());
   }
 }

◆ operator<<() [47/157]

std::ostream& OpenDDS::DCPS::operator<<	(	std::ostream &	str,
		const DataLink &	value
	)

Definition at line 1212 of file DataLink.cpp.

References OpenDDS::DCPS::DataLink::assoc_by_local_.

 {
   str << "   There are " << value.assoc_by_local_.size()
       << " local entities currently using this link";
 
   if (!value.assoc_by_local_.empty()) {
     str << " comprising following associations:";
   }
   str << std::endl;
 
   typedef DataLink::AssocByLocal::const_iterator assoc_iter_t;
   const DataLink::AssocByLocal& abl = value.assoc_by_local_;
   for (assoc_iter_t ait = abl.begin(); ait != abl.end(); ++ait) {
     const RepoIdSet& set = ait->second.associated_;
     for (RepoIdSet::const_iterator rit = set.begin(); rit != set.end(); ++rit) {
       str << GuidConverter(ait->first) << " --> "
           << GuidConverter(*rit) << "   " << std::endl;
     }
   }
   return str;
 }

◆ operator<<() [48/157]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::LBoundSeq &	seq
	)

Definition at line 1319 of file TypeObject.cpp.

References OpenDDS::XTypes::Sequence< T >::get_buffer(), OpenDDS::XTypes::Sequence< T >::length(), and OpenDDS::DCPS::Serializer::write_ulong_array().

 {
   const ACE_CDR::ULong length = seq.length();
   if (!(strm << length)) {
     return false;
   }
   if (length == 0) {
     return true;
   }
   return strm.write_ulong_array(seq.get_buffer(), length);
 }

◆ operator<<() [49/157]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::SBoundSeq &	seq
	)

Definition at line 1355 of file TypeObject.cpp.

References OpenDDS::XTypes::Sequence< T >::get_buffer(), OpenDDS::XTypes::Sequence< T >::length(), and OpenDDS::DCPS::Serializer::write_octet_array().

 {
   const ACE_CDR::ULong length = seq.length();
   if (!(strm << length)) {
     return false;
   }
   if (length == 0) {
     return true;
   }
   return strm.write_octet_array(seq.get_buffer(), length);
 }

◆ operator<<() [50/157]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::UnionCaseLabelSeq &	seq
	)

Definition at line 1391 of file TypeObject.cpp.

References OpenDDS::XTypes::Sequence< T >::get_buffer(), OpenDDS::XTypes::Sequence< T >::length(), and OpenDDS::DCPS::Serializer::write_long_array().

 {
   const ACE_CDR::ULong length = seq.length();
   if (!(strm << length)) {
     return false;
   }
   if (length == 0) {
     return true;
   }
   return strm.write_long_array(seq.get_buffer(), length);
 }

◆ operator<<() [51/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::ExtendedAnnotationParameterValue &
	)

Definition at line 1423 of file TypeObject.cpp.

References OpenDDS::XTypes::write_empty_xcdr2_nonfinal().

 {
   return XTypes::write_empty_xcdr2_nonfinal(strm);
 }

◆ operator<<() [52/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::NameHash_forany &	arr
	)

Definition at line 1440 of file TypeObject.cpp.

References OpenDDS::XTypes::Fake_TAO_Array_Forany_T< T, T_slice, TAG >::in(), and OpenDDS::DCPS::Serializer::write_octet_array().

 {
   return strm.write_octet_array(arr.in(), 4);
 }

◆ operator<<() [53/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::EquivalenceHash_forany &	arr
	)

Definition at line 1457 of file TypeObject.cpp.

References OpenDDS::XTypes::Fake_TAO_Array_Forany_T< T, T_slice, TAG >::in(), and OpenDDS::DCPS::Serializer::write_octet_array().

 {
   return strm.write_octet_array(arr.in(), 14);
 }

◆ operator<<() [54/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteTypeDetail &	stru
	)

Definition at line 1477 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteTypeDetail::ann_builtin, OpenDDS::XTypes::CompleteTypeDetail::ann_custom, OpenDDS::XTypes::CompleteTypeDetail::type_name, and OpenDDS::XTypes::TYPE_NAME_MAX_LENGTH.

 {
   return (strm << stru.ann_builtin)
     && (strm << stru.ann_custom)
     && (strm << Serializer::FromBoundedString<char>(stru.type_name, TYPE_NAME_MAX_LENGTH));
 }

◆ operator<<() [55/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteStructHeader &	stru
	)

Definition at line 1500 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteStructHeader::base_type, OpenDDS::XTypes::CompleteStructHeader::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.base_type)
     && (strm << stru.detail);
 }

◆ operator<<() [56/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalStructHeader &	stru
	)

Definition at line 1539 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalStructHeader::base_type, OpenDDS::XTypes::MinimalStructHeader::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.base_type)
     && (strm << stru.detail);
 }

◆ operator<<() [57/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteStructType &	stru
	)

Definition at line 1577 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteStructType::header, OpenDDS::XTypes::CompleteStructType::member_seq, and OpenDDS::XTypes::CompleteStructType::struct_flags.

 {
   return (strm << stru.struct_flags)
     && (strm << stru.header)
     && (strm << stru.member_seq);
 }

◆ operator<<() [58/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalStructType &	stru
	)

Definition at line 1600 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalStructType::header, OpenDDS::XTypes::MinimalStructType::member_seq, and OpenDDS::XTypes::MinimalStructType::struct_flags.

 {
   return (strm << stru.struct_flags)
     && (strm << stru.header)
     && (strm << stru.member_seq);
 }

◆ operator<<() [59/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteUnionType &	stru
	)

Definition at line 1624 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteUnionType::discriminator, OpenDDS::XTypes::CompleteUnionType::header, OpenDDS::XTypes::CompleteUnionType::member_seq, and OpenDDS::XTypes::CompleteUnionType::union_flags.

 {
   return (strm << stru.union_flags)
     && (strm << stru.header)
     && (strm << stru.discriminator)
     && (strm << stru.member_seq);
 }

◆ operator<<() [60/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalUnionType &	stru
	)

Definition at line 1650 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalUnionType::discriminator, OpenDDS::XTypes::MinimalUnionType::header, OpenDDS::XTypes::MinimalUnionType::member_seq, and OpenDDS::XTypes::MinimalUnionType::union_flags.

 {
   return (strm << stru.union_flags)
     && (strm << stru.header)
     && (strm << stru.discriminator)
     && (strm << stru.member_seq);
 }

◆ operator<<() [61/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteAnnotationType &	stru
	)

Definition at line 1675 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAnnotationType::annotation_flag, OpenDDS::XTypes::CompleteAnnotationType::header, and OpenDDS::XTypes::CompleteAnnotationType::member_seq.

 {
   return (strm << stru.annotation_flag)
     && (strm << stru.header)
     && (strm << stru.member_seq);
 }

◆ operator<<() [62/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalAnnotationType &	stru
	)

Definition at line 1698 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalAnnotationType::annotation_flag, OpenDDS::XTypes::MinimalAnnotationType::header, and OpenDDS::XTypes::MinimalAnnotationType::member_seq.

 {
   return (strm << stru.annotation_flag)
     && (strm << stru.header)
     && (strm << stru.member_seq);
 }

◆ operator<<() [63/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteAliasType &	stru
	)

Definition at line 1721 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAliasType::alias_flags, OpenDDS::XTypes::CompleteAliasType::body, and OpenDDS::XTypes::CompleteAliasType::header.

 {
   return (strm << stru.alias_flags)
     && (strm << stru.header)
     && (strm << stru.body);
 }

◆ operator<<() [64/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalAliasType &	stru
	)

Definition at line 1744 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalAliasType::alias_flags, OpenDDS::XTypes::MinimalAliasType::body, and OpenDDS::XTypes::MinimalAliasType::header.

 {
   return (strm << stru.alias_flags)
     && (strm << stru.header)
     && (strm << stru.body);
 }

◆ operator<<() [65/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteSequenceType &	stru
	)

Definition at line 1767 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteSequenceType::collection_flag, OpenDDS::XTypes::CompleteSequenceType::element, and OpenDDS::XTypes::CompleteSequenceType::header.

 {
   return (strm << stru.collection_flag)
     && (strm << stru.header)
     && (strm << stru.element);
 }

◆ operator<<() [66/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalSequenceType &	stru
	)

Definition at line 1790 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalSequenceType::collection_flag, OpenDDS::XTypes::MinimalSequenceType::element, and OpenDDS::XTypes::MinimalSequenceType::header.

 {
   return (strm << stru.collection_flag)
     && (strm << stru.header)
     && (strm << stru.element);
 }

◆ operator<<() [67/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteArrayType &	stru
	)

Definition at line 1814 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteArrayType::collection_flag, OpenDDS::XTypes::CompleteArrayType::element, OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::CompleteArrayType::header, serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.collection_flag)
     && (strm << stru.header)
     && (strm << stru.element);
 }

◆ operator<<() [68/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalArrayType &	stru
	)

Definition at line 1855 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalArrayType::collection_flag, OpenDDS::XTypes::MinimalArrayType::element, and OpenDDS::XTypes::MinimalArrayType::header.

 {
   return (strm << stru.collection_flag)
     && (strm << stru.header)
     && (strm << stru.element);
 }

◆ operator<<() [69/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteMapType &	stru
	)

Definition at line 1879 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteMapType::collection_flag, OpenDDS::XTypes::CompleteMapType::element, OpenDDS::XTypes::CompleteMapType::header, and OpenDDS::XTypes::CompleteMapType::key.

 {
   return (strm << stru.collection_flag)
     && (strm << stru.header)
     && (strm << stru.key)
     && (strm << stru.element);
 }

◆ operator<<() [70/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalMapType &	stru
	)

Definition at line 1905 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalMapType::collection_flag, OpenDDS::XTypes::MinimalMapType::element, OpenDDS::XTypes::MinimalMapType::header, and OpenDDS::XTypes::MinimalMapType::key.

 {
   return (strm << stru.collection_flag)
     && (strm << stru.header)
     && (strm << stru.key)
     && (strm << stru.element);
 }

◆ operator<<() [71/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteEnumeratedHeader &	stru
	)

Definition at line 1930 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteEnumeratedHeader::common, OpenDDS::XTypes::CompleteEnumeratedHeader::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common)
     && (strm << stru.detail);
 }

◆ operator<<() [72/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalEnumeratedHeader &	stru
	)

Definition at line 1967 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalEnumeratedHeader::common, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common);
 }

◆ operator<<() [73/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteEnumeratedType &	stru
	)

Definition at line 2004 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteEnumeratedType::enum_flags, OpenDDS::XTypes::CompleteEnumeratedType::header, and OpenDDS::XTypes::CompleteEnumeratedType::literal_seq.

 {
   return (strm << stru.enum_flags)
     && (strm << stru.header)
     && (strm << stru.literal_seq);
 }

◆ operator<<() [74/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalEnumeratedType &	stru
	)

Definition at line 2027 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalEnumeratedType::enum_flags, OpenDDS::XTypes::MinimalEnumeratedType::header, and OpenDDS::XTypes::MinimalEnumeratedType::literal_seq.

 {
   return (strm << stru.enum_flags)
     && (strm << stru.header)
     && (strm << stru.literal_seq);
 }

◆ operator<<() [75/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteBitmaskType &	stru
	)

Definition at line 2051 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteBitmaskType::bitmask_flags, OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::CompleteBitmaskType::flag_seq, OpenDDS::XTypes::CompleteBitmaskType::header, serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.bitmask_flags)
     && (strm << stru.header)
     && (strm << stru.flag_seq);
 }

◆ operator<<() [76/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalBitmaskType &	stru
	)

Definition at line 2093 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalBitmaskType::bitmask_flags, OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::MinimalBitmaskType::flag_seq, OpenDDS::XTypes::MinimalBitmaskType::header, serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.bitmask_flags)
     && (strm << stru.header)
     && (strm << stru.flag_seq);
 }

◆ operator<<() [77/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteBitsetType &	stru
	)

Definition at line 2135 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteBitsetType::bitset_flags, OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::CompleteBitsetType::field_seq, OpenDDS::XTypes::CompleteBitsetType::header, serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.bitset_flags)
     && (strm << stru.header)
     && (strm << stru.field_seq);
 }

◆ operator<<() [78/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalBitsetType &	stru
	)

Definition at line 2177 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalBitsetType::bitset_flags, OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::MinimalBitsetType::field_seq, OpenDDS::XTypes::MinimalBitsetType::header, serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.bitset_flags)
     && (strm << stru.header)
     && (strm << stru.field_seq);
 }

◆ operator<<() [79/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteExtendedType &
	)

Definition at line 2216 of file TypeObject.cpp.

References OpenDDS::XTypes::write_empty_xcdr2_nonfinal().

 {
   return XTypes::write_empty_xcdr2_nonfinal(strm);
 }

◆ operator<<() [80/157]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::TypeIdentifierWithSize &	stru
	)

Definition at line 2235 of file TypeObject.cpp.

References OpenDDS::DCPS::Serializer::encoding(), serialized_size(), OpenDDS::XTypes::TypeIdentifierWithSize::type_id, OpenDDS::XTypes::TypeIdentifierWithSize::typeobject_serialized_size, and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.type_id)
     && (strm << stru.typeobject_serialized_size);
 }

◆ operator<<() [81/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::TypeIdentifierWithDependencies &	stru
	)

Definition at line 2275 of file TypeObject.cpp.

References OpenDDS::XTypes::TypeIdentifierWithDependencies::dependent_typeid_count, OpenDDS::XTypes::TypeIdentifierWithDependencies::dependent_typeids, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), OpenDDS::XTypes::TypeIdentifierWithDependencies::typeid_with_size, and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.typeid_with_size)
     && (strm << stru.dependent_typeid_count)
     && (strm << stru.dependent_typeids);
 }

◆ operator<<() [82/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::AppliedAnnotation &	stru
	)

Definition at line 2316 of file TypeObject.cpp.

References OpenDDS::XTypes::AppliedAnnotation::annotation_typeid, OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::AppliedAnnotation::param_seq, serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.annotation_typeid)
     && (strm << stru.param_seq);
 }

◆ operator<<() [83/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::AppliedBuiltinTypeAnnotations &	stru
	)

Definition at line 2353 of file TypeObject.cpp.

References OpenDDS::DCPS::Serializer::encoding(), serialized_size(), OpenDDS::XTypes::AppliedBuiltinTypeAnnotations::verbatim, and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.verbatim);
 }

◆ operator<<() [84/157]

template<typename T >

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::Optional< T > &	opt
	)

Definition at line 2373 of file TypeObject.h.

 {
   if (!(strm << ACE_OutputCDR::from_boolean(opt.present))) {
     return false;
   }
   return !opt.present || strm << opt.value;
 }

◆ operator<<() [85/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteAliasBody &	stru
	)

Definition at line 2391 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAliasBody::ann_builtin, OpenDDS::XTypes::CompleteAliasBody::ann_custom, OpenDDS::XTypes::CompleteAliasBody::common, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common)
     && (strm << stru.ann_builtin)
     && (strm << stru.ann_custom);
 }

◆ operator<<() [86/157]

template<typename T >

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::Sequence< T > &	seq
	)

Definition at line 2407 of file TypeObject.h.

References serialized_size().

 {
   if (!strm.encoding().skip_sequence_dheader()) {
     size_t total_size = 0;
     serialized_size(strm.encoding(), total_size, seq);
     if (!strm.write_delimiter(total_size)) {
       return false;
     }
   }
   const ACE_CDR::ULong length = seq.length();
   if (!(strm << length)) {
     return false;
   }
   for (ACE_CDR::ULong i = 0; i < length; ++i) {
     if (!(strm << seq[i])) {
       return false;
     }
   }
   return true;
 }

◆ operator<<() [87/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteAliasHeader &	stru
	)

Definition at line 2431 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAliasHeader::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.detail);
 }

◆ operator<<() [88/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteAnnotationHeader &	stru
	)

Definition at line 2468 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAnnotationHeader::annotation_name, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), OpenDDS::XTypes::TYPE_NAME_MAX_LENGTH, and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << Serializer::FromBoundedString<char>(stru.annotation_name, TYPE_NAME_MAX_LENGTH));
 }

◆ operator<<() [89/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	,
		const XTypes::MinimalTypeDetail &
	)

inline

Definition at line 2501 of file TypeObject.h.

2501 { return true; }

◆ operator<<() [90/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteAnnotationParameter &	stru
	)

Definition at line 2507 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAnnotationParameter::common, OpenDDS::XTypes::CompleteAnnotationParameter::default_value, OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::MEMBER_NAME_MAX_LENGTH, OpenDDS::XTypes::CompleteAnnotationParameter::name, serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common)
     && (strm << Serializer::FromBoundedString<char>(stru.name, MEMBER_NAME_MAX_LENGTH))
     && (strm << stru.default_value);
 }

◆ operator<<() [91/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteArrayHeader &	stru
	)

Definition at line 2548 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteArrayHeader::common, OpenDDS::XTypes::CompleteArrayHeader::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common)
     && (strm << stru.detail);
 }

◆ operator<<() [92/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	ser,
		XTypes::MinimalAnnotationType &	stru
	)

◆ operator<<() [93/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	ser,
		XTypes::CompleteAliasType &	stru
	)

◆ operator<<() [94/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	ser,
		XTypes::MinimalAliasType &	stru
	)

Referenced by operator>>().

◆ operator<<() [95/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteBitfield &	stru
	)

Definition at line 2587 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteBitfield::common, OpenDDS::XTypes::CompleteBitfield::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common)
     && (strm << stru.detail);
 }

◆ operator<<() [96/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteBitflag &	stru
	)

Definition at line 2626 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteBitflag::common, OpenDDS::XTypes::CompleteBitflag::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common)
     && (strm << stru.detail);
 }

◆ operator<<() [97/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteBitsetHeader &	stru
	)

Definition at line 2664 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteBitsetHeader::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.detail);
 }

◆ operator<<() [98/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteCollectionElement &	stru
	)

Definition at line 2701 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteCollectionElement::common, OpenDDS::XTypes::CompleteCollectionElement::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common)
     && (strm << stru.detail);
 }

◆ operator<<() [99/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteCollectionHeader &	stru
	)

Definition at line 2740 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteCollectionHeader::common, OpenDDS::XTypes::CompleteCollectionHeader::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common)
     && (strm << stru.detail);
 }

◆ operator<<() [100/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteDiscriminatorMember &	stru
	)

Definition at line 2780 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteDiscriminatorMember::ann_builtin, OpenDDS::XTypes::CompleteDiscriminatorMember::ann_custom, OpenDDS::XTypes::CompleteDiscriminatorMember::common, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common)
     && (strm << stru.ann_builtin)
     && (strm << stru.ann_custom);
 }

◆ operator<<() [101/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteEnumeratedLiteral &	stru
	)

Definition at line 2821 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteEnumeratedLiteral::common, OpenDDS::XTypes::CompleteEnumeratedLiteral::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common)
     && (strm << stru.detail);
 }

◆ operator<<() [102/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteStructMember &	stru
	)

Definition at line 2860 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteStructMember::common, OpenDDS::XTypes::CompleteStructMember::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common)
     && (strm << stru.detail);
 }

◆ operator<<() [103/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteUnionHeader &	stru
	)

Definition at line 2899 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteUnionHeader::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.detail);
 }

◆ operator<<() [104/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteUnionMember &	stru
	)

Definition at line 2936 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteUnionMember::common, OpenDDS::XTypes::CompleteUnionMember::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common)
     && (strm << stru.detail);
 }

◆ operator<<() [105/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalAliasBody &	stru
	)

Definition at line 2974 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalAliasBody::common, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common);
 }

◆ operator<<() [106/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalAliasHeader &
	)

Definition at line 3009 of file TypeObject.cpp.

References OpenDDS::XTypes::write_empty_xcdr2_nonfinal().

 {
   return XTypes::write_empty_xcdr2_nonfinal(strm);
 }

◆ operator<<() [107/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalAnnotationHeader &
	)

Definition at line 3026 of file TypeObject.cpp.

References OpenDDS::XTypes::write_empty_xcdr2_nonfinal().

 {
   return XTypes::write_empty_xcdr2_nonfinal(strm);
 }

◆ operator<<() [108/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalAnnotationParameter &	stru
	)

Definition at line 3047 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalAnnotationParameter::common, OpenDDS::XTypes::MinimalAnnotationParameter::default_value, OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::MinimalAnnotationParameter::name_hash, serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
   return (strm << stru.common)
     && (strm << stru_name_hash)
     && (strm << stru.default_value);
 }

◆ operator<<() [109/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalArrayHeader &	stru
	)

Definition at line 3089 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalArrayHeader::common, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common);
 }

◆ operator<<() [110/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalBitfield &	stru
	)

Definition at line 3127 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalBitfield::common, OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::MinimalBitfield::name_hash, serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
   return (strm << stru.common)
     && (strm << stru_name_hash);
 }

◆ operator<<() [111/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalBitflag &	stru
	)

Definition at line 3168 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalBitflag::common, OpenDDS::XTypes::MinimalBitflag::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common)
     && (strm << stru.detail);
 }

◆ operator<<() [112/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalBitsetHeader &
	)

Definition at line 3205 of file TypeObject.cpp.

References OpenDDS::XTypes::write_empty_xcdr2_nonfinal().

 {
   return XTypes::write_empty_xcdr2_nonfinal(strm);
 }

◆ operator<<() [113/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalCollectionElement &	stru
	)

Definition at line 3223 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalCollectionElement::common, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common);
 }

◆ operator<<() [114/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalCollectionHeader &	stru
	)

Definition at line 3259 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalCollectionHeader::common, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common);
 }

◆ operator<<() [115/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalDiscriminatorMember &	stru
	)

Definition at line 3295 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalDiscriminatorMember::common, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common);
 }

◆ operator<<() [116/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalEnumeratedLiteral &	stru
	)

Definition at line 3332 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalEnumeratedLiteral::common, OpenDDS::XTypes::MinimalEnumeratedLiteral::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common)
     && (strm << stru.detail);
 }

◆ operator<<() [117/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalStructMember &	stru
	)

Definition at line 3371 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalStructMember::common, OpenDDS::XTypes::MinimalStructMember::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common)
     && (strm << stru.detail);
 }

◆ operator<<() [118/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalUnionHeader &	stru
	)

Definition at line 3409 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalUnionHeader::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.detail);
 }

◆ operator<<() [119/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalUnionMember &	stru
	)

Definition at line 3446 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalUnionMember::common, OpenDDS::XTypes::MinimalUnionMember::detail, OpenDDS::DCPS::Serializer::encoding(), serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.common)
     && (strm << stru.detail);
 }

◆ operator<<() [120/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::AnnotationParameterValue &	uni
	)

Definition at line 3557 of file TypeObject.cpp.

 {
   if (!(strm << ACE_OutputCDR::from_octet(uni.kind()))) {
     return false;
   }
   switch (uni.kind()) {
   case XTypes::TK_BOOLEAN: {
     return (strm << ACE_OutputCDR::from_boolean(uni.boolean_value()));
   }
   case XTypes::TK_BYTE: {
     return (strm << ACE_OutputCDR::from_octet(uni.byte_value()));
   }
   case XTypes::TK_INT16: {
     return (strm << uni.int16_value());
   }
   case XTypes::TK_UINT16: {
     return (strm << uni.uint16_value());
   }
   case XTypes::TK_INT32: {
     return (strm << uni.int32_value());
   }
   case XTypes::TK_UINT32: {
     return (strm << uni.uint32_value());
   }
   case XTypes::TK_INT64: {
     return (strm << uni.int64_value());
   }
   case XTypes::TK_UINT64: {
     return (strm << uni.uint64_value());
   }
   case XTypes::TK_FLOAT32: {
     return (strm << uni.float32_value());
   }
   case XTypes::TK_FLOAT64: {
     return (strm << uni.float64_value());
   }
   case XTypes::TK_FLOAT128: {
     return (strm << uni.float128_value());
   }
   case XTypes::TK_CHAR8: {
     return (strm << ACE_OutputCDR::from_char(uni.char_value()));
   }
   case XTypes::TK_CHAR16: {
     return (strm << ACE_OutputCDR::from_wchar(uni.wchar_value()));
   }
   case XTypes::TK_ENUM: {
     return (strm << uni.enumerated_value());
   }
   case XTypes::TK_STRING8: {
     return (strm << Serializer::FromBoundedString<char>(uni.string8_value(), 128));
   }
   case XTypes::TK_STRING16: {
 #ifdef DDS_HAS_WCHAR
     return (strm << Serializer::FromBoundedString<wchar_t>(uni.string16_value(), 128));
 #else
     return false;
 #endif
   }
   default: {
     return (strm << uni.extended_value());
   }
   }
 }

◆ operator<<() [121/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::AppliedAnnotationParameter &	stru
	)

Definition at line 3680 of file TypeObject.cpp.

References OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::AppliedAnnotationParameter::paramname_hash, serialized_size(), OpenDDS::XTypes::AppliedAnnotationParameter::value, and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   XTypes::NameHash_forany stru_paramname_hash(const_cast<XTypes::NameHash_slice*>(stru.paramname_hash));
   return (strm << stru_paramname_hash)
     && (strm << stru.value);
 }

◆ operator<<() [122/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::AppliedBuiltinMemberAnnotations &	stru
	)

Definition at line 3734 of file TypeObject.cpp.

References OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::AppliedBuiltinMemberAnnotations::hash_id, OpenDDS::XTypes::AppliedBuiltinMemberAnnotations::max, OpenDDS::XTypes::AppliedBuiltinMemberAnnotations::min, serialized_size(), OpenDDS::XTypes::AppliedBuiltinMemberAnnotations::unit, and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.unit)
     && (strm << stru.min)
     && (strm << stru.max)
     && (strm << stru.hash_id);
 }

◆ operator<<() [123/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::AppliedVerbatimAnnotation &	stru
	)

Definition at line 3780 of file TypeObject.cpp.

References OpenDDS::XTypes::AppliedVerbatimAnnotation::language, OpenDDS::XTypes::AppliedVerbatimAnnotation::placement, and OpenDDS::XTypes::AppliedVerbatimAnnotation::text.

 {
   return (strm << Serializer::FromBoundedString<char>(stru.placement, 32))
     && (strm << Serializer::FromBoundedString<char>(stru.language, 32))
     && (strm << stru.text);
 }

◆ operator<<() [124/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CommonAliasBody &	stru
	)

Definition at line 3802 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonAliasBody::related_flags, and OpenDDS::XTypes::CommonAliasBody::related_type.

 {
   return (strm << stru.related_flags)
     && (strm << stru.related_type);
 }

◆ operator<<() [125/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CommonAnnotationParameter &	stru
	)

Definition at line 3822 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonAnnotationParameter::member_flags, and OpenDDS::XTypes::CommonAnnotationParameter::member_type_id.

 {
   return (strm << stru.member_flags)
     && (strm << stru.member_type_id);
 }

◆ operator<<() [126/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CommonArrayHeader &	stru
	)

Definition at line 3841 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonArrayHeader::bound_seq.

 {
   return (strm << stru.bound_seq);
 }

◆ operator<<() [127/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CommonBitfield &	stru
	)

Definition at line 3861 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonBitfield::bitcount, OpenDDS::XTypes::CommonBitfield::flags, OpenDDS::XTypes::CommonBitfield::holder_type, and OpenDDS::XTypes::CommonBitfield::position.

 {
   return (strm << stru.position)
     && (strm << stru.flags)
     && (strm << ACE_OutputCDR::from_octet(stru.bitcount))
     && (strm << ACE_OutputCDR::from_octet(stru.holder_type));
 }

◆ operator<<() [128/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CommonBitflag &	stru
	)

Definition at line 3885 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonBitflag::flags, and OpenDDS::XTypes::CommonBitflag::position.

 {
   return (strm << stru.position)
     && (strm << stru.flags);
 }

◆ operator<<() [129/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CommonCollectionElement &	stru
	)

Definition at line 3905 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonCollectionElement::element_flags, and OpenDDS::XTypes::CommonCollectionElement::type.

 {
   return (strm << stru.element_flags)
     && (strm << stru.type);
 }

◆ operator<<() [130/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CommonCollectionHeader &	stru
	)

Definition at line 3924 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonCollectionHeader::bound.

 {
   return (strm << stru.bound);
 }

◆ operator<<() [131/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CommonDiscriminatorMember &	stru
	)

Definition at line 3942 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonDiscriminatorMember::member_flags, and OpenDDS::XTypes::CommonDiscriminatorMember::type_id.

 {
   return (strm << stru.member_flags)
     && (strm << stru.type_id);
 }

◆ operator<<() [132/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CommonEnumeratedHeader &	stru
	)

Definition at line 3961 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonEnumeratedHeader::bit_bound.

 {
   return (strm << stru.bit_bound);
 }

◆ operator<<() [133/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CommonEnumeratedLiteral &	stru
	)

Definition at line 3980 of file TypeObject.cpp.

References OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::CommonEnumeratedLiteral::flags, serialized_size(), OpenDDS::XTypes::CommonEnumeratedLiteral::value, and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(strm.encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.value)
     && (strm << stru.flags);
 }

◆ operator<<() [134/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CommonStructMember &	stru
	)

Definition at line 4019 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonStructMember::member_flags, OpenDDS::XTypes::CommonStructMember::member_id, and OpenDDS::XTypes::CommonStructMember::member_type_id.

 {
   return (strm << stru.member_id)
     && (strm << stru.member_flags)
     && (strm << stru.member_type_id);
 }

◆ operator<<() [135/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CommonUnionMember &	stru
	)

Definition at line 4043 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonUnionMember::label_seq, OpenDDS::XTypes::CommonUnionMember::member_flags, OpenDDS::XTypes::CommonUnionMember::member_id, and OpenDDS::XTypes::CommonUnionMember::type_id.

 {
   return (strm << stru.member_id)
     && (strm << stru.member_flags)
     && (strm << stru.type_id)
     && (strm << stru.label_seq);
 }

◆ operator<<() [136/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteElementDetail &	stru
	)

Definition at line 4067 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteElementDetail::ann_builtin, and OpenDDS::XTypes::CompleteElementDetail::ann_custom.

 {
   return (strm << stru.ann_builtin)
     && (strm << stru.ann_custom);
 }

◆ operator<<() [137/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::CompleteMemberDetail &	stru
	)

Definition at line 4089 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteMemberDetail::ann_builtin, OpenDDS::XTypes::CompleteMemberDetail::ann_custom, OpenDDS::XTypes::MEMBER_NAME_MAX_LENGTH, and OpenDDS::XTypes::CompleteMemberDetail::name.

 {
   return (strm << Serializer::FromBoundedString<char>(stru.name, MEMBER_NAME_MAX_LENGTH))
     && (strm << stru.ann_builtin)
     && (strm << stru.ann_custom);
 }

◆ operator<<() [138/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalMemberDetail &	stru
	)

Definition at line 4111 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalMemberDetail::name_hash.

 {
   XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
   return (strm << stru_name_hash);
 }

◆ operator<<() [139/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::ExtendedTypeDefn &
	)

Definition at line 4130 of file TypeObject.cpp.

References OpenDDS::XTypes::write_empty_xcdr2_nonfinal().

 {
   return XTypes::write_empty_xcdr2_nonfinal(strm);
 }

◆ operator<<() [140/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::PlainArrayLElemDefn &	stru
	)

Definition at line 4149 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainArrayLElemDefn::array_bound_seq, OpenDDS::XTypes::PlainArrayLElemDefn::element_identifier, and OpenDDS::XTypes::PlainArrayLElemDefn::header.

 {
   return (strm << stru.header)
     && (strm << stru.array_bound_seq)
     && (strm << *stru.element_identifier);
 }

◆ operator<<() [141/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::PlainArraySElemDefn &	stru
	)

Definition at line 4172 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainArraySElemDefn::array_bound_seq, OpenDDS::XTypes::PlainArraySElemDefn::element_identifier, and OpenDDS::XTypes::PlainArraySElemDefn::header.

 {
   return (strm << stru.header)
     && (strm << stru.array_bound_seq)
     && (strm << *stru.element_identifier);
 }

◆ operator<<() [142/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::PlainMapLTypeDefn &	stru
	)

Definition at line 4197 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainMapLTypeDefn::bound, OpenDDS::XTypes::PlainMapLTypeDefn::element_identifier, OpenDDS::XTypes::PlainMapLTypeDefn::header, OpenDDS::XTypes::PlainMapLTypeDefn::key_flags, and OpenDDS::XTypes::PlainMapLTypeDefn::key_identifier.

 {
   return (strm << stru.header)
     && (strm << stru.bound)
     && (strm << *stru.element_identifier)
     && (strm << stru.key_flags)
     && (strm << *stru.key_identifier);
 }

◆ operator<<() [143/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::PlainMapSTypeDefn &	stru
	)

Definition at line 4226 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainMapSTypeDefn::bound, OpenDDS::XTypes::PlainMapSTypeDefn::element_identifier, OpenDDS::XTypes::PlainMapSTypeDefn::header, OpenDDS::XTypes::PlainMapSTypeDefn::key_flags, and OpenDDS::XTypes::PlainMapSTypeDefn::key_identifier.

 {
   return (strm << stru.header)
     && (strm << ACE_OutputCDR::from_octet(stru.bound))
     && (strm << *stru.element_identifier)
     && (strm << stru.key_flags)
     && (strm << *stru.key_identifier);
 }

◆ operator<<() [144/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::PlainSequenceLElemDefn &	stru
	)

Definition at line 4253 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainSequenceLElemDefn::bound, OpenDDS::XTypes::PlainSequenceLElemDefn::element_identifier, and OpenDDS::XTypes::PlainSequenceLElemDefn::header.

 {
   return (strm << stru.header)
     && (strm << stru.bound)
     && (strm << *stru.element_identifier);
 }

◆ operator<<() [145/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::PlainSequenceSElemDefn &	stru
	)

Definition at line 4276 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainSequenceSElemDefn::bound, OpenDDS::XTypes::PlainSequenceSElemDefn::element_identifier, and OpenDDS::XTypes::PlainSequenceSElemDefn::header.

 {
   return (strm << stru.header)
     && (strm << ACE_OutputCDR::from_octet(stru.bound))
     && (strm << *stru.element_identifier);
 }

◆ operator<<() [146/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::StringLTypeDefn &	stru
	)

Definition at line 4297 of file TypeObject.cpp.

References OpenDDS::XTypes::StringLTypeDefn::bound.

 {
   return (strm << stru.bound);
 }

◆ operator<<() [147/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::StringSTypeDefn &	stru
	)

Definition at line 4314 of file TypeObject.cpp.

References OpenDDS::XTypes::StringSTypeDefn::bound.

 {
   return (strm << ACE_OutputCDR::from_octet(stru.bound));
 }

◆ operator<<() [148/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::StronglyConnectedComponentId &	stru
	)

Definition at line 4334 of file TypeObject.cpp.

References OpenDDS::XTypes::get_typeobject_encoding(), OpenDDS::XTypes::StronglyConnectedComponentId::sc_component_id, OpenDDS::XTypes::StronglyConnectedComponentId::scc_index, OpenDDS::XTypes::StronglyConnectedComponentId::scc_length, serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(XTypes::get_typeobject_encoding(), total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   return (strm << stru.sc_component_id)
     && (strm << stru.scc_length)
     && (strm << stru.scc_index);
 }

◆ operator<<() [149/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::PlainCollectionHeader &	stru
	)

Definition at line 4377 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainCollectionHeader::element_flags, and OpenDDS::XTypes::PlainCollectionHeader::equiv_kind.

 {
   return (strm << ACE_OutputCDR::from_octet(stru.equiv_kind))
     && (strm << stru.element_flags);
 }

◆ operator<<() [150/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::TypeObjectHashId &	uni
	)

Definition at line 4406 of file TypeObject.cpp.

References OpenDDS::XTypes::EK_COMPLETE, OpenDDS::XTypes::EK_MINIMAL, OpenDDS::XTypes::TypeObjectHashId::hash, and OpenDDS::XTypes::TypeObjectHashId::kind.

 {
   if (!(strm << ACE_OutputCDR::from_octet(uni.kind))) {
     return false;
   }
   switch (uni.kind) {
   case XTypes::EK_MINIMAL:
   case XTypes::EK_COMPLETE: {
     XTypes::EquivalenceHash_forany uni_hash(const_cast<XTypes::EquivalenceHash_slice*>(uni.hash));
     return strm << uni_hash;
   }
   default:
     return true;
   }
 }

◆ operator<<() [151/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	ser,
		const XTypes::CompleteTypeObject &	type_object
	)

Definition at line 4481 of file TypeObject.cpp.

 {
   using namespace XTypes;
   if (!(ser << ACE_OutputCDR::from_octet(type_object.kind))) {
     return false;
   }
 
   switch (type_object.kind) {
   case TK_ALIAS:
     return ser << type_object.alias_type;
   case TK_ANNOTATION:
     return ser << type_object.annotation_type;
   case TK_STRUCTURE:
     return ser << type_object.struct_type;
   case TK_UNION:
     return ser << type_object.union_type;
   case TK_BITSET:
     return ser << type_object.bitset_type;
   case TK_SEQUENCE:
     return ser << type_object.sequence_type;
   case TK_ARRAY:
     return ser << type_object.array_type;
   case TK_MAP:
     return ser << type_object.map_type;
   case TK_ENUM:
     return ser << type_object.enumerated_type;
   case TK_BITMASK:
     return ser << type_object.bitmask_type;
   default:
     return ser << type_object.extended_type;
   }
 }

◆ operator<<() [152/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	ser,
		const XTypes::MinimalTypeObject &	type_object
	)

Definition at line 4580 of file TypeObject.cpp.

 {
   using namespace XTypes;
   if (!(ser << ACE_OutputCDR::from_octet(type_object.kind))) {
     return false;
   }
 
   switch (type_object.kind) {
   case TK_ALIAS:
     return ser << type_object.alias_type;
   case TK_ANNOTATION:
     return ser << type_object.annotation_type;
   case TK_STRUCTURE:
     return ser << type_object.struct_type;
   case TK_UNION:
     return ser << type_object.union_type;
   case TK_BITSET:
     return ser << type_object.bitset_type;
   case TK_SEQUENCE:
     return ser << type_object.sequence_type;
   case TK_ARRAY:
     return ser << type_object.array_type;
   case TK_MAP:
     return ser << type_object.map_type;
   case TK_ENUM:
     return ser << type_object.enumerated_type;
   case TK_BITMASK:
     return ser << type_object.bitmask_type;
   default:
     return ser << type_object.extended_type;
   }
 }

◆ operator<<() [153/157]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator<<	(	Serializer &	ser,
		const XTypes::TypeObject &	type_object
	)

Definition at line 4662 of file TypeObject.cpp.

References OpenDDS::XTypes::TypeObject::complete, OpenDDS::XTypes::EK_COMPLETE, OpenDDS::XTypes::EK_MINIMAL, OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::TypeObject::kind, OpenDDS::XTypes::TypeObject::minimal, serialized_size(), and OpenDDS::DCPS::Serializer::write_delimiter().

 {
   size_t total_size = 0;
   serialized_size(ser.encoding(), total_size, type_object);
   if (!ser.write_delimiter(total_size)) {
     return false;
   }
 
   if (!(ser << ACE_OutputCDR::from_octet(type_object.kind))) {
     return false;
   }
 
   switch (type_object.kind) {
   case XTypes::EK_COMPLETE:
     return ser << type_object.complete;
   case XTypes::EK_MINIMAL:
     return ser << type_object.minimal;
   }
 
   return true;
 }

◆ operator<<() [154/157]

bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::MinimalExtendedType &
	)

Definition at line 4715 of file TypeObject.cpp.

References OpenDDS::XTypes::write_empty_xcdr2_nonfinal().

 {
   return XTypes::write_empty_xcdr2_nonfinal(strm);
 }

◆ operator<<() [155/157]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::TypeInformation &	stru
	)

Definition at line 4741 of file TypeObject.cpp.

References OpenDDS::XTypes::TypeInformation::complete, OpenDDS::STUN::encoding(), OpenDDS::DCPS::Serializer::encoding(), OpenDDS::XTypes::TypeInformation::minimal, serialized_size(), OpenDDS::DCPS::Serializer::write_delimiter(), and OpenDDS::DCPS::Serializer::write_parameter_id().

 {
   const Encoding& encoding = strm.encoding();
   size_t total_size = 0;
   serialized_size(encoding, total_size, stru);
   if (!strm.write_delimiter(total_size)) {
     return false;
   }
 
   size_t size = 0;
 
   serialized_size(encoding, size, stru.minimal);
   if (!strm.write_parameter_id(4097, size)) {
     return false;
   }
   size = 0;
   if (!(strm << stru.minimal)) {
     return false;
   }
 
   serialized_size(encoding, size, stru.complete);
   if (!strm.write_parameter_id(4098, size)) {
     return false;
   }
   size = 0;
   if (!(strm << stru.complete)) {
     return false;
   }
 
   return true;
 }

◆ operator<<() [156/157]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::TypeIdentifierTypeObjectPair &	stru
	)

Definition at line 4830 of file TypeObject.cpp.

References OpenDDS::XTypes::TypeIdentifierTypeObjectPair::type_identifier, and OpenDDS::XTypes::TypeIdentifierTypeObjectPair::type_object.

 {
   return (strm << stru.type_identifier)
     && (strm << stru.type_object);
 }

◆ operator<<() [157/157]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator<<	(	Serializer &	strm,
		const XTypes::TypeIdentifierPair &	stru
	)

Definition at line 4850 of file TypeObject.cpp.

References OpenDDS::XTypes::TypeIdentifierPair::type_identifier1, and OpenDDS::XTypes::TypeIdentifierPair::type_identifier2.

 {
   return (strm << stru.type_identifier1)
     && (strm << stru.type_identifier2);
 }

◆ operator<=() [1/5]

ACE_INLINE bool OpenDDS::DCPS::operator<=	(	const DDS::Duration_t &	t1,
		const DDS::Duration_t &	t2
	)

Definition at line 55 of file Time_Helper.inl.

References ACE_INLINE.

 {
   // If t2 is *not* less than t1, t1 must be less than
   // or equal to t2.
   // This is more concise than:
   //   t1 < t2 || t1 == t2
   return !(t2 < t1);
 }

◆ operator<=() [2/5]

ACE_INLINE bool OpenDDS::DCPS::operator<=	(	const DDS::Time_t &	t1,
		const DDS::Time_t &	t2
	)

Definition at line 107 of file Time_Helper.inl.

References ACE_INLINE.

 {
   return !(t2 < t1);
 }

◆ operator<=() [3/5]

ACE_INLINE bool OpenDDS::DCPS::operator<=	(	const TimeDuration &	x,
		const TimeDuration &	y
	)

Definition at line 204 of file TimeDuration.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimeDuration::value().

 {
   return x.value() <= y.value();
 }

◆ operator<=() [4/5]

template<typename AceClock >

bool OpenDDS::DCPS::operator<=	(	const TimePoint_T< AceClock > &	x,
		const TimePoint_T< AceClock > &	y
	)

Definition at line 171 of file TimePoint_T.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return x.value() <= y.value();
 }

◆ operator<=() [5/5]

template<typename AceClock >

ACE_INLINE bool OpenDDS::DCPS::operator<=	(	const TimePoint_T< AceClock > &	x,
		const TimePoint_T< AceClock > &	y
	)

Definition at line 171 of file TimePoint_T.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return x.value() <= y.value();
 }

◆ operator==() [1/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::Duration_t &	t1,
		const DDS::Duration_t &	t2
	)

Definition at line 22 of file Time_Helper.inl.

References ACE_INLINE, DDS::Duration_t::nanosec, and DDS::Duration_t::sec.

 {
   return t1.sec == t2.sec && t1.nanosec == t2.nanosec;
 }

◆ operator==() [2/42]

template<typename X , typename Y >

bool OpenDDS::DCPS::operator==	(	const SafeBool_T< X > &	x,
		const SafeBool_T< Y > &
	)

Definition at line 75 of file SafeBool_T.h.

References OpenDDS::DCPS::SafeBoolBase::this_type_does_not_support_comparisons().

 {
   x.this_type_does_not_support_comparisons();
   return false;
 }

◆ operator==() [3/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::Time_t &	t1,
		const DDS::Time_t &	t2
	)

Definition at line 85 of file Time_Helper.inl.

References ACE_INLINE.

 {
   return !(t1 < t2) && !(t2 < t1);
 }

◆ operator==() [4/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const TimeDuration &	x,
		const TimeDuration &	y
	)

Definition at line 218 of file TimeDuration.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimeDuration::value().

 {
   return x.value() == y.value();
 }

◆ operator==() [5/42]

bool OpenDDS::DCPS::operator==	(	const GUID_t &	lhs,
		const GUID_t &	rhs
	)

inline

Definition at line 132 of file GuidUtils.h.

References memcmp().

 {
   return memcmp(&lhs, &rhs, sizeof(GUID_t)) == 0;
 }

◆ operator==() [6/42]

template<typename AceClock >

bool OpenDDS::DCPS::operator==	(	const TimePoint_T< AceClock > &	x,
		const TimePoint_T< AceClock > &	y
	)

Definition at line 187 of file TimePoint_T.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return x.value() == y.value();
 }

◆ operator==() [7/42]

bool OpenDDS::DCPS::operator==	(	const EntityId_t &	lhs,
		const EntityId_t &	rhs
	)

inline

Definition at line 164 of file GuidUtils.h.

References memcmp().

 {
   return memcmp(&lhs, &rhs, sizeof(EntityId_t)) == 0;
 }

◆ operator==() [8/42]

template<typename AceClock >

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const TimePoint_T< AceClock > &	x,
		const TimePoint_T< AceClock > &	y
	)

Definition at line 187 of file TimePoint_T.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return x.value() == y.value();
 }

◆ operator==() [9/42]

template<typename T >

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const TAO::unbounded_value_sequence< T > &	seq1,
		const TAO::unbounded_value_sequence< T > &	seq2
	)

Definition at line 213 of file Qos_Helper.inl.

References ACE_INLINE, TAO::unbounded_value_sequence< T, Tag >::length(), name, and value.

 {
   if (seq1.length() != seq2.length()) {
     return false;
   }
 
   for (unsigned int i = 0; i < seq1.length(); ++i) {
     if (seq1[i].name != seq2[i].name || seq1[i].value != seq2[i].value || seq1[i].propagate != seq2[i].propagate) {
       return false;
     }
   }
   return true;
 }

◆ operator==() [10/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::PropertyQosPolicy &	qos1,
		const DDS::PropertyQosPolicy &	qos2
	)

Definition at line 228 of file Qos_Helper.inl.

References ACE_INLINE, DDS::PropertyQosPolicy::binary_value, and DDS::PropertyQosPolicy::value.

 {
   return qos1.value == qos2.value && qos1.binary_value == qos2.binary_value;
 }

◆ operator==() [11/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::UserDataQosPolicy &	qos1,
		const DDS::UserDataQosPolicy &	qos2
	)

Definition at line 20 of file Qos_Helper.inl.

References ACE_INLINE, and DDS::UserDataQosPolicy::value.

 {
   return qos1.value == qos2.value;
 }

◆ operator==() [12/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::TopicDataQosPolicy &	qos1,
		const DDS::TopicDataQosPolicy &	qos2
	)

Definition at line 27 of file Qos_Helper.inl.

References ACE_INLINE, and DDS::TopicDataQosPolicy::value.

 {
   return qos1.value == qos2.value;
 }

◆ operator==() [13/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::GroupDataQosPolicy &	qos1,
		const DDS::GroupDataQosPolicy &	qos2
	)

Definition at line 34 of file Qos_Helper.inl.

References ACE_INLINE, and DDS::GroupDataQosPolicy::value.

 {
   return qos1.value == qos2.value;
 }

◆ operator==() [14/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::TransportPriorityQosPolicy &	qos1,
		const DDS::TransportPriorityQosPolicy &	qos2
	)

Definition at line 41 of file Qos_Helper.inl.

References ACE_INLINE, and DDS::TransportPriorityQosPolicy::value.

 {
   return qos1.value == qos2.value;
 }

◆ operator==() [15/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::LifespanQosPolicy &	qos1,
		const DDS::LifespanQosPolicy &	qos2
	)

Definition at line 48 of file Qos_Helper.inl.

References ACE_INLINE, and DDS::LifespanQosPolicy::duration.

 {
   return qos1.duration == qos2.duration;
 }

◆ operator==() [16/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::DurabilityQosPolicy &	qos1,
		const DDS::DurabilityQosPolicy &	qos2
	)

Definition at line 56 of file Qos_Helper.inl.

References ACE_INLINE, and DDS::DurabilityQosPolicy::kind.

 {
   return qos1.kind == qos2.kind;
 }

◆ operator==() [17/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::DurabilityServiceQosPolicy &	qos1,
		const DDS::DurabilityServiceQosPolicy &	qos2
	)

Definition at line 64 of file Qos_Helper.inl.

References ACE_INLINE, DDS::DurabilityServiceQosPolicy::history_depth, DDS::DurabilityServiceQosPolicy::history_kind, DDS::DurabilityServiceQosPolicy::max_instances, DDS::DurabilityServiceQosPolicy::max_samples, DDS::DurabilityServiceQosPolicy::max_samples_per_instance, and DDS::DurabilityServiceQosPolicy::service_cleanup_delay.

 {
   return
     qos1.service_cleanup_delay == qos2.service_cleanup_delay
     && qos1.history_kind == qos2.history_kind
     && qos1.history_depth == qos2.history_depth
     && qos1.max_samples == qos2.max_samples
     && qos1.max_instances == qos2.max_instances
     && qos1.max_samples_per_instance == qos2.max_samples_per_instance;
 }

◆ operator==() [18/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::PresentationQosPolicy &	qos1,
		const DDS::PresentationQosPolicy &	qos2
	)

Definition at line 77 of file Qos_Helper.inl.

References DDS::PresentationQosPolicy::access_scope, ACE_INLINE, DDS::PresentationQosPolicy::coherent_access, and DDS::PresentationQosPolicy::ordered_access.

 {
   return
     qos1.access_scope == qos2.access_scope
     && qos1.coherent_access == qos2.coherent_access
     && qos1.ordered_access == qos2.ordered_access;
 }

◆ operator==() [19/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::DeadlineQosPolicy &	qos1,
		const DDS::DeadlineQosPolicy &	qos2
	)

Definition at line 87 of file Qos_Helper.inl.

References ACE_INLINE, and DDS::DeadlineQosPolicy::period.

 {
   return qos1.period == qos2.period;
 }

◆ operator==() [20/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::LatencyBudgetQosPolicy &	qos1,
		const DDS::LatencyBudgetQosPolicy &	qos2
	)

Definition at line 94 of file Qos_Helper.inl.

References ACE_INLINE, and DDS::LatencyBudgetQosPolicy::duration.

 {
   return qos1.duration == qos2.duration;
 }

◆ operator==() [21/42]

template<typename T >

bool OpenDDS::DCPS::operator==	(	const DisjointSequence::OrderedRanges< T > &	a,
		const DisjointSequence::OrderedRanges< T > &	b
	)

Definition at line 296 of file DisjointSequence.h.

References OPENDDS_END_VERSIONED_NAMESPACE_DECL, and OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::ranges_.

Referenced by OpenDDS::SafetyProfile::Sequence< T, Bounds, Elts >::end(), OpenDDS::DCPS::DisjointSequence::OrderedRanges< SequenceNumber >::has_any(), OpenDDS::Security::CryptoBuiltInImpl::register_matched_remote_participant(), and OpenDDS::STUN::TransactionId::TransactionId().

 {
   return a.ranges_ == b.ranges_;
 }

◆ operator==() [22/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::OwnershipQosPolicy &	qos1,
		const DDS::OwnershipQosPolicy &	qos2
	)

Definition at line 101 of file Qos_Helper.inl.

References ACE_INLINE, and DDS::OwnershipQosPolicy::kind.

 {
   return qos1.kind == qos2.kind;
 }

◆ operator==() [23/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::OwnershipStrengthQosPolicy &	qos1,
		const DDS::OwnershipStrengthQosPolicy &	qos2
	)

Definition at line 108 of file Qos_Helper.inl.

References ACE_INLINE, and DDS::OwnershipStrengthQosPolicy::value.

 {
   return qos1.value == qos2.value;
 }

◆ operator==() [24/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::LivelinessQosPolicy &	qos1,
		const DDS::LivelinessQosPolicy &	qos2
	)

Definition at line 115 of file Qos_Helper.inl.

References ACE_INLINE, DDS::LivelinessQosPolicy::kind, and DDS::LivelinessQosPolicy::lease_duration.

 {
   return
     qos1.kind == qos2.kind
     && qos1.lease_duration == qos2.lease_duration;
 }

◆ operator==() [25/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::TimeBasedFilterQosPolicy &	qos1,
		const DDS::TimeBasedFilterQosPolicy &	qos2
	)

Definition at line 124 of file Qos_Helper.inl.

References ACE_INLINE, and DDS::TimeBasedFilterQosPolicy::minimum_separation.

 {
   return qos1.minimum_separation == qos2.minimum_separation;
 }

◆ operator==() [26/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::PartitionQosPolicy &	qos1,
		const DDS::PartitionQosPolicy &	qos2
	)

Definition at line 131 of file Qos_Helper.inl.

References ACE_INLINE, DDS::PartitionQosPolicy::name, and ACE_OS::strcmp().

 {
   const CORBA::ULong len = qos1.name.length();
 
   if (len == qos2.name.length()) {
     for (CORBA::ULong i = 0; i < len; ++i) {
       if (0 != ACE_OS::strcmp(qos1.name[i], qos2.name[i])) {
         return false;
       }
     }
 
     return true;
   }
 
   return false;
 }

◆ operator==() [27/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::ReliabilityQosPolicy &	qos1,
		const DDS::ReliabilityQosPolicy &	qos2
	)

Definition at line 150 of file Qos_Helper.inl.

References ACE_INLINE, DDS::ReliabilityQosPolicy::kind, and DDS::ReliabilityQosPolicy::max_blocking_time.

 {
   return
     qos1.kind == qos2.kind
     && qos1.max_blocking_time == qos2.max_blocking_time;
 }

◆ operator==() [28/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::DestinationOrderQosPolicy &	qos1,
		const DDS::DestinationOrderQosPolicy &	qos2
	)

Definition at line 159 of file Qos_Helper.inl.

References ACE_INLINE, and DDS::DestinationOrderQosPolicy::kind.

 {
   return qos1.kind == qos2.kind;
 }

◆ operator==() [29/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::HistoryQosPolicy &	qos1,
		const DDS::HistoryQosPolicy &	qos2
	)

Definition at line 166 of file Qos_Helper.inl.

References ACE_INLINE, DDS::HistoryQosPolicy::depth, and DDS::HistoryQosPolicy::kind.

 {
   return
     qos1.kind == qos2.kind
     && qos1.depth == qos2.depth;
 }

◆ operator==() [30/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::ResourceLimitsQosPolicy &	qos1,
		const DDS::ResourceLimitsQosPolicy &	qos2
	)

Definition at line 175 of file Qos_Helper.inl.

References ACE_INLINE, DDS::ResourceLimitsQosPolicy::max_instances, DDS::ResourceLimitsQosPolicy::max_samples, and DDS::ResourceLimitsQosPolicy::max_samples_per_instance.

 {
   return
     qos1.max_samples == qos2.max_samples
     && qos1.max_instances == qos2.max_instances
     && qos1.max_samples_per_instance == qos2.max_samples_per_instance;
 }

◆ operator==() [31/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::EntityFactoryQosPolicy &	qos1,
		const DDS::EntityFactoryQosPolicy &	qos2
	)

Definition at line 185 of file Qos_Helper.inl.

References ACE_INLINE, and DDS::EntityFactoryQosPolicy::autoenable_created_entities.

 {
   // Marked_Default_Qos for DomainParticipant uses a value that's not 0 or 1
   return std::memcmp(&qos1.autoenable_created_entities,
                      &qos2.autoenable_created_entities,
                      sizeof qos2.autoenable_created_entities) == 0;
 }

◆ operator==() [32/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::WriterDataLifecycleQosPolicy &	qos1,
		const DDS::WriterDataLifecycleQosPolicy &	qos2
	)

Definition at line 195 of file Qos_Helper.inl.

References ACE_INLINE, and DDS::WriterDataLifecycleQosPolicy::autodispose_unregistered_instances.

 {
   return
     qos1.autodispose_unregistered_instances == qos2.autodispose_unregistered_instances;
 }

◆ operator==() [33/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::ReaderDataLifecycleQosPolicy &	qos1,
		const DDS::ReaderDataLifecycleQosPolicy &	qos2
	)

Definition at line 203 of file Qos_Helper.inl.

References ACE_INLINE, DDS::ReaderDataLifecycleQosPolicy::autopurge_disposed_samples_delay, and DDS::ReaderDataLifecycleQosPolicy::autopurge_nowriter_samples_delay.

 {
   return
     (qos1.autopurge_nowriter_samples_delay == qos2.autopurge_nowriter_samples_delay)
     && (qos1.autopurge_disposed_samples_delay == qos2.autopurge_disposed_samples_delay);
 }

◆ operator==() [34/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::DomainParticipantQos &	qos1,
		const DDS::DomainParticipantQos &	qos2
	)

Definition at line 235 of file Qos_Helper.inl.

References ACE_INLINE, DDS::DomainParticipantQos::entity_factory, DDS::DomainParticipantQos::property, and DDS::DomainParticipantQos::user_data.

 {
   return
     qos1.user_data == qos2.user_data
     && qos1.entity_factory == qos2.entity_factory
     && qos1.property == qos2.property;
 }

◆ operator==() [35/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::TopicQos &	qos1,
		const DDS::TopicQos &	qos2
	)

Definition at line 245 of file Qos_Helper.inl.

References ACE_INLINE, DDS::TopicQos::deadline, DDS::TopicQos::destination_order, DDS::TopicQos::durability, DDS::TopicQos::durability_service, DDS::TopicQos::history, DDS::TopicQos::latency_budget, DDS::TopicQos::lifespan, DDS::TopicQos::liveliness, DDS::TopicQos::ownership, DDS::TopicQos::reliability, DDS::TopicQos::representation, DDS::TopicQos::resource_limits, DDS::TopicQos::topic_data, and DDS::TopicQos::transport_priority.

 {
   return
     qos1.topic_data == qos2.topic_data
     && qos1.durability == qos2.durability
     && qos1.durability_service == qos2.durability_service
     && qos1.deadline == qos2.deadline
     && qos1.latency_budget == qos2.latency_budget
     && qos1.liveliness == qos2.liveliness
     && qos1.reliability == qos2.reliability
     && qos1.destination_order == qos2.destination_order
     && qos1.history == qos2.history
     && qos1.resource_limits == qos2.resource_limits
     && qos1.transport_priority == qos2.transport_priority
     && qos1.lifespan == qos2.lifespan
     && qos1.ownership == qos2.ownership
     && qos1.representation == qos2.representation;
 }

◆ operator==() [36/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::DataWriterQos &	qos1,
		const DDS::DataWriterQos &	qos2
	)

Definition at line 266 of file Qos_Helper.inl.

 {
   return
     qos1.durability == qos2.durability
     && qos1.durability_service == qos2.durability_service
     && qos1.deadline == qos2.deadline
     && qos1.latency_budget == qos2.latency_budget
     && qos1.liveliness == qos2.liveliness
     && qos1.reliability == qos2.reliability
     && qos1.destination_order == qos2.destination_order
     && qos1.history == qos2.history
     && qos1.resource_limits == qos2.resource_limits
     && qos1.transport_priority == qos2.transport_priority
     && qos1.lifespan == qos2.lifespan
     && qos1.user_data == qos2.user_data
     && qos1.ownership == qos2.ownership
 #ifndef OPENDDS_NO_OWNERSHIP_KIND_EXCLUSIVE
     && qos1.ownership_strength == qos2.ownership_strength
 #endif
     && qos1.writer_data_lifecycle == qos2.writer_data_lifecycle
     && qos1.representation == qos2.representation;
 }

◆ operator==() [37/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::PublisherQos &	qos1,
		const DDS::PublisherQos &	qos2
	)

Definition at line 291 of file Qos_Helper.inl.

References ACE_INLINE, DDS::PublisherQos::entity_factory, DDS::PublisherQos::group_data, DDS::PublisherQos::partition, and DDS::PublisherQos::presentation.

 {
   return
     qos1.presentation == qos2.presentation
     && qos1.partition == qos2.partition
     && qos1.group_data == qos2.group_data
     && qos1.entity_factory == qos2.entity_factory;
 }

◆ operator==() [38/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::DataReaderQos &	qos1,
		const DDS::DataReaderQos &	qos2
	)

Definition at line 302 of file Qos_Helper.inl.

References ACE_INLINE, DDS::DataReaderQos::deadline, DDS::DataReaderQos::destination_order, DDS::DataReaderQos::durability, DDS::DataReaderQos::history, DDS::DataReaderQos::latency_budget, DDS::DataReaderQos::liveliness, DDS::DataReaderQos::reader_data_lifecycle, DDS::DataReaderQos::reliability, DDS::DataReaderQos::representation, DDS::DataReaderQos::resource_limits, DDS::DataReaderQos::time_based_filter, and DDS::DataReaderQos::user_data.

 {
   return
     qos1.durability == qos2.durability
     && qos1.deadline == qos2.deadline
     && qos1.latency_budget == qos2.latency_budget
     && qos1.liveliness == qos2.liveliness
     && qos1.reliability == qos2.reliability
     && qos1.destination_order == qos2.destination_order
     && qos1.history == qos2.history
     && qos1.resource_limits == qos2.resource_limits
     && qos1.user_data == qos2.user_data
     && qos1.time_based_filter == qos2.time_based_filter
     && qos1.reader_data_lifecycle == qos2.reader_data_lifecycle
     && qos1.representation == qos2.representation;
 }

◆ operator==() [39/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::SubscriberQos &	qos1,
		const DDS::SubscriberQos &	qos2
	)

Definition at line 321 of file Qos_Helper.inl.

References ACE_INLINE, DDS::SubscriberQos::entity_factory, DDS::SubscriberQos::group_data, DDS::SubscriberQos::partition, and DDS::SubscriberQos::presentation.

 {
   return
     qos1.presentation == qos2.presentation
     && qos1.partition == qos2.partition
     && qos1.group_data == qos2.group_data
     && qos1.entity_factory == qos2.entity_factory;
 }

◆ operator==() [40/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::DomainParticipantFactoryQos &	qos1,
		const DDS::DomainParticipantFactoryQos &	qos2
	)

Definition at line 332 of file Qos_Helper.inl.

References ACE_INLINE, and DDS::DomainParticipantFactoryQos::entity_factory.

 {
   return qos1.entity_factory == qos2.entity_factory;
 }

◆ operator==() [41/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::DataRepresentationQosPolicy &	qos1,
		const DDS::DataRepresentationQosPolicy &	qos2
	)

Definition at line 339 of file Qos_Helper.inl.

References ACE_INLINE, and DDS::DataRepresentationQosPolicy::value.

 {
   const CORBA::ULong count = qos1.value.length();
   const CORBA::ULong count2 = qos2.value.length();
   if (count != count2) {
     return false;
   }
   for (CORBA::ULong i = 0; i < count; ++i) {
     if (qos1.value[i] != qos2.value[i]) {
       return false;
     }
   }
   return true;
 }

◆ operator==() [42/42]

ACE_INLINE bool OpenDDS::DCPS::operator==	(	const DDS::TypeConsistencyEnforcementQosPolicy &	qos1,
		const DDS::TypeConsistencyEnforcementQosPolicy &	qos2
	)

Definition at line 356 of file Qos_Helper.inl.

References ACE_INLINE, DDS::TypeConsistencyEnforcementQosPolicy::force_type_validation, DDS::TypeConsistencyEnforcementQosPolicy::ignore_member_names, DDS::TypeConsistencyEnforcementQosPolicy::ignore_sequence_bounds, DDS::TypeConsistencyEnforcementQosPolicy::ignore_string_bounds, DDS::TypeConsistencyEnforcementQosPolicy::kind, and DDS::TypeConsistencyEnforcementQosPolicy::prevent_type_widening.

 {
   return qos1.kind == qos2.kind
     && qos1.ignore_sequence_bounds == qos2.ignore_sequence_bounds
     && qos1.ignore_string_bounds == qos2.ignore_string_bounds
     && qos1.ignore_member_names == qos2.ignore_member_names
     && qos1.prevent_type_widening == qos2.prevent_type_widening
     && qos1.force_type_validation == qos2.force_type_validation;
 }

◆ operator>() [1/5]

ACE_INLINE bool OpenDDS::DCPS::operator>	(	const DDS::Duration_t &	t1,
		const DDS::Duration_t &	t2
	)

Definition at line 65 of file Time_Helper.inl.

References ACE_INLINE.

 {
   return t2 < t1;
 }

◆ operator>() [2/5]

ACE_INLINE bool OpenDDS::DCPS::operator>	(	const DDS::Time_t &	t1,
		const DDS::Time_t &	t2
	)

Definition at line 113 of file Time_Helper.inl.

References ACE_INLINE.

 {
   return t2 < t1;
 }

◆ operator>() [3/5]

ACE_INLINE bool OpenDDS::DCPS::operator>	(	const TimeDuration &	x,
		const TimeDuration &	y
	)

Definition at line 197 of file TimeDuration.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimeDuration::value().

 {
   return x.value() > y.value();
 }

◆ operator>() [4/5]

template<typename AceClock >

bool OpenDDS::DCPS::operator>	(	const TimePoint_T< AceClock > &	x,
		const TimePoint_T< AceClock > &	y
	)

Definition at line 163 of file TimePoint_T.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return x.value() > y.value();
 }

◆ operator>() [5/5]

template<typename AceClock >

ACE_INLINE bool OpenDDS::DCPS::operator>	(	const TimePoint_T< AceClock > &	x,
		const TimePoint_T< AceClock > &	y
	)

Definition at line 163 of file TimePoint_T.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return x.value() > y.value();
 }

◆ operator>=() [1/6]

bool OpenDDS::DCPS::operator>=	(	const LogLevel &	ll,
		LogLevel::Value	value
	)

inline

Definition at line 61 of file debug.h.

References DCPS_debug_level, OpenDDS::DCPS::LogLevel::get(), OpenDDS_Dcps_Export, set_DCPS_debug_level(), transport_debug, Transport_debug_level, and value.

 {
   return ll.get() >= value;
 }

◆ operator>=() [2/6]

ACE_INLINE bool OpenDDS::DCPS::operator>=	(	const DDS::Duration_t &	t1,
		const DDS::Duration_t &	t2
	)

Definition at line 71 of file Time_Helper.inl.

References ACE_INLINE.

 {
   return t2 <= t1;
 }

◆ operator>=() [3/6]

ACE_INLINE bool OpenDDS::DCPS::operator>=	(	const DDS::Time_t &	t1,
		const DDS::Time_t &	t2
	)

Definition at line 119 of file Time_Helper.inl.

References ACE_INLINE.

 {
   return t2 <= t1;
 }

◆ operator>=() [4/6]

ACE_INLINE bool OpenDDS::DCPS::operator>=	(	const TimeDuration &	x,
		const TimeDuration &	y
	)

Definition at line 211 of file TimeDuration.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimeDuration::value().

 {
   return x.value() >= y.value();
 }

◆ operator>=() [5/6]

template<typename AceClock >

bool OpenDDS::DCPS::operator>=	(	const TimePoint_T< AceClock > &	x,
		const TimePoint_T< AceClock > &	y
	)

Definition at line 179 of file TimePoint_T.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return x.value() >= y.value();
 }

◆ operator>=() [6/6]

template<typename AceClock >

ACE_INLINE bool OpenDDS::DCPS::operator>=	(	const TimePoint_T< AceClock > &	x,
		const TimePoint_T< AceClock > &	y
	)

Definition at line 179 of file TimePoint_T.inl.

References ACE_INLINE, and OpenDDS::DCPS::TimePoint_T< AceClock >::value().

 {
   return x.value() >= y.value();
 }

◆ operator>>() [1/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::TypeLookup_getTypes_In &	stru
	)

Definition at line 44 of file TypeLookup.cpp.

References ACE_DEBUG, ACE_TEXT(), DCPS_debug_level, LM_DEBUG, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::read_parameter_id(), OpenDDS::DCPS::Serializer::rpos(), OpenDDS::DCPS::Serializer::skip(), and OpenDDS::XTypes::TypeLookup_getTypes_In::type_ids.

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   unsigned member_id;
   size_t field_size;
   while (true) {
 
     if (strm.rpos() - start_pos >= total_size) {
       return true;
     }
 
     bool must_understand = false;
     if (!strm.read_parameter_id(member_id, field_size, must_understand)) {
       return false;
     }
 
     switch (member_id) {
     case 206790757:
       if (!(strm >> stru.type_ids)) {
         return false;
       }
       break;
     default:
       if (must_understand) {
         if (DCPS_debug_level >= 8) {
           ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) unknown must_understand field(%u) in OpenDDS::XTypes::TypeLookup_getTypes_In\n"), member_id));
         }
         return false;
       }
       strm.skip(field_size);
       break;
     }
   }
   return false;
 }

◆ operator>>() [2/146]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator>>	(	Serializer &	serializer,
		CoherentChangeControl &	value
	)

Definition at line 64 of file CoherentChangeControl.cpp.

References OpenDDS::DCPS::CoherentChangeControl::coherent_samples_, OpenDDS::DCPS::Serializer::good_bit(), OpenDDS::DCPS::CoherentChangeControl::group_coherent_, OpenDDS::DCPS::CoherentChangeControl::group_coherent_samples_, GUID_UNKNOWN, OpenDDS::DCPS::WriterCoherentSample::last_sample_, OpenDDS::DCPS::WriterCoherentSample::num_samples_, OpenDDS_Dcps_Export, and OpenDDS::DCPS::CoherentChangeControl::publisher_id_.

Referenced by address_to_bytes(), assign(), and operator>>().

 {
   if (!(serializer >> value.coherent_samples_.num_samples_) ||
       !(serializer >> value.coherent_samples_.last_sample_) ||
       !(serializer >> ACE_InputCDR::to_boolean(value.group_coherent_))) {
     return false;
   }
 
   if (value.group_coherent_) {
     ACE_UINT32 sz = 0;
     if (!(serializer >> value.publisher_id_) ||
         !(serializer >> sz)) {
       return false;
     }
 
     for (ACE_UINT32 i = 0; i < sz; ++i) {
       PublicationId writer(GUID_UNKNOWN);
       ACE_UINT32 num_sample = 0;
       ACE_INT16 last_sample = 0;
 
       if (!(serializer >> writer) ||
           !(serializer >> num_sample) ||
           !(serializer >> last_sample)) {
         return false;
       }
 
       std::pair<GroupCoherentSamples::iterator, bool> pair =
         value.group_coherent_samples_.insert(GroupCoherentSamples::value_type(
           writer, WriterCoherentSample(num_sample, last_sample)));
       if (!pair.second) {
         return false;
       }
     }
   }
 
   return serializer.good_bit();
 }

◆ operator>>() [3/146]

OpenDDS_Dcps_Export std::istream & OpenDDS::DCPS::operator>>	(	std::istream &	is,
		GUID_t &	rhs
	)

Definition at line 98 of file GuidUtils.cpp.

References OpenDDS::DCPS::GuidBuilder::entityId(), OpenDDS::DCPS::GuidBuilder::guidPrefix0(), OpenDDS::DCPS::GuidBuilder::guidPrefix1(), OpenDDS::DCPS::GuidBuilder::guidPrefix2(), and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

 {
   long word;
   char discard;
 
   GuidBuilder builder(rhs);
 
   is >> std::hex >> word;
   builder.guidPrefix0(word);
   is >> discard; // sep
 
   is >> std::hex >> word;
   builder.guidPrefix1(word);
   is >> discard; // sep
 
   is >> std::hex >> word;
   builder.guidPrefix2(word);
   is >> discard; // sep
 
   is >> std::hex >> word;
   builder.entityId(word);
 
   return is;
 }

◆ operator>>() [4/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::TypeLookup_getTypes_Out &	stru
	)

Definition at line 128 of file TypeLookup.cpp.

References ACE_DEBUG, ACE_TEXT(), OpenDDS::XTypes::TypeLookup_getTypes_Out::complete_to_minimal, DCPS_debug_level, LM_DEBUG, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::read_parameter_id(), OpenDDS::DCPS::Serializer::rpos(), OpenDDS::DCPS::Serializer::skip(), and OpenDDS::XTypes::TypeLookup_getTypes_Out::types.

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   unsigned member_id;
   size_t field_size;
   while (true) {
 
     if (strm.rpos() - start_pos >= total_size) {
       return true;
     }
 
     bool must_understand = false;
     if (!strm.read_parameter_id(member_id, field_size, must_understand)) {
       return false;
     }
 
     switch (member_id) {
     case 41962193:
       if (!(strm >> stru.types)) {
         return false;
       }
       break;
     case 193881463:
       if (!(strm >> stru.complete_to_minimal)) {
         return false;
       }
       break;
     default:
       if (must_understand) {
         if (DCPS_debug_level >= 8) {
           ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) unknown must_understand field(%u) in OpenDDS::XTypes::TypeLookup_getTypes_Out\n"), member_id));
         }
         return false;
       }
       strm.skip(field_size);
       break;
     }
   }
   return false;
 }

◆ operator>>() [5/146]

ACE_CDR::Boolean OpenDDS::DCPS::operator>>	(	Serializer &	s,
		SequenceNumber &	x
	)

inline

Definition at line 164 of file SequenceNumber.h.

                                              {
   ACE_INT32 high;
   ACE_UINT32 low;
   if (!(s >> high)) {
     return false;
   }
   if (!(s >> low)) {
     return false;
   }
   x = SequenceNumber(high, low);
   return true;
 }

◆ operator>>() [6/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::TypeLookup_getTypes_Result &	uni
	)

Definition at line 209 of file TypeLookup.cpp.

References OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::XTypes::TypeLookup_getTypes_Result::result, and OpenDDS::XTypes::TypeLookup_getTypes_Result::return_code.

 {
   size_t total_size;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   if (!(strm >> uni.return_code)) {
     return false;
   }
 
   switch (uni.return_code) {
   case 0:
     return strm >> uni.result;
   }
 
   return true;
 }

◆ operator>>() [7/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::TypeLookup_getTypeDependencies_In &	stru
	)

Definition at line 270 of file TypeLookup.cpp.

References ACE_DEBUG, ACE_TEXT(), OpenDDS::XTypes::TypeLookup_getTypeDependencies_In::continuation_point, DCPS_debug_level, LM_DEBUG, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::read_parameter_id(), OpenDDS::DCPS::Serializer::rpos(), OpenDDS::DCPS::Serializer::skip(), and OpenDDS::XTypes::TypeLookup_getTypeDependencies_In::type_ids.

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
   unsigned member_id;
   size_t field_size;
   while (true) {
 
     if (strm.rpos() - start_pos >= total_size) {
       return true;
     }
 
     bool must_understand = false;
     if (!strm.read_parameter_id(member_id, field_size, must_understand)) {
       return false;
     }
 
     switch (member_id) {
     case 206790757:
       if (!(strm >> stru.type_ids)) {
         return false;
       }
       break;
     case 84468690:
       if (!(strm >> stru.continuation_point)) {
         return false;
       }
       break;
     default:
       if (must_understand) {
         if (DCPS_debug_level >= 8) {
           ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) unknown must_understand field(%u) in OpenDDS::XTypes::TypeLookup_getTypeDependencies_In\n"), member_id));
         }
         return false;
       }
       strm.skip(field_size);
       break;
     }
   }
   return false;
 }

◆ operator>>() [8/146]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		EncapsulationHeader &	value
	)

Definition at line 297 of file Serializer.cpp.

References OpenDDS::DCPS::EncapsulationHeader::kind(), OpenDDS::DCPS::EncapsulationHeader::options(), OpenDDS::DCPS::Serializer::read_octet_array(), OpenDDS::DCPS::Serializer::reset_alignment(), and OpenDDS::DCPS::EncapsulationHeader::serialized_size.

 {
   ACE_CDR::Octet data[EncapsulationHeader::serialized_size];
   if (!s.read_octet_array(&data[0], EncapsulationHeader::serialized_size)) {
     return false;
   }
   value.kind(static_cast<EncapsulationHeader::Kind>(
     (static_cast<ACE_UINT16>(data[0]) << 8) | data[1]));
   value.options((static_cast<ACE_UINT16>(data[2]) << 8) | data[3]);
   s.reset_alignment();
   return true;
 }

◆ operator>>() [9/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::TypeLookup_getTypeDependencies_Out &	stru
	)

Definition at line 358 of file TypeLookup.cpp.

References ACE_DEBUG, ACE_TEXT(), OpenDDS::XTypes::TypeLookup_getTypeDependencies_Out::continuation_point, DCPS_debug_level, OpenDDS::XTypes::TypeLookup_getTypeDependencies_Out::dependent_typeids, LM_DEBUG, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::read_parameter_id(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
   unsigned member_id;
   size_t field_size;
 
   while (true) {
 
     if (strm.rpos() - start_pos >= total_size) {
       return true;
     }
 
     bool must_understand = false;
     if (!strm.read_parameter_id(member_id, field_size, must_understand)) {
       return false;
     }
 
     switch (member_id) {
     case 195354569:
       if (!(strm >> stru.dependent_typeids)) {
         return false;
       }
       break;
     case 84468690:
       if (!(strm >> stru.continuation_point)) {
         return false;
       }
       break;
     default:
       if (must_understand) {
         if (DCPS_debug_level >= 8) {
           ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) unknown must_understand field(%u) in OpenDDS::XTypes::TypeLookup_getTypeDependencies_Out\n"), member_id));
         }
         return false;
       }
       strm.skip(field_size);
       break;
     }
   }
   return false;
 }

◆ operator>>() [10/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::TypeLookup_getTypeDependencies_Result &	uni
	)

Definition at line 440 of file TypeLookup.cpp.

References OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::XTypes::TypeLookup_getTypeDependencies_Result::result, and OpenDDS::XTypes::TypeLookup_getTypeDependencies_Result::return_code.

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   if (!(strm >> uni.return_code)) {
     return false;
   }
 
   switch (uni.return_code) {
   case 0:
     return strm >> uni.result;
   }
 
   return true;
 }

◆ operator>>() [11/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::TypeLookup_Call &	uni
	)

Definition at line 497 of file TypeLookup.cpp.

References OpenDDS::XTypes::TypeLookup_Call::getTypeDependencies, OpenDDS::XTypes::TypeLookup_Call::getTypes, OpenDDS::XTypes::TypeLookup_Call::kind, and OpenDDS::DCPS::Serializer::read_delimiter().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   if (!(strm >> uni.kind)) {
     return false;
   }
 
   switch (uni.kind) {
   case 25318099:
     return strm >> uni.getTypes;
   case 95091505:
     return strm >> uni.getTypeDependencies;
   }
 
   return true;
 }

◆ operator>>() [12/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::TypeLookup_Request &	stru
	)

Definition at line 532 of file TypeLookup.cpp.

References OpenDDS::XTypes::TypeLookup_Request::data, and OpenDDS::XTypes::TypeLookup_Request::header.

 {
   return (strm >> stru.header)
     && (strm >> stru.data);
 }

◆ operator>>() [13/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::TypeLookup_Return &	uni
	)

Definition at line 577 of file TypeLookup.cpp.

References OpenDDS::XTypes::TypeLookup_Return::getType, OpenDDS::XTypes::TypeLookup_Return::getTypeDependencies, OpenDDS::XTypes::TypeLookup_Return::kind, and OpenDDS::DCPS::Serializer::read_delimiter().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   if (!(strm >> uni.kind)) {
     return false;
   }
 
   switch (uni.kind) {
   case 25318099:
     return strm >> uni.getType;
   case 95091505:
     return strm >> uni.getTypeDependencies;
   }
 
   return true;
 }

◆ operator>>() [14/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::TypeLookup_Reply &	stru
	)

Definition at line 612 of file TypeLookup.cpp.

References OpenDDS::XTypes::TypeLookup_Reply::_cxx_return, and OpenDDS::XTypes::TypeLookup_Reply::header.

 {
   return (strm >> stru.header)
     && (strm >> stru._cxx_return);
 }

◆ operator>>() [15/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::OctetSeq32 &	seq
	)

Definition at line 644 of file TypeLookup.cpp.

References OpenDDS::XTypes::Sequence< T >::get_buffer(), OpenDDS::XTypes::Sequence< T >::length(), OPENDDS_END_VERSIONED_NAMESPACE_DECL, and OpenDDS::DCPS::Serializer::read_octet_array().

 {
   CORBA::ULong length;
   if (!(strm >> length)) {
     return false;
   }
   if (length > 32) {
     return false;
   }
   seq.length(length);
   if (length == 0) {
     return true;
   }
   return strm.read_octet_array(seq.get_buffer(), length);
 }

◆ operator>>() [16/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_CDR::Char &	x
	)

Definition at line 1227 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::buffer_read(), char8_cdr_size, OpenDDS::DCPS::Serializer::good_bit(), and OpenDDS::DCPS::Serializer::swap_bytes().

 {
   s.buffer_read(reinterpret_cast<char*>(&x), char8_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>>() [17/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_CDR::Short &	x
	)

Definition at line 1234 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_r(), OpenDDS::DCPS::Serializer::buffer_read(), OpenDDS::DCPS::Serializer::good_bit(), int16_cdr_size, and OpenDDS::DCPS::Serializer::swap_bytes().

 {
   if (!s.align_r(int16_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), int16_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>>() [18/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_CDR::UShort &	x
	)

Definition at line 1244 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_r(), OpenDDS::DCPS::Serializer::buffer_read(), OpenDDS::DCPS::Serializer::good_bit(), OpenDDS::DCPS::Serializer::swap_bytes(), and uint16_cdr_size.

 {
   if (!s.align_r(uint16_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), uint16_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>>() [19/146]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::TypeIdentifier &	uni
	)

Definition at line 1251 of file TypeObject.cpp.

 {
   ACE_CDR::Octet k;
   if (!(strm >> ACE_InputCDR::to_octet(k))) {
     return false;
   }
   uni = XTypes::TypeIdentifier(k);
 
   switch (k) {
   case XTypes::TI_STRING8_SMALL:
   case XTypes::TI_STRING16_SMALL:
     return (strm >> uni.string_sdefn());
   case XTypes::TI_STRING8_LARGE:
   case XTypes::TI_STRING16_LARGE:
     return (strm >> uni.string_ldefn());
   case XTypes::TI_PLAIN_SEQUENCE_SMALL:
     return (strm >> uni.seq_sdefn());
   case XTypes::TI_PLAIN_SEQUENCE_LARGE:
     return (strm >> uni.seq_ldefn());
   case XTypes::TI_PLAIN_ARRAY_SMALL:
     return (strm >> uni.array_sdefn());
   case XTypes::TI_PLAIN_ARRAY_LARGE:
     return (strm >> uni.array_ldefn());
   case XTypes::TI_PLAIN_MAP_SMALL:
     return (strm >> uni.map_sdefn());
   case XTypes::TI_PLAIN_MAP_LARGE:
     return (strm >> uni.map_ldefn());
   case XTypes::TI_STRONGLY_CONNECTED_COMPONENT:
     return (strm >> uni.sc_component_id());
   case XTypes::EK_COMPLETE:
   case XTypes::EK_MINIMAL:
     {
       XTypes::EquivalenceHash_forany uni_equivalence_hash(uni.equivalence_hash());
       return (strm >> uni_equivalence_hash);
     }
   case XTypes::TK_NONE:
   case XTypes::TK_BOOLEAN:
   case XTypes::TK_BYTE:
   case XTypes::TK_INT16:
   case XTypes::TK_INT32:
   case XTypes::TK_INT64:
   case XTypes::TK_UINT16:
   case XTypes::TK_UINT32:
   case XTypes::TK_UINT64:
   case XTypes::TK_FLOAT32:
   case XTypes::TK_FLOAT64:
   case XTypes::TK_FLOAT128:
   case XTypes::TK_INT8:
   case XTypes::TK_UINT8:
   case XTypes::TK_CHAR8:
   case XTypes::TK_CHAR16:
     return true; // no-op, no member selected
   default:
     return (strm >> uni.extended_defn());
   }
 }

◆ operator>>() [20/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_CDR::Long &	x
	)

Definition at line 1254 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_r(), OpenDDS::DCPS::Serializer::buffer_read(), OpenDDS::DCPS::Serializer::good_bit(), int32_cdr_size, and OpenDDS::DCPS::Serializer::swap_bytes().

 {
   if (!s.align_r(int32_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), int32_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>>() [21/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_CDR::ULong &	x
	)

Definition at line 1264 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_r(), OpenDDS::DCPS::Serializer::buffer_read(), OpenDDS::DCPS::Serializer::good_bit(), OpenDDS::DCPS::Serializer::swap_bytes(), and uint32_cdr_size.

 {
   if (!s.align_r(uint32_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), uint32_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>>() [22/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_CDR::LongLong &	x
	)

Definition at line 1274 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_r(), OpenDDS::DCPS::Serializer::buffer_read(), OpenDDS::DCPS::Serializer::good_bit(), int64_cdr_size, and OpenDDS::DCPS::Serializer::swap_bytes().

 {
   if (!s.align_r(int64_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), int64_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>>() [23/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_CDR::ULongLong &	x
	)

Definition at line 1284 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_r(), OpenDDS::DCPS::Serializer::buffer_read(), OpenDDS::DCPS::Serializer::good_bit(), OpenDDS::DCPS::Serializer::swap_bytes(), and uint64_cdr_size.

 {
   if (!s.align_r(uint64_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), uint64_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>>() [24/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_CDR::Float &	x
	)

Definition at line 1294 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_r(), OpenDDS::DCPS::Serializer::buffer_read(), float32_cdr_size, OpenDDS::DCPS::Serializer::good_bit(), and OpenDDS::DCPS::Serializer::swap_bytes().

 {
   if (!s.align_r(float32_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), float32_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>>() [25/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_CDR::Double &	x
	)

Definition at line 1304 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_r(), OpenDDS::DCPS::Serializer::buffer_read(), float64_cdr_size, OpenDDS::DCPS::Serializer::good_bit(), and OpenDDS::DCPS::Serializer::swap_bytes().

 {
   if (!s.align_r(float64_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), float64_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>>() [26/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_CDR::LongDouble &	x
	)

Definition at line 1314 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_r(), OpenDDS::DCPS::Serializer::buffer_read(), float128_cdr_size, OpenDDS::DCPS::Serializer::good_bit(), and OpenDDS::DCPS::Serializer::swap_bytes().

 {
   if (!s.align_r(float128_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), float128_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>>() [27/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_CDR::Char *&	x
	)

Definition at line 1324 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::good_bit(), and OpenDDS::DCPS::Serializer::read_string().

 {
   s.read_string(x);
   return s.good_bit();
 }

◆ operator>>() [28/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_CDR::WChar *&	x
	)

Definition at line 1331 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_r(), float128_cdr_size, OpenDDS::DCPS::Serializer::good_bit(), operator>>(), and OpenDDS::DCPS::Serializer::read_string().

 {
   s.read_string(x);
   return s.good_bit();
 }

◆ operator>>() [29/146]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::LBoundSeq &	seq
	)

Definition at line 1331 of file TypeObject.cpp.

References OpenDDS::XTypes::Sequence< T >::get_buffer(), OpenDDS::XTypes::Sequence< T >::length(), and OpenDDS::DCPS::Serializer::read_ulong_array().

 {
   ACE_CDR::ULong length;
   if (!(strm >> length)) {
     return false;
   }
   seq.length(length);
   if (length == 0) {
     return true;
   }
   return strm.read_ulong_array(seq.get_buffer(), length);
 }

◆ operator>>() [30/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_InputCDR::to_boolean	x
	)

Definition at line 1354 of file Serializer.inl.

References ACE_INLINE, boolean_cdr_size, OpenDDS::DCPS::Serializer::buffer_read(), OpenDDS::DCPS::Serializer::good_bit(), ACE_InputCDR::to_boolean::ref_, and OpenDDS::DCPS::Serializer::swap_bytes().

 {
   s.buffer_read(reinterpret_cast<char*>(&x.ref_), boolean_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>>() [31/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_InputCDR::to_char	x
	)

Definition at line 1361 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::buffer_read(), char8_cdr_size, OpenDDS::DCPS::Serializer::good_bit(), ACE_InputCDR::to_char::ref_, and OpenDDS::DCPS::Serializer::swap_bytes().

 {
   s.buffer_read(reinterpret_cast<char*>(&x.ref_), char8_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>>() [32/146]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::SBoundSeq &	seq
	)

Definition at line 1367 of file TypeObject.cpp.

References OpenDDS::XTypes::Sequence< T >::get_buffer(), OpenDDS::XTypes::Sequence< T >::length(), and OpenDDS::DCPS::Serializer::read_octet_array().

 {
   ACE_CDR::ULong length;
   if (!(strm >> length)) {
     return false;
   }
   seq.length(length);
   if (length == 0) {
     return true;
   }
   return strm.read_octet_array(seq.get_buffer(), length);
 }

◆ operator>>() [33/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_InputCDR::to_wchar	x
	)

Definition at line 1368 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::align_r(), OpenDDS::DCPS::Serializer::buffer_read(), char16_cdr_size, OpenDDS::DCPS::Serializer::good_bit(), ACE_InputCDR::to_wchar::ref_, and OpenDDS::DCPS::Serializer::swap_bytes().

 {
   if (!s.align_r(char16_cdr_size)) {
     return false;
   }
 #if ACE_SIZEOF_WCHAR == 2
   s.buffer_read(reinterpret_cast<char*>(&x.ref_), char16_cdr_size,
     s.swap_bytes());
 #else
   ACE_UINT16 as_utf16;
   s.buffer_read(reinterpret_cast<char*>(&as_utf16), char16_cdr_size,
     s.swap_bytes());
   x.ref_ = as_utf16;
 #endif
   return s.good_bit();
 }

◆ operator>>() [34/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_InputCDR::to_octet	x
	)

Definition at line 1386 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::buffer_read(), byte_cdr_size, OpenDDS::DCPS::Serializer::good_bit(), and ACE_InputCDR::to_octet::ref_.

 {
   s.buffer_read(reinterpret_cast<char*>(&x.ref_), byte_cdr_size, false);
   return s.good_bit();
 }

◆ operator>>() [35/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_InputCDR::to_string	x
	)

Definition at line 1393 of file Serializer.inl.

References ACE_INLINE, ACE_InputCDR::to_string::bound_, OpenDDS::DCPS::Serializer::BoundConstructionFailure, OpenDDS::DCPS::Serializer::good_bit(), OpenDDS::DCPS::Serializer::read_string(), OpenDDS::DCPS::Serializer::set_construction_status(), and ACE_InputCDR::to_string::val_.

 {
   const size_t length = s.read_string(const_cast<char*&>(x.val_));
   if (s.good_bit() && (x.bound_ != 0) && (length > x.bound_)) {
     s.set_construction_status(Serializer::BoundConstructionFailure);
     return false;
   }
   return s.good_bit();
 }

◆ operator>>() [36/146]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::UnionCaseLabelSeq &	seq
	)

Definition at line 1403 of file TypeObject.cpp.

References OpenDDS::XTypes::Sequence< T >::get_buffer(), OpenDDS::XTypes::Sequence< T >::length(), and OpenDDS::DCPS::Serializer::read_long_array().

 {
   ACE_CDR::ULong length;
   if (!(strm >> length)) {
     return false;
   }
   seq.length(length);
   if (length == 0) {
     return true;
   }
   return strm.read_long_array(seq.get_buffer(), length);
 }

◆ operator>>() [37/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		ACE_InputCDR::to_wstring	x
	)

Definition at line 1404 of file Serializer.inl.

References ACE_INLINE, ACE_InputCDR::to_wstring::bound_, OpenDDS::DCPS::Serializer::BoundConstructionFailure, OpenDDS::DCPS::Serializer::buffer_read(), OpenDDS::DCPS::Serializer::good_bit(), int8_cdr_size, operator>>(), OpenDDS::DCPS::Serializer::read_string(), ACE_InputCDR::to_uint8::ref_, ACE_InputCDR::to_int8::ref_, OpenDDS::DCPS::Serializer::set_construction_status(), uint8_cdr_size, and ACE_InputCDR::to_wstring::val_.

 {
   const size_t length = s.read_string(const_cast<ACE_CDR::WChar*&>(x.val_));
   if (s.good_bit() && (x.bound_ != 0) && (length > x.bound_)) {
     s.set_construction_status(Serializer::BoundConstructionFailure);
     return false;
   }
   return s.good_bit();
 }

◆ operator>>() [38/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::ExtendedAnnotationParameterValue &
	)

Definition at line 1428 of file TypeObject.cpp.

References OpenDDS::XTypes::read_empty_xcdr2_nonfinal().

 {
   return XTypes::read_empty_xcdr2_nonfinal(strm);
 }

◆ operator>>() [39/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		String &	x
	)

Definition at line 1431 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::free_string(), OpenDDS::DCPS::Serializer::good_bit(), and OpenDDS::DCPS::Serializer::read_string().

 {
   char* buf = 0;
   const size_t length = s.read_string(buf);
   x.assign(buf, length);
   s.free_string(buf);
   return s.good_bit();
 }

◆ operator>>() [40/146]

ACE_INLINE bool OpenDDS::DCPS::operator>>	(	Serializer &	s,
		Serializer::ToBoundedString< char >	x
	)

Definition at line 1441 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Serializer::ToBoundedString< CharT >::bound_, OpenDDS::DCPS::Serializer::BoundConstructionFailure, OpenDDS::DCPS::Serializer::free_string(), OpenDDS::DCPS::Serializer::good_bit(), operator>>(), OpenDDS::DCPS::Serializer::read_string(), OpenDDS::DCPS::Serializer::set_construction_status(), and OpenDDS::DCPS::Serializer::ToBoundedString< CharT >::str_.

 {
   if (s >> x.str_) {
     if ((x.bound_ != 0) && (x.str_.size() > x.bound_)) {
       s.set_construction_status(Serializer::BoundConstructionFailure);
       return false;
     }
     return true;
   }
   return false;
 }

◆ operator>>() [41/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::NameHash_forany &	arr
	)

Definition at line 1445 of file TypeObject.cpp.

References OpenDDS::XTypes::Fake_TAO_Array_Forany_T< T, T_slice, TAG >::out(), and OpenDDS::DCPS::Serializer::read_octet_array().

 {
   return strm.read_octet_array(arr.out(), 4);
 }

◆ operator>>() [42/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::EquivalenceHash_forany &	arr
	)

Definition at line 1462 of file TypeObject.cpp.

References OpenDDS::XTypes::Fake_TAO_Array_Forany_T< T, T_slice, TAG >::out(), and OpenDDS::DCPS::Serializer::read_octet_array().

 {
   return strm.read_octet_array(arr.out(), 14);
 }

◆ operator>>() [43/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteTypeDetail &	stru
	)

Definition at line 1484 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteTypeDetail::ann_builtin, OpenDDS::XTypes::CompleteTypeDetail::ann_custom, OpenDDS::XTypes::CompleteTypeDetail::type_name, and OpenDDS::XTypes::TYPE_NAME_MAX_LENGTH.

 {
   return (strm >> stru.ann_builtin)
     && (strm >> stru.ann_custom)
     && (strm >> Serializer::ToBoundedString<char>(stru.type_name, TYPE_NAME_MAX_LENGTH));
 }

◆ operator>>() [44/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteStructHeader &	stru
	)

Definition at line 1512 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteStructHeader::base_type, OpenDDS::XTypes::CompleteStructHeader::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.base_type)
     && (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [45/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalStructHeader &	stru
	)

Definition at line 1551 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalStructHeader::base_type, OpenDDS::XTypes::MinimalStructHeader::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.base_type)
     && (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [46/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteStructType &	stru
	)

Definition at line 1584 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteStructType::header, OpenDDS::XTypes::CompleteStructType::member_seq, and OpenDDS::XTypes::CompleteStructType::struct_flags.

 {
   return (strm >> stru.struct_flags)
     && (strm >> stru.header)
     && (strm >> stru.member_seq);
 }

◆ operator>>() [47/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalStructType &	stru
	)

Definition at line 1607 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalStructType::header, OpenDDS::XTypes::MinimalStructType::member_seq, and OpenDDS::XTypes::MinimalStructType::struct_flags.

 {
   return (strm >> stru.struct_flags)
     && (strm >> stru.header)
     && (strm >> stru.member_seq);
 }

◆ operator>>() [48/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteUnionType &	stru
	)

Definition at line 1632 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteUnionType::discriminator, OpenDDS::XTypes::CompleteUnionType::header, OpenDDS::XTypes::CompleteUnionType::member_seq, and OpenDDS::XTypes::CompleteUnionType::union_flags.

 {
   return (strm >> stru.union_flags)
     && (strm >> stru.header)
     && (strm >> stru.discriminator)
     && (strm >> stru.member_seq);
 }

◆ operator>>() [49/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalUnionType &	stru
	)

Definition at line 1658 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalUnionType::discriminator, OpenDDS::XTypes::MinimalUnionType::header, OpenDDS::XTypes::MinimalUnionType::member_seq, and OpenDDS::XTypes::MinimalUnionType::union_flags.

 {
   return (strm >> stru.union_flags)
     && (strm >> stru.header)
     && (strm >> stru.discriminator)
     && (strm >> stru.member_seq);
 }

◆ operator>>() [50/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteAnnotationType &	stru
	)

Definition at line 1682 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAnnotationType::annotation_flag, OpenDDS::XTypes::CompleteAnnotationType::header, and OpenDDS::XTypes::CompleteAnnotationType::member_seq.

 {
   return (strm >> stru.annotation_flag)
     && (strm >> stru.header)
     && (strm >> stru.member_seq);
 }

◆ operator>>() [51/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalAnnotationType &	stru
	)

Definition at line 1705 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalAnnotationType::annotation_flag, OpenDDS::XTypes::MinimalAnnotationType::header, and OpenDDS::XTypes::MinimalAnnotationType::member_seq.

 {
   return (strm >> stru.annotation_flag)
     && (strm >> stru.header)
     && (strm >> stru.member_seq);
 }

◆ operator>>() [52/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteAliasType &	stru
	)

Definition at line 1728 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAliasType::alias_flags, OpenDDS::XTypes::CompleteAliasType::body, and OpenDDS::XTypes::CompleteAliasType::header.

 {
   return (strm >> stru.alias_flags)
     && (strm >> stru.header)
     && (strm >> stru.body);
 }

◆ operator>>() [53/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalAliasType &	stru
	)

Definition at line 1751 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalAliasType::alias_flags, OpenDDS::XTypes::MinimalAliasType::body, and OpenDDS::XTypes::MinimalAliasType::header.

 {
   return (strm >> stru.alias_flags)
     && (strm >> stru.header)
     && (strm >> stru.body);
 }

◆ operator>>() [54/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteSequenceType &	stru
	)

Definition at line 1774 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteSequenceType::collection_flag, OpenDDS::XTypes::CompleteSequenceType::element, and OpenDDS::XTypes::CompleteSequenceType::header.

 {
   return (strm >> stru.collection_flag)
     && (strm >> stru.header)
     && (strm >> stru.element);
 }

◆ operator>>() [55/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalSequenceType &	stru
	)

Definition at line 1797 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalSequenceType::collection_flag, OpenDDS::XTypes::MinimalSequenceType::element, and OpenDDS::XTypes::MinimalSequenceType::header.

 {
   return (strm >> stru.collection_flag)
     && (strm >> stru.header)
     && (strm >> stru.element);
 }

◆ operator>>() [56/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteArrayType &	stru
	)

Definition at line 1827 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteArrayType::collection_flag, OpenDDS::XTypes::CompleteArrayType::element, OpenDDS::XTypes::CompleteArrayType::header, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.collection_flag)
     && (strm >> stru.header)
     && (strm >> stru.element);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [57/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalArrayType &	stru
	)

Definition at line 1862 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalArrayType::collection_flag, OpenDDS::XTypes::MinimalArrayType::element, and OpenDDS::XTypes::MinimalArrayType::header.

 {
   return (strm >> stru.collection_flag)
     && (strm >> stru.header)
     && (strm >> stru.element);
 }

◆ operator>>() [58/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteMapType &	stru
	)

Definition at line 1887 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteMapType::collection_flag, OpenDDS::XTypes::CompleteMapType::element, OpenDDS::XTypes::CompleteMapType::header, and OpenDDS::XTypes::CompleteMapType::key.

 {
   return (strm >> stru.collection_flag)
     && (strm >> stru.header)
     && (strm >> stru.key)
     && (strm >> stru.element);
 }

◆ operator>>() [59/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalMapType &	stru
	)

Definition at line 1913 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalMapType::collection_flag, OpenDDS::XTypes::MinimalMapType::element, OpenDDS::XTypes::MinimalMapType::header, and OpenDDS::XTypes::MinimalMapType::key.

 {
   return (strm >> stru.collection_flag)
     && (strm >> stru.header)
     && (strm >> stru.key)
     && (strm >> stru.element);
 }

◆ operator>>() [60/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteEnumeratedHeader &	stru
	)

Definition at line 1942 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteEnumeratedHeader::common, OpenDDS::XTypes::CompleteEnumeratedHeader::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [61/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalEnumeratedHeader &	stru
	)

Definition at line 1978 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalEnumeratedHeader::common, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [62/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteEnumeratedType &	stru
	)

Definition at line 2011 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteEnumeratedType::enum_flags, OpenDDS::XTypes::CompleteEnumeratedType::header, and OpenDDS::XTypes::CompleteEnumeratedType::literal_seq.

 {
   return (strm >> stru.enum_flags)
     && (strm >> stru.header)
     && (strm >> stru.literal_seq);
 }

◆ operator>>() [63/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalEnumeratedType &	stru
	)

Definition at line 2034 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalEnumeratedType::enum_flags, OpenDDS::XTypes::MinimalEnumeratedType::header, and OpenDDS::XTypes::MinimalEnumeratedType::literal_seq.

 {
   return (strm >> stru.enum_flags)
     && (strm >> stru.header)
     && (strm >> stru.literal_seq);
 }

◆ operator>>() [64/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteBitmaskType &	stru
	)

Definition at line 2064 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteBitmaskType::bitmask_flags, OpenDDS::XTypes::CompleteBitmaskType::flag_seq, OpenDDS::XTypes::CompleteBitmaskType::header, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.bitmask_flags)
     && (strm >> stru.header)
     && (strm >> stru.flag_seq);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [65/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalBitmaskType &	stru
	)

Definition at line 2106 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalBitmaskType::bitmask_flags, OpenDDS::XTypes::MinimalBitmaskType::flag_seq, OpenDDS::XTypes::MinimalBitmaskType::header, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.bitmask_flags)
     && (strm >> stru.header)
     && (strm >> stru.flag_seq);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [66/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteBitsetType &	stru
	)

Definition at line 2148 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteBitsetType::bitset_flags, OpenDDS::XTypes::CompleteBitsetType::field_seq, OpenDDS::XTypes::CompleteBitsetType::header, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.bitset_flags)
     && (strm >> stru.header)
     && (strm >> stru.field_seq);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [67/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalBitsetType &	stru
	)

Definition at line 2190 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalBitsetType::bitset_flags, OpenDDS::XTypes::MinimalBitsetType::field_seq, OpenDDS::XTypes::MinimalBitsetType::header, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.bitset_flags)
     && (strm >> stru.header)
     && (strm >> stru.field_seq);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [68/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteExtendedType &
	)

Definition at line 2221 of file TypeObject.cpp.

References OpenDDS::XTypes::read_empty_xcdr2_nonfinal().

 {
   return XTypes::read_empty_xcdr2_nonfinal(strm);
 }

◆ operator>>() [69/146]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::TypeIdentifierWithSize &	stru
	)

Definition at line 2247 of file TypeObject.cpp.

References OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), OpenDDS::DCPS::Serializer::skip(), OpenDDS::XTypes::TypeIdentifierWithSize::type_id, and OpenDDS::XTypes::TypeIdentifierWithSize::typeobject_serialized_size.

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.type_id)
     && (strm >> stru.typeobject_serialized_size);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [70/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::TypeIdentifierWithDependencies &	stru
	)

Definition at line 2288 of file TypeObject.cpp.

References OpenDDS::XTypes::TypeIdentifierWithDependencies::dependent_typeid_count, OpenDDS::XTypes::TypeIdentifierWithDependencies::dependent_typeids, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), OpenDDS::DCPS::Serializer::skip(), and OpenDDS::XTypes::TypeIdentifierWithDependencies::typeid_with_size.

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.typeid_with_size)
     && (strm >> stru.dependent_typeid_count)
     && (strm >> stru.dependent_typeids);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [71/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::AppliedAnnotation &	stru
	)

Definition at line 2328 of file TypeObject.cpp.

References OpenDDS::XTypes::AppliedAnnotation::annotation_typeid, OpenDDS::XTypes::AppliedAnnotation::param_seq, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
   const bool ret = (strm >> stru.annotation_typeid)
     && (strm >> stru.param_seq);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [72/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::AppliedBuiltinTypeAnnotations &	stru
	)

Definition at line 2364 of file TypeObject.cpp.

References OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), OpenDDS::DCPS::Serializer::skip(), and OpenDDS::XTypes::AppliedBuiltinTypeAnnotations::verbatim.

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.verbatim);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [73/146]

template<typename T >

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::Optional< T > &	opt
	)

Definition at line 2382 of file TypeObject.h.

References OpenDDS::XTypes::Optional< T >::present, and OpenDDS::XTypes::Optional< T >::value.

 {
   if (!(strm >> ACE_InputCDR::to_boolean(opt.present))) {
     return false;
   }
   return !opt.present || strm >> opt.value;
 }

◆ operator>>() [74/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteAliasBody &	stru
	)

Definition at line 2404 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAliasBody::ann_builtin, OpenDDS::XTypes::CompleteAliasBody::ann_custom, OpenDDS::XTypes::CompleteAliasBody::common, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> stru.ann_builtin)
     && (strm >> stru.ann_custom);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [75/146]

template<typename T >

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::Sequence< T > &	seq
	)

Definition at line 2429 of file TypeObject.h.

References OpenDDS::STUN::encoding(), OpenDDS::XTypes::Sequence< T >::length(), OpenDDS::DCPS::Serializer::length(), OpenDDS_Dcps_Export, operator<<(), operator>>(), OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), serialized_size(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   // special cases for compatibility with older versions that encoded this
   // sequence incorrectly - if the DHeader was read as a 0, it's an empty
   // sequence although it should have been encoded as DHeader (4) + Length (0)
   if (total_size == 0) {
     seq.length(0);
     return true;
   }
 
   if (total_size < 4) {
     return false;
   }
 
   const size_t end_of_seq = strm.rpos() + total_size;
   ACE_CDR::ULong length;
   if (!(strm >> length)) {
     return false;
   }
 
   if (length > strm.length()) {
     // if encoded incorrectly, the first 4 bytes of the elements were read
     // as if they were the length - this may end up being larger than the
     // number of bytes remaining in the Serializer
     return false;
   }
 
   seq.length(length);
   for (ACE_CDR::ULong i = 0; i < length; ++i) {
     if (!(strm >> seq[i])) {
       return false;
     }
   }
   return strm.skip(end_of_seq - strm.rpos());
 }

◆ operator>>() [76/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteAliasHeader &	stru
	)

Definition at line 2442 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAliasHeader::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [77/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteAnnotationHeader &	stru
	)

Definition at line 2479 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAnnotationHeader::annotation_name, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), OpenDDS::DCPS::Serializer::skip(), and OpenDDS::XTypes::TYPE_NAME_MAX_LENGTH.

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> Serializer::ToBoundedString<char>(stru.annotation_name, TYPE_NAME_MAX_LENGTH));
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [78/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	,
		XTypes::MinimalTypeDetail &
	)

inline

Definition at line 2502 of file TypeObject.h.

References OpenDDS_Dcps_Export, OPENDDS_END_VERSIONED_NAMESPACE_DECL, operator<<(), operator>>(), serialized_size(), and to_type_object().

2502 { return true; }

◆ operator>>() [79/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteAnnotationParameter &	stru
	)

Definition at line 2520 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAnnotationParameter::common, OpenDDS::XTypes::CompleteAnnotationParameter::default_value, OpenDDS::XTypes::MEMBER_NAME_MAX_LENGTH, OpenDDS::XTypes::CompleteAnnotationParameter::name, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> Serializer::ToBoundedString<char>(stru.name, MEMBER_NAME_MAX_LENGTH))
     && (strm >> stru.default_value);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [80/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteArrayHeader &	stru
	)

Definition at line 2560 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteArrayHeader::common, OpenDDS::XTypes::CompleteArrayHeader::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [81/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	ser,
		const XTypes::MinimalAnnotationType &	stru
	)

◆ operator>>() [82/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	ser,
		const XTypes::CompleteAliasType &	stru
	)

◆ operator>>() [83/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	ser,
		const XTypes::MinimalAliasType &	stru
	)

Referenced by operator>>().

◆ operator>>() [84/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteBitfield &	stru
	)

Definition at line 2599 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteBitfield::common, OpenDDS::XTypes::CompleteBitfield::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [85/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteBitflag &	stru
	)

Definition at line 2638 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteBitflag::common, OpenDDS::XTypes::CompleteBitflag::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [86/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteBitsetHeader &	stru
	)

Definition at line 2675 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteBitsetHeader::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [87/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteCollectionElement &	stru
	)

Definition at line 2713 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteCollectionElement::common, OpenDDS::XTypes::CompleteCollectionElement::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [88/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteCollectionHeader &	stru
	)

Definition at line 2752 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteCollectionHeader::common, OpenDDS::XTypes::CompleteCollectionHeader::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [89/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteDiscriminatorMember &	stru
	)

Definition at line 2793 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteDiscriminatorMember::ann_builtin, OpenDDS::XTypes::CompleteDiscriminatorMember::ann_custom, OpenDDS::XTypes::CompleteDiscriminatorMember::common, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> stru.ann_builtin)
     && (strm >> stru.ann_custom);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [90/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteEnumeratedLiteral &	stru
	)

Definition at line 2833 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteEnumeratedLiteral::common, OpenDDS::XTypes::CompleteEnumeratedLiteral::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [91/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteStructMember &	stru
	)

Definition at line 2872 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteStructMember::common, OpenDDS::XTypes::CompleteStructMember::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
 
   return ret;
 }

◆ operator>>() [92/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteUnionHeader &	stru
	)

Definition at line 2910 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteUnionHeader::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [93/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteUnionMember &	stru
	)

Definition at line 2948 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteUnionMember::common, OpenDDS::XTypes::CompleteUnionMember::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [94/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalAliasBody &	stru
	)

Definition at line 2985 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalAliasBody::common, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [95/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalAliasHeader &
	)

Definition at line 3014 of file TypeObject.cpp.

References OpenDDS::XTypes::read_empty_xcdr2_nonfinal().

 {
   return XTypes::read_empty_xcdr2_nonfinal(strm);
 }

◆ operator>>() [96/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalAnnotationHeader &
	)

Definition at line 3031 of file TypeObject.cpp.

References OpenDDS::XTypes::read_empty_xcdr2_nonfinal().

 {
   return XTypes::read_empty_xcdr2_nonfinal(strm);
 }

◆ operator>>() [97/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalAnnotationParameter &	stru
	)

Definition at line 3061 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalAnnotationParameter::common, OpenDDS::XTypes::MinimalAnnotationParameter::default_value, OpenDDS::XTypes::MinimalAnnotationParameter::name_hash, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> stru_name_hash)
     && (strm >> stru.default_value);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [98/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalArrayHeader &	stru
	)

Definition at line 3100 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalArrayHeader::common, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [99/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalBitfield &	stru
	)

Definition at line 3140 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalBitfield::common, OpenDDS::XTypes::MinimalBitfield::name_hash, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> stru_name_hash);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [100/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalBitflag &	stru
	)

Definition at line 3180 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalBitflag::common, OpenDDS::XTypes::MinimalBitflag::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [101/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalBitsetHeader &
	)

Definition at line 3210 of file TypeObject.cpp.

References OpenDDS::XTypes::read_empty_xcdr2_nonfinal().

 {
   return XTypes::read_empty_xcdr2_nonfinal(strm);
 }

◆ operator>>() [102/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalCollectionElement &	stru
	)

Definition at line 3234 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalCollectionElement::common, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [103/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalCollectionHeader &	stru
	)

Definition at line 3270 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalCollectionHeader::common, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [104/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalDiscriminatorMember &	stru
	)

Definition at line 3306 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalDiscriminatorMember::common, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [105/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalEnumeratedLiteral &	stru
	)

Definition at line 3344 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalEnumeratedLiteral::common, OpenDDS::XTypes::MinimalEnumeratedLiteral::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [106/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalStructMember &	stru
	)

Definition at line 3383 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalStructMember::common, OpenDDS::XTypes::MinimalStructMember::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [107/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalUnionHeader &	stru
	)

Definition at line 3420 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalUnionHeader::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [108/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalUnionMember &	stru
	)

Definition at line 3458 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalUnionMember::common, OpenDDS::XTypes::MinimalUnionMember::detail, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.common)
     && (strm >> stru.detail);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [109/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::AnnotationParameterValue &	uni
	)

Definition at line 3621 of file TypeObject.cpp.

 {
   ACE_CDR::Octet kind;
   if (!(strm >> ACE_InputCDR::to_octet(kind))) {
     return false;
   }
   uni = XTypes::AnnotationParameterValue(kind);
 
   switch (kind) {
   case XTypes::TK_BOOLEAN:
     return (strm >> ACE_InputCDR::to_boolean(uni.boolean_value()));
   case XTypes::TK_BYTE:
     return (strm >> ACE_InputCDR::to_octet(uni.byte_value()));
   case XTypes::TK_INT16:
     return (strm >> uni.int16_value());
   case XTypes::TK_UINT16:
     return (strm >> uni.uint16_value());
   case XTypes::TK_INT32:
     return (strm >> uni.int32_value());
   case XTypes::TK_UINT32:
     return (strm >> uni.uint32_value());
   case XTypes::TK_INT64:
     return (strm >> uni.int64_value());
   case XTypes::TK_UINT64:
     return (strm >> uni.uint64_value());
   case XTypes::TK_FLOAT32:
     return (strm >> uni.float32_value());
   case XTypes::TK_FLOAT64:
     return (strm >> uni.float64_value());
   case XTypes::TK_FLOAT128:
     return (strm >> uni.float128_value());
   case XTypes::TK_CHAR8:
     return (strm >> ACE_InputCDR::to_char(uni.char_value()));
   case XTypes::TK_CHAR16:
     return (strm >> ACE_InputCDR::to_wchar(uni.wchar_value()));
   case XTypes::TK_ENUM:
     return (strm >> uni.enumerated_value());
   case XTypes::TK_STRING8:
     return (strm >> Serializer::ToBoundedString<char>(uni.string8_value(), 128));
   case XTypes::TK_STRING16:
 #ifdef DDS_HAS_WCHAR
     return (strm >> Serializer::ToBoundedString<wchar_t>(uni.string16_value(), 128));
 #endif
     return false;
   default:
     return (strm >> uni.extended_value());
   }
 }

◆ operator>>() [110/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::AppliedAnnotationParameter &	stru
	)

Definition at line 3693 of file TypeObject.cpp.

References OpenDDS::XTypes::AppliedAnnotationParameter::paramname_hash, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), OpenDDS::DCPS::Serializer::skip(), and OpenDDS::XTypes::AppliedAnnotationParameter::value.

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   XTypes::NameHash_forany stru_paramname_hash(const_cast<XTypes::NameHash_slice*>(stru.paramname_hash));
   const bool ret = (strm >> stru_paramname_hash)
     && (strm >> stru.value);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [111/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::AppliedBuiltinMemberAnnotations &	stru
	)

Definition at line 3748 of file TypeObject.cpp.

References OpenDDS::XTypes::AppliedBuiltinMemberAnnotations::hash_id, OpenDDS::XTypes::AppliedBuiltinMemberAnnotations::max, OpenDDS::XTypes::AppliedBuiltinMemberAnnotations::min, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), OpenDDS::DCPS::Serializer::skip(), and OpenDDS::XTypes::AppliedBuiltinMemberAnnotations::unit.

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.unit)
     && (strm >> stru.min)
     && (strm >> stru.max)
     && (strm >> stru.hash_id);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [112/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::AppliedVerbatimAnnotation &	stru
	)

Definition at line 3787 of file TypeObject.cpp.

References OpenDDS::XTypes::AppliedVerbatimAnnotation::language, OpenDDS::XTypes::AppliedVerbatimAnnotation::placement, and OpenDDS::XTypes::AppliedVerbatimAnnotation::text.

 {
   return (strm >> Serializer::ToBoundedString<char>(stru.placement, 32))
     && (strm >> Serializer::ToBoundedString<char>(stru.language, 32))
     && (strm >> stru.text);
 }

◆ operator>>() [113/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CommonAliasBody &	stru
	)

Definition at line 3808 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonAliasBody::related_flags, and OpenDDS::XTypes::CommonAliasBody::related_type.

 {
   return (strm >> stru.related_flags)
     && (strm >> stru.related_type);
 }

◆ operator>>() [114/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CommonAnnotationParameter &	stru
	)

Definition at line 3828 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonAnnotationParameter::member_flags, and OpenDDS::XTypes::CommonAnnotationParameter::member_type_id.

 {
   return (strm >> stru.member_flags)
     && (strm >> stru.member_type_id);
 }

◆ operator>>() [115/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CommonArrayHeader &	stru
	)

Definition at line 3846 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonArrayHeader::bound_seq.

 {
   return (strm >> stru.bound_seq);
 }

◆ operator>>() [116/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CommonBitfield &	stru
	)

Definition at line 3869 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonBitfield::bitcount, OpenDDS::XTypes::CommonBitfield::flags, OpenDDS::XTypes::CommonBitfield::holder_type, and OpenDDS::XTypes::CommonBitfield::position.

 {
   return (strm >> stru.position)
     && (strm >> stru.flags)
     && (strm >> ACE_InputCDR::to_octet(stru.bitcount))
     && (strm >> ACE_InputCDR::to_octet(stru.holder_type));
 }

◆ operator>>() [117/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CommonBitflag &	stru
	)

Definition at line 3891 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonBitflag::flags, and OpenDDS::XTypes::CommonBitflag::position.

 {
   return (strm >> stru.position)
     && (strm >> stru.flags);
 }

◆ operator>>() [118/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CommonCollectionElement &	stru
	)

Definition at line 3911 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonCollectionElement::element_flags, and OpenDDS::XTypes::CommonCollectionElement::type.

 {
   return (strm >> stru.element_flags)
     && (strm >> stru.type);
 }

◆ operator>>() [119/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CommonCollectionHeader &	stru
	)

Definition at line 3929 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonCollectionHeader::bound.

 {
   return (strm >> stru.bound);
 }

◆ operator>>() [120/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CommonDiscriminatorMember &	stru
	)

Definition at line 3948 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonDiscriminatorMember::member_flags, and OpenDDS::XTypes::CommonDiscriminatorMember::type_id.

 {
   return (strm >> stru.member_flags)
     && (strm >> stru.type_id);
 }

◆ operator>>() [121/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CommonEnumeratedHeader &	stru
	)

Definition at line 3966 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonEnumeratedHeader::bit_bound.

 {
   return (strm >> stru.bit_bound);
 }

◆ operator>>() [122/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CommonEnumeratedLiteral &	stru
	)

Definition at line 3992 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonEnumeratedLiteral::flags, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), OpenDDS::DCPS::Serializer::skip(), and OpenDDS::XTypes::CommonEnumeratedLiteral::value.

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   const bool ret = (strm >> stru.value)
     && (strm >> stru.flags);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
   return ret;
 }

◆ operator>>() [123/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CommonStructMember &	stru
	)

Definition at line 4026 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonStructMember::member_flags, OpenDDS::XTypes::CommonStructMember::member_id, and OpenDDS::XTypes::CommonStructMember::member_type_id.

 {
   return (strm >> stru.member_id)
     && (strm >> stru.member_flags)
     && (strm >> stru.member_type_id);
 }

◆ operator>>() [124/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CommonUnionMember &	stru
	)

Definition at line 4051 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonUnionMember::label_seq, OpenDDS::XTypes::CommonUnionMember::member_flags, OpenDDS::XTypes::CommonUnionMember::member_id, and OpenDDS::XTypes::CommonUnionMember::type_id.

 {
   return (strm >> stru.member_id)
     && (strm >> stru.member_flags)
     && (strm >> stru.type_id)
     && (strm >> stru.label_seq);
 }

◆ operator>>() [125/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteElementDetail &	stru
	)

Definition at line 4073 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteElementDetail::ann_builtin, and OpenDDS::XTypes::CompleteElementDetail::ann_custom.

 {
   return (strm >> stru.ann_builtin)
     && (strm >> stru.ann_custom);
 }

◆ operator>>() [126/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::CompleteMemberDetail &	stru
	)

Definition at line 4096 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteMemberDetail::ann_builtin, OpenDDS::XTypes::CompleteMemberDetail::ann_custom, OpenDDS::XTypes::MEMBER_NAME_MAX_LENGTH, and OpenDDS::XTypes::CompleteMemberDetail::name.

 {
   return (strm >> Serializer::ToBoundedString<char>(stru.name, MEMBER_NAME_MAX_LENGTH))
     && (strm >> stru.ann_builtin)
     && (strm >> stru.ann_custom);
 }

◆ operator>>() [127/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalMemberDetail &	stru
	)

Definition at line 4117 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalMemberDetail::name_hash.

 {
   XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
   return (strm >> stru_name_hash);
 }

◆ operator>>() [128/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::ExtendedTypeDefn &
	)

Definition at line 4135 of file TypeObject.cpp.

References OpenDDS::XTypes::read_empty_xcdr2_nonfinal().

 {
   return XTypes::read_empty_xcdr2_nonfinal(strm);
 }

◆ operator>>() [129/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::PlainArrayLElemDefn &	stru
	)

Definition at line 4156 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainArrayLElemDefn::array_bound_seq, OpenDDS::XTypes::PlainArrayLElemDefn::element_identifier, and OpenDDS::XTypes::PlainArrayLElemDefn::header.

 {
   return (strm >> stru.header)
     && (strm >> stru.array_bound_seq)
     && (strm >> *stru.element_identifier);
 }

◆ operator>>() [130/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::PlainArraySElemDefn &	stru
	)

Definition at line 4179 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainArraySElemDefn::array_bound_seq, OpenDDS::XTypes::PlainArraySElemDefn::element_identifier, and OpenDDS::XTypes::PlainArraySElemDefn::header.

 {
   return (strm >> stru.header)
     && (strm >> stru.array_bound_seq)
     && (strm >> *stru.element_identifier);
 }

◆ operator>>() [131/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::PlainMapLTypeDefn &	stru
	)

Definition at line 4206 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainMapLTypeDefn::bound, OpenDDS::XTypes::PlainMapLTypeDefn::element_identifier, OpenDDS::XTypes::PlainMapLTypeDefn::header, OpenDDS::XTypes::PlainMapLTypeDefn::key_flags, and OpenDDS::XTypes::PlainMapLTypeDefn::key_identifier.

 {
   return (strm >> stru.header)
     && (strm >> stru.bound)
     && (strm >> *stru.element_identifier)
     && (strm >> stru.key_flags)
     && (strm >> *stru.key_identifier);
 }

◆ operator>>() [132/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::PlainMapSTypeDefn &	stru
	)

Definition at line 4235 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainMapSTypeDefn::bound, OpenDDS::XTypes::PlainMapSTypeDefn::element_identifier, OpenDDS::XTypes::PlainMapSTypeDefn::header, OpenDDS::XTypes::PlainMapSTypeDefn::key_flags, and OpenDDS::XTypes::PlainMapSTypeDefn::key_identifier.

 {
   return (strm >> stru.header)
     && (strm >> ACE_InputCDR::to_octet(stru.bound))
     && (strm >> *stru.element_identifier)
     && (strm >> stru.key_flags)
     && (strm >> *stru.key_identifier);
 }

◆ operator>>() [133/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::PlainSequenceLElemDefn &	stru
	)

Definition at line 4260 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainSequenceLElemDefn::bound, OpenDDS::XTypes::PlainSequenceLElemDefn::element_identifier, and OpenDDS::XTypes::PlainSequenceLElemDefn::header.

 {
   return (strm >> stru.header)
     && (strm >> stru.bound)
     && (strm >> *stru.element_identifier);
 }

◆ operator>>() [134/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::PlainSequenceSElemDefn &	stru
	)

Definition at line 4283 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainSequenceSElemDefn::bound, OpenDDS::XTypes::PlainSequenceSElemDefn::element_identifier, and OpenDDS::XTypes::PlainSequenceSElemDefn::header.

 {
   return (strm >> stru.header)
     && (strm >> ACE_InputCDR::to_octet(stru.bound))
     && (strm >> *stru.element_identifier);
 }

◆ operator>>() [135/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::StringLTypeDefn &	stru
	)

Definition at line 4302 of file TypeObject.cpp.

References OpenDDS::XTypes::StringLTypeDefn::bound.

 {
   return (strm >> stru.bound);
 }

◆ operator>>() [136/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::StringSTypeDefn &	stru
	)

Definition at line 4319 of file TypeObject.cpp.

References OpenDDS::XTypes::StringSTypeDefn::bound.

 {
   return (strm >> ACE_InputCDR::to_octet(stru.bound));
 }

◆ operator>>() [137/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::StronglyConnectedComponentId &	stru
	)

Definition at line 4347 of file TypeObject.cpp.

References OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::rpos(), OpenDDS::XTypes::StronglyConnectedComponentId::sc_component_id, OpenDDS::XTypes::StronglyConnectedComponentId::scc_index, OpenDDS::XTypes::StronglyConnectedComponentId::scc_length, and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   // appendable, but no need to handle truncated streams since
   // this struct is defined in the spec with the following members:
   const bool ret = (strm >> stru.sc_component_id)
     && (strm >> stru.scc_length)
     && (strm >> stru.scc_index);
 
   if (ret && strm.rpos() - start_pos < total_size) {
     strm.skip(total_size - strm.rpos() + start_pos);
   }
 
   return ret;
 }

◆ operator>>() [138/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::PlainCollectionHeader &	stru
	)

Definition at line 4383 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainCollectionHeader::element_flags, and OpenDDS::XTypes::PlainCollectionHeader::equiv_kind.

 {
   return (strm >> ACE_InputCDR::to_octet(stru.equiv_kind))
     && (strm >> stru.element_flags);
 }

◆ operator>>() [139/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::TypeObjectHashId &	uni
	)

Definition at line 4422 of file TypeObject.cpp.

References OpenDDS::XTypes::EK_COMPLETE, OpenDDS::XTypes::EK_MINIMAL, OpenDDS::XTypes::TypeObjectHashId::hash, and OpenDDS::XTypes::TypeObjectHashId::kind.

 {
   if (!(strm >> ACE_InputCDR::to_octet(uni.kind))) {
     return false;
   }
   switch (uni.kind) {
   case XTypes::EK_MINIMAL:
   case XTypes::EK_COMPLETE: {
     XTypes::EquivalenceHash_forany uni_hash(uni.hash);
     return strm >> uni_hash;
   }
   default:
     return true;
   }
 }

◆ operator>>() [140/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	ser,
		XTypes::CompleteTypeObject &	type_object
	)

Definition at line 4514 of file TypeObject.cpp.

 {
   using namespace XTypes;
   if (!(ser >> ACE_InputCDR::to_octet(type_object.kind))) {
     return false;
   }
 
   switch (type_object.kind) {
   case TK_ALIAS:
     return ser >> type_object.alias_type;
   case TK_ANNOTATION:
     return ser >> type_object.annotation_type;
   case TK_STRUCTURE:
     return ser >> type_object.struct_type;
   case TK_UNION:
     return ser >> type_object.union_type;
   case TK_BITSET:
     return ser >> type_object.bitset_type;
   case TK_SEQUENCE:
     return ser >> type_object.sequence_type;
   case TK_ARRAY:
     return ser >> type_object.array_type;
   case TK_MAP:
     return ser >> type_object.map_type;
   case TK_ENUM:
     return ser >> type_object.enumerated_type;
   case TK_BITMASK:
     return ser >> type_object.bitmask_type;
   default:
     return ser >> type_object.extended_type;
   }
 }

◆ operator>>() [141/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	ser,
		XTypes::MinimalTypeObject &	type_object
	)

Definition at line 4613 of file TypeObject.cpp.

 {
   using namespace XTypes;
   if (!(ser >> ACE_InputCDR::to_octet(type_object.kind))) {
     return false;
   }
 
   switch (type_object.kind) {
   case TK_ALIAS:
     return ser >> type_object.alias_type;
   case TK_ANNOTATION:
     return ser >> type_object.annotation_type;
   case TK_STRUCTURE:
     return ser >> type_object.struct_type;
   case TK_UNION:
     return ser >> type_object.union_type;
   case TK_BITSET:
     return ser >> type_object.bitset_type;
   case TK_SEQUENCE:
     return ser >> type_object.sequence_type;
   case TK_ARRAY:
     return ser >> type_object.array_type;
   case TK_MAP:
     return ser >> type_object.map_type;
   case TK_ENUM:
     return ser >> type_object.enumerated_type;
   case TK_BITMASK:
     return ser >> type_object.bitmask_type;
   default:
     return ser >> type_object.extended_type;
   }
 }

◆ operator>>() [142/146]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator>>	(	Serializer &	ser,
		XTypes::TypeObject &	type_object
	)

Definition at line 4684 of file TypeObject.cpp.

References OpenDDS::XTypes::TypeObject::complete, OpenDDS::XTypes::EK_COMPLETE, OpenDDS::XTypes::EK_MINIMAL, OpenDDS::XTypes::TypeObject::kind, OpenDDS::XTypes::TypeObject::minimal, and OpenDDS::DCPS::Serializer::read_delimiter().

 {
   size_t total_size = 0;
   if (!ser.read_delimiter(total_size)) {
     return false;
   }
 
   if (!(ser >> ACE_InputCDR::to_octet(type_object.kind))) {
     return false;
   }
 
   bool ret = true;
   switch (type_object.kind) {
   case XTypes::EK_COMPLETE:
     ret = ser >> type_object.complete;
     break;
   case XTypes::EK_MINIMAL:
     ret = ser >> type_object.minimal;
     break;
   }
 
   return ret;
 }

◆ operator>>() [143/146]

bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::MinimalExtendedType &
	)

Definition at line 4720 of file TypeObject.cpp.

References OpenDDS::XTypes::read_empty_xcdr2_nonfinal().

 {
   return XTypes::read_empty_xcdr2_nonfinal(strm);
 }

◆ operator>>() [144/146]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::TypeInformation &	stru
	)

Definition at line 4773 of file TypeObject.cpp.

References ACE_DEBUG, ACE_TEXT(), OpenDDS::XTypes::TypeInformation::complete, DCPS_debug_level, LM_DEBUG, OpenDDS::XTypes::TypeInformation::minimal, OpenDDS::DCPS::Serializer::read_delimiter(), OpenDDS::DCPS::Serializer::read_parameter_id(), OpenDDS::DCPS::Serializer::rpos(), and OpenDDS::DCPS::Serializer::skip().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
 
   const size_t start_pos = strm.rpos();
 
   unsigned member_id;
   size_t field_size;
   while (true) {
 
     if (strm.rpos() - start_pos >= total_size) {
       return true;
     }
 
     bool must_understand = false;
     if (!strm.read_parameter_id(member_id, field_size, must_understand)) {
       return false;
     }
 
     switch (member_id) {
     case 4097: {
       if (!(strm >> stru.minimal)) {
         return false;
       }
       break;
     }
     case 4098: {
       if (!(strm >> stru.complete)) {
         return false;
       }
       break;
     }
     default:
       if (must_understand) {
         if (DCPS_debug_level >= 8) {
           ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) unknown must_understand field(%u) in OpenDDS::XTypes::TypeInformation\n"), member_id));
         }
         return false;
       }
       strm.skip(field_size);
       break;
     }
   }
   return false;
 }

◆ operator>>() [145/146]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::TypeIdentifierTypeObjectPair &	stru
	)

Definition at line 4836 of file TypeObject.cpp.

References OpenDDS::XTypes::TypeIdentifierTypeObjectPair::type_identifier, and OpenDDS::XTypes::TypeIdentifierTypeObjectPair::type_object.

 {
   return (strm >> stru.type_identifier)
     && (strm >> stru.type_object);
 }

◆ operator>>() [146/146]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::operator>>	(	Serializer &	strm,
		XTypes::TypeIdentifierPair &	stru
	)

Definition at line 4856 of file TypeObject.cpp.

References OpenDDS::XTypes::TypeIdentifierPair::type_identifier1, and OpenDDS::XTypes::TypeIdentifierPair::type_identifier2.

 {
   return (strm >> stru.type_identifier1)
     && (strm >> stru.type_identifier2);
 }

◆ primitive_serialized_size() [1/13]

ACE_INLINE bool OpenDDS::DCPS::primitive_serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const ACE_CDR::Short &	value,
		size_t	count = `1`
	)

Definition at line 1482 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::align(), and int16_cdr_size.

Referenced by primitive_serialized_size(), serialized_size(), and set_default().

 {
   encoding.align(size, int16_cdr_size);
   size += int16_cdr_size * count;
   return true;
 }

◆ primitive_serialized_size() [2/13]

ACE_INLINE bool OpenDDS::DCPS::primitive_serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const ACE_CDR::UShort &	value,
		size_t	count = `1`
	)

Definition at line 1492 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::align(), and uint16_cdr_size.

 {
   encoding.align(size, uint16_cdr_size);
   size += uint16_cdr_size * count;
   return true;
 }

◆ primitive_serialized_size() [3/13]

ACE_INLINE bool OpenDDS::DCPS::primitive_serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const ACE_CDR::Long &	value,
		size_t	count = `1`
	)

Definition at line 1502 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::align(), and int32_cdr_size.

 {
   encoding.align(size, int32_cdr_size);
   size += int32_cdr_size * count;
   return true;
 }

◆ primitive_serialized_size() [4/13]

ACE_INLINE bool OpenDDS::DCPS::primitive_serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const ACE_CDR::ULong &	value,
		size_t	count = `1`
	)

Definition at line 1512 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::align(), and uint32_cdr_size.

 {
   encoding.align(size, uint32_cdr_size);
   size += uint32_cdr_size * count;
   return true;
 }

◆ primitive_serialized_size() [5/13]

ACE_INLINE bool OpenDDS::DCPS::primitive_serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const ACE_CDR::LongLong &	value,
		size_t	count = `1`
	)

Definition at line 1522 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::align(), and int64_cdr_size.

 {
   encoding.align(size, int64_cdr_size);
   size += int64_cdr_size * count;
   return true;
 }

◆ primitive_serialized_size() [6/13]

ACE_INLINE bool OpenDDS::DCPS::primitive_serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const ACE_CDR::ULongLong &	value,
		size_t	count = `1`
	)

Definition at line 1532 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::align(), and uint64_cdr_size.

 {
   encoding.align(size, uint64_cdr_size);
   size += uint64_cdr_size * count;
   return true;
 }

◆ primitive_serialized_size() [7/13]

ACE_INLINE bool OpenDDS::DCPS::primitive_serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const ACE_CDR::Float &	value,
		size_t	count = `1`
	)

Definition at line 1542 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::align(), and float32_cdr_size.

 {
   encoding.align(size, float32_cdr_size);
   size += float32_cdr_size * count;
   return true;
 }

◆ primitive_serialized_size() [8/13]

ACE_INLINE bool OpenDDS::DCPS::primitive_serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const ACE_CDR::Double &	value,
		size_t	count = `1`
	)

Definition at line 1552 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::align(), and float64_cdr_size.

 {
   encoding.align(size, float64_cdr_size);
   size += float64_cdr_size * count;
   return true;
 }

◆ primitive_serialized_size() [9/13]

ACE_INLINE bool OpenDDS::DCPS::primitive_serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const ACE_CDR::LongDouble &	value,
		size_t	count = `1`
	)

Definition at line 1562 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::align(), and float128_cdr_size.

 {
   encoding.align(size, float128_cdr_size);
   size += float128_cdr_size * count;
   return true;
 }

◆ primitive_serialized_size() [10/13]

ACE_INLINE bool OpenDDS::DCPS::primitive_serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const ACE_OutputCDR::from_boolean	value,
		size_t	count = `1`
	)

Definition at line 1573 of file Serializer.inl.

References ACE_INLINE, and boolean_cdr_size.

 {
   size += boolean_cdr_size * count;
   return true;
 }

◆ primitive_serialized_size() [11/13]

ACE_INLINE bool OpenDDS::DCPS::primitive_serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const ACE_OutputCDR::from_char	value,
		size_t	count = `1`
	)

Definition at line 1582 of file Serializer.inl.

References ACE_INLINE, and char8_cdr_size.

 {
   size += char8_cdr_size * count;
   return true;
 }

◆ primitive_serialized_size() [12/13]

ACE_INLINE bool OpenDDS::DCPS::primitive_serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const ACE_OutputCDR::from_wchar	value,
		size_t	count = `1`
	)

Definition at line 1591 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::align(), and char16_cdr_size.

 {
   encoding.align(size, char16_cdr_size);
   size += char16_cdr_size * count;
   return true;
 }

◆ primitive_serialized_size() [13/13]

ACE_INLINE bool OpenDDS::DCPS::primitive_serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const ACE_OutputCDR::from_octet	value,
		size_t	count = `1`
	)

Definition at line 1601 of file Serializer.inl.

References ACE_INLINE, byte_cdr_size, int8_cdr_size, primitive_serialized_size(), and uint8_cdr_size.

 {
   size += byte_cdr_size * count;
   return true;
 }

◆ primitive_serialized_size_boolean()

ACE_INLINE void OpenDDS::DCPS::primitive_serialized_size_boolean	(	const Encoding &	encoding,
		size_t &	size,
		size_t	count = `1`
	)

Definition at line 1632 of file Serializer.inl.

References ACE_INLINE, and boolean_cdr_size.

Referenced by OpenDDS::DCPS::RtpsUdpTransport::get_last_recv_locator(), OpenDDS::RTPS::Sedp::populate_origination_locator(), set_default(), and OpenDDS::RTPS::Sedp::shutting_down().

 {
   size += boolean_cdr_size * count;
 }

◆ primitive_serialized_size_char()

ACE_INLINE void OpenDDS::DCPS::primitive_serialized_size_char	(	const Encoding &	encoding,
		size_t &	size,
		size_t	count = `1`
	)

Definition at line 1639 of file Serializer.inl.

References ACE_INLINE, and char8_cdr_size.

Referenced by set_default().

 {
   size += char8_cdr_size * count;
 }

◆ primitive_serialized_size_octet()

ACE_INLINE void OpenDDS::DCPS::primitive_serialized_size_octet	(	const Encoding &	encoding,
		size_t &	size,
		size_t	count = `1`
	)

Definition at line 1654 of file Serializer.inl.

References ACE_INLINE, and byte_cdr_size.

Referenced by serialized_size(), and set_default().

 {
   size += byte_cdr_size * count;
 }

◆ primitive_serialized_size_ulong()

ACE_INLINE void OpenDDS::DCPS::primitive_serialized_size_ulong	(	const Encoding &	encoding,
		size_t &	size,
		size_t	count = `1`
	)

Definition at line 1661 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::align(), int8_cdr_size, uint32_cdr_size, and uint8_cdr_size.

Referenced by serialized_size(), serialized_size_delimiter(), set_default(), OpenDDS::RTPS::Sedp::Writer::write_parameter_list(), OpenDDS::RTPS::Sedp::LivelinessWriter::write_participant_message(), OpenDDS::RTPS::Sedp::SecurityWriter::write_stateless_message(), OpenDDS::RTPS::Sedp::DiscoveryWriter::write_unregister_dispose(), and OpenDDS::RTPS::Sedp::SecurityWriter::write_volatile_message_secure().

 {
   encoding.align(size, uint32_cdr_size);
   size += uint32_cdr_size * count;
 }

◆ primitive_serialized_size_wchar()

ACE_INLINE void OpenDDS::DCPS::primitive_serialized_size_wchar	(	const Encoding &	encoding,
		size_t &	size,
		size_t	count = `1`
	)

Definition at line 1646 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::align(), and char16_cdr_size.

Referenced by set_default().

 {
   encoding.align(size, char16_cdr_size);
   size += char16_cdr_size * count;
 }

◆ processSections()

OpenDDS_Dcps_Export int OpenDDS::DCPS::processSections	(	ACE_Configuration_Heap &	cf,
		const ACE_Configuration_Section_Key &	key,
		KeyList &	subsections
	)

Function that processes the specified ACE Configuration Section for subsections. If multiple levels of subsections are found, a non-zero value is returned to indicate the error. All valid subsection will be placed into the supplied KeyList (std::pair<> of the subsection number and ACE_Configuration_Section_Key). A return value of zero indicates error-free success.

cf ACE_Configuration_Heap object being processed key ACE_Configuration_Section_Key object that specifies the section of the .ini file to process subsections List of subsections found (list contains a std::pair<> of the subsection number and ACE_Configuration_Section_Key).

Definition at line 41 of file ConfigUtils.cpp.

References ACE_TEXT_ALWAYS_CHAR, ACE_String_Base< char >::c_str(), ACE_Configuration_Heap::enumerate_sections(), name, ACE_Configuration_Heap::open_section(), and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

Referenced by OpenDDS::DCPS::InfoRepoDiscovery::Config::discovery_config(), OpenDDS::RTPS::RtpsDiscovery::Config::discovery_config(), OpenDDS::DCPS::Service_Participant::load_discovery_templates(), OpenDDS::DCPS::Service_Participant::load_domain_configuration(), OpenDDS::DCPS::Service_Participant::load_domain_ranges(), OpenDDS::Security::SecurityRegistry::load_security_configuration(), OpenDDS::DCPS::TransportRegistry::load_transport_configuration(), OpenDDS::DCPS::TransportRegistry::load_transport_templates(), OpenDDS::DCPS::StaticDiscovery::parse_datareaderqos(), OpenDDS::DCPS::StaticDiscovery::parse_datawriterqos(), OpenDDS::DCPS::StaticDiscovery::parse_endpoints(), OpenDDS::DCPS::StaticDiscovery::parse_publisherqos(), OpenDDS::DCPS::StaticDiscovery::parse_subscriberqos(), and OpenDDS::DCPS::StaticDiscovery::parse_topics().

                                               {
     int index = 0;
     ACE_TString name;
     while (cf.enumerate_sections( key, index, name ) == 0) {
       ACE_Configuration_Section_Key subkey;
       if (cf.open_section( key, name.c_str(), false, subkey ) != 0) {
         return 1;
       }
       subsections.push_back( SubsectionPair( ACE_TEXT_ALWAYS_CHAR(name.c_str()),
                                              subkey ) );
       int subindex = 0;
       ACE_TString subname;
       if (cf.enumerate_sections( subkey, subindex, subname ) == 0) {
         // Found additional nesting of subsections that we don't care
         // to allow (e.g. [transport/my/yours]), so return an error.
         return 1;
       }
       index++;
     }
     return 0;
   }

◆ pullValues()

OpenDDS_Dcps_Export int OpenDDS::DCPS::pullValues	(	ACE_Configuration_Heap &	cf,
		const ACE_Configuration_Section_Key &	key,
		ValueMap &	values
	)

Function that pulls all the values from the specified ACE Configuration Section and places them in a value map based on the field name. Returns the number of values found in the section (and added to the value map).

cf ACE_Configuration_Heap object being processed key ACE_Configuration_Section_Key object that specifies the section of the .ini file to process values Map of field names to values (both OPENDDS_STRING) that this function will add to.

Definition at line 17 of file ConfigUtils.cpp.

References ACE_DEBUG, ACE_TEXT_ALWAYS_CHAR, ACE_String_Base< char >::c_str(), ACE_Configuration_Heap::enumerate_values(), ACE_Configuration_Heap::get_string_value(), LM_WARNING, name, ACE_Configuration::STRING, and value.

Referenced by OpenDDS::DCPS::InfoRepoDiscovery::Config::discovery_config(), OpenDDS::RTPS::RtpsDiscovery::Config::discovery_config(), OpenDDS::DCPS::Service_Participant::load_discovery_templates(), OpenDDS::DCPS::Service_Participant::load_domain_configuration(), OpenDDS::DCPS::Service_Participant::load_domain_ranges(), OpenDDS::Security::SecurityRegistry::load_security_configuration(), OpenDDS::DCPS::TransportRegistry::load_transport_configuration(), OpenDDS::DCPS::TransportRegistry::load_transport_templates(), OpenDDS::DCPS::StaticDiscovery::parse_datareaderqos(), OpenDDS::DCPS::StaticDiscovery::parse_datawriterqos(), OpenDDS::DCPS::StaticDiscovery::parse_endpoints(), OpenDDS::DCPS::StaticDiscovery::parse_publisherqos(), OpenDDS::DCPS::StaticDiscovery::parse_subscriberqos(), and OpenDDS::DCPS::StaticDiscovery::parse_topics().

                                      {
     int index = 0;
     ACE_TString name;
     ACE_Configuration::VALUETYPE type;
 
     while (cf.enumerate_values( key, index, name, type ) == 0) {
 
       ACE_TString value;
       if (type == ACE_Configuration::STRING) {
         cf.get_string_value( key, name.c_str(), value );
         values[ACE_TEXT_ALWAYS_CHAR(name.c_str())] =
           ACE_TEXT_ALWAYS_CHAR(value.c_str());
       } else {
         ACE_DEBUG((LM_WARNING, "Unexpected value type in config file (ignored): "
                    "name=%s, type=%d\n", name.c_str(), type));
       }
       index++;
     }
     return index;
   }

◆ push_back()

template<typename Seq >

void OpenDDS::DCPS::push_back	(	Seq &	seq,
		const typename Seq::value_type &	val
	)

std::vector-style push_back() for CORBA Sequences

Definition at line 136 of file Util.h.

Referenced by OpenDDS::DCPS::MulticastTransport::accept_datalink(), OpenDDS::RTPS::ParameterListConverter::add_DataRepresentationQos(), append(), OpenDDS::RTPS::append_submessage(), OpenDDS::DCPS::RtpsUdpSendStrategy::append_submessages(), OpenDDS::DCPS::RtpsUdpDataLink::bundle_and_send_submessages(), OpenDDS::DCPS::RtpsUdpReceiveStrategy::deliver_from_secure(), OpenDDS::DCPS::RtpsUdpReceiveStrategy::deliver_sample(), OpenDDS::Security::SSL::SubjectName::find(), OpenDDS::RTPS::ParameterListConverter::from_param_list(), OpenDDS::DCPS::SubscriberImpl::get_datareaders(), OpenDDS::DCPS::DomainParticipantImpl::get_discovered_participants(), OpenDDS::DCPS::DomainParticipantImpl::get_discovered_topics(), OpenDDS::DCPS::ReceiveListenerSet::get_keys(), OpenDDS::DCPS::SequenceBackInsertIterator< DDS::PropertySeq >::operator=(), OpenDDS::DCPS::RtpsSampleHeader::populate_data_sample_submessages(), OpenDDS::Security::CryptoBuiltInImpl::register_local_datareader(), OpenDDS::Security::CryptoBuiltInImpl::register_local_datawriter(), OpenDDS::Security::CryptoBuiltInImpl::register_local_participant(), OpenDDS::DCPS::RecorderImpl::remove_associations_i(), OpenDDS::DCPS::DataReaderImpl::remove_associations_i(), OpenDDS::RTPS::Sedp::set_inline_qos(), OpenDDS::DCPS::DataLink::target_intersection(), OpenDDS::RTPS::ParameterListConverter::to_param_list(), OpenDDS::Security::CryptoBuiltInImpl::unregister_datareader(), OpenDDS::DCPS::DataWriterImpl::write_w_timestamp(), and OpenDDS::DCPS::AbstractSamples::~AbstractSamples().

 {
   const ACE_CDR::ULong len = seq.length();
   // Grow by factor of 2 when length is a power of 2 in order to prevent every call to length(+1)
   // allocating a new buffer & copying previous results. The maximum is kept when length is reduced.
   if (len && !(len & (len - 1))) {
     seq.length(2 * len);
   }
   seq.length(len + 1);
   seq[len] = val;
 }

◆ rchandle_from()

template<typename T >

RcHandle<T> OpenDDS::DCPS::rchandle_from ( T * pointer )

Definition at line 310 of file RcHandle_T.h.

References OPENDDS_ASSERT, and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

 {
   OPENDDS_ASSERT(pointer == 0 || pointer->ref_count() > 0);
   return RcHandle<T>(pointer, inc_count());
 }

◆ ref()

template<typename T >

reference_wrapper<T> OpenDDS::DCPS::ref ( T & r )

Definition at line 237 of file RcHandle_T.h.

Referenced by OpenDDS::DCPS::TcpTransport::accept_datalink(), OpenDDS::RTPS::RtpsDiscovery::add_domain_participant(), OpenDDS::DCPS::StaticDiscovery::add_domain_participant(), OpenDDS::DCPS::EndHistoricSamplesMissedSweeper::cancel_timer(), OpenDDS::DCPS::TcpTransport::connect_datalink(), OpenDDS::DCPS::TcpTransport::connect_tcp_datalink(), OpenDDS::ICE::EndpointManager::create_checklist(), OpenDDS::DCPS::DomainParticipantFactoryImpl::create_participant(), OpenDDS::DCPS::DispatchService::fun_ptr_proxy(), marshal_generator::gen_enum(), OpenDDS::DCPS::RtpsUdpTransport::get_last_recv_locator(), OpenDDS::RTPS::Spdp::init(), OpenDDS::DCPS::UdpTransport::make_datalink(), OpenDDS::DCPS::ShmemTransport::make_datalink(), OpenDDS::DCPS::MulticastTransport::make_datalink(), OpenDDS::DCPS::RtpsUdpTransport::make_datalink(), OpenDDS::Security::AccessControlBuiltInImpl::make_task(), OpenDDS::DCPS::ShmemInst::new_impl(), OpenDDS::DCPS::UdpInst::new_impl(), OpenDDS::DCPS::MulticastInst::new_impl(), OpenDDS::DCPS::TcpInst::new_impl(), OpenDDS::DCPS::RtpsUdpInst::new_impl(), OpenDDS::DCPS::ShmemDataLink::open(), OpenDDS::RTPS::Spdp::SpdpTransport::open(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsUdpDataLink(), OpenDDS::DCPS::EndHistoricSamplesMissedSweeper::schedule_timer(), and OpenDDS::DCPS::DataReaderImpl_T< MessageType >::store_instance_data().

 {
   return reference_wrapper<T>(r);
 }

◆ remove()

template<typename Container , typename ValueType >

int OpenDDS::DCPS::remove	(	Container &	c,
		const ValueType &	v
	)

Definition at line 119 of file Util.h.

Referenced by OpenDDS::DCPS::TransportRegistry::process_customizations(), OpenDDS::DCPS::ReplayerImpl::remove_associations(), and OpenDDS::DCPS::ContentFilteredTopicImpl::remove_reader().

 {
   if (c.find(v) != c.end()) {
     if (c.erase(v) == 1) {
       return 0;
     }
 
     return -1;
   }
 
   return -1;
 }

◆ repo_id_to_bit_key()

OpenDDS_Dcps_Export DDS::BuiltinTopicKey_t OpenDDS::DCPS::repo_id_to_bit_key ( const GUID_t & guid )

inline

Definition at line 262 of file GuidUtils.h.

References OpenDDS_Dcps_Export, and DDS::BuiltinTopicKey_t::value.

Referenced by OpenDDS::RTPS::Sedp::assign_bit_key(), OpenDDS::RTPS::Sedp::DiscoveryReader::data_received_i(), OpenDDS::RTPS::Spdp::handle_participant_data(), OpenDDS::DCPS::StaticEndpointManager::init_bit(), DCPS_IR_Domain::publish_participant_bit(), DCPS_IR_Domain::publish_publication_bit(), DCPS_IR_Domain::publish_subscription_bit(), and DCPS_IR_Domain::publish_topic_bit().

 {
   DDS::BuiltinTopicKey_t key;
   std::memcpy(key.value, &guid, sizeof(key.value));
   return key;
 }

◆ reportErrors()

void OpenDDS::DCPS::reportErrors	(	yard::SimpleTextParser &	parser,
		const char *	input
	)

inline

called after parsing has failed, throws std::exception with details

Definition at line 27 of file AstNodeWrapper.h.

References OPENDDS_STRING.

Referenced by OpenDDS::DCPS::FilterEvaluator::FilterEvaluator(), and OpenDDS::DCPS::MultiTopicImpl::MultiTopicImpl().

 {
   AstNode* prev = 0;
   for (AstNode* iter = parser.GetAstRoot()->GetFirstChild(); iter;
       iter = iter->GetSibling()) {
     prev = iter;
   }
   ptrdiff_t pos = prev ? prev->GetLastToken() - parser.Begin() : 0;
   std::ostringstream oss;
   oss << pos;
   throw std::runtime_error("Invalid expression [" + OPENDDS_STRING(input)
     + "] at character " + oss.str());
 }

◆ repr_seq_to_string()

OpenDDS_Dcps_Export DCPS::String OpenDDS::DCPS::repr_seq_to_string	(	const DDS::DataRepresentationIdSeq &	id_seq,
		bool	is_data_writer
	)

Definition at line 495 of file DCPS_Utils.cpp.

References repr_to_string().

Referenced by OpenDDS::DCPS::TopicImpl::check_data_representation().

 {
   DCPS::String repr_string;
   const ACE_CDR::ULong length = is_data_writer ? 1 : id_seq.length();
   for (ACE_CDR::ULong i = 0; i < length; ++i) {
     if (i > 0) {
       repr_string += ", ";
     }
     repr_string += repr_to_string(id_seq[i]);
   }
   return repr_string;
 }

◆ repr_to_encoding_kind()

OpenDDS_Dcps_Export bool OpenDDS::DCPS::repr_to_encoding_kind	(	DDS::DataRepresentationId_t	repr,
		Encoding::Kind &	kind
	)

Definition at line 455 of file DCPS_Utils.cpp.

References OpenDDS::DCPS::Encoding::KIND_UNALIGNED_CDR, OpenDDS::DCPS::Encoding::KIND_XCDR1, OpenDDS::DCPS::Encoding::KIND_XCDR2, UNALIGNED_CDR_DATA_REPRESENTATION, DDS::XCDR2_DATA_REPRESENTATION, and DDS::XCDR_DATA_REPRESENTATION.

Referenced by OpenDDS::DCPS::StaticEndpointManager::match_continue(), OpenDDS::RTPS::Sedp::match_continue(), OpenDDS::DCPS::DataReaderImpl::setup_deserialization(), and OpenDDS::DCPS::DataWriterImpl::setup_serialization().

 {
   switch(repr) {
   case DDS::XCDR_DATA_REPRESENTATION:
     kind = Encoding::KIND_XCDR1;
     break;
   case DDS::XCDR2_DATA_REPRESENTATION:
     kind = Encoding::KIND_XCDR2;
     break;
   case OpenDDS::DCPS::UNALIGNED_CDR_DATA_REPRESENTATION:
     kind = Encoding::KIND_UNALIGNED_CDR;
     break;
   default:
     return false;
   }
   return true;
 }

◆ repr_to_string()

OpenDDS_Dcps_Export DCPS::String OpenDDS::DCPS::repr_to_string ( const DDS::DataRepresentationId_t & repr )

Definition at line 473 of file DCPS_Utils.cpp.

References to_dds_string(), UNALIGNED_CDR_DATA_REPRESENTATION, DDS::XCDR2_DATA_REPRESENTATION, DDS::XCDR_DATA_REPRESENTATION, and DDS::XML_DATA_REPRESENTATION.

Referenced by repr_seq_to_string(), OpenDDS::DCPS::DataReaderImpl::setup_deserialization(), and OpenDDS::DCPS::DataWriterImpl::setup_serialization().

 {
   DCPS::String repr_string;
   switch (repr) {
   case DDS::XCDR_DATA_REPRESENTATION:
     repr_string = "XCDR_DATA_REPRESENTATION";
     break;
   case DDS::XML_DATA_REPRESENTATION:
     repr_string = "XML_DATA_REPRESENTATION";
     break;
   case DDS::XCDR2_DATA_REPRESENTATION:
     repr_string = "XCDR2_DATA_REPRESENTATION";
     break;
   case OpenDDS::DCPS::UNALIGNED_CDR_DATA_REPRESENTATION:
     repr_string = "UNALIGNED_CDR_DATA_REPRESENTATION";
     break;
   default:
     repr_string = to_dds_string(repr);
   }
   return repr_string;
 }

◆ resend_data_expired()

bool OpenDDS::DCPS::resend_data_expired	(	const DataSampleElement &	element,
		const DDS::LifespanQosPolicy &	lifespan
	)

Todo:: Refactor this code and DataReaderImpl::data_expired() to a common function.

Definition at line 37 of file WriteDataContainer.cpp.

References ACE_DEBUG, ACE_TEXT(), DCPS_debug_level, DDS::LifespanQosPolicy::duration, DDS::DURATION_INFINITE_NSEC, DDS::DURATION_INFINITE_SEC, OpenDDS::DCPS::DataSampleElement::get_header(), LM_DEBUG, DDS::Duration_t::nanosec, OpenDDS::DCPS::TimePoint_T< SystemClock >::now(), ACE_Time_Value::sec(), DDS::Duration_t::sec, OpenDDS::DCPS::DataSampleHeader::source_timestamp_nanosec_, OpenDDS::DCPS::DataSampleHeader::source_timestamp_sec_, time_to_time_value(), ACE_Time_Value::usec(), and OpenDDS::DCPS::TimeDuration::value().

Referenced by OpenDDS::DCPS::WriteDataContainer::copy_and_prepend().

 {
   if (lifespan.duration.sec != DDS::DURATION_INFINITE_SEC
       || lifespan.duration.nanosec != DDS::DURATION_INFINITE_NSEC) {
     // Finite lifespan.  Check if data has expired.
 
     const DDS::Time_t tmp = {
       element.get_header().source_timestamp_sec_ + lifespan.duration.sec,
       element.get_header().source_timestamp_nanosec_ + lifespan.duration.nanosec
     };
     const SystemTimePoint expiration_time(time_to_time_value(tmp));
     const SystemTimePoint now = SystemTimePoint::now();
 
     if (now >= expiration_time) {
       if (DCPS_debug_level >= 8) {
         const TimeDuration diff = now - expiration_time;
         ACE_DEBUG((LM_DEBUG,
                    ACE_TEXT("OpenDDS (%P|%t) Data to be sent ")
                    ACE_TEXT("expired by %d seconds, %d microseconds.\n"),
                    diff.value().sec(),
                    diff.value().usec()));
       }
 
       return true; // Data expired.
     }
   }
 
   return false;
 }

◆ retcode_to_string()

OpenDDS_Dcps_Export const char * OpenDDS::DCPS::retcode_to_string ( DDS::ReturnCode_t value )

Definition at line 29 of file DCPS_Utils.cpp.

References ACE_ERROR, ACE_TEXT(), LM_ERROR, DDS::RETCODE_ALREADY_DELETED, DDS::RETCODE_BAD_PARAMETER, DDS::RETCODE_ERROR, DDS::RETCODE_ILLEGAL_OPERATION, DDS::RETCODE_IMMUTABLE_POLICY, DDS::RETCODE_INCONSISTENT_POLICY, DDS::RETCODE_NO_DATA, DDS::Security::RETCODE_NOT_ALLOWED_BY_SECURITY, DDS::RETCODE_NOT_ENABLED, DDS::RETCODE_OK, DDS::RETCODE_OUT_OF_RESOURCES, DDS::RETCODE_PRECONDITION_NOT_MET, DDS::RETCODE_TIMEOUT, and DDS::RETCODE_UNSUPPORTED.

 {
   switch (value) {
   case DDS::RETCODE_OK:
     return "OK";
   case DDS::RETCODE_ERROR:
     return "Error";
   case DDS::RETCODE_UNSUPPORTED:
     return "Unsupported";
   case DDS::RETCODE_BAD_PARAMETER:
     return "Bad parameter";
   case DDS::RETCODE_PRECONDITION_NOT_MET:
     return "Precondition not met";
   case DDS::RETCODE_OUT_OF_RESOURCES:
     return "Out of resources";
   case DDS::RETCODE_NOT_ENABLED:
     return "Not enabled";
   case DDS::RETCODE_IMMUTABLE_POLICY:
     return "Immutable policy";
   case DDS::RETCODE_INCONSISTENT_POLICY:
     return "Inconsistent policy";
   case DDS::RETCODE_ALREADY_DELETED:
     return "Already deleted";
   case DDS::RETCODE_TIMEOUT:
     return "Timeout";
   case DDS::RETCODE_NO_DATA:
     return "No data";
   case DDS::RETCODE_ILLEGAL_OPERATION:
     return "Illegal operation";
 #ifdef OPENDDS_SECURITY
   case DDS::Security::RETCODE_NOT_ALLOWED_BY_SECURITY:
     return "Not allowed by security";
 #endif
   default:
     ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: retcode_to_string: ")
       ACE_TEXT("%d is either invalid or not recognized.\n"),
       value));
     return "Invalid return code";
   }
 }

◆ sequence_begin()

template<typename Sequence >

SequenceIterator<Sequence> OpenDDS::DCPS::sequence_begin ( Sequence & seq )

inline

Definition at line 250 of file SequenceIterator.h.

References OpenDDS::DCPS::SequenceIteratorBase< SequenceIterator< Sequence >, SequenceIterTraits< Sequence > >::begin().

 {
   return SequenceIterator<Sequence>::Base::begin(seq);
 }

◆ sequence_end()

template<typename Sequence >

SequenceIterator<Sequence> OpenDDS::DCPS::sequence_end ( Sequence & seq )

inline

Definition at line 256 of file SequenceIterator.h.

References OpenDDS::DCPS::SequenceIteratorBase< SequenceIterator< Sequence >, SequenceIterTraits< Sequence > >::end().

 {
   return SequenceIterator<Sequence>::Base::end(seq);
 }

◆ serialized_size() [1/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeLookup_getTypes_In &	stru
	)

Definition at line 13 of file TypeLookup.cpp.

References serialized_size_delimiter(), serialized_size_list_end_parameter_id(), serialized_size_parameter_id(), and OpenDDS::XTypes::TypeLookup_getTypes_In::type_ids.

 {
   size_t mutable_running_total = 0;
   serialized_size_delimiter(encoding, size);
 
   serialized_size_parameter_id(encoding, size, mutable_running_total);
   serialized_size(encoding, size, stru.type_ids);
 
   serialized_size_list_end_parameter_id(encoding, size, mutable_running_total);
 }

◆ serialized_size() [2/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeLookup_getTypes_Out &	stru
	)

Definition at line 87 of file TypeLookup.cpp.

References OpenDDS::XTypes::TypeLookup_getTypes_Out::complete_to_minimal, serialized_size(), serialized_size_delimiter(), serialized_size_list_end_parameter_id(), serialized_size_parameter_id(), and OpenDDS::XTypes::TypeLookup_getTypes_Out::types.

 {
   size_t mutable_running_total = 0;
   serialized_size_delimiter(encoding, size);
 
   serialized_size_parameter_id(encoding, size, mutable_running_total);
   serialized_size(encoding, size, stru.types);
 
   serialized_size_parameter_id(encoding, size, mutable_running_total);
   serialized_size(encoding, size, stru.complete_to_minimal);
 
   serialized_size_list_end_parameter_id(encoding, size, mutable_running_total);
 }

◆ serialized_size() [3/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeLookup_getTypes_Result &	uni
	)

Definition at line 176 of file TypeLookup.cpp.

References primitive_serialized_size(), OpenDDS::XTypes::TypeLookup_getTypes_Result::result, OpenDDS::XTypes::TypeLookup_getTypes_Result::return_code, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   primitive_serialized_size(encoding, size, uni.return_code);
   switch (uni.return_code) {
   case 0:
     serialized_size(encoding, size, uni.result);
     break;
   }
 }

◆ serialized_size() [4/122]

ACE_INLINE bool OpenDDS::DCPS::serialized_size	(	const Encoding &	,
		size_t &	size,
		const EncapsulationHeader &
	)

Definition at line 191 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::EncapsulationHeader::serialized_size.

 {
   size += EncapsulationHeader::serialized_size;
   return true;
 }

◆ serialized_size() [5/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const SequenceNumber &
	)

inline

Definition at line 197 of file SequenceNumber.h.

References primitive_serialized_size_ulong().

 {
   primitive_serialized_size_ulong(encoding, size, 2);
 }

◆ serialized_size() [6/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeLookup_getTypeDependencies_In &	stru
	)

Definition at line 229 of file TypeLookup.cpp.

References OpenDDS::XTypes::TypeLookup_getTypeDependencies_In::continuation_point, serialized_size(), serialized_size_delimiter(), serialized_size_list_end_parameter_id(), serialized_size_parameter_id(), and OpenDDS::XTypes::TypeLookup_getTypeDependencies_In::type_ids.

 {
   size_t mutable_running_total = 0;
   serialized_size_delimiter(encoding, size);
 
   serialized_size_parameter_id(encoding, size, mutable_running_total);
   serialized_size(encoding, size, stru.type_ids);
 
   serialized_size_parameter_id(encoding, size, mutable_running_total);
   serialized_size(encoding, size, stru.continuation_point);
 
   serialized_size_list_end_parameter_id(encoding, size, mutable_running_total);
 }

◆ serialized_size() [7/122]

template<typename T >

size_t OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		const T &	value
	)

Convenience function for the serialized_size of a single value with no alignment needed.

Definition at line 301 of file Serializer.h.

References serialized_size().

 {
   size_t size = 0;
   serialized_size(encoding, size, value);
   return size;
 }

◆ serialized_size() [8/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeLookup_getTypeDependencies_Out &	stru
	)

Definition at line 317 of file TypeLookup.cpp.

References OpenDDS::XTypes::TypeLookup_getTypeDependencies_Out::continuation_point, OpenDDS::XTypes::TypeLookup_getTypeDependencies_Out::dependent_typeids, serialized_size(), serialized_size_delimiter(), serialized_size_list_end_parameter_id(), and serialized_size_parameter_id().

 {
   size_t mutable_running_total = 0;
   serialized_size_delimiter(encoding, size);
 
   serialized_size_parameter_id(encoding, size, mutable_running_total);
   serialized_size(encoding, size, stru.dependent_typeids);
 
   serialized_size_parameter_id(encoding, size, mutable_running_total);
   serialized_size(encoding, size, stru.continuation_point);
 
   serialized_size_list_end_parameter_id(encoding, size, mutable_running_total);
 }

◆ serialized_size() [9/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeLookup_getTypeDependencies_Result &	uni
	)

Definition at line 406 of file TypeLookup.cpp.

References primitive_serialized_size(), OpenDDS::XTypes::TypeLookup_getTypeDependencies_Result::result, OpenDDS::XTypes::TypeLookup_getTypeDependencies_Result::return_code, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   primitive_serialized_size(encoding, size, uni.return_code);
 
   switch (uni.return_code) {
   case 0:
     serialized_size(encoding, size, uni.result);
     break;
   }
 }

◆ serialized_size() [10/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeLookup_Call &	uni
	)

Definition at line 460 of file TypeLookup.cpp.

References OpenDDS::XTypes::TypeLookup_Call::getTypeDependencies, OpenDDS::XTypes::TypeLookup_Call::getTypes, OpenDDS::XTypes::TypeLookup_Call::kind, primitive_serialized_size(), serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   primitive_serialized_size(encoding, size, uni.kind);
   switch (uni.kind) {
   case 25318099:
     serialized_size(encoding, size, uni.getTypes);
     break;
   case 95091505:
     serialized_size(encoding, size, uni.getTypeDependencies);
     break;
   }
 }

◆ serialized_size() [11/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeLookup_Request &	stru
	)

Definition at line 519 of file TypeLookup.cpp.

References OpenDDS::XTypes::TypeLookup_Request::data, OpenDDS::XTypes::TypeLookup_Request::header, and serialized_size().

 {
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.data);
 }

◆ serialized_size() [12/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeLookup_Return &	uni
	)

Definition at line 539 of file TypeLookup.cpp.

References OpenDDS::XTypes::TypeLookup_Return::getType, OpenDDS::XTypes::TypeLookup_Return::getTypeDependencies, OpenDDS::XTypes::TypeLookup_Return::kind, primitive_serialized_size(), serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   primitive_serialized_size(encoding, size, uni.kind);
 
   switch (uni.kind) {
   case 25318099:
     serialized_size(encoding, size, uni.getType);
     break;
   case 95091505:
     serialized_size(encoding, size, uni.getTypeDependencies);
     break;
   }
 }

◆ serialized_size() [13/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeLookup_Reply &	stru
	)

Definition at line 599 of file TypeLookup.cpp.

References OpenDDS::XTypes::TypeLookup_Reply::_cxx_return, OpenDDS::XTypes::TypeLookup_Reply::header, and serialized_size().

 {
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru._cxx_return);
 }

◆ serialized_size() [14/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::OctetSeq32 &	seq
	)

Definition at line 619 of file TypeLookup.cpp.

References OpenDDS::XTypes::Sequence< T >::length(), primitive_serialized_size_octet(), and primitive_serialized_size_ulong().

 {
   primitive_serialized_size_ulong(encoding, size);
   if (seq.length() == 0) {
     return;
   }
   primitive_serialized_size_octet(encoding, size, seq.length());
 }

◆ serialized_size() [15/122]

OpenDDS_Dcps_Export void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeIdentifier &	uni
	)

Definition at line 1132 of file TypeObject.cpp.

 {
   primitive_serialized_size_octet(encoding, size);
 
   switch (uni.kind()) {
   case XTypes::TI_STRING8_SMALL:
   case XTypes::TI_STRING16_SMALL:
     serialized_size(encoding, size, uni.string_sdefn());
     break;
   case XTypes::TI_STRING8_LARGE:
   case XTypes::TI_STRING16_LARGE:
     serialized_size(encoding, size, uni.string_ldefn());
     break;
   case XTypes::TI_PLAIN_SEQUENCE_SMALL:
     serialized_size(encoding, size, uni.seq_sdefn());
     break;
   case XTypes::TI_PLAIN_SEQUENCE_LARGE:
     serialized_size(encoding, size, uni.seq_ldefn());
     break;
   case XTypes::TI_PLAIN_ARRAY_SMALL:
     serialized_size(encoding, size, uni.array_sdefn());
     break;
   case XTypes::TI_PLAIN_ARRAY_LARGE:
     serialized_size(encoding, size, uni.array_ldefn());
     break;
   case XTypes::TI_PLAIN_MAP_SMALL:
     serialized_size(encoding, size, uni.map_sdefn());
     break;
   case XTypes::TI_PLAIN_MAP_LARGE:
     serialized_size(encoding, size, uni.map_ldefn());
     break;
   case XTypes::TI_STRONGLY_CONNECTED_COMPONENT:
     serialized_size(encoding, size, uni.sc_component_id());
     break;
   case XTypes::EK_COMPLETE:
   case XTypes::EK_MINIMAL:
     {
       XTypes::EquivalenceHash_forany uni_equivalence_hash(const_cast<XTypes::EquivalenceHash_slice*>(uni.equivalence_hash()));
       serialized_size(encoding, size, uni_equivalence_hash);
       break;
     }
   case XTypes::TK_NONE:
   case XTypes::TK_BOOLEAN:
   case XTypes::TK_BYTE:
   case XTypes::TK_INT16:
   case XTypes::TK_INT32:
   case XTypes::TK_INT64:
   case XTypes::TK_UINT16:
   case XTypes::TK_UINT32:
   case XTypes::TK_UINT64:
   case XTypes::TK_FLOAT32:
   case XTypes::TK_FLOAT64:
   case XTypes::TK_FLOAT128:
   case XTypes::TK_INT8:
   case XTypes::TK_UINT8:
   case XTypes::TK_CHAR8:
   case XTypes::TK_CHAR16:
     break; // no-op, no member selected
   default:
     serialized_size(encoding, size, uni.extended_defn());
   }
 }

◆ serialized_size() [16/122]

OpenDDS_Dcps_Export void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::LBoundSeq &	seq
	)

Definition at line 1309 of file TypeObject.cpp.

References OpenDDS::XTypes::Sequence< T >::length(), primitive_serialized_size(), and primitive_serialized_size_ulong().

 {
   DCPS::primitive_serialized_size_ulong(encoding, size);
   if (seq.length() == 0) {
     return;
   }
   primitive_serialized_size(encoding, size, ACE_CDR::ULong(), seq.length());
 }

◆ serialized_size() [17/122]

OpenDDS_Dcps_Export void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::SBoundSeq &	seq
	)

Definition at line 1345 of file TypeObject.cpp.

References OpenDDS::XTypes::Sequence< T >::length(), primitive_serialized_size_octet(), and primitive_serialized_size_ulong().

 {
   DCPS::primitive_serialized_size_ulong(encoding, size);
   if (seq.length() == 0) {
     return;
   }
   primitive_serialized_size_octet(encoding, size, seq.length());
 }

◆ serialized_size() [18/122]

OpenDDS_Dcps_Export void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::UnionCaseLabelSeq &	seq
	)

Definition at line 1381 of file TypeObject.cpp.

References OpenDDS::XTypes::Sequence< T >::length(), primitive_serialized_size(), and primitive_serialized_size_ulong().

 {
   DCPS::primitive_serialized_size_ulong(encoding, size);
   if (seq.length() == 0) {
     return;
   }
   primitive_serialized_size(encoding, size, ACE_CDR::Long(), seq.length());
 }

◆ serialized_size() [19/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::ExtendedAnnotationParameterValue &
	)

Definition at line 1417 of file TypeObject.cpp.

References serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
 }

◆ serialized_size() [20/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::NameHash_forany &
	)

Definition at line 1434 of file TypeObject.cpp.

References primitive_serialized_size_octet().

 {
   primitive_serialized_size_octet(encoding, size, 4);
 }

◆ serialized_size() [21/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::EquivalenceHash_forany &
	)

Definition at line 1451 of file TypeObject.cpp.

References primitive_serialized_size_octet().

 {
   primitive_serialized_size_octet(encoding, size, 14);
 }

◆ serialized_size() [22/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteTypeDetail &	stru
	)

Definition at line 1468 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteTypeDetail::ann_builtin, OpenDDS::XTypes::CompleteTypeDetail::ann_custom, primitive_serialized_size_ulong(), serialized_size(), and OpenDDS::XTypes::CompleteTypeDetail::type_name.

 {
   serialized_size(encoding, size, stru.ann_builtin);
   serialized_size(encoding, size, stru.ann_custom);
   DCPS::primitive_serialized_size_ulong(encoding, size);
   size += stru.type_name.size() + 1;
 }

◆ serialized_size() [23/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteStructHeader &	stru
	)

Definition at line 1492 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteStructHeader::base_type, OpenDDS::XTypes::CompleteStructHeader::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.base_type);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [24/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalStructHeader &	stru
	)

Definition at line 1531 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalStructHeader::base_type, OpenDDS::XTypes::MinimalStructHeader::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.base_type);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [25/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteStructType &	stru
	)

Definition at line 1569 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteStructType::header, OpenDDS::XTypes::CompleteStructType::member_seq, primitive_serialized_size(), serialized_size(), and OpenDDS::XTypes::CompleteStructType::struct_flags.

 {
   primitive_serialized_size(encoding, size, stru.struct_flags);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.member_seq);
 }

◆ serialized_size() [26/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalStructType &	stru
	)

Definition at line 1592 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalStructType::header, OpenDDS::XTypes::MinimalStructType::member_seq, primitive_serialized_size(), serialized_size(), and OpenDDS::XTypes::MinimalStructType::struct_flags.

 {
   primitive_serialized_size(encoding, size, stru.struct_flags);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.member_seq);
 }

◆ serialized_size() [27/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteUnionType &	stru
	)

Definition at line 1615 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteUnionType::discriminator, OpenDDS::XTypes::CompleteUnionType::header, OpenDDS::XTypes::CompleteUnionType::member_seq, primitive_serialized_size(), serialized_size(), and OpenDDS::XTypes::CompleteUnionType::union_flags.

 {
   primitive_serialized_size(encoding, size, stru.union_flags);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.discriminator);
   serialized_size(encoding, size, stru.member_seq);
 }

◆ serialized_size() [28/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalUnionType &	stru
	)

Definition at line 1641 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalUnionType::discriminator, OpenDDS::XTypes::MinimalUnionType::header, OpenDDS::XTypes::MinimalUnionType::member_seq, primitive_serialized_size(), serialized_size(), and OpenDDS::XTypes::MinimalUnionType::union_flags.

 {
   primitive_serialized_size(encoding, size, stru.union_flags);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.discriminator);
   serialized_size(encoding, size, stru.member_seq);
 }

◆ serialized_size() [29/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteAnnotationType &	stru
	)

Definition at line 1667 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAnnotationType::annotation_flag, OpenDDS::XTypes::CompleteAnnotationType::header, OpenDDS::XTypes::CompleteAnnotationType::member_seq, primitive_serialized_size(), and serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.annotation_flag);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.member_seq);
 }

◆ serialized_size() [30/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalAnnotationType &	stru
	)

Definition at line 1690 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalAnnotationType::annotation_flag, OpenDDS::XTypes::MinimalAnnotationType::header, OpenDDS::XTypes::MinimalAnnotationType::member_seq, primitive_serialized_size(), and serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.annotation_flag);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.member_seq);
 }

◆ serialized_size() [31/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteAliasType &	stru
	)

Definition at line 1713 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAliasType::alias_flags, OpenDDS::XTypes::CompleteAliasType::body, OpenDDS::XTypes::CompleteAliasType::header, primitive_serialized_size(), and serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.alias_flags);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.body);
 }

◆ serialized_size() [32/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalAliasType &	stru
	)

Definition at line 1736 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalAliasType::alias_flags, OpenDDS::XTypes::MinimalAliasType::body, OpenDDS::XTypes::MinimalAliasType::header, primitive_serialized_size(), and serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.alias_flags);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.body);
 }

◆ serialized_size() [33/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteSequenceType &	stru
	)

Definition at line 1759 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteSequenceType::collection_flag, OpenDDS::XTypes::CompleteSequenceType::element, OpenDDS::XTypes::CompleteSequenceType::header, primitive_serialized_size(), and serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.collection_flag);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.element);
 }

◆ serialized_size() [34/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalSequenceType &	stru
	)

Definition at line 1782 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalSequenceType::collection_flag, OpenDDS::XTypes::MinimalSequenceType::element, OpenDDS::XTypes::MinimalSequenceType::header, primitive_serialized_size(), and serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.collection_flag);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.element);
 }

◆ serialized_size() [35/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteArrayType &	stru
	)

Definition at line 1805 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteArrayType::collection_flag, OpenDDS::XTypes::CompleteArrayType::element, OpenDDS::XTypes::CompleteArrayType::header, primitive_serialized_size(), serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   primitive_serialized_size(encoding, size, stru.collection_flag);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.element);
 }

◆ serialized_size() [36/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalArrayType &	stru
	)

Definition at line 1847 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalArrayType::collection_flag, OpenDDS::XTypes::MinimalArrayType::element, OpenDDS::XTypes::MinimalArrayType::header, primitive_serialized_size(), and serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.collection_flag);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.element);
 }

◆ serialized_size() [37/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteMapType &	stru
	)

Definition at line 1870 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteMapType::collection_flag, OpenDDS::XTypes::CompleteMapType::element, OpenDDS::XTypes::CompleteMapType::header, OpenDDS::XTypes::CompleteMapType::key, primitive_serialized_size(), and serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.collection_flag);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.key);
   serialized_size(encoding, size, stru.element);
 }

◆ serialized_size() [38/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalMapType &	stru
	)

Definition at line 1896 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalMapType::collection_flag, OpenDDS::XTypes::MinimalMapType::element, OpenDDS::XTypes::MinimalMapType::header, OpenDDS::XTypes::MinimalMapType::key, primitive_serialized_size(), and serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.collection_flag);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.key);
   serialized_size(encoding, size, stru.element);
 }

◆ serialized_size() [39/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteEnumeratedHeader &	stru
	)

Definition at line 1922 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteEnumeratedHeader::common, OpenDDS::XTypes::CompleteEnumeratedHeader::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [40/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalEnumeratedHeader &	stru
	)

Definition at line 1960 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalEnumeratedHeader::common, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
 }

◆ serialized_size() [41/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteEnumeratedType &	stru
	)

Definition at line 1996 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteEnumeratedType::enum_flags, OpenDDS::XTypes::CompleteEnumeratedType::header, OpenDDS::XTypes::CompleteEnumeratedType::literal_seq, primitive_serialized_size(), and serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.enum_flags);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.literal_seq);
 }

◆ serialized_size() [42/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalEnumeratedType &	stru
	)

Definition at line 2019 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalEnumeratedType::enum_flags, OpenDDS::XTypes::MinimalEnumeratedType::header, OpenDDS::XTypes::MinimalEnumeratedType::literal_seq, primitive_serialized_size(), and serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.enum_flags);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.literal_seq);
 }

◆ serialized_size() [43/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteBitmaskType &	stru
	)

Definition at line 2042 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteBitmaskType::bitmask_flags, OpenDDS::XTypes::CompleteBitmaskType::flag_seq, OpenDDS::XTypes::CompleteBitmaskType::header, primitive_serialized_size(), serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   primitive_serialized_size(encoding, size, stru.bitmask_flags);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.flag_seq);
 }

◆ serialized_size() [44/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalBitmaskType &	stru
	)

Definition at line 2084 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalBitmaskType::bitmask_flags, OpenDDS::XTypes::MinimalBitmaskType::flag_seq, OpenDDS::XTypes::MinimalBitmaskType::header, primitive_serialized_size(), serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   primitive_serialized_size(encoding, size, stru.bitmask_flags);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.flag_seq);
 }

◆ serialized_size() [45/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteBitsetType &	stru
	)

Definition at line 2126 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteBitsetType::bitset_flags, OpenDDS::XTypes::CompleteBitsetType::field_seq, OpenDDS::XTypes::CompleteBitsetType::header, primitive_serialized_size(), serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   primitive_serialized_size(encoding, size, stru.bitset_flags);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.field_seq);
 }

◆ serialized_size() [46/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalBitsetType &	stru
	)

Definition at line 2168 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalBitsetType::bitset_flags, OpenDDS::XTypes::MinimalBitsetType::field_seq, OpenDDS::XTypes::MinimalBitsetType::header, primitive_serialized_size(), serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   primitive_serialized_size(encoding, size, stru.bitset_flags);
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.field_seq);
 }

◆ serialized_size() [47/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteExtendedType &
	)

Definition at line 2210 of file TypeObject.cpp.

References serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
 }

◆ serialized_size() [48/122]

OpenDDS_Dcps_Export void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeIdentifierWithSize &	stru
	)

Definition at line 2227 of file TypeObject.cpp.

References primitive_serialized_size(), serialized_size(), serialized_size_delimiter(), OpenDDS::XTypes::TypeIdentifierWithSize::type_id, and OpenDDS::XTypes::TypeIdentifierWithSize::typeobject_serialized_size.

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.type_id);
   primitive_serialized_size(encoding, size, stru.typeobject_serialized_size);
 }

◆ serialized_size() [49/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeIdentifierWithDependencies &	stru
	)

Definition at line 2266 of file TypeObject.cpp.

References OpenDDS::XTypes::TypeIdentifierWithDependencies::dependent_typeid_count, OpenDDS::XTypes::TypeIdentifierWithDependencies::dependent_typeids, primitive_serialized_size(), serialized_size(), serialized_size_delimiter(), and OpenDDS::XTypes::TypeIdentifierWithDependencies::typeid_with_size.

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.typeid_with_size);
   primitive_serialized_size(encoding, size, stru.dependent_typeid_count);
   serialized_size(encoding, size, stru.dependent_typeids);
 }

◆ serialized_size() [50/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::AppliedAnnotation &	stru
	)

Definition at line 2308 of file TypeObject.cpp.

References OpenDDS::XTypes::AppliedAnnotation::annotation_typeid, OpenDDS::XTypes::AppliedAnnotation::param_seq, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.annotation_typeid);
   serialized_size(encoding, size, stru.param_seq);
 }

◆ serialized_size() [51/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::AppliedBuiltinTypeAnnotations &	stru
	)

Definition at line 2346 of file TypeObject.cpp.

References serialized_size(), serialized_size_delimiter(), and OpenDDS::XTypes::AppliedBuiltinTypeAnnotations::verbatim.

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.verbatim);
 }

◆ serialized_size() [52/122]

template<typename T >

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::Optional< T > &	opt
	)

Definition at line 2363 of file TypeObject.h.

References boolean_cdr_size, OpenDDS::XTypes::Optional< T >::present, serialized_size(), and OpenDDS::XTypes::Optional< T >::value.

 {
   size += DCPS::boolean_cdr_size;
   if (opt.present) {
     serialized_size(encoding, size, opt.value);
   }
 }

◆ serialized_size() [53/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteAliasBody &	stru
	)

Definition at line 2382 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAliasBody::ann_builtin, OpenDDS::XTypes::CompleteAliasBody::ann_custom, OpenDDS::XTypes::CompleteAliasBody::common, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
   serialized_size(encoding, size, stru.ann_builtin);
   serialized_size(encoding, size, stru.ann_custom);
 }

◆ serialized_size() [54/122]

template<typename T >

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::Sequence< T > &	seq
	)

Definition at line 2394 of file TypeObject.h.

References OpenDDS::XTypes::Sequence< T >::length(), primitive_serialized_size_ulong(), serialized_size(), serialized_size_delimiter(), and OpenDDS::DCPS::Encoding::skip_sequence_dheader().

 {
   if (!encoding.skip_sequence_dheader()) {
     serialized_size_delimiter(encoding, size);
   }
   primitive_serialized_size_ulong(encoding, size);
   for (ACE_CDR::ULong i = 0; i < seq.length(); ++i) {
     serialized_size(encoding, size, seq[i]);
   }
 }

◆ serialized_size() [55/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteAliasHeader &	stru
	)

Definition at line 2424 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAliasHeader::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [56/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteAnnotationHeader &	stru
	)

Definition at line 2460 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAnnotationHeader::annotation_name, primitive_serialized_size_ulong(), serialized_size_delimiter(), and ACE_OS::strlen().

 {
   serialized_size_delimiter(encoding, size);
   DCPS::primitive_serialized_size_ulong(encoding, size);
   size += ACE_OS::strlen(stru.annotation_name.c_str()) + 1;
 }

◆ serialized_size() [57/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteAnnotationParameter &	stru
	)

Definition at line 2497 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteAnnotationParameter::common, OpenDDS::XTypes::CompleteAnnotationParameter::default_value, OpenDDS::XTypes::CompleteAnnotationParameter::name, primitive_serialized_size_ulong(), serialized_size(), serialized_size_delimiter(), and ACE_OS::strlen().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
   primitive_serialized_size_ulong(encoding, size);
   size += ACE_OS::strlen(stru.name.c_str()) + 1;
   serialized_size(encoding, size, stru.default_value);
 }

◆ serialized_size() [58/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	,
		size_t &	,
		const XTypes::MinimalTypeDetail &
	)

inline

Definition at line 2499 of file TypeObject.h.

Referenced by operator<<(), operator>>(), and serialized_size().

2500 {}

◆ serialized_size() [59/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteArrayHeader &	stru
	)

Definition at line 2540 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteArrayHeader::common, OpenDDS::XTypes::CompleteArrayHeader::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [60/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteBitfield &	stru
	)

Definition at line 2579 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteBitfield::common, OpenDDS::XTypes::CompleteBitfield::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [61/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteBitflag &	stru
	)

Definition at line 2618 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteBitflag::common, OpenDDS::XTypes::CompleteBitflag::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [62/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteBitsetHeader &	stru
	)

Definition at line 2657 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteBitsetHeader::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [63/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteCollectionElement &	stru
	)

Definition at line 2693 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteCollectionElement::common, OpenDDS::XTypes::CompleteCollectionElement::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [64/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteCollectionHeader &	stru
	)

Definition at line 2732 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteCollectionHeader::common, OpenDDS::XTypes::CompleteCollectionHeader::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [65/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteDiscriminatorMember &	stru
	)

Definition at line 2771 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteDiscriminatorMember::ann_builtin, OpenDDS::XTypes::CompleteDiscriminatorMember::ann_custom, OpenDDS::XTypes::CompleteDiscriminatorMember::common, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
   serialized_size(encoding, size, stru.ann_builtin);
   serialized_size(encoding, size, stru.ann_custom);
 }

◆ serialized_size() [66/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteEnumeratedLiteral &	stru
	)

Definition at line 2813 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteEnumeratedLiteral::common, OpenDDS::XTypes::CompleteEnumeratedLiteral::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [67/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteStructMember &	stru
	)

Definition at line 2852 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteStructMember::common, OpenDDS::XTypes::CompleteStructMember::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [68/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteUnionHeader &	stru
	)

Definition at line 2892 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteUnionHeader::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [69/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteUnionMember &	stru
	)

Definition at line 2928 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteUnionMember::common, OpenDDS::XTypes::CompleteUnionMember::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [70/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalAliasBody &	stru
	)

Definition at line 2967 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalAliasBody::common, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
 }

◆ serialized_size() [71/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalAliasHeader &
	)

Definition at line 3003 of file TypeObject.cpp.

References serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
 }

◆ serialized_size() [72/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalAnnotationHeader &
	)

Definition at line 3020 of file TypeObject.cpp.

References serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
 }

◆ serialized_size() [73/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalAnnotationParameter &	stru
	)

Definition at line 3037 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalAnnotationParameter::common, OpenDDS::XTypes::MinimalAnnotationParameter::default_value, OpenDDS::XTypes::MinimalAnnotationParameter::name_hash, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
   serialized_size(encoding, size, stru.common);
   serialized_size(encoding, size, stru_name_hash);
   serialized_size(encoding, size, stru.default_value);
 }

◆ serialized_size() [74/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalArrayHeader &	stru
	)

Definition at line 3082 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalArrayHeader::common, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
 }

◆ serialized_size() [75/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalBitfield &	stru
	)

Definition at line 3118 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalBitfield::common, OpenDDS::XTypes::MinimalBitfield::name_hash, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
   serialized_size(encoding, size, stru.common);
   serialized_size(encoding, size, stru_name_hash);
 }

◆ serialized_size() [76/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalBitflag &	stru
	)

Definition at line 3160 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalBitflag::common, OpenDDS::XTypes::MinimalBitflag::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [77/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalBitsetHeader &
	)

Definition at line 3199 of file TypeObject.cpp.

References serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
 }

◆ serialized_size() [78/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalCollectionElement &	stru
	)

Definition at line 3216 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalCollectionElement::common, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
 }

◆ serialized_size() [79/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalCollectionHeader &	stru
	)

Definition at line 3252 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalCollectionHeader::common, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
 }

◆ serialized_size() [80/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalDiscriminatorMember &	stru
	)

Definition at line 3288 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalDiscriminatorMember::common, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
 }

◆ serialized_size() [81/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalEnumeratedLiteral &	stru
	)

Definition at line 3324 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalEnumeratedLiteral::common, OpenDDS::XTypes::MinimalEnumeratedLiteral::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [82/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalStructMember &	stru
	)

Definition at line 3363 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalStructMember::common, OpenDDS::XTypes::MinimalStructMember::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [83/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalUnionHeader &	stru
	)

Definition at line 3402 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalUnionHeader::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [84/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalUnionMember &	stru
	)

Definition at line 3438 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalUnionMember::common, OpenDDS::XTypes::MinimalUnionMember::detail, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.common);
   serialized_size(encoding, size, stru.detail);
 }

◆ serialized_size() [85/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::AnnotationParameterValue &	uni
	)

Definition at line 3477 of file TypeObject.cpp.

 {
   primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(uni.kind()));
   switch (uni.kind()) {
   case XTypes::TK_BOOLEAN: {
     primitive_serialized_size(encoding, size, ACE_OutputCDR::from_boolean(uni.boolean_value()));
     break;
   }
   case XTypes::TK_BYTE: {
     primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(uni.byte_value()));
     break;
   }
   case XTypes::TK_INT16: {
     primitive_serialized_size(encoding, size, uni.int16_value());
     break;
   }
   case XTypes::TK_UINT16: {
     primitive_serialized_size(encoding, size, uni.uint16_value());
     break;
   }
   case XTypes::TK_INT32: {
     primitive_serialized_size(encoding, size, uni.int32_value());
     break;
   }
   case XTypes::TK_UINT32: {
     primitive_serialized_size(encoding, size, uni.uint32_value());
     break;
   }
   case XTypes::TK_INT64: {
     primitive_serialized_size(encoding, size, uni.int64_value());
     break;
   }
   case XTypes::TK_UINT64: {
     primitive_serialized_size(encoding, size, uni.uint64_value());
     break;
   }
   case XTypes::TK_FLOAT32: {
     primitive_serialized_size(encoding, size, uni.float32_value());
     break;
   }
   case XTypes::TK_FLOAT64: {
     primitive_serialized_size(encoding, size, uni.float64_value());
     break;
   }
   case XTypes::TK_FLOAT128: {
     primitive_serialized_size(encoding, size, uni.float128_value());
     break;
   }
   case XTypes::TK_CHAR8: {
     primitive_serialized_size(encoding, size, ACE_OutputCDR::from_char(uni.char_value()));
     break;
   }
   case XTypes::TK_CHAR16: {
     primitive_serialized_size(encoding, size, ACE_OutputCDR::from_wchar(uni.wchar_value()));
     break;
   }
   case XTypes::TK_ENUM: {
     primitive_serialized_size(encoding, size, uni.enumerated_value());
     break;
   }
   case XTypes::TK_STRING8: {
     DCPS::primitive_serialized_size_ulong(encoding, size);
     size += ACE_OS::strlen(uni.string8_value().c_str()) + 1;
     break;
   }
   case XTypes::TK_STRING16: {
 #ifdef DDS_HAS_WCHAR
     DCPS::primitive_serialized_size_ulong(encoding, size);
     size += ACE_OS::strlen(uni.string16_value().c_str()) * DCPS::char16_cdr_size;
 #endif
     break;
   }
   default: {
     serialized_size(encoding, size, uni.extended_value());
     break;
   }
   }
 }

◆ serialized_size() [86/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::AppliedAnnotationParameter &	stru
	)

Definition at line 3671 of file TypeObject.cpp.

References OpenDDS::XTypes::AppliedAnnotationParameter::paramname_hash, serialized_size(), serialized_size_delimiter(), and OpenDDS::XTypes::AppliedAnnotationParameter::value.

 {
   serialized_size_delimiter(encoding, size);
   XTypes::NameHash_forany stru_paramname_hash(const_cast<XTypes::NameHash_slice*>(stru.paramname_hash));
   serialized_size(encoding, size, stru_paramname_hash);
   serialized_size(encoding, size, stru.value);
 }

◆ serialized_size() [87/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::AppliedBuiltinMemberAnnotations &	stru
	)

Definition at line 3713 of file TypeObject.cpp.

References boolean_cdr_size, OpenDDS::XTypes::AppliedBuiltinMemberAnnotations::hash_id, OpenDDS::XTypes::AppliedBuiltinMemberAnnotations::max, OpenDDS::XTypes::AppliedBuiltinMemberAnnotations::min, OpenDDS::XTypes::Optional< T >::present, primitive_serialized_size_ulong(), serialized_size(), serialized_size_delimiter(), ACE_OS::strlen(), OpenDDS::XTypes::AppliedBuiltinMemberAnnotations::unit, and OpenDDS::XTypes::Optional< T >::value.

 {
   serialized_size_delimiter(encoding, size);
 
   size += DCPS::boolean_cdr_size;
   if (stru.unit.present) {
     DCPS::primitive_serialized_size_ulong(encoding, size);
     size += ACE_OS::strlen(stru.unit.value.c_str()) + 1;
   }
 
   serialized_size(encoding, size, stru.min);
   serialized_size(encoding, size, stru.max);
 
   size += DCPS::boolean_cdr_size;
   if (stru.hash_id.present) {
     DCPS::primitive_serialized_size_ulong(encoding, size);
     size += ACE_OS::strlen(stru.hash_id.value.c_str()) + 1;
   }
 }

◆ serialized_size() [88/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::AppliedVerbatimAnnotation &	stru
	)

Definition at line 3769 of file TypeObject.cpp.

References OpenDDS::XTypes::AppliedVerbatimAnnotation::language, OpenDDS::XTypes::AppliedVerbatimAnnotation::placement, primitive_serialized_size_ulong(), ACE_OS::strlen(), and OpenDDS::XTypes::AppliedVerbatimAnnotation::text.

 {
   DCPS::primitive_serialized_size_ulong(encoding, size);
   size += ACE_OS::strlen(stru.placement.c_str()) + 1;
   DCPS::primitive_serialized_size_ulong(encoding, size);
   size += ACE_OS::strlen(stru.language.c_str()) + 1;
   DCPS::primitive_serialized_size_ulong(encoding, size);
   size += ACE_OS::strlen(stru.text.c_str()) + 1;
 }

◆ serialized_size() [89/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CommonAliasBody &	stru
	)

Definition at line 3795 of file TypeObject.cpp.

References primitive_serialized_size(), OpenDDS::XTypes::CommonAliasBody::related_flags, OpenDDS::XTypes::CommonAliasBody::related_type, and serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.related_flags);
   serialized_size(encoding, size, stru.related_type);
 }

◆ serialized_size() [90/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CommonAnnotationParameter &	stru
	)

Definition at line 3815 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonAnnotationParameter::member_flags, OpenDDS::XTypes::CommonAnnotationParameter::member_type_id, primitive_serialized_size(), and serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.member_flags);
   serialized_size(encoding, size, stru.member_type_id);
 }

◆ serialized_size() [91/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CommonArrayHeader &	stru
	)

Definition at line 3835 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonArrayHeader::bound_seq, and serialized_size().

 {
   serialized_size(encoding, size, stru.bound_seq);
 }

◆ serialized_size() [92/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CommonBitfield &	stru
	)

Definition at line 3852 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonBitfield::bitcount, OpenDDS::XTypes::CommonBitfield::flags, OpenDDS::XTypes::CommonBitfield::holder_type, OpenDDS::XTypes::CommonBitfield::position, and primitive_serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.position);
   primitive_serialized_size(encoding, size, stru.flags);
   primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(stru.bitcount));
   primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(stru.holder_type));
 }

◆ serialized_size() [93/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CommonBitflag &	stru
	)

Definition at line 3878 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonBitflag::flags, OpenDDS::XTypes::CommonBitflag::position, and primitive_serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.position);
   primitive_serialized_size(encoding, size, stru.flags);
 }

◆ serialized_size() [94/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CommonCollectionElement &	stru
	)

Definition at line 3898 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonCollectionElement::element_flags, primitive_serialized_size(), serialized_size(), and OpenDDS::XTypes::CommonCollectionElement::type.

 {
   primitive_serialized_size(encoding, size, stru.element_flags);
   serialized_size(encoding, size, stru.type);
 }

◆ serialized_size() [95/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CommonCollectionHeader &	stru
	)

Definition at line 3918 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonCollectionHeader::bound, and primitive_serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.bound);
 }

◆ serialized_size() [96/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CommonDiscriminatorMember &	stru
	)

Definition at line 3935 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonDiscriminatorMember::member_flags, primitive_serialized_size(), serialized_size(), and OpenDDS::XTypes::CommonDiscriminatorMember::type_id.

 {
   primitive_serialized_size(encoding, size, stru.member_flags);
   serialized_size(encoding, size, stru.type_id);
 }

◆ serialized_size() [97/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CommonEnumeratedHeader &	stru
	)

Definition at line 3955 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonEnumeratedHeader::bit_bound, and primitive_serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.bit_bound);
 }

◆ serialized_size() [98/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CommonEnumeratedLiteral &	stru
	)

Definition at line 3972 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonEnumeratedLiteral::flags, primitive_serialized_size(), serialized_size_delimiter(), and OpenDDS::XTypes::CommonEnumeratedLiteral::value.

 {
   serialized_size_delimiter(encoding, size);
   primitive_serialized_size(encoding, size, stru.value);
   primitive_serialized_size(encoding, size, stru.flags);
 }

◆ serialized_size() [99/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CommonStructMember &	stru
	)

Definition at line 4011 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonStructMember::member_flags, OpenDDS::XTypes::CommonStructMember::member_id, OpenDDS::XTypes::CommonStructMember::member_type_id, primitive_serialized_size(), and serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.member_id);
   primitive_serialized_size(encoding, size, stru.member_flags);
   serialized_size(encoding, size, stru.member_type_id);
 }

◆ serialized_size() [100/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CommonUnionMember &	stru
	)

Definition at line 4034 of file TypeObject.cpp.

References OpenDDS::XTypes::CommonUnionMember::label_seq, OpenDDS::XTypes::CommonUnionMember::member_flags, OpenDDS::XTypes::CommonUnionMember::member_id, primitive_serialized_size(), serialized_size(), and OpenDDS::XTypes::CommonUnionMember::type_id.

 {
   primitive_serialized_size(encoding, size, stru.member_id);
   primitive_serialized_size(encoding, size, stru.member_flags);
   serialized_size(encoding, size, stru.type_id);
   serialized_size(encoding, size, stru.label_seq);
 }

◆ serialized_size() [101/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteElementDetail &	stru
	)

Definition at line 4060 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteElementDetail::ann_builtin, OpenDDS::XTypes::CompleteElementDetail::ann_custom, and serialized_size().

 {
   serialized_size(encoding, size, stru.ann_builtin);
   serialized_size(encoding, size, stru.ann_custom);
 }

◆ serialized_size() [102/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteMemberDetail &	stru
	)

Definition at line 4080 of file TypeObject.cpp.

References OpenDDS::XTypes::CompleteMemberDetail::ann_builtin, OpenDDS::XTypes::CompleteMemberDetail::ann_custom, OpenDDS::XTypes::CompleteMemberDetail::name, primitive_serialized_size_ulong(), serialized_size(), and ACE_OS::strlen().

 {
   DCPS::primitive_serialized_size_ulong(encoding, size);
   size += ACE_OS::strlen(stru.name.c_str()) + 1;
   serialized_size(encoding, size, stru.ann_builtin);
   serialized_size(encoding, size, stru.ann_custom);
 }

◆ serialized_size() [103/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalMemberDetail &	stru
	)

Definition at line 4104 of file TypeObject.cpp.

References OpenDDS::XTypes::MinimalMemberDetail::name_hash, and serialized_size().

 {
   XTypes::NameHash_forany stru_name_hash(const_cast<XTypes::NameHash_slice*>(stru.name_hash));
   serialized_size(encoding, size, stru_name_hash);
 }

◆ serialized_size() [104/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::ExtendedTypeDefn &
	)

Definition at line 4124 of file TypeObject.cpp.

References serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
 }

◆ serialized_size() [105/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::PlainArrayLElemDefn &	stru
	)

Definition at line 4141 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainArrayLElemDefn::array_bound_seq, OpenDDS::XTypes::PlainArrayLElemDefn::element_identifier, OpenDDS::XTypes::PlainArrayLElemDefn::header, and serialized_size().

 {
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.array_bound_seq);
   serialized_size(encoding, size, *stru.element_identifier);
 }

◆ serialized_size() [106/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::PlainArraySElemDefn &	stru
	)

Definition at line 4164 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainArraySElemDefn::array_bound_seq, OpenDDS::XTypes::PlainArraySElemDefn::element_identifier, OpenDDS::XTypes::PlainArraySElemDefn::header, and serialized_size().

 {
   serialized_size(encoding, size, stru.header);
   serialized_size(encoding, size, stru.array_bound_seq);
   serialized_size(encoding, size, *stru.element_identifier);
 }

◆ serialized_size() [107/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::PlainMapLTypeDefn &	stru
	)

Definition at line 4187 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainMapLTypeDefn::bound, OpenDDS::XTypes::PlainMapLTypeDefn::element_identifier, OpenDDS::XTypes::PlainMapLTypeDefn::header, OpenDDS::XTypes::PlainMapLTypeDefn::key_flags, OpenDDS::XTypes::PlainMapLTypeDefn::key_identifier, primitive_serialized_size(), and serialized_size().

 {
   serialized_size(encoding, size, stru.header);
   primitive_serialized_size(encoding, size, stru.bound);
   serialized_size(encoding, size, *stru.element_identifier);
   primitive_serialized_size(encoding, size, stru.key_flags);
   serialized_size(encoding, size, *stru.key_identifier);
 }

◆ serialized_size() [108/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::PlainMapSTypeDefn &	stru
	)

Definition at line 4216 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainMapSTypeDefn::bound, OpenDDS::XTypes::PlainMapSTypeDefn::element_identifier, OpenDDS::XTypes::PlainMapSTypeDefn::header, OpenDDS::XTypes::PlainMapSTypeDefn::key_flags, OpenDDS::XTypes::PlainMapSTypeDefn::key_identifier, primitive_serialized_size(), and serialized_size().

 {
   serialized_size(encoding, size, stru.header);
   primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(stru.bound));
   serialized_size(encoding, size, *stru.element_identifier);
   primitive_serialized_size(encoding, size, stru.key_flags);
   serialized_size(encoding, size, *stru.key_identifier);
 }

◆ serialized_size() [109/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::PlainSequenceLElemDefn &	stru
	)

Definition at line 4245 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainSequenceLElemDefn::bound, OpenDDS::XTypes::PlainSequenceLElemDefn::element_identifier, OpenDDS::XTypes::PlainSequenceLElemDefn::header, primitive_serialized_size(), and serialized_size().

 {
   serialized_size(encoding, size, stru.header);
   primitive_serialized_size(encoding, size, stru.bound);
   serialized_size(encoding, size, *stru.element_identifier);
 }

◆ serialized_size() [110/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::PlainSequenceSElemDefn &	stru
	)

Definition at line 4268 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainSequenceSElemDefn::bound, OpenDDS::XTypes::PlainSequenceSElemDefn::element_identifier, OpenDDS::XTypes::PlainSequenceSElemDefn::header, primitive_serialized_size(), and serialized_size().

 {
   serialized_size(encoding, size, stru.header);
   primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(stru.bound));
   serialized_size(encoding, size, *stru.element_identifier);
 }

◆ serialized_size() [111/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::StringLTypeDefn &	stru
	)

Definition at line 4291 of file TypeObject.cpp.

References OpenDDS::XTypes::StringLTypeDefn::bound, and primitive_serialized_size().

 {
   primitive_serialized_size(encoding, size, stru.bound);
 }

◆ serialized_size() [112/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::StringSTypeDefn &	stru
	)

Definition at line 4308 of file TypeObject.cpp.

References OpenDDS::XTypes::StringSTypeDefn::bound, and primitive_serialized_size().

 {
   primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(stru.bound));
 }

◆ serialized_size() [113/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::StronglyConnectedComponentId &	stru
	)

Definition at line 4325 of file TypeObject.cpp.

References primitive_serialized_size(), OpenDDS::XTypes::StronglyConnectedComponentId::sc_component_id, OpenDDS::XTypes::StronglyConnectedComponentId::scc_index, OpenDDS::XTypes::StronglyConnectedComponentId::scc_length, serialized_size(), and serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
   serialized_size(encoding, size, stru.sc_component_id);
   primitive_serialized_size(encoding, size, stru.scc_length);
   primitive_serialized_size(encoding, size, stru.scc_index);
 }

◆ serialized_size() [114/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::PlainCollectionHeader &	stru
	)

Definition at line 4370 of file TypeObject.cpp.

References OpenDDS::XTypes::PlainCollectionHeader::element_flags, OpenDDS::XTypes::PlainCollectionHeader::equiv_kind, and primitive_serialized_size().

 {
   primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(stru.equiv_kind));
   primitive_serialized_size(encoding, size, stru.element_flags);
 }

◆ serialized_size() [115/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeObjectHashId &	uni
	)

Definition at line 4390 of file TypeObject.cpp.

References OpenDDS::XTypes::EK_COMPLETE, OpenDDS::XTypes::EK_MINIMAL, OpenDDS::XTypes::TypeObjectHashId::hash, OpenDDS::XTypes::TypeObjectHashId::kind, primitive_serialized_size(), and serialized_size().

 {
   primitive_serialized_size(encoding, size, ACE_OutputCDR::from_octet(uni.kind));
   switch (uni.kind) {
   case XTypes::EK_MINIMAL:
   case XTypes::EK_COMPLETE: {
     XTypes::EquivalenceHash_forany uni_hash(const_cast<XTypes::EquivalenceHash_slice*>(uni.hash));
     serialized_size(encoding, size, uni_hash);
     break;
   }
   default:
     break;
   }
 }

◆ serialized_size() [116/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::CompleteTypeObject &	type_object
	)

Definition at line 4439 of file TypeObject.cpp.

 {
   using namespace XTypes;
   primitive_serialized_size_octet(encoding, size); // discriminator
 
   switch (type_object.kind) {
   case TK_ALIAS:
     serialized_size(encoding, size, type_object.alias_type);
     return;
   case TK_ANNOTATION:
     serialized_size(encoding, size, type_object.annotation_type);
     return;
   case TK_STRUCTURE:
     serialized_size(encoding, size, type_object.struct_type);
     return;
   case TK_UNION:
     serialized_size(encoding, size, type_object.union_type);
     return;
   case TK_BITSET:
     serialized_size(encoding, size, type_object.bitset_type);
     return;
   case TK_SEQUENCE:
     serialized_size(encoding, size, type_object.sequence_type);
     return;
   case TK_ARRAY:
     serialized_size(encoding, size, type_object.array_type);
     return;
   case TK_MAP:
     serialized_size(encoding, size, type_object.map_type);
     return;
   case TK_ENUM:
     serialized_size(encoding, size, type_object.enumerated_type);
     return;
   case TK_BITMASK:
     serialized_size(encoding, size, type_object.bitmask_type);
     return;
   default:
     serialized_size(encoding, size, type_object.extended_type);
   }
 }

◆ serialized_size() [117/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalTypeObject &	type_object
	)

Definition at line 4548 of file TypeObject.cpp.

 {
   using namespace XTypes;
   primitive_serialized_size_octet(encoding, size); // discriminator
 
   switch (type_object.kind) {
   case TK_ALIAS:
     return serialized_size(encoding, size, type_object.alias_type);
   case TK_ANNOTATION:
     return serialized_size(encoding, size, type_object.annotation_type);
   case TK_STRUCTURE:
     return serialized_size(encoding, size, type_object.struct_type);
   case TK_UNION:
     return serialized_size(encoding, size, type_object.union_type);
   case TK_BITSET:
     return serialized_size(encoding, size, type_object.bitset_type);
   case TK_SEQUENCE:
     return serialized_size(encoding, size, type_object.sequence_type);
   case TK_ARRAY:
     return serialized_size(encoding, size, type_object.array_type);
   case TK_MAP:
     return serialized_size(encoding, size, type_object.map_type);
   case TK_ENUM:
     return serialized_size(encoding, size, type_object.enumerated_type);
   case TK_BITMASK:
     return serialized_size(encoding, size, type_object.bitmask_type);
   default:
     return serialized_size(encoding, size, type_object.extended_type);
   }
 }

◆ serialized_size() [118/122]

OpenDDS_Dcps_Export void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeObject &	type_object
	)

Definition at line 4647 of file TypeObject.cpp.

References OpenDDS::XTypes::TypeObject::complete, OpenDDS::XTypes::EK_COMPLETE, OpenDDS::XTypes::EK_MINIMAL, OpenDDS::XTypes::TypeObject::kind, OpenDDS::XTypes::TypeObject::minimal, primitive_serialized_size_octet(), primitive_serialized_size_ulong(), and serialized_size().

 {
   using namespace XTypes;
   primitive_serialized_size_ulong(encoding, size); // DHEADER
   primitive_serialized_size_octet(encoding, size); // discriminator
 
   switch (type_object.kind) {
   case EK_COMPLETE:
     return serialized_size(encoding, size, type_object.complete);
   case EK_MINIMAL:
     return serialized_size(encoding, size, type_object.minimal);
   }
 }

◆ serialized_size() [119/122]

void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::MinimalExtendedType &
	)

Definition at line 4709 of file TypeObject.cpp.

References serialized_size_delimiter().

 {
   serialized_size_delimiter(encoding, size);
 }

◆ serialized_size() [120/122]

OpenDDS_Dcps_Export void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeInformation &	stru
	)

Definition at line 4726 of file TypeObject.cpp.

References OpenDDS::XTypes::TypeInformation::complete, OpenDDS::XTypes::TypeInformation::minimal, serialized_size(), serialized_size_delimiter(), serialized_size_list_end_parameter_id(), and serialized_size_parameter_id().

 {
   size_t mutable_running_total = 0;
   serialized_size_delimiter(encoding, size);
 
   serialized_size_parameter_id(encoding, size, mutable_running_total);
   serialized_size(encoding, size, stru.minimal);
 
   serialized_size_parameter_id(encoding, size, mutable_running_total);
   serialized_size(encoding, size, stru.complete);
 
   serialized_size_list_end_parameter_id(encoding, size, mutable_running_total);
 }

◆ serialized_size() [121/122]

OpenDDS_Dcps_Export void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeIdentifierTypeObjectPair &	stru
	)

Definition at line 4823 of file TypeObject.cpp.

References serialized_size(), OpenDDS::XTypes::TypeIdentifierTypeObjectPair::type_identifier, and OpenDDS::XTypes::TypeIdentifierTypeObjectPair::type_object.

 {
   serialized_size(encoding, size, stru.type_identifier);
   serialized_size(encoding, size, stru.type_object);
 }

◆ serialized_size() [122/122]

OpenDDS_Dcps_Export void OpenDDS::DCPS::serialized_size	(	const Encoding &	encoding,
		size_t &	size,
		const XTypes::TypeIdentifierPair &	stru
	)

Definition at line 4843 of file TypeObject.cpp.

References OpenDDS::XTypes::TypeIdentifierPair::type_identifier1, and OpenDDS::XTypes::TypeIdentifierPair::type_identifier2.

Referenced by OpenDDS::XTypes::makeTypeIdentifier(), operator<<(), and serialized_size().

 {
   serialized_size(encoding, size, stru.type_identifier1);
   serialized_size(encoding, size, stru.type_identifier2);
 }

◆ serialized_size_delimiter()

ACE_INLINE void OpenDDS::DCPS::serialized_size_delimiter	(	const Encoding &	encoding,
		size_t &	size
	)

Add delimiter to the size of a serialized size if the encoding has them.

Definition at line 1685 of file Serializer.inl.

References ACE_INLINE, primitive_serialized_size_ulong(), OpenDDS::DCPS::Encoding::xcdr_version(), and OpenDDS::DCPS::Encoding::XCDR_VERSION_2.

Referenced by serialized_size(), set_default(), and OpenDDS::XTypes::write_empty_xcdr2_nonfinal().

 {
   if (encoding.xcdr_version() == Encoding::XCDR_VERSION_2) {
     primitive_serialized_size_ulong(encoding, size);
   }
 }

◆ serialized_size_list_end_parameter_id()

ACE_INLINE void OpenDDS::DCPS::serialized_size_list_end_parameter_id	(	const Encoding &	encoding,
		size_t &	size,
		size_t &	running_size
	)

Definition at line 1717 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::align(), uint16_cdr_size, uint32_cdr_size, xcdr1_pid_alignment, OpenDDS::DCPS::Encoding::xcdr_version(), OpenDDS::DCPS::Encoding::XCDR_VERSION_1, and OpenDDS::DCPS::Encoding::XCDR_VERSION_2.

Referenced by serialized_size(), and set_default().

 {
   if (encoding.xcdr_version() == Encoding::XCDR_VERSION_1) {
     /*
      * TODO(iguessthislldo): See how DDSXTY14-23 is resolved.
      * https://github.com/objectcomputing/OpenDDS/pull/1722#discussion_r447165924
      */
     encoding.align(size, xcdr1_pid_alignment);
     size += uint16_cdr_size * 2;
 
     // Restore Saved Totals from Alignment Resets
     size += running_size;
   } else if (encoding.xcdr_version() == Encoding::XCDR_VERSION_2) {
     if (running_size != 0 && size != 1 && size != 2 && size != 4 && size != 8) {
       size += uint32_cdr_size; // nextint
     }
     size += running_size;
   }
 }

◆ serialized_size_parameter_id()

ACE_INLINE void OpenDDS::DCPS::serialized_size_parameter_id	(	const Encoding &	encoding,
		size_t &	size,
		size_t &	running_size
	)

Definition at line 1693 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::align(), uint16_cdr_size, uint32_cdr_size, xcdr1_pid_alignment, OpenDDS::DCPS::Encoding::xcdr_version(), OpenDDS::DCPS::Encoding::XCDR_VERSION_1, and OpenDDS::DCPS::Encoding::XCDR_VERSION_2.

Referenced by serialized_size(), and set_default().

 {
   const Encoding::XcdrVersion xcdr = encoding.xcdr_version();
   if (xcdr == Encoding::XCDR_VERSION_1) {
     encoding.align(size, xcdr1_pid_alignment);
     size += uint16_cdr_size * 2;
     // TODO(iguessthislldo): Extended PID
 
     // Save and Zero Size to Reset the Alignment
     running_size += size;
     size = 0;
   } else if (xcdr == Encoding::XCDR_VERSION_2) {
     if (running_size != 0 && size != 1 && size != 2 && size != 4 && size != 8) {
       size += uint32_cdr_size; // nextint
     }
     encoding.align(size, uint32_cdr_size);
     size += uint32_cdr_size; // emheader
     running_size += size;
     size = 0;
   }
 }

◆ set_DCPS_debug_level()

void OpenDDS_Dcps_Export OpenDDS::DCPS::set_DCPS_debug_level ( unsigned int lvl )

The proper way to set the DCPS_debug_level. This function allows for possible side-effects of setting the level.

Definition at line 98 of file debug.cpp.

References ACE_DEBUG, OpenDDS::DCPS::LogLevel::Debug, OpenDDS::DCPS::LogLevel::get(), OpenDDS::DCPS::LogLevel::Info, LM_INFO, log_level, and OpenDDS::DCPS::LogLevel::set().

Referenced by operator>=(), OpenDDS::DCPS::Service_Participant::parse_args(), and FACE::TS::Receive_Message().

 {
   if (log_level.get() < LogLevel::Debug) {
     log_level.set(LogLevel::Debug);
   }
   if (log_level >= LogLevel::Info) {
     ACE_DEBUG((LM_INFO, "(%P|%t) INFO: set_DCPS_debug_level: set to %u\n", lvl));
   }
   DCPS_debug_level = lvl;
 }

◆ set_default() [1/2]

template<typename Type >

void OpenDDS::DCPS::set_default ( Type & )

Definition at line 920 of file Serializer.h.

References OPENDDS_ASSERT.

Referenced by marshal_generator::gen_enum(), marshal_generator::gen_struct(), and marshal_generator::gen_union().

 {
   OPENDDS_ASSERT(false);
 }

◆ set_default() [2/2]

template<typename Type , typename Tag >

void OpenDDS::DCPS::set_default ( IDL::DistinctType< Type, Tag > )

Definition at line 926 of file Serializer.h.

References OpenDDS::STUN::encoding(), OPENDDS_ASSERT, OpenDDS_Dcps_Export, OPENDDS_END_VERSIONED_NAMESPACE_DECL, primitive_serialized_size(), primitive_serialized_size_boolean(), primitive_serialized_size_char(), primitive_serialized_size_octet(), primitive_serialized_size_ulong(), primitive_serialized_size_wchar(), serialized_size_delimiter(), serialized_size_list_end_parameter_id(), and serialized_size_parameter_id().

 {
   OPENDDS_ASSERT(false);
 }

◆ set_intersect()

template<typename SetA , typename SortedB , typename LessThan >

bool OpenDDS::DCPS::set_intersect	(	SetA &	sA,
		const SortedB &	sB,
		LessThan	lessThan
	)

Definition at line 198 of file Util.h.

Referenced by OpenDDS::DCPS::RtpsUdpReceiveStrategy::deliver_sample_i().

 {
   typename SetA::iterator a = sA.begin();
   typename SortedB::const_iterator b = sB.begin();
   while (a != sA.end()) {
     if (b != sB.end()) {
       if (lessThan(*a, *b)) {
         sA.erase(a++);
       } else {
         if (!lessThan(*b, *a)) { ++a; }
         ++b;
       }
     } else {
       sA.erase(a, sA.end());
       break;
     }
   }
   return !sA.empty();
 }

◆ set_reader_effective_data_rep_qos()

OpenDDS_Dcps_Export void OpenDDS::DCPS::set_reader_effective_data_rep_qos ( DDS::DataRepresentationIdSeq & qos )

Definition at line 517 of file DCPS_Utils.cpp.

References OPENDDS_END_VERSIONED_NAMESPACE_DECL, UNALIGNED_CDR_DATA_REPRESENTATION, DDS::XCDR2_DATA_REPRESENTATION, and DDS::XCDR_DATA_REPRESENTATION.

Referenced by OpenDDS::RTPS::ParameterListConverter::add_DataRepresentationQos(), OpenDDS::DCPS::RecorderImpl::enable(), OpenDDS::DCPS::DataReaderImpl::enable(), OpenDDS::FaceTSS::config::Parser::parse(), and OpenDDS::DCPS::StaticDiscovery::parse_endpoints().

 {
   if (qos.length() == 0) {
     qos.length(3);
     qos[0] = DDS::XCDR2_DATA_REPRESENTATION;
     qos[1] = DDS::XCDR_DATA_REPRESENTATION;
     qos[2] = OpenDDS::DCPS::UNALIGNED_CDR_DATA_REPRESENTATION;
   }
 }

◆ set_socket_multicast_ttl()

OpenDDS_Dcps_Export bool OpenDDS::DCPS::set_socket_multicast_ttl	(	const ACE_SOCK_Dgram &	socket,
		const unsigned char &	ttl
	)

Helper function to set the ttl on a socket appropriately given whether it is IPV4 or IPV6

Definition at line 389 of file NetworkResource.cpp.

References ACE_ERROR_RETURN, ACE_TEXT(), ACE_IPC_SAP::get_handle(), ACE_SOCK::get_local_addr(), ACE_Addr::get_type(), IP_MULTICAST_TTL, IPPROTO_IP, LM_ERROR, LM_WARNING, ACE_OS::setsockopt(), TTL, and VDBG.

Referenced by OpenDDS::DCPS::MulticastDataLink::join(), OpenDDS::DCPS::RtpsUdpDataLink::open(), and OpenDDS::RTPS::Spdp::SpdpTransport::open_unicast_socket().

 {
   ACE_HANDLE handle = socket.get_handle();
   const void* ttlp = &ttl;
 #if defined(ACE_LINUX) || defined(__linux__) || defined(ACE_HAS_MAC_OSX)
   int ttl_2 = ttl;
   ttlp = &ttl_2;
 #define TTL ttl_2
 #else
 #define TTL ttl
 #endif
 #if defined (ACE_HAS_IPV6)
   ACE_INET_Addr local_addr;
   if (0 != socket.get_local_addr(local_addr)) {
     VDBG((LM_WARNING, "(%P|%t) set_socket_ttl: "
           "ACE_SOCK_Dgram::get_local_addr %p\n", ACE_TEXT("")));
   }
   if (local_addr.get_type () == AF_INET6) {
     if (0 != ACE_OS::setsockopt(handle,
                                 IPPROTO_IPV6,
                                 IPV6_MULTICAST_HOPS,
                                 static_cast<const char*>(ttlp),
                                 sizeof(TTL))) {
       ACE_ERROR_RETURN((LM_ERROR,
                         ACE_TEXT("(%P|%t) ERROR: ")
                         ACE_TEXT("set_socket_ttl: ")
                         ACE_TEXT("failed to set IPV6 TTL: %d %p\n"),
                         ttl,
                         ACE_TEXT("ACE_OS::setsockopt(TTL)")),
                        false);
     }
   } else
 #endif  /* ACE_HAS_IPV6 */
   if (0 != ACE_OS::setsockopt(handle,
                               IPPROTO_IP,
                               IP_MULTICAST_TTL,
                               static_cast<const char*>(ttlp),
                               sizeof(TTL))) {
     ACE_ERROR_RETURN((LM_ERROR,
                       ACE_TEXT("(%P|%t) ERROR: ")
                       ACE_TEXT("set_socket_ttl: ")
                       ACE_TEXT("failed to set TTL: %d %p\n"),
                       ttl,
                       ACE_TEXT("ACE_OS::setsockopt(TTL)")),
                      false);
   }
   return true;
 }

◆ set_to_seq()

template<typename Seq >

void OpenDDS::DCPS::set_to_seq	(	const RepoIdSet &	rids,
		Seq &	seq
	)

Definition at line 457 of file DataLink.cpp.

Referenced by OpenDDS::DCPS::DataLink::clear_associations(), OpenDDS::DCPS::DataLink::notify(), and OpenDDS::DCPS::DataLink::peer_ids().

 {
   seq.length(static_cast<CORBA::ULong>(rids.size()));
   CORBA::ULong i = 0;
   for (RepoIdSet::const_iterator iter = rids.begin(); iter != rids.end(); ++iter) {
     seq[i++] = *iter;
   }
 }

◆ set_writer_effective_data_rep_qos()

OpenDDS_Dcps_Export void OpenDDS::DCPS::set_writer_effective_data_rep_qos	(	DDS::DataRepresentationIdSeq &	qos,
		bool	cdr_encapsulated
	)

Definition at line 508 of file DCPS_Utils.cpp.

References UNALIGNED_CDR_DATA_REPRESENTATION, and DDS::XCDR2_DATA_REPRESENTATION.

Referenced by OpenDDS::DCPS::ReplayerImpl::enable(), OpenDDS::DCPS::DataWriterImpl::enable(), OpenDDS::FaceTSS::config::Parser::parse(), and OpenDDS::DCPS::StaticDiscovery::parse_endpoints().

 {
   if (qos.length() == 0) {
     qos.length(1);
     qos[0] = cdr_encapsulated ? DDS::XCDR2_DATA_REPRESENTATION : OpenDDS::DCPS::UNALIGNED_CDR_DATA_REPRESENTATION;
   }
 }

◆ should_check_association_upon_change() [1/6]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::should_check_association_upon_change	(	const DDS::DataReaderQos &	qos1,
		const DDS::DataReaderQos &	qos2
	)

Definition at line 415 of file DCPS_Utils.cpp.

References DDS::DataReaderQos::deadline, and DDS::DataReaderQos::latency_budget.

Referenced by DCPS_IR_Publication::set_qos(), and DCPS_IR_Subscription::set_qos().

 {
   return !(
            (qos1.deadline == qos2.deadline) &&
            (qos1.latency_budget == qos2.latency_budget));
 }

◆ should_check_association_upon_change() [2/6]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::should_check_association_upon_change	(	const DDS::DataWriterQos &	qos1,
		const DDS::DataWriterQos &	qos2
	)

Definition at line 423 of file DCPS_Utils.cpp.

References DDS::DataWriterQos::deadline, and DDS::DataWriterQos::latency_budget.

 {
   return !(
            (qos1.deadline == qos2.deadline) &&
            (qos1.latency_budget == qos2.latency_budget));
 }

◆ should_check_association_upon_change() [3/6]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::should_check_association_upon_change	(	const DDS::SubscriberQos &	qos1,
		const DDS::SubscriberQos &	qos2
	)

Definition at line 431 of file DCPS_Utils.cpp.

References DDS::SubscriberQos::partition.

 {
   return !(qos1.partition == qos2.partition);
 }

◆ should_check_association_upon_change() [4/6]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::should_check_association_upon_change	(	const DDS::PublisherQos &	qos1,
		const DDS::PublisherQos &	qos2
	)

Definition at line 437 of file DCPS_Utils.cpp.

References DDS::PublisherQos::partition.

 {
   return !(qos1.partition == qos2.partition);
 }

◆ should_check_association_upon_change() [5/6]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::should_check_association_upon_change	(	const DDS::TopicQos &	,
		const DDS::TopicQos &
	)

Definition at line 443 of file DCPS_Utils.cpp.

 {
   return false;
 }

◆ should_check_association_upon_change() [6/6]

OpenDDS_Dcps_Export bool OpenDDS::DCPS::should_check_association_upon_change	(	const DDS::DomainParticipantQos &	,
		const DDS::DomainParticipantQos &
	)

Definition at line 449 of file DCPS_Utils.cpp.

 {
   return false;
 }

◆ signed_int_helper()

template<typename IntType >

std::ostream& OpenDDS::DCPS::signed_int_helper	(	std::ostream &	o,
		IntType	value,
		IntType	min
	)

Definition at line 22 of file ValueHelper.h.

References value.

 {
   /*
    * It seems that in C/C++ the minus sign and the bare number are parsed
    * separately for negative integer literals. This can cause compilers
    * to complain when using the minimum value of a signed integer because
    * the number without the minus sign is 1 past the max signed value.
    *
    * https://stackoverflow.com/questions/65007935
    *
    * Apparently the workaround is to write it as `VALUE_PLUS_ONE - 1`.
    */
   const bool min_value = value == min;
   if (min_value) ++value;
   o << value;
   if (min_value) o << " - 1";
   return o;
 }

◆ static_rchandle_cast()

template<typename T , typename U >

RcHandle<T> OpenDDS::DCPS::static_rchandle_cast ( const RcHandle< U > & h )

Definition at line 202 of file RcHandle_T.h.

References OpenDDS::DCPS::RcHandle< T >::in().

Referenced by OpenDDS::DCPS::RtpsUdpInst::append_transport_statistics(), OpenDDS::DCPS::InfoRepoDiscovery::bit_config(), OpenDDS::DCPS::RtpsUdpTransport::get_ice_endpoint(), OpenDDS::RTPS::Spdp::SpdpTransport::get_ice_endpoint(), OpenDDS::DCPS::RtpsUdpInst::get_last_recv_locator(), InfoRepo::init(), OpenDDS::RTPS::Sedp::init(), OpenDDS::ICE::Agent::instance(), OpenDDS::RTPS::Sedp::local_address(), OpenDDS::RTPS::Sedp::multicast_group(), OpenDDS::DCPS::UdpTransport::passive_connection(), OpenDDS::DCPS::MulticastTransport::passive_connection(), OpenDDS::DCPS::InternalDataWriter< OpenDDS::DCPS::NetworkInterfaceAddress >::publication_handle(), OpenDDS::DCPS::TcpDataLink::receive_strategy(), OpenDDS::Federator::ManagerImpl::repository(), OpenDDS::RTPS::Sedp::rtps_relay_address(), OpenDDS::DCPS::RtpsUdpInst::rtps_relay_address_change(), OpenDDS::DCPS::TcpDataLink::send_strategy(), OpenDDS::RTPS::Sedp::stun_server_address(), OpenDDS::DCPS::RtpsUdpInst::update_locators(), and OpenDDS::RTPS::Sedp::~Sedp().

 {
   return RcHandle<T>(static_cast<T*>(h.in()), inc_count());
 }

◆ string_helper() [1/2]

template<typename CharType >

std::ostream& OpenDDS::DCPS::string_helper	(	std::ostream &	o,
		const CharType *	value
	)

Definition at line 108 of file ValueHelper.h.

Referenced by OpenDDS::XTypes::print_member(), OpenDDS::DCPS::PrinterValueWriter::write_string(), and OpenDDS::DCPS::PrinterValueWriter::write_wstring().

 {
   for (size_t i = 0; value[i] != 0; ++i) {
     char_helper<CharType>(o, value[i]);
   }
   return o;
 }

◆ string_helper() [2/2]

template<typename CharType >

std::ostream& OpenDDS::DCPS::string_helper	(	std::ostream &	o,
		const CharType *	value,
		size_t	length
	)

Definition at line 117 of file ValueHelper.h.

References OPENDDS_END_VERSIONED_NAMESPACE_DECL.

 {
   for (size_t i = 0; i != length; ++i) {
     char_helper<CharType>(o, value[i]);
   }
   return o;
 }

◆ swap() [1/4]

void OpenDDS::DCPS::swap	(	RawDataSample &	lhs,
		RawDataSample &	rhs
	)

Definition at line 65 of file RawDataSample.cpp.

References OpenDDS::DCPS::RawDataSample::encoding_kind_, OpenDDS::DCPS::RawDataSample::header_, OpenDDS::DCPS::RawDataSample::message_id_, OPENDDS_END_VERSIONED_NAMESPACE_DECL, OpenDDS::DCPS::RawDataSample::publication_id_, OpenDDS::DCPS::RawDataSample::sample_, OpenDDS::DCPS::RawDataSample::sample_byte_order_, and OpenDDS::DCPS::RawDataSample::source_timestamp_.

Referenced by OpenDDS::DCPS::InternalDataReaderListener< NetworkInterfaceAddress >::execute(), get_fully_qualified_hostname(), get_interface_addrs(), OpenDDS::SafetyProfile::StringEltPolicy< CharT >::move_n(), OpenDDS::DCPS::RawDataSample::operator=(), OpenDDS::DCPS::Message_Block_Shared_Ptr::operator=(), OpenDDS::DCPS::RcHandle< OpenDDS::DCPS::DataReaderImpl::LivelinessTimer >::operator=(), OpenDDS::DCPS::ReceivedDataSample::MessageBlock::operator=(), OpenDDS::DCPS::TopicDescriptionPtr< OpenDDS::DCPS::MultiTopicImpl >::operator=(), OpenDDS::DCPS::DataDurabilityCache::sample_data_type::operator=(), OpenDDS::DCPS::WeakRcHandle< OpenDDS::DCPS::ThreadSynchWorker >::operator=(), OpenDDS::DCPS::container_supported_unique_ptr< OpenDDS::DCPS::DataReaderImpl_T::MessageTypeWithAllocator >::operator=(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsReader::process_data_i(), OpenDDS::RTPS::Spdp::process_location_updates_i(), OpenDDS::DCPS::DataReaderImpl_T< MessageType >::qos_change(), OpenDDS::DCPS::TransportReassembly::reassemble_i(), OpenDDS::DCPS::RcHandle< OpenDDS::DCPS::DataReaderImpl::LivelinessTimer >::reset(), OpenDDS::DCPS::container_supported_unique_ptr< OpenDDS::DCPS::DataReaderImpl_T::MessageTypeWithAllocator >::reset(), OpenDDS::DCPS::WriteDataContainer::set_deadline_period(), OpenDDS::DCPS::ContentFilteredTopicImpl::set_expression_parameters(), OpenDDS::DCPS::Message_Block_Shared_Ptr::swap(), OpenDDS::DCPS::Value::swap(), OpenDDS::DCPS::DurabilityQueue< T >::swap(), OpenDDS::DCPS::DurabilityArray< T >::swap(), OpenDDS::SafetyProfile::AllocPolicy< T, Sequence, Unbounded >::swap(), TAO::DCPS::ZeroCopyDataSeq< Sample_T, DEF_MAX >::swap(), TAO::DCPS::ZeroCopyDataSeq< Sample_T, DEF_MAX >::ZeroCopyVector::swap(), OpenDDS::SafetyProfile::Sequence< T, Bounds, Elts >::swap(), and OpenDDS::DCPS::DataReaderImpl::OwnershipManagerScopedAccess::swap().

 {
   using std::swap;
   swap(lhs.header_, rhs.header_);
   swap(lhs.message_id_, rhs.message_id_);
   swap(lhs.source_timestamp_, rhs.source_timestamp_);
   swap(lhs.publication_id_, rhs.publication_id_);
   swap(lhs.sample_byte_order_, rhs.sample_byte_order_);
   swap(lhs.sample_, rhs.sample_);
   swap(lhs.encoding_kind_, rhs.encoding_kind_);
 }

◆ swap() [2/4]

template<typename T , typename Deleter >

void OpenDDS::DCPS::swap	(	unique_ptr< T, Deleter > &	a,
		unique_ptr< T, Deleter > &	b
	)

Definition at line 153 of file unique_ptr.h.

References OpenDDS::DCPS::unique_ptr< T, Deleter >::swap().

 {
   return a.swap(b);
 }

◆ swap() [3/4]

template<typename T >

void OpenDDS::DCPS::swap	(	RcHandle< T > &	lhs,
		RcHandle< T > &	rhs
	)

Definition at line 196 of file RcHandle_T.h.

References OpenDDS::DCPS::RcHandle< T >::swap().

 {
   lhs.swap(rhs);
 }

◆ swap() [4/4]

template<typename T >

void OpenDDS::DCPS::swap	(	container_supported_unique_ptr< T > &	lhs,
		container_supported_unique_ptr< T > &	rhs
	)

Definition at line 303 of file unique_ptr.h.

References OpenDDS::DCPS::container_supported_unique_ptr< T >::swap().

Referenced by OpenDDS::DCPS::unique_ptr< OpenDDS::DCPS::Cached_Allocator_With_Overflow >::swap().

 {
   lhs.swap(rhs);
 }

◆ time_to_duration()

ACE_INLINE DDS::Duration_t OpenDDS::DCPS::time_to_duration ( const DDS::Time_t & t )

Definition at line 238 of file Time_Helper.inl.

References ACE_INLINE, DDS::Time_t::nanosec, and DDS::Time_t::sec.

 {
   DDS::Duration_t d = { t.sec, t.nanosec };
   return d;
 }

◆ time_to_time_value()

ACE_INLINE ACE_Time_Value OpenDDS::DCPS::time_to_time_value ( const DDS::Time_t & t )

Definition at line 170 of file Time_Helper.inl.

References ACE_INLINE, DDS::Time_t::nanosec, and DDS::Time_t::sec.

Referenced by resend_data_expired().

 {
   ACE_Time_Value tv(t.sec, t.nanosec / 1000);
   return tv;
 }

◆ time_value_to_duration()

ACE_INLINE DDS::Duration_t OpenDDS::DCPS::time_value_to_duration ( const ACE_Time_Value & tv )

Definition at line 229 of file Time_Helper.inl.

References ACE_INLINE, DDS::Duration_t::nanosec, ACE_Time_Value::sec(), DDS::Duration_t::sec, ACE_Utils::truncate_cast(), and ACE_Time_Value::usec().

Referenced by OpenDDS::DCPS::TimeDuration::to_dds_duration().

 {
   DDS::Duration_t t;
   t.sec = ACE_Utils::truncate_cast<CORBA::Long>(tv.sec());
   t.nanosec = ACE_Utils::truncate_cast<CORBA::ULong>(tv.usec() * 1000);
   return t;
 }

◆ time_value_to_monotonic_time()

ACE_INLINE MonotonicTime_t OpenDDS::DCPS::time_value_to_monotonic_time ( const ACE_Time_Value & tv )

Definition at line 186 of file Time_Helper.inl.

References ACE_INLINE, OpenDDS::DCPS::MonotonicTime_t::nanosec, ACE_Time_Value::sec(), OpenDDS::DCPS::MonotonicTime_t::sec, ACE_Utils::truncate_cast(), and ACE_Time_Value::usec().

Referenced by OpenDDS::DCPS::TimePoint_T< SystemClock >::to_monotonic_time().

 {
   MonotonicTime_t t;
   t.sec = ACE_Utils::truncate_cast<CORBA::Long>(tv.sec());
   t.nanosec = ACE_Utils::truncate_cast<CORBA::ULong>(tv.usec() * 1000);
   return t;
 }

◆ time_value_to_time()

ACE_INLINE DDS::Time_t OpenDDS::DCPS::time_value_to_time ( const ACE_Time_Value & tv )

Definition at line 177 of file Time_Helper.inl.

References ACE_INLINE, DDS::Time_t::nanosec, ACE_Time_Value::sec(), DDS::Time_t::sec, ACE_Utils::truncate_cast(), and ACE_Time_Value::usec().

Referenced by OpenDDS::DCPS::TimePoint_T< SystemClock >::to_dds_time().

 {
   DDS::Time_t t;
   t.sec = ACE_Utils::truncate_cast<CORBA::Long>(tv.sec());
   t.nanosec = ACE_Utils::truncate_cast<CORBA::ULong>(tv.usec() * 1000);
   return t;
 }

◆ to_dds_string() [1/10]

OpenDDS_Dcps_Export String OpenDDS::DCPS::to_dds_string ( unsigned short to_convert )

Definition at line 17 of file SafetyProfileStreams.cpp.

References ACE_OS::snprintf().

 {
   const char* fmt = "%hu";
   const int buff_size = 5 + 1; // note +1 for null terminator
   char buf[buff_size];
   ACE_OS::snprintf(&buf[0], buff_size, fmt, to_convert);
   return String(buf);
 }

◆ to_dds_string() [2/10]

OpenDDS_Dcps_Export String OpenDDS::DCPS::to_dds_string ( int to_convert )

Definition at line 26 of file SafetyProfileStreams.cpp.

References ACE_OS::snprintf().

 {
   const char* fmt = "%d";
   const int buff_size = 20 + 1; // note +1 for null terminator
   char buf[buff_size];
   ACE_OS::snprintf(&buf[0], buff_size, fmt, to_convert);
   return String(buf);
 }

◆ to_dds_string() [3/10]

String OpenDDS::DCPS::to_dds_string ( const String & to_convert )

inline

Definition at line 33 of file SafetyProfileStreams.h.

References OpenDDS_Dcps_Export, and to_hex_dds_string().

 {
   return to_convert;
 }

◆ to_dds_string() [4/10]

OpenDDS_Dcps_Export String OpenDDS::DCPS::to_dds_string	(	unsigned int	to_convert,
		bool	as_hex
	)

Definition at line 35 of file SafetyProfileStreams.cpp.

References ACE_OS::snprintf().

 {
   const char* fmt;
   if (as_hex) {
     fmt = "%02x";
     const int buff_size = 3; // note +1 for null terminator
     char buf[buff_size];
     ACE_OS::snprintf(&buf[0], buff_size, fmt, to_convert);
     return String(buf);
   } else {
     fmt = "%u";
     const int buff_size = 20 + 1; // note +1 for null terminator
     char buf[buff_size];
     ACE_OS::snprintf(&buf[0], buff_size, fmt, to_convert);
     return String(buf);
   }
 }

◆ to_dds_string() [5/10]

OpenDDS_Dcps_Export String OpenDDS::DCPS::to_dds_string ( long to_convert )

Definition at line 53 of file SafetyProfileStreams.cpp.

References ACE_OS::snprintf().

 {
   const char* fmt = "%ld";
   const int buff_size = 20 + 1; // note +1 for null terminator
   char buf[buff_size];
   ACE_OS::snprintf(&buf[0], buff_size, fmt, to_convert);
   return String(buf);
 }

◆ to_dds_string() [6/10]

template<typename T >

String OpenDDS::DCPS::to_dds_string ( const T * to_convert )

inline

Convert Pointer to String.

Definition at line 55 of file SafetyProfileStreams.h.

References ACE_OS::snprintf().

 {
   const char* fmt = "%p";
   const int buff_size = 20 + 1; // note +1 for null terminator
   char buf[buff_size];
   ACE_OS::snprintf(&buf[0], buff_size, fmt, to_convert);
   return String(buf);
 }

◆ to_dds_string() [7/10]

OpenDDS_Dcps_Export String OpenDDS::DCPS::to_dds_string ( long long to_convert )

Definition at line 62 of file SafetyProfileStreams.cpp.

References ACE_OS::snprintf().

 {
   const char* fmt = "%lld";
   const int buff_size = 20 + 1; // note +1 for null terminator
   char buf[buff_size];
   ACE_OS::snprintf(&buf[0], buff_size, fmt, to_convert);
   return String(buf);
 }

◆ to_dds_string() [8/10]

OpenDDS_Dcps_Export String OpenDDS::DCPS::to_dds_string	(	unsigned long long	to_convert,
		bool	as_hex
	)

Definition at line 71 of file SafetyProfileStreams.cpp.

References ACE_OS::snprintf().

 {
   const char* fmt;
   if (as_hex) {
     fmt = "%0llx";
   } else {
     fmt = "%llu";
   }
   const int buff_size = 20 + 1; // note +1 for null terminator
   char buf[buff_size];
   ACE_OS::snprintf(&buf[0], buff_size, fmt, to_convert);
   return String(buf);
 }

◆ to_dds_string() [9/10]

OpenDDS_Dcps_Export String OpenDDS::DCPS::to_dds_string	(	unsigned long	to_convert,
		bool	as_hex
	)

Definition at line 85 of file SafetyProfileStreams.cpp.

References ACE_OS::snprintf().

 {
   const char* fmt;
   if (as_hex) {
     fmt = "%0.8lx";
   } else {
     fmt = "%lu";
   }
   const int buff_size = 20 + 1; // note +1 for null terminator
   char buf[buff_size];
   ACE_OS::snprintf(&buf[0], buff_size, fmt, to_convert);
   return String(buf);
 }

◆ to_dds_string() [10/10]

OpenDDS_Dcps_Export String OpenDDS::DCPS::to_dds_string	(	const unsigned char *	array,
		size_t	length
	)

Definition at line 99 of file SafetyProfileStreams.cpp.

References ACE_OS::snprintf().

 {
   static const size_t bytes_per_elt = 5; // largest byte as decimal plus comma and space
   String ret(length * bytes_per_elt, '\0');
   char* buf = &ret[0];
   size_t total_used = 0;
   for (size_t i = 0; i < length; ++i) {
     const int used = ACE_OS::snprintf(buf, bytes_per_elt + 1,
                                       i < length - 1 ? "%d, " : "%d", array[i]);
     if (used < 1) {
       return "";
     }
     buf += used;
     total_used += static_cast<size_t>(used);
   }
 
   ret.resize(total_used);
   return ret;
 }

◆ to_hex_dds_string() [1/2]

OpenDDS_Dcps_Export String OpenDDS::DCPS::to_hex_dds_string	(	const unsigned char *	data,
		size_t	size,
		char	delim = `'\0'`,
		size_t	delim_every = `1`
	)

Converts a series of bytes at data to a optionally delimited String of hexadecimal numbers.

If delim is '\0' (the default) or delim_every is 0, then the output will not be delimited.

Definition at line 119 of file SafetyProfileStreams.cpp.

Referenced by OpenDDS::ICE::EndpointManager::change_password(), OpenDDS::ICE::EndpointManager::change_username(), OpenDDS::Security::CommonUtilities::ctk_to_dds_string(), OpenDDS::Security::CommonUtilities::ctki_to_dds_string(), OpenDDS::RTPS::Sedp::Endpoint::get_instance_name(), to_dds_string(), OpenDDS::Security::CommonUtilities::to_dds_string(), and to_string().

 {
   return to_hex_dds_string(reinterpret_cast<const char*>(data), size, delim, delim_every);
 }

◆ to_hex_dds_string() [2/2]

OpenDDS_Dcps_Export String OpenDDS::DCPS::to_hex_dds_string	(	const char *	data,
		size_t	size,
		const char	delim,
		const size_t	delim_every
	)

Converts a series of bytes at data to a optionally delimited String of hexadecimal numbers.

If delim is '\0' (the default) or delim_every is 0, then the output will not be delimited.

Definition at line 131 of file SafetyProfileStreams.cpp.

References nibble_to_hex_char(), and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

 {
   const bool valid_delim = delim && delim_every;
   size_t l = size * 2;
   if (valid_delim && size > 1) {
     l += size / delim_every;
     if (!(size % delim_every)) {
       l--;
     }
   }
 
   String rv;
   rv.reserve(l);
   for (size_t i = 0; i < size; i++) {
     if (valid_delim && i && !(i % delim_every)) {
       rv.push_back(delim);
     }
     rv.push_back(nibble_to_hex_char(data[i] >> 4));
     rv.push_back(nibble_to_hex_char(data[i]));
   }
   return rv;
 }

◆ to_string() [1/5]

OpenDDS_Dcps_Export OPENDDS_STRING OpenDDS::DCPS::to_string ( const EntityId_t & entityId )

Definition at line 47 of file GuidUtils.cpp.

References OpenDDS::DCPS::EntityId_t::entityKey, OpenDDS::DCPS::EntityId_t::entityKind, OPENDDS_STRING, to_dds_string(), and to_hex_dds_string().

 {
   return to_hex_dds_string(&entityId.entityKey[0], sizeof(EntityKey_t)) +
     to_dds_string(unsigned(entityId.entityKind), true);
 }

◆ to_string() [2/5]

OpenDDS_Dcps_Export OPENDDS_STRING OpenDDS::DCPS::to_string ( const GUID_t & guid )

Definition at line 54 of file GuidUtils.cpp.

References OpenDDS::DCPS::GUID_t::entityId, OpenDDS::DCPS::GUID_t::guidPrefix, to_hex_dds_string(), and to_string().

 {
   return to_hex_dds_string(&guid.guidPrefix[0], sizeof(GuidPrefix_t), '.', 4) +
     '.' + to_string(guid.entityId);
 }

◆ to_string() [3/5]

OpenDDS_Dcps_Export const char * OpenDDS::DCPS::to_string ( MessageId value )

Definition at line 474 of file DataSampleHeader.cpp.

References ACE_ERROR, ACE_TEXT(), DATAWRITER_LIVELINESS, DISPOSE_INSTANCE, DISPOSE_UNREGISTER_INSTANCE, END_COHERENT_CHANGES, END_HISTORIC_SAMPLES, GRACEFUL_DISCONNECT, INSTANCE_REGISTRATION, LM_ERROR, REQUEST_ACK, SAMPLE_ACK, SAMPLE_DATA, TRANSPORT_CONTROL, and UNREGISTER_INSTANCE.

Referenced by assign(), OpenDDS::DCPS::DataWriterImpl::create_control_message(), OpenDDS::DCPS::DataWriterImpl::create_sample_data_message(), OpenDDS::DCPS::RecorderImpl::data_received(), OpenDDS::DCPS::DataReaderImpl::data_received(), OpenDDS::RTPS::Sedp::Reader::data_received(), OpenDDS::DCPS::DataLink::data_received_i(), OpenDDS::DCPS::DataReaderImpl_T< MessageType >::dds_demarshal(), langmap_generator::gen_const(), OpenDDS::Security::Permissions::load(), dds_generator::module_scope_helper(), OpenDDS::DCPS::GuidConverter::operator OPENDDS_STRING(), operator<<(), OpenDDS::XTypes::TypeLookupService::remove_guid_from_dynamic_map(), dds_generator::scoped_helper(), and to_string().

 {
   switch (value) {
   case SAMPLE_DATA:
     return "SAMPLE_DATA";
   case DATAWRITER_LIVELINESS:
     return "DATAWRITER_LIVELINESS";
   case INSTANCE_REGISTRATION:
     return "INSTANCE_REGISTRATION";
   case UNREGISTER_INSTANCE:
     return "UNREGISTER_INSTANCE";
   case DISPOSE_INSTANCE:
     return "DISPOSE_INSTANCE";
   case GRACEFUL_DISCONNECT:
     return "GRACEFUL_DISCONNECT";
   case REQUEST_ACK:
     return "REQUEST_ACK";
   case SAMPLE_ACK:
     return "SAMPLE_ACK";
   case END_COHERENT_CHANGES:
     return "END_COHERENT_CHANGES";
   case TRANSPORT_CONTROL:
     return "TRANSPORT_CONTROL";
   case DISPOSE_UNREGISTER_INSTANCE:
     return "DISPOSE_UNREGISTER_INSTANCE";
   case END_HISTORIC_SAMPLES:
     return "END_HISTORIC_SAMPLES";
   default:
     ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: to_string(MessageId): ")
       ACE_TEXT("%d is either invalid or not recognized.\n"),
       value));
     return "Invalid MessageId";
   }
 }

◆ to_string() [4/5]

OpenDDS_Dcps_Export const char * OpenDDS::DCPS::to_string ( SubMessageId value )

Definition at line 509 of file DataSampleHeader.cpp.

References ACE_ERROR, ACE_TEXT(), LM_ERROR, MULTICAST_NAK, MULTICAST_NAKACK, MULTICAST_SYN, MULTICAST_SYNACK, and SUBMESSAGE_NONE.

 {
   switch (value) {
   case SUBMESSAGE_NONE:
     return "SUBMESSAGE_NONE";
   case MULTICAST_SYN:
     return "MULTICAST_SYN";
   case MULTICAST_SYNACK:
     return "MULTICAST_SYNACK";
   case MULTICAST_NAK:
     return "MULTICAST_NAK";
   case MULTICAST_NAKACK:
     return "MULTICAST_NAKACK";
   default:
     ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: to_string(SubMessageId): ")
       ACE_TEXT("%d is either invalid or not recognized.\n"),
       value));
     return "Invalid SubMessageId";
   }
 }

◆ to_string() [5/5]

OpenDDS_Dcps_Export OPENDDS_STRING OpenDDS::DCPS::to_string ( const DataSampleHeader & value )

Definition at line 530 of file DataSampleHeader.cpp.

 {
   OPENDDS_STRING ret;
   if (value.submessage_id_ != SUBMESSAGE_NONE) {
     ret += to_string(SubMessageId(value.submessage_id_));
     ret += " 0x";
     ret += to_dds_string(unsigned(value.submessage_id_), true);
     ret += "), ";
   } else {
     ret += to_string(MessageId(value.message_id_));
     ret += " (0x";
     ret += to_dds_string(unsigned(value.message_id_), true);
     ret += "), ";
   }
 
   ret += "Length: ";
   ret += to_dds_string(value.message_length_);
   ret += ", ";
 
   ret += "Byte order: ";
   ret += (value.byte_order_ == 1 ? "Little" : "Big");
   ret += " Endian";
 
   if (value.message_id_ != TRANSPORT_CONTROL) {
     ret += ", ";
 
     if (value.coherent_change_ == 1) ret += "Coherent, ";
     if (value.historic_sample_ == 1) ret += "Historic, ";
     if (value.lifespan_duration_ == 1) ret += "Lifespan, ";
 #ifndef OPENDDS_NO_OBJECT_MODEL_PROFILE
     if (value.group_coherent_ == 1) ret += "Group-Coherent, ";
 #endif
     if (value.content_filter_ == 1) ret += "Content-Filtered, ";
     if (value.sequence_repair_ == 1) ret += "Sequence Repair, ";
     if (value.more_fragments_ == 1) ret += "More Fragments, ";
     if (value.cdr_encapsulation_ == 1) ret += "CDR Encapsulation, ";
     if (value.key_fields_only_ == 1) ret += "Key Fields Only, ";
 
     ret += "Sequence: 0x";
     ret += to_dds_string(unsigned(value.sequence_.getValue()), true);
     ret += ", ";
 
     ret += "Timestamp: ";
     ret += to_dds_string(value.source_timestamp_sec_);
     ret += ".";
     ret += to_dds_string(value.source_timestamp_nanosec_);
     ret += ", ";
 
     if (value.lifespan_duration_) {
       ret += "Lifespan: ";
       ret += to_dds_string(value.lifespan_duration_sec_);
       ret += ".";
       ret += to_dds_string(value.lifespan_duration_nanosec_);
       ret += ", ";
     }
 
     ret += "Publication: " + LogGuid(value.publication_id_).conv_;
 #ifndef OPENDDS_NO_OBJECT_MODEL_PROFILE
     if (value.group_coherent_) {
       ret += ", Publisher: " + LogGuid(value.publisher_id_).conv_;
     }
 #endif
 
     if (value.content_filter_) {
       const CORBA::ULong len = value.content_filter_entries_.length();
       ret += ", Content-Filter Entries (";
       ret += to_dds_string(len);
       ret += "): [";
       for (CORBA::ULong i(0); i < len; ++i) {
         ret += LogGuid(value.content_filter_entries_[i]).conv_ + ' ';
       }
       ret += ']';
     }
   }
   return ret;
 }

◆ to_type_object()

OpenDDS_Dcps_Export bool OpenDDS::DCPS::to_type_object	(	const unsigned char *	buffer,
		size_t	size,
		XTypes::TypeObject &	to
	)

Definition at line 4862 of file TypeObject.cpp.

References OpenDDS::XTypes::get_typeobject_encoding(), ACE_Message_Block::length(), and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

Referenced by operator>>().

 {
   ACE_Message_Block message_block(reinterpret_cast<const char*>(buffer), size);
   message_block.length(size);
   DCPS::Serializer ser(&message_block, XTypes::get_typeobject_encoding());
   return ser >> to;
 }

◆ topicIsBIT()

bool OpenDDS::DCPS::topicIsBIT	(	const char *	name,
		const char *	type
	)

inline

Returns true if the topic name and type pair matches one of the built-in topic name and type pairs.

Definition at line 57 of file BuiltInTopicUtils.h.

References ACE_OS::strcmp().

Referenced by DCPS_IR_Domain::add_topic(), OpenDDS::DCPS::DomainParticipantImpl::create_new_topic(), DCPS_IR_Domain::force_add_topic(), OpenDDS::DCPS::ReplayerImpl::init(), OpenDDS::DCPS::DataWriterImpl::init(), OpenDDS::DCPS::DataReaderImpl::init(), OpenDDS::DCPS::DomainParticipantImpl::is_clean(), DCPS_IR_Domain::publish_subscription_bit(), and DCPS_IR_Domain::publish_topic_bit().

 {
   return (
     !ACE_OS::strcmp(name, BUILT_IN_PARTICIPANT_TOPIC) &&
     !ACE_OS::strcmp(type, BUILT_IN_PARTICIPANT_TOPIC_TYPE)
   ) || (
     !ACE_OS::strcmp(name, BUILT_IN_TOPIC_TOPIC) &&
     !ACE_OS::strcmp(type, BUILT_IN_TOPIC_TOPIC_TYPE)
   ) || (
     !ACE_OS::strcmp(name, BUILT_IN_SUBSCRIPTION_TOPIC) &&
     !ACE_OS::strcmp(type, BUILT_IN_SUBSCRIPTION_TOPIC_TYPE)
   ) || (
     !ACE_OS::strcmp(name, BUILT_IN_PUBLICATION_TOPIC) &&
     !ACE_OS::strcmp(type, BUILT_IN_PUBLICATION_TOPIC_TYPE)
   ) || (
     !ACE_OS::strcmp(name, BUILT_IN_PARTICIPANT_LOCATION_TOPIC) &&
     !ACE_OS::strcmp(type, BUILT_IN_PARTICIPANT_LOCATION_TOPIC_TYPE)
   ) || (
     !ACE_OS::strcmp(name, BUILT_IN_CONNECTION_RECORD_TOPIC) &&
     !ACE_OS::strcmp(type, BUILT_IN_CONNECTION_RECORD_TOPIC_TYPE)
   ) || (
     !ACE_OS::strcmp(name, BUILT_IN_INTERNAL_THREAD_TOPIC) &&
     !ACE_OS::strcmp(type, BUILT_IN_INTERNAL_THREAD_TOPIC_TYPE)
   );
 }

◆ topicstatus_to_string()

OpenDDS_Dcps_Export const char * OpenDDS::DCPS::topicstatus_to_string ( TopicStatus value )

Definition at line 70 of file DCPS_Utils.cpp.

References ACE_ERROR, ACE_TEXT(), CONFLICTING_TYPENAME, CREATED, ENABLED, FOUND, INTERNAL_ERROR, LM_ERROR, NOT_FOUND, PRECONDITION_NOT_MET, REMOVED, and TOPIC_DISABLED.

Referenced by OpenDDS::DCPS::DomainParticipantImpl::delete_topic_i(), and OpenDDS::DCPS::TopicImpl::enable().

 {
   switch (value) {
   case CREATED:
     return "Created";
   case ENABLED:
     return "Enabled";
   case FOUND:
     return "Found";
   case NOT_FOUND:
     return "Not found";
   case REMOVED:
     return "Removed";
   case CONFLICTING_TYPENAME:
     return "Conflicting typename";
   case PRECONDITION_NOT_MET:
     return "Precondition not met";
   case INTERNAL_ERROR:
     return "Internal error";
   case TOPIC_DISABLED:
     return "Topic disabled";
   default:
     ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: topicstatus_to_string: ")
       ACE_TEXT("%d is either invalid or not recognized.\n"),
       value));
     return "Invalid topic status";
   }
 }

◆ toString()

OPENDDS_STRING OpenDDS::DCPS::toString ( yard::TreeBuildingParser< char >::Node * iter )

inline

Definition at line 42 of file AstNodeWrapper.h.

References OPENDDS_STRING.

Referenced by OpenDDS::DCPS::FilterEvaluator::FilterEvaluator(), OpenDDS::DCPS::FilterEvaluator::has_non_key_fields(), OpenDDS::DCPS::MultiTopicImpl::MultiTopicImpl(), and OpenDDS::DCPS::FilterEvaluator::walkOperand().

 {
   return iter ? OPENDDS_STRING(iter->GetFirstToken(), iter->GetLastToken()) : "";
 }

◆ TRANSPORT_HDR_SERIALIZED_SZ()

static const ACE_UINT32 OpenDDS::DCPS::TRANSPORT_HDR_SERIALIZED_SZ ( 28 )

static

◆ uint32_fractional_seconds_to_microseconds()

ACE_INLINE OpenDDS_Dcps_Export ACE_UINT32 OpenDDS::DCPS::uint32_fractional_seconds_to_microseconds ( ACE_UINT32 fraction )

Definition at line 278 of file Time_Helper.inl.

References ACE_INLINE, and OpenDDS_Dcps_Export.

Referenced by OpenDDS::RTPS::rtps_duration_to_time_duration().

 {
   return static_cast<ACE_UINT32>((static_cast<ACE_UINT64>(fraction) * 1000000) >> 32);
 }

◆ uint32_fractional_seconds_to_nanoseconds()

ACE_INLINE OpenDDS_Dcps_Export ACE_UINT32 OpenDDS::DCPS::uint32_fractional_seconds_to_nanoseconds ( ACE_UINT32 fraction )

Definition at line 266 of file Time_Helper.inl.

References ACE_INLINE, and OpenDDS_Dcps_Export.

Referenced by OpenDDS::DCPS::RtpsUdpReceiveStrategy::MessageReceiver::fill_header().

 {
   return static_cast<ACE_UINT32>((static_cast<ACE_UINT64>(fraction) * 1000000000) >> 32);
 }

◆ unbind() [1/2]

template<typename Container >

int OpenDDS::DCPS::unbind	(	Container &	c,
		const typename Container::key_type &	k,
		typename Container::mapped_type &	v
	)

Definition at line 38 of file Util.h.

Referenced by OpenDDS::DCPS::ReceiveListenerSetMap::release_subscriber(), OpenDDS::DCPS::ReceiveListenerSetMap::remove(), OpenDDS::DCPS::ReceiveListenerSet::remove(), OpenDDS::DCPS::ReceiveListenerSet::remove_all(), OpenDDS::DCPS::DataLinkSet::remove_link(), OpenDDS::DCPS::ReceiveListenerSetMap::remove_set(), unbind(), and OpenDDS::DCPS::OwnershipManager::unregister_reader().

 {
   typename Container::const_iterator iter = c.find(k);
 
   if (iter != c.end()) {
     v = iter->second;
 
     if (c.erase(k) == 1) {
       return 0;
     }
 
     return -1;
   }
 
   return -1;
 }

◆ unbind() [2/2]

template<typename Container >

int OpenDDS::DCPS::unbind	(	Container &	c,
		const typename Container::key_type &	k
	)

Definition at line 60 of file Util.h.

References unbind().

 {
   typename Container::mapped_type v;
   return unbind(c, k, v);
 }

◆ unknown_sequence_range()

const SequenceRange OpenDDS::DCPS::unknown_sequence_range	(	SequenceNumber::SEQUENCENUMBER_UNKNOWN()	,
		SequenceNumber::SEQUENCENUMBER_UNKNOWN()
	)

◆ unwrap_reference() [1/2]

template<typename T >

T const& OpenDDS::DCPS::unwrap_reference ( T const & t )

Definition at line 243 of file RcHandle_T.h.

Referenced by make_rch().

 {
   return t;
 }

◆ unwrap_reference() [2/2]

template<typename T >

T& OpenDDS::DCPS::unwrap_reference ( reference_wrapper< T > const & t )

Definition at line 249 of file RcHandle_T.h.

References OpenDDS::DCPS::reference_wrapper< T >::get().

 {
   return t.get();
 }

◆ valid_duration()

ACE_INLINE bool OpenDDS::DCPS::valid_duration ( DDS::Duration_t const & t )

Validate DDS::Duration_t value (infinite or positive and non-zero).

Definition at line 245 of file Time_Helper.inl.

References ACE_INLINE, is_infinite(), DDS::Duration_t::nanosec, and DDS::Duration_t::sec.

Referenced by non_negative_duration(), and OpenDDS::DCPS::Qos_Helper::valid().

 {
   // Only accept infinite or positive finite durations.  (Zero
   // excluded).
   //
   // Note that it doesn't make much sense for users to set
   // durations less than 10 milliseconds since the underlying
   // timer resolution is generally no better than that.
   return is_infinite(t) || t.sec > 0 || (t.sec >= 0 && t.nanosec > 0);
 }

◆ verify_hostname()

bool OpenDDS::DCPS::verify_hostname	(	const String &	hostname,
		ACE_INET_Addr *	addr_array,
		size_t	addr_count,
		bool	prefer_loopback,
		bool	allow_ipv4_fallback
	)

Definition at line 69 of file NetworkResource.cpp.

References choose_single_coherent_address().

Referenced by get_fully_qualified_hostname().

 {
   const ACE_INET_Addr addr = choose_single_coherent_address(hostname, prefer_loopback, allow_ipv4_fallback);
   for (size_t i = 0; i < addr_count; ++i) {
     if (addr == addr_array[i]) {
       return true;
     }
   }
   return false;
 }

◆ vwrite()

OpenDDS_Dcps_Export void OpenDDS::DCPS::vwrite	(	ValueWriter &	vw,
		const Observer::Sample &	sample
	)

Definition at line 51 of file Observer.cpp.

References OpenDDS::DCPS::ValueWriter::begin_struct(), OpenDDS::DCPS::ValueWriter::begin_struct_member(), OpenDDS::DCPS::Observer::Sample::data, OpenDDS::DCPS::Observer::Sample::data_dispatcher, OpenDDS::DCPS::ValueWriter::end_struct(), OpenDDS::DCPS::ValueWriter::end_struct_member(), OpenDDS::DCPS::SequenceNumber::getValue(), OpenDDS::DCPS::Observer::Sample::instance, OpenDDS::DCPS::Observer::Sample::instance_state, OPENDDS_END_VERSIONED_NAMESPACE_DECL, OpenDDS::DCPS::Observer::Sample::sequence_number, OpenDDS::DCPS::Observer::Sample::timestamp, OpenDDS::DCPS::ValueDispatcher::write(), OpenDDS::DCPS::ValueWriter::write_int32(), OpenDDS::DCPS::ValueWriter::write_int64(), and OpenDDS::DCPS::ValueWriter::write_uint32().

Referenced by OpenDDS::DCPS::ValueDispatcher_T< T >::write().

 {
   vw.begin_struct();
   vw.begin_struct_member(XTypes::MemberDescriptorImpl("instance", false));
   vw.write_int32(sample.instance);
   vw.end_struct_member();
   vw.begin_struct_member(XTypes::MemberDescriptorImpl("instance_state", false));
   vw.write_uint32(sample.instance_state);
   vw.end_struct_member();
   vw.begin_struct_member(XTypes::MemberDescriptorImpl("timestamp", false));
   vwrite(vw, sample.timestamp);
   vw.end_struct_member();
   vw.begin_struct_member(XTypes::MemberDescriptorImpl("sequence_number", false));
   vw.write_int64(sample.sequence_number.getValue());
   vw.end_struct_member();
   vw.begin_struct_member(XTypes::MemberDescriptorImpl("data", false));
   sample.data_dispatcher.write(vw, sample.data);
   vw.end_struct_member();
   vw.end_struct();
 }

Variable Documentation

◆ AceTimestampSize

const size_t OpenDDS::DCPS::AceTimestampSize = 27

Size of TCHAR buffer for use with ACE::timestamp, e.g., ACE_TCHAR buffer[AceTimestampSize]; ACE::timestamp(buffer, AceTimestampSize);

Definition at line 131 of file Definitions.h.

◆ AddrToStringSize

const size_t OpenDDS::DCPS::AddrToStringSize = 256

Size of TCHAR buffer for use with addr_to_string.

Definition at line 134 of file Definitions.h.

◆ ALL_STATUS_MASK

const DDS::StatusMask OpenDDS::DCPS::ALL_STATUS_MASK = 0xffffffff

Definition at line 321 of file DdsDcpsInfrastructure.idl.

Referenced by OpenDDS::DCPS::MultiTopicDataReaderBase::init().

◆ BIT_LOOKUP_DURATION_MSEC

const int OpenDDS::DCPS::BIT_LOOKUP_DURATION_MSEC = 2000

Definition at line 118 of file Service_Participant.cpp.

◆ boolean_cdr_size

const size_t OpenDDS::DCPS::boolean_cdr_size = 1

Definition at line 75 of file Serializer.h.

Referenced by operator<<(), operator>>(), OpenDDS::RTPS::populate_locators(), primitive_serialized_size(), primitive_serialized_size_boolean(), OpenDDS::DCPS::Serializer::read_boolean_array(), serialized_size(), and OpenDDS::DCPS::Serializer::write_boolean_array().

◆ BUILT_IN_CONNECTION_RECORD_TOPIC

OpenDDS_Dcps_Export const char *const OpenDDS::DCPS::BUILT_IN_CONNECTION_RECORD_TOPIC = "OpenDDSConnectionRecord"

Definition at line 36 of file BuiltInTopicUtils.cpp.

Referenced by OpenDDS::DCPS::BitSubscriber::add_connection_record(), OpenDDS::DCPS::StaticParticipant::connection_record_bit(), OpenDDS::DCPS::Discovery::create_bit_topics(), OpenDDS::RTPS::RtpsDiscovery::init_bit(), and OpenDDS::DCPS::StaticDiscovery::init_bit().

◆ BUILT_IN_CONNECTION_RECORD_TOPIC_TYPE

OpenDDS_Dcps_Export const char *const OpenDDS::DCPS::BUILT_IN_CONNECTION_RECORD_TOPIC_TYPE = "CONNECTION_RECORD_BUILT_IN_TOPIC_TYPE"

Definition at line 37 of file BuiltInTopicUtils.cpp.

Referenced by OpenDDS::DCPS::Discovery::create_bit_topics(), OpenDDS::RTPS::RtpsDiscovery::init_bit(), and OpenDDS::DCPS::StaticDiscovery::init_bit().

◆ BUILT_IN_INTERNAL_THREAD_TOPIC

OpenDDS_Dcps_Export const char *const OpenDDS::DCPS::BUILT_IN_INTERNAL_THREAD_TOPIC = "OpenDDSInternalThread"

Definition at line 39 of file BuiltInTopicUtils.cpp.

Referenced by OpenDDS::DCPS::Discovery::create_bit_topics(), OpenDDS::RTPS::RtpsDiscovery::init_bit(), OpenDDS::DCPS::StaticDiscovery::init_bit(), and OpenDDS::DCPS::StaticParticipant::internal_thread_bit().

◆ BUILT_IN_INTERNAL_THREAD_TOPIC_TYPE

OpenDDS_Dcps_Export const char *const OpenDDS::DCPS::BUILT_IN_INTERNAL_THREAD_TOPIC_TYPE = "INTERNAL_THREAD_BUILT_IN_TOPIC_TYPE"

Definition at line 40 of file BuiltInTopicUtils.cpp.

Referenced by OpenDDS::DCPS::Discovery::create_bit_topics(), OpenDDS::RTPS::RtpsDiscovery::init_bit(), and OpenDDS::DCPS::StaticDiscovery::init_bit().

◆ BUILT_IN_PARTICIPANT_LOCATION_TOPIC

OpenDDS_Dcps_Export const char *const OpenDDS::DCPS::BUILT_IN_PARTICIPANT_LOCATION_TOPIC = "OpenDDSParticipantLocation"

Definition at line 33 of file BuiltInTopicUtils.cpp.

Referenced by OpenDDS::DCPS::BitSubscriber::add_participant_location(), OpenDDS::DCPS::Discovery::create_bit_topics(), OpenDDS::RTPS::RtpsDiscovery::init_bit(), OpenDDS::DCPS::StaticDiscovery::init_bit(), and OpenDDS::DCPS::StaticParticipant::part_loc_bit().

◆ BUILT_IN_PARTICIPANT_LOCATION_TOPIC_TYPE

OpenDDS_Dcps_Export const char *const OpenDDS::DCPS::BUILT_IN_PARTICIPANT_LOCATION_TOPIC_TYPE = "PARTICIPANT_LOCATION_BUILT_IN_TOPIC_TYPE"

Definition at line 34 of file BuiltInTopicUtils.cpp.

Referenced by OpenDDS::DCPS::Discovery::create_bit_topics(), OpenDDS::RTPS::RtpsDiscovery::init_bit(), and OpenDDS::DCPS::StaticDiscovery::init_bit().

◆ BUILT_IN_PARTICIPANT_TOPIC

OpenDDS_Dcps_Export const char *const OpenDDS::DCPS::BUILT_IN_PARTICIPANT_TOPIC = "DCPSParticipant"

Definition at line 21 of file BuiltInTopicUtils.cpp.

Referenced by OpenDDS::DCPS::BitSubscriber::add_participant(), OpenDDS::DCPS::Discovery::create_bit_topics(), OpenDDS::DCPS::InfoRepoDiscovery::init_bit(), OpenDDS::RTPS::RtpsDiscovery::init_bit(), OpenDDS::DCPS::StaticDiscovery::init_bit(), DCPS_IR_Domain::init_built_in_topics_topics(), and OpenDDS::DCPS::StaticParticipant::part_bit().

◆ BUILT_IN_PARTICIPANT_TOPIC_TYPE

OpenDDS_Dcps_Export const char *const OpenDDS::DCPS::BUILT_IN_PARTICIPANT_TOPIC_TYPE = "PARTICIPANT_BUILT_IN_TOPIC_TYPE"

Definition at line 22 of file BuiltInTopicUtils.cpp.

Referenced by OpenDDS::DCPS::Discovery::create_bit_topics(), OpenDDS::RTPS::RtpsDiscovery::init_bit(), OpenDDS::DCPS::StaticDiscovery::init_bit(), DCPS_IR_Domain::init_built_in_topics_topics(), and DCPS_IR_Domain::publish_publication_bit().

◆ BUILT_IN_PUBLICATION_TOPIC

OpenDDS_Dcps_Export const char *const OpenDDS::DCPS::BUILT_IN_PUBLICATION_TOPIC = "DCPSPublication"

Definition at line 30 of file BuiltInTopicUtils.cpp.

Referenced by OpenDDS::DCPS::BitSubscriber::add_publication(), OpenDDS::DCPS::Discovery::create_bit_topics(), OpenDDS::DCPS::DataReaderImpl::get_matched_publication_data(), OpenDDS::DCPS::InfoRepoDiscovery::init_bit(), OpenDDS::RTPS::RtpsDiscovery::init_bit(), OpenDDS::DCPS::StaticDiscovery::init_bit(), DCPS_IR_Domain::init_built_in_topics_topics(), OpenDDS::FaceTSS::populate_header_received(), OpenDDS::DCPS::StaticEndpointManager::pub_bit(), and OpenDDS::DCPS::RecorderImpl::repoid_to_bit_key().

◆ BUILT_IN_PUBLICATION_TOPIC_TYPE

OpenDDS_Dcps_Export const char *const OpenDDS::DCPS::BUILT_IN_PUBLICATION_TOPIC_TYPE = "PUBLICATION_BUILT_IN_TOPIC_TYPE"

Definition at line 31 of file BuiltInTopicUtils.cpp.

Referenced by OpenDDS::DCPS::Discovery::create_bit_topics(), OpenDDS::RTPS::RtpsDiscovery::init_bit(), OpenDDS::DCPS::StaticDiscovery::init_bit(), DCPS_IR_Domain::init_built_in_topics_topics(), and DCPS_IR_Domain::publish_publication_bit().

◆ BUILT_IN_SUBSCRIPTION_TOPIC

OpenDDS_Dcps_Export const char *const OpenDDS::DCPS::BUILT_IN_SUBSCRIPTION_TOPIC = "DCPSSubscription"

Definition at line 27 of file BuiltInTopicUtils.cpp.

Referenced by OpenDDS::DCPS::BitSubscriber::add_subscription(), OpenDDS::DCPS::Discovery::create_bit_topics(), OpenDDS::DCPS::DataWriterImpl::get_matched_subscription_data(), OpenDDS::DCPS::InfoRepoDiscovery::init_bit(), OpenDDS::RTPS::RtpsDiscovery::init_bit(), OpenDDS::DCPS::StaticDiscovery::init_bit(), DCPS_IR_Domain::init_built_in_topics_topics(), and OpenDDS::DCPS::StaticEndpointManager::sub_bit().

◆ BUILT_IN_SUBSCRIPTION_TOPIC_TYPE

OpenDDS_Dcps_Export const char *const OpenDDS::DCPS::BUILT_IN_SUBSCRIPTION_TOPIC_TYPE = "SUBSCRIPTION_BUILT_IN_TOPIC_TYPE"

Definition at line 28 of file BuiltInTopicUtils.cpp.

Referenced by OpenDDS::DCPS::Discovery::create_bit_topics(), OpenDDS::RTPS::RtpsDiscovery::init_bit(), OpenDDS::DCPS::StaticDiscovery::init_bit(), DCPS_IR_Domain::init_built_in_topics_topics(), and DCPS_IR_Domain::publish_publication_bit().

◆ BUILT_IN_TOPIC_TOPIC

OpenDDS_Dcps_Export const char *const OpenDDS::DCPS::BUILT_IN_TOPIC_TOPIC = "DCPSTopic"

Definition at line 24 of file BuiltInTopicUtils.cpp.

Referenced by OpenDDS::DCPS::Discovery::create_bit_topics(), OpenDDS::DCPS::InfoRepoDiscovery::init_bit(), OpenDDS::RTPS::RtpsDiscovery::init_bit(), OpenDDS::DCPS::StaticDiscovery::init_bit(), and DCPS_IR_Domain::init_built_in_topics_topics().

◆ BUILT_IN_TOPIC_TOPIC_TYPE

OpenDDS_Dcps_Export const char *const OpenDDS::DCPS::BUILT_IN_TOPIC_TOPIC_TYPE = "TOPIC_BUILT_IN_TOPIC_TYPE"

Definition at line 25 of file BuiltInTopicUtils.cpp.

Referenced by OpenDDS::DCPS::Discovery::create_bit_topics(), OpenDDS::RTPS::RtpsDiscovery::init_bit(), OpenDDS::DCPS::StaticDiscovery::init_bit(), DCPS_IR_Domain::init_built_in_topics_topics(), and DCPS_IR_Domain::publish_publication_bit().

◆ byte_cdr_size

const size_t OpenDDS::DCPS::byte_cdr_size = 1

Definition at line 76 of file Serializer.h.

Referenced by OpenDDS::DCPS::DataSampleHeader::init(), operator<<(), operator>>(), primitive_serialized_size(), primitive_serialized_size_octet(), OpenDDS::DCPS::Serializer::read_octet_array(), and OpenDDS::DCPS::Serializer::write_octet_array().

◆ char16_cdr_size

const size_t OpenDDS::DCPS::char16_cdr_size = 2

Definition at line 89 of file Serializer.h.

Referenced by operator<<(), operator>>(), primitive_serialized_size(), primitive_serialized_size_wchar(), OpenDDS::DCPS::Serializer::read_string(), and serialized_size().

◆ char8_cdr_size

const size_t OpenDDS::DCPS::char8_cdr_size = 1

Definition at line 88 of file Serializer.h.

Referenced by operator<<(), operator>>(), primitive_serialized_size(), primitive_serialized_size_char(), OpenDDS::DCPS::Serializer::read_char_array(), and OpenDDS::DCPS::Serializer::write_char_array().

◆ COMMON_SECTION_NAME

const ACE_TCHAR OpenDDS::DCPS::COMMON_SECTION_NAME[] = ACE_TEXT("common")

static

Definition at line 128 of file Service_Participant.cpp.

◆ config_fname

ACE_TString OpenDDS::DCPS::config_fname(ACE_TEXT(""))

static

Referenced by OpenDDS::DCPS::Service_Participant::get_domain_participant_factory(), OpenDDS::DCPS::Service_Participant::load_configuration(), and OpenDDS::DCPS::Service_Participant::parse_args().

◆ CONFIG_SECTION_NAME

const ACE_TCHAR OpenDDS::DCPS::CONFIG_SECTION_NAME[] = ACE_TEXT("config")

static

Definition at line 188 of file TransportDefs.h.

Referenced by OpenDDS::DCPS::TransportRegistry::load_transport_configuration().

◆ CONNINFO_ALL

const ConnectionInfoFlags OpenDDS::DCPS::CONNINFO_ALL = static_cast<ConnectionInfoFlags>(-1)

static

Definition at line 259 of file TransportDefs.h.

Referenced by OpenDDS::DCPS::UdpDataLink::open(), OpenDDS::DCPS::TransportClient::populate_connection_info(), and OpenDDS::DCPS::TransportConfig::populate_locators().

◆ CONNINFO_MULTICAST

const ConnectionInfoFlags OpenDDS::DCPS::CONNINFO_MULTICAST = (1 << 1)

static

Definition at line 258 of file TransportDefs.h.

Referenced by OpenDDS::RTPS::Sedp::multicast_locators(), and OpenDDS::DCPS::RtpsUdpInst::populate_locator().

◆ CONNINFO_UNICAST

const ConnectionInfoFlags OpenDDS::DCPS::CONNINFO_UNICAST = (1 << 0)

static

Definition at line 257 of file TransportDefs.h.

Referenced by OpenDDS::DCPS::RtpsUdpInst::populate_locator(), and OpenDDS::RTPS::Sedp::unicast_locators().

◆ CUSTOMIZATION_SECTION_NAME

const ACE_TCHAR OpenDDS::DCPS::CUSTOMIZATION_SECTION_NAME[] = ACE_TEXT("Customization")

static

Definition at line 189 of file TransportDefs.h.

Referenced by OpenDDS::DCPS::Service_Participant::load_discovery_templates(), and OpenDDS::DCPS::TransportRegistry::load_transport_templates().

◆ DATA_READER_MONITOR_TOPIC

const string OpenDDS::DCPS::DATA_READER_MONITOR_TOPIC = "Data Reader Monitor"

Definition at line 22 of file monitor.idl.

Referenced by OpenDDS::DCPS::MonitorFactoryImpl::initialize().

◆ DATA_READER_PERIODIC_MONITOR_TOPIC

const string OpenDDS::DCPS::DATA_READER_PERIODIC_MONITOR_TOPIC = "Data Reader Periodic Monitor"

Definition at line 23 of file monitor.idl.

Referenced by OpenDDS::DCPS::MonitorFactoryImpl::initialize().

◆ DATA_WRITER_MONITOR_TOPIC

const string OpenDDS::DCPS::DATA_WRITER_MONITOR_TOPIC = "Data Writer Monitor"

Definition at line 20 of file monitor.idl.

Referenced by OpenDDS::DCPS::MonitorFactoryImpl::initialize().

◆ DATA_WRITER_PERIODIC_MONITOR_TOPIC

const string OpenDDS::DCPS::DATA_WRITER_PERIODIC_MONITOR_TOPIC = "Data Writer Periodic Monitor"

Definition at line 21 of file monitor.idl.

Referenced by OpenDDS::DCPS::MonitorFactoryImpl::initialize().

◆ DCPS_debug_level

OpenDDS_Dcps_Export unsigned int OpenDDS::DCPS::DCPS_debug_level = 0

Logging verbosity level. set by Service_Participant value guidelines: 1 - logs that should happen once per process 2 - logs that should happen once per DDS entity 4 - logs that are related to administrative interfaces 6 - logs that should happen every Nth sample write/read 8 - logs that should happen once per sample write/read 10 - logs that may happen more than once per sample write/read

Definition at line 30 of file debug.cpp.

◆ DEFAULT_CHUNK_MULTIPLIER

const size_t OpenDDS::DCPS::DEFAULT_CHUNK_MULTIPLIER = 10

Definition at line 111 of file Service_Participant.cpp.

◆ DEFAULT_FEDERATION_BACKOFF_MULTIPLIER

const int OpenDDS::DCPS::DEFAULT_FEDERATION_BACKOFF_MULTIPLIER = 2

Definition at line 115 of file Service_Participant.cpp.

◆ DEFAULT_FEDERATION_INITIAL_BACKOFF_SECONDS

const int OpenDDS::DCPS::DEFAULT_FEDERATION_INITIAL_BACKOFF_SECONDS = 1

Definition at line 114 of file Service_Participant.cpp.

◆ DEFAULT_FEDERATION_LIVELINESS

const int OpenDDS::DCPS::DEFAULT_FEDERATION_LIVELINESS = 60

Definition at line 116 of file Service_Participant.cpp.

◆ DEFAULT_FEDERATION_RECOVERY_DURATION

const int OpenDDS::DCPS::DEFAULT_FEDERATION_RECOVERY_DURATION = 900

Definition at line 113 of file Service_Participant.cpp.

◆ DEFAULT_NUM_CHUNKS

const size_t OpenDDS::DCPS::DEFAULT_NUM_CHUNKS = 20

Definition at line 109 of file Service_Participant.cpp.

◆ DEFAULT_ORB_NAME

const char OpenDDS::DCPS::DEFAULT_ORB_NAME[] = "OpenDDS_DCPS"

Definition at line 50 of file Service_Participant.h.

Referenced by OpenDDS::DCPS::InfoRepoDiscovery::get_dcps_info().

◆ DEFAULT_PERSISTENT_DATA_DIR

const char OpenDDS::DCPS::DEFAULT_PERSISTENT_DATA_DIR[] = "OpenDDS-durable-data-dir"

static

Definition at line 125 of file Service_Participant.cpp.

◆ DEFAULT_REPO_IOR

const ACE_TCHAR OpenDDS::DCPS::DEFAULT_REPO_IOR[] = ACE_TEXT("file://repo.ior")

static

Definition at line 122 of file Service_Participant.cpp.

◆ DEFAULT_STATUS_MASK

const DDS::StatusMask OpenDDS::DCPS::DEFAULT_STATUS_MASK = ALL_STATUS_MASK

Definition at line 323 of file DdsDcpsInfrastructure.idl.

Referenced by OpenDDS::DCPS::Discovery::create_bit_topics(), OpenDDS::DCPS::MonitorFactoryImpl::create_data_writer(), OpenDDS::DCPS::DomainParticipantImpl::find_topic(), OpenDDS::DCPS::InfoRepoDiscovery::init_bit(), OpenDDS::RTPS::RtpsDiscovery::init_bit(), OpenDDS::DCPS::StaticDiscovery::init_bit(), DCPS_IR_Domain::init_built_in_topics(), DCPS_IR_Domain::init_built_in_topics_datawriters(), DCPS_IR_Domain::init_built_in_topics_topics(), DCPS_IR_Domain::init_built_in_topics_transport(), OpenDDS::DCPS::MonitorFactoryImpl::initialize(), and OpenDDS::Federator::ManagerImpl::initialize().

◆ DOMAIN_PARTICIPANT_MONITOR_TOPIC

const string OpenDDS::DCPS::DOMAIN_PARTICIPANT_MONITOR_TOPIC = "Domain Participant Monitor"

Definition at line 16 of file monitor.idl.

Referenced by OpenDDS::DCPS::MonitorFactoryImpl::initialize().

◆ DOMAIN_RANGE_SECTION_NAME

const ACE_TCHAR OpenDDS::DCPS::DOMAIN_RANGE_SECTION_NAME[] = ACE_TEXT("DomainRange")

static

Definition at line 130 of file Service_Participant.cpp.

Referenced by OpenDDS::DCPS::Service_Participant::parse_domain_range().

◆ DOMAIN_SECTION_NAME

const ACE_TCHAR OpenDDS::DCPS::DOMAIN_SECTION_NAME[] = ACE_TEXT("domain")

static

Definition at line 129 of file Service_Participant.cpp.

◆ ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_READER

const EntityId_t OpenDDS::DCPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_READER = { {0x00,0x02,0x00}, 0xc7}

Entity Id values specified in Version 2.1 of RTPS specification.

Definition at line 48 of file GuidUtils.h.

Referenced by OpenDDS::RTPS::Sedp::associate(), OpenDDS::RTPS::Sedp::association_complete_i(), OpenDDS::RTPS::Sedp::replay_durable_data_for(), OpenDDS::RTPS::Spdp::start_ice(), OpenDDS::RTPS::Spdp::stop_ice(), and OpenDDS::RTPS::Sedp::update_locators().

◆ ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_WRITER

const EntityId_t OpenDDS::DCPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_WRITER = { {0x00,0x02,0x00}, 0xc2}

Entity Id values specified in Version 2.1 of RTPS specification.

Definition at line 47 of file GuidUtils.h.

Referenced by OpenDDS::RTPS::Sedp::associate(), OpenDDS::RTPS::Sedp::Reader::data_received(), OpenDDS::RTPS::Sedp::LivelinessReader::data_received_i(), OpenDDS::RTPS::Spdp::start_ice(), OpenDDS::RTPS::Spdp::stop_ice(), and OpenDDS::RTPS::Sedp::update_locators().

◆ ENTITYID_PARTICIPANT

const EntityId_t OpenDDS::DCPS::ENTITYID_PARTICIPANT = { {0x00,0x00,0x01}, 0xc1}

Entity Id values specified in Version 2.1 of RTPS specification.

Definition at line 38 of file GuidUtils.h.

◆ ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER

const EntityId_t OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER = { {0x00,0x00,0x03}, 0xc7}

Entity Id values specified in Version 2.1 of RTPS specification.

Definition at line 42 of file GuidUtils.h.

Referenced by OpenDDS::RTPS::Sedp::associate(), OpenDDS::RTPS::Sedp::association_complete_i(), OpenDDS::RTPS::Spdp::init_bit(), OpenDDS::RTPS::Sedp::remote_knows_about_local_i(), OpenDDS::RTPS::Sedp::replay_durable_data_for(), OpenDDS::RTPS::Spdp::shutdown(), OpenDDS::RTPS::Spdp::start_ice(), OpenDDS::RTPS::Spdp::stop_ice(), OpenDDS::RTPS::Sedp::update_locators(), and OpenDDS::RTPS::Spdp::use_ice_now().

◆ ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER

const EntityId_t OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER = { {0x00,0x00,0x03}, 0xc2}

Entity Id values specified in Version 2.1 of RTPS specification.

Definition at line 41 of file GuidUtils.h.

Referenced by OpenDDS::RTPS::Sedp::associate(), OpenDDS::RTPS::Sedp::data_acked_i(), OpenDDS::RTPS::Sedp::Reader::data_received(), OpenDDS::RTPS::Sedp::DiscoveryReader::data_received_i(), OpenDDS::RTPS::Sedp::populate_origination_locator(), OpenDDS::RTPS::Spdp::start_ice(), OpenDDS::RTPS::Spdp::stop_ice(), and OpenDDS::RTPS::Sedp::update_locators().

◆ ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_READER

const EntityId_t OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_READER = { {0x00,0x00,0x04}, 0xc7}

Entity Id values specified in Version 2.1 of RTPS specification.

Definition at line 44 of file GuidUtils.h.

Referenced by OpenDDS::RTPS::Sedp::associate(), OpenDDS::RTPS::Sedp::association_complete_i(), OpenDDS::RTPS::Sedp::remote_knows_about_local_i(), OpenDDS::RTPS::Sedp::replay_durable_data_for(), OpenDDS::RTPS::Spdp::start_ice(), OpenDDS::RTPS::Spdp::stop_ice(), and OpenDDS::RTPS::Sedp::update_locators().

◆ ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER

const EntityId_t OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER = { {0x00,0x00,0x04}, 0xc2}

Entity Id values specified in Version 2.1 of RTPS specification.

Definition at line 43 of file GuidUtils.h.

Referenced by OpenDDS::RTPS::Sedp::associate(), OpenDDS::RTPS::Sedp::data_acked_i(), OpenDDS::RTPS::Sedp::Reader::data_received(), OpenDDS::RTPS::Sedp::DiscoveryReader::data_received_i(), OpenDDS::RTPS::Sedp::populate_origination_locator(), OpenDDS::RTPS::Spdp::start_ice(), OpenDDS::RTPS::Spdp::stop_ice(), and OpenDDS::RTPS::Sedp::update_locators().

◆ ENTITYID_SEDP_BUILTIN_TOPIC_READER

const EntityId_t OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_TOPIC_READER = { {0x00,0x00,0x02}, 0xc7}

Entity Id values specified in Version 2.1 of RTPS specification.

Definition at line 40 of file GuidUtils.h.

◆ ENTITYID_SEDP_BUILTIN_TOPIC_WRITER

const EntityId_t OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_TOPIC_WRITER = { {0x00,0x00,0x02}, 0xc2}

Entity Id values specified in Version 2.1 of RTPS specification.

Definition at line 39 of file GuidUtils.h.

◆ ENTITYID_SPDP_BUILTIN_PARTICIPANT_READER

const EntityId_t OpenDDS::DCPS::ENTITYID_SPDP_BUILTIN_PARTICIPANT_READER = { {0x00,0x01,0x00}, 0xc7}

Entity Id values specified in Version 2.1 of RTPS specification.

Definition at line 46 of file GuidUtils.h.

Referenced by OpenDDS::RTPS::Sedp::update_locators().

◆ ENTITYID_SPDP_BUILTIN_PARTICIPANT_WRITER

const EntityId_t OpenDDS::DCPS::ENTITYID_SPDP_BUILTIN_PARTICIPANT_WRITER = { {0x00,0x01,0x00}, 0xc2}

Entity Id values specified in Version 2.1 of RTPS specification.

Definition at line 45 of file GuidUtils.h.

Referenced by OpenDDS::RTPS::Spdp::SpdpTransport::handle_input(), OpenDDS::RTPS::Spdp::SpdpTransport::send(), OpenDDS::RTPS::Spdp::SpdpTransport::SpdpTransport(), and OpenDDS::RTPS::Sedp::update_locators().

◆ ENTITYID_TL_SVC_REPLY_READER

const EntityId_t OpenDDS::DCPS::ENTITYID_TL_SVC_REPLY_READER = { {0x00,0x03,0x01}, 0xc4}

XTypes Type Lookup Service

Definition at line 56 of file GuidUtils.h.

Referenced by OpenDDS::RTPS::Sedp::associate(), OpenDDS::RTPS::Sedp::association_complete_i(), OpenDDS::RTPS::Sedp::TypeLookupRequestReader::data_received_i(), OpenDDS::RTPS::Spdp::start_ice(), OpenDDS::RTPS::Spdp::stop_ice(), and OpenDDS::RTPS::Sedp::update_locators().

◆ ENTITYID_TL_SVC_REPLY_WRITER

const EntityId_t OpenDDS::DCPS::ENTITYID_TL_SVC_REPLY_WRITER = { {0x00,0x03,0x01}, 0xc3}

XTypes Type Lookup Service

Definition at line 55 of file GuidUtils.h.

Referenced by OpenDDS::RTPS::Sedp::associate(), OpenDDS::RTPS::Sedp::Reader::data_received(), OpenDDS::RTPS::Sedp::TypeLookupReplyReader::data_received_i(), OpenDDS::RTPS::Spdp::start_ice(), OpenDDS::RTPS::Spdp::stop_ice(), and OpenDDS::RTPS::Sedp::update_locators().

◆ ENTITYID_TL_SVC_REQ_READER

const EntityId_t OpenDDS::DCPS::ENTITYID_TL_SVC_REQ_READER = { {0x00,0x03,0x00}, 0xc4}

XTypes Type Lookup Service

Definition at line 54 of file GuidUtils.h.

Referenced by OpenDDS::RTPS::Sedp::associate(), OpenDDS::RTPS::Sedp::association_complete_i(), OpenDDS::RTPS::Sedp::send_type_lookup_request(), OpenDDS::RTPS::Spdp::start_ice(), OpenDDS::RTPS::Spdp::stop_ice(), and OpenDDS::RTPS::Sedp::update_locators().

◆ ENTITYID_TL_SVC_REQ_WRITER

const EntityId_t OpenDDS::DCPS::ENTITYID_TL_SVC_REQ_WRITER = { {0x00,0x03,0x00}, 0xc3}

XTypes Type Lookup Service

Definition at line 53 of file GuidUtils.h.

Referenced by OpenDDS::RTPS::Sedp::associate(), OpenDDS::RTPS::Sedp::Reader::data_received(), OpenDDS::RTPS::Sedp::TypeLookupRequestReader::data_received_i(), OpenDDS::RTPS::Spdp::start_ice(), OpenDDS::RTPS::Spdp::stop_ice(), and OpenDDS::RTPS::Sedp::update_locators().

◆ ENTITYID_UNKNOWN

const EntityId_t OpenDDS::DCPS::ENTITYID_UNKNOWN = { {0x00,0x00,0x00}, 0x00}

Entity Id values specified in Version 2.1 of RTPS specification.

Definition at line 37 of file GuidUtils.h.

◆ ENTITYKIND_BUILTIN_PARTICIPANT

const octet OpenDDS::DCPS::ENTITYKIND_BUILTIN_PARTICIPANT = 0xc1

Definition at line 32 of file DdsDcpsGuid.idl.

Referenced by OpenDDS::DCPS::GuidConverter::entityKind().

◆ ENTITYKIND_BUILTIN_READER_NO_KEY

const octet OpenDDS::DCPS::ENTITYKIND_BUILTIN_READER_NO_KEY = 0xc4

Definition at line 35 of file DdsDcpsGuid.idl.

Referenced by OpenDDS::RTPS::Sedp::Endpoint::counterpart_entity_id(), OpenDDS::DCPS::GuidConverter::entityKind(), and OpenDDS::DCPS::GuidConverter::isBuiltinDomainEntity().

◆ ENTITYKIND_BUILTIN_READER_WITH_KEY

const octet OpenDDS::DCPS::ENTITYKIND_BUILTIN_READER_WITH_KEY = 0xc7

Definition at line 36 of file DdsDcpsGuid.idl.

Referenced by OpenDDS::RTPS::Sedp::Endpoint::counterpart_entity_id(), OpenDDS::DCPS::GuidBuilder::entityKind(), OpenDDS::DCPS::GuidConverter::entityKind(), and OpenDDS::DCPS::GuidConverter::isBuiltinDomainEntity().

◆ ENTITYKIND_BUILTIN_TOPIC

const octet OpenDDS::DCPS::ENTITYKIND_BUILTIN_TOPIC = 0xc5

Definition at line 37 of file DdsDcpsGuid.idl.

Referenced by OpenDDS::DCPS::GuidBuilder::entityKind(), OpenDDS::DCPS::GuidConverter::entityKind(), and OpenDDS::DCPS::GuidConverter::isBuiltinDomainEntity().

◆ ENTITYKIND_BUILTIN_UNKNOWN

const octet OpenDDS::DCPS::ENTITYKIND_BUILTIN_UNKNOWN = 0xc0

Definition at line 31 of file DdsDcpsGuid.idl.

Referenced by OpenDDS::RTPS::Sedp::Endpoint::counterpart_entity_id(), and OpenDDS::DCPS::GuidConverter::entityKind().

◆ ENTITYKIND_BUILTIN_WRITER_NO_KEY

const octet OpenDDS::DCPS::ENTITYKIND_BUILTIN_WRITER_NO_KEY = 0xc3

Definition at line 34 of file DdsDcpsGuid.idl.

Referenced by OpenDDS::RTPS::Sedp::Endpoint::counterpart_entity_id(), OpenDDS::DCPS::GuidConverter::entityKind(), and OpenDDS::DCPS::GuidConverter::isBuiltinDomainEntity().

◆ ENTITYKIND_BUILTIN_WRITER_WITH_KEY

const octet OpenDDS::DCPS::ENTITYKIND_BUILTIN_WRITER_WITH_KEY = 0xc2

Definition at line 33 of file DdsDcpsGuid.idl.

Referenced by OpenDDS::RTPS::Sedp::Endpoint::counterpart_entity_id(), OpenDDS::DCPS::GuidBuilder::entityKind(), OpenDDS::DCPS::GuidConverter::entityKind(), and OpenDDS::DCPS::GuidConverter::isBuiltinDomainEntity().

◆ ENTITYKIND_OPENDDS_NIL_WRITER

const octet OpenDDS::DCPS::ENTITYKIND_OPENDDS_NIL_WRITER = 0x4e

Definition at line 53 of file DdsDcpsGuid.idl.

Referenced by OpenDDS::DCPS::DataReaderImpl::accept_sample_processing(), and OpenDDS::DCPS::GuidConverter::entityKind().

◆ ENTITYKIND_OPENDDS_PUBLISHER

const octet OpenDDS::DCPS::ENTITYKIND_OPENDDS_PUBLISHER = 0x42

Definition at line 47 of file DdsDcpsGuid.idl.

Referenced by OpenDDS::DCPS::GuidBuilder::entityKind(), and OpenDDS::DCPS::GuidConverter::entityKind().

◆ ENTITYKIND_OPENDDS_SUBSCRIBER

const octet OpenDDS::DCPS::ENTITYKIND_OPENDDS_SUBSCRIBER = 0x41

Definition at line 46 of file DdsDcpsGuid.idl.

Referenced by OpenDDS::DCPS::GuidBuilder::entityKind(), and OpenDDS::DCPS::GuidConverter::entityKind().

◆ ENTITYKIND_OPENDDS_TOPIC

const octet OpenDDS::DCPS::ENTITYKIND_OPENDDS_TOPIC = 0x45

Definition at line 49 of file DdsDcpsGuid.idl.

Referenced by OpenDDS::DCPS::GuidBuilder::entityKind(), OpenDDS::DCPS::GuidConverter::entityKind(), OpenDDS::DCPS::GuidConverter::isUserDomainEntity(), OpenDDS::DCPS::StaticEndpointManager::make_topic_guid(), and OpenDDS::RTPS::Sedp::make_topic_guid().

◆ ENTITYKIND_OPENDDS_USER

const octet OpenDDS::DCPS::ENTITYKIND_OPENDDS_USER = 0x4a

Definition at line 50 of file DdsDcpsGuid.idl.

Referenced by OpenDDS::DCPS::GuidBuilder::entityKind(), and OpenDDS::DCPS::GuidConverter::entityKind().

◆ ENTITYKIND_USER_READER_NO_KEY

const octet OpenDDS::DCPS::ENTITYKIND_USER_READER_NO_KEY = 0x04

Definition at line 42 of file DdsDcpsGuid.idl.

Referenced by OpenDDS::RTPS::Sedp::assign_subscription_key(), OpenDDS::DCPS::GuidConverter::entityKind(), and OpenDDS::DCPS::GuidConverter::isUserDomainEntity().

◆ ENTITYKIND_USER_READER_WITH_KEY

const octet OpenDDS::DCPS::ENTITYKIND_USER_READER_WITH_KEY = 0x07

Definition at line 43 of file DdsDcpsGuid.idl.

Referenced by OpenDDS::DCPS::StaticEndpointManager::assign_subscription_key(), OpenDDS::RTPS::Sedp::assign_subscription_key(), OpenDDS::DCPS::GuidBuilder::entityKind(), OpenDDS::DCPS::GuidConverter::entityKind(), OpenDDS::DCPS::GuidConverter::isUserDomainEntity(), OpenDDS::DCPS::StaticDiscovery::parse_endpoints(), and OpenDDS::DCPS::StaticDiscovery::pre_reader().

◆ ENTITYKIND_USER_UNKNOWN

const octet OpenDDS::DCPS::ENTITYKIND_USER_UNKNOWN = 0x00

Definition at line 39 of file DdsDcpsGuid.idl.

Referenced by OpenDDS::DCPS::GuidBuilder::entityKind(), and OpenDDS::DCPS::GuidConverter::entityKind().

◆ ENTITYKIND_USER_WRITER_NO_KEY

const octet OpenDDS::DCPS::ENTITYKIND_USER_WRITER_NO_KEY = 0x03

Definition at line 41 of file DdsDcpsGuid.idl.

Referenced by OpenDDS::RTPS::Sedp::assign_publication_key(), OpenDDS::DCPS::GuidConverter::entityKind(), and OpenDDS::DCPS::GuidConverter::isUserDomainEntity().

◆ ENTITYKIND_USER_WRITER_WITH_KEY

const octet OpenDDS::DCPS::ENTITYKIND_USER_WRITER_WITH_KEY = 0x02

Definition at line 40 of file DdsDcpsGuid.idl.

Referenced by OpenDDS::DCPS::StaticEndpointManager::assign_publication_key(), OpenDDS::RTPS::Sedp::assign_publication_key(), OpenDDS::DCPS::GuidBuilder::entityKind(), OpenDDS::DCPS::GuidConverter::entityKind(), OpenDDS::DCPS::GuidConverter::isUserDomainEntity(), OpenDDS::DCPS::StaticDiscovery::parse_endpoints(), and OpenDDS::DCPS::StaticDiscovery::pre_writer().

◆ float128_cdr_size

const size_t OpenDDS::DCPS::float128_cdr_size = 16

Definition at line 87 of file Serializer.h.

Referenced by operator<<(), operator>>(), primitive_serialized_size(), OpenDDS::DCPS::Serializer::read_longdouble_array(), and OpenDDS::DCPS::Serializer::write_longdouble_array().

◆ float32_cdr_size

const size_t OpenDDS::DCPS::float32_cdr_size = 4

Definition at line 85 of file Serializer.h.

Referenced by operator<<(), operator>>(), primitive_serialized_size(), OpenDDS::DCPS::Serializer::read_float_array(), and OpenDDS::DCPS::Serializer::write_float_array().

◆ float64_cdr_size

const size_t OpenDDS::DCPS::float64_cdr_size = 8

Definition at line 86 of file Serializer.h.

Referenced by operator<<(), operator>>(), primitive_serialized_size(), OpenDDS::DCPS::Serializer::read_double_array(), and OpenDDS::DCPS::Serializer::write_double_array().

◆ got_bidir_giop

bool OpenDDS::DCPS::got_bidir_giop = false

static

Definition at line 169 of file Service_Participant.cpp.

◆ got_bit_flag

bool OpenDDS::DCPS::got_bit_flag = false

static

Definition at line 144 of file Service_Participant.cpp.

◆ got_bit_lookup_duration_msec

bool OpenDDS::DCPS::got_bit_lookup_duration_msec = false

static

Definition at line 142 of file Service_Participant.cpp.

◆ got_bit_transport_ip

bool OpenDDS::DCPS::got_bit_transport_ip = false

static

Definition at line 141 of file Service_Participant.cpp.

◆ got_bit_transport_port

bool OpenDDS::DCPS::got_bit_transport_port = false

static

Definition at line 140 of file Service_Participant.cpp.

◆ got_chunk_association_multiplier

bool OpenDDS::DCPS::got_chunk_association_multiplier = false

static

Definition at line 138 of file Service_Participant.cpp.

◆ got_chunks

bool OpenDDS::DCPS::got_chunks = false

static

Definition at line 137 of file Service_Participant.cpp.

◆ got_debug_level

bool OpenDDS::DCPS::got_debug_level = false

static

Definition at line 134 of file Service_Participant.cpp.

◆ got_default_address

bool OpenDDS::DCPS::got_default_address = false

static

Definition at line 168 of file Service_Participant.cpp.

◆ got_default_discovery

bool OpenDDS::DCPS::got_default_discovery = false

static

Definition at line 158 of file Service_Participant.cpp.

◆ got_global_transport_config

bool OpenDDS::DCPS::got_global_transport_config = false

static

Definition at line 143 of file Service_Participant.cpp.

◆ got_info

bool OpenDDS::DCPS::got_info = false

static

Definition at line 136 of file Service_Participant.cpp.

◆ got_liveliness_factor

bool OpenDDS::DCPS::got_liveliness_factor = false

static

Definition at line 139 of file Service_Participant.cpp.

◆ got_log_fname

bool OpenDDS::DCPS::got_log_fname = false

static

Definition at line 166 of file Service_Participant.cpp.

◆ got_log_level

bool OpenDDS::DCPS::got_log_level = false

static

Definition at line 173 of file Service_Participant.cpp.

◆ got_log_verbose

bool OpenDDS::DCPS::got_log_verbose = false

static

Definition at line 167 of file Service_Participant.cpp.

◆ got_monitor

bool OpenDDS::DCPS::got_monitor = false

static

Definition at line 171 of file Service_Participant.cpp.

◆ got_pending_timeout

bool OpenDDS::DCPS::got_pending_timeout = false

static

Definition at line 154 of file Service_Participant.cpp.

◆ got_persistent_data_dir

bool OpenDDS::DCPS::got_persistent_data_dir = false

static

Definition at line 156 of file Service_Participant.cpp.

◆ got_publisher_content_filter

bool OpenDDS::DCPS::got_publisher_content_filter = false

static

Definition at line 152 of file Service_Participant.cpp.

◆ got_security_debug

bool OpenDDS::DCPS::got_security_debug = false

static

Definition at line 148 of file Service_Participant.cpp.

◆ got_security_fake_encryption

bool OpenDDS::DCPS::got_security_fake_encryption = false

static

Definition at line 149 of file Service_Participant.cpp.

◆ got_security_flag

bool OpenDDS::DCPS::got_security_flag = false

static

Definition at line 147 of file Service_Participant.cpp.

◆ got_thread_status_interval

bool OpenDDS::DCPS::got_thread_status_interval = false

static

Definition at line 170 of file Service_Participant.cpp.

◆ got_transport_debug_level

bool OpenDDS::DCPS::got_transport_debug_level = false

static

Definition at line 153 of file Service_Participant.cpp.

◆ got_type_object_encoding

bool OpenDDS::DCPS::got_type_object_encoding = false

static

Definition at line 172 of file Service_Participant.cpp.

◆ got_use_rti_serialization

bool OpenDDS::DCPS::got_use_rti_serialization = false

static

Definition at line 135 of file Service_Participant.cpp.

◆ guid_cdr_size

const size_t OpenDDS::DCPS::guid_cdr_size = 16

Definition at line 128 of file GuidUtils.h.

Referenced by OpenDDS::DCPS::DataSampleHeader::partial(), OpenDDS::DCPS::TcpDataLink::request_ack_received(), OpenDDS::DCPS::ShmemDataLink::request_ack_received(), OpenDDS::DCPS::TcpDataLink::send_association_msg(), OpenDDS::DCPS::ShmemDataLink::send_association_msg(), and OpenDDS::DCPS::DataSampleHeader::split().

◆ GUID_UNKNOWN

const GUID_t OpenDDS::DCPS::GUID_UNKNOWN = { { 0 }, { { 0 }, 0 } }

Nil value for GUID.

Definition at line 60 of file GuidUtils.h.

◆ GUIDPREFIX_UNKNOWN

const GuidPrefix_t OpenDDS::DCPS::GUIDPREFIX_UNKNOWN = { 0 }

Nil value for the GUID prefix (participant identifier).

Definition at line 33 of file GuidUtils.h.

Referenced by OpenDDS::DCPS::RtpsUdpDataLink::build_meta_submessage_map(), OpenDDS::DCPS::RtpsUdpTransport::make_datalink(), OpenDDS::DCPS::RtpsSampleHeader::populate_data_sample_submessages(), OpenDDS::DCPS::RtpsUdpTransport::relay_stun_task(), and OpenDDS::DCPS::RtpsUdpTransport::RtpsUdpTransport().

◆ initial_bundle_size

const size_t OpenDDS::DCPS::initial_bundle_size = 32

Definition at line 91 of file RtpsUdpDataLink.h.

◆ initialize_inforepodisco

InfoRepoDiscovery::StaticInitializer OpenDDS::DCPS::initialize_inforepodisco

static

Definition at line 290 of file InfoRepoDiscovery.h.

◆ int16_cdr_size

const size_t OpenDDS::DCPS::int16_cdr_size = 2

Definition at line 79 of file Serializer.h.

Referenced by operator<<(), operator>>(), primitive_serialized_size(), OpenDDS::DCPS::Serializer::read_short_array(), and OpenDDS::DCPS::Serializer::write_short_array().

◆ int32_cdr_size

const size_t OpenDDS::DCPS::int32_cdr_size = 4

Definition at line 81 of file Serializer.h.

Referenced by OpenDDS::DCPS::DataSampleHeader::add_cfentries(), operator<<(), operator>>(), OpenDDS::DCPS::DataSampleHeader::partial(), primitive_serialized_size(), OpenDDS::DCPS::Serializer::read_long_array(), and OpenDDS::DCPS::Serializer::write_long_array().

◆ int64_cdr_size

const size_t OpenDDS::DCPS::int64_cdr_size = 8

Definition at line 83 of file Serializer.h.

Referenced by operator<<(), operator>>(), primitive_serialized_size(), OpenDDS::DCPS::Serializer::read_longlong_array(), and OpenDDS::DCPS::Serializer::write_longlong_array().

◆ int8_cdr_size

const size_t OpenDDS::DCPS::int8_cdr_size = 1

Definition at line 77 of file Serializer.h.

Referenced by operator<<(), operator>>(), primitive_serialized_size(), primitive_serialized_size_ulong(), OpenDDS::DCPS::Serializer::read_octet_array(), and OpenDDS::DCPS::Serializer::write_octet_array().

◆ INVALID_ENUM_VALUE

int const OpenDDS::DCPS::INVALID_ENUM_VALUE = 999

Definition at line 17 of file Marked_Default_Qos.cpp.

Referenced by OpenDDS::DCPS::Marked_Default_Qos::marked_default_DataReader_Use_TopicQos(), OpenDDS::DCPS::Marked_Default_Qos::marked_default_DataReaderQos(), OpenDDS::DCPS::Marked_Default_Qos::marked_default_DataWriter_Use_TopicQos(), OpenDDS::DCPS::Marked_Default_Qos::marked_default_DataWriterQos(), OpenDDS::DCPS::Marked_Default_Qos::marked_default_PublisherQos(), OpenDDS::DCPS::Marked_Default_Qos::marked_default_SubscriberQos(), and OpenDDS::DCPS::Marked_Default_Qos::marked_default_TopicQos().

◆ LOCATION_ICE

const ParticipantLocation OpenDDS::DCPS::LOCATION_ICE = 0x0001 << 1

Definition at line 35 of file OpenddsDcpsExt.idl.

Referenced by OpenDDS::RTPS::Spdp::process_location_updates_i(), OpenDDS::RTPS::Spdp::process_participant_ice(), OpenDDS::RTPS::Spdp::rtps_relay_only_now(), and OpenDDS::RTPS::Spdp::use_ice_now().

◆ LOCATION_ICE6

const ParticipantLocation OpenDDS::DCPS::LOCATION_ICE6 = 0x0001 << 4

Definition at line 38 of file OpenddsDcpsExt.idl.

Referenced by OpenDDS::RTPS::Spdp::process_location_updates_i(), OpenDDS::RTPS::Spdp::rtps_relay_only_now(), and OpenDDS::RTPS::Spdp::use_ice_now().

◆ LOCATION_LOCAL

const ParticipantLocation OpenDDS::DCPS::LOCATION_LOCAL = 0x0001 << 0

Definition at line 34 of file OpenddsDcpsExt.idl.

Referenced by OpenDDS::RTPS::Spdp::process_location_updates_i(), and OpenDDS::RTPS::Spdp::rtps_relay_only_now().

◆ LOCATION_LOCAL6

const ParticipantLocation OpenDDS::DCPS::LOCATION_LOCAL6 = 0x0001 << 3

Definition at line 37 of file OpenddsDcpsExt.idl.

Referenced by OpenDDS::RTPS::Spdp::process_location_updates_i(), and OpenDDS::RTPS::Spdp::rtps_relay_only_now().

◆ LOCATION_RELAY

const ParticipantLocation OpenDDS::DCPS::LOCATION_RELAY = 0x0001 << 2

Definition at line 36 of file OpenddsDcpsExt.idl.

Referenced by OpenDDS::RTPS::Spdp::process_location_updates_i(), and OpenDDS::RTPS::Spdp::use_rtps_relay_now().

◆ LOCATION_RELAY6

const ParticipantLocation OpenDDS::DCPS::LOCATION_RELAY6 = 0x0001 << 5

Definition at line 39 of file OpenddsDcpsExt.idl.

Referenced by OpenDDS::RTPS::Spdp::process_location_updates_i(), and OpenDDS::RTPS::Spdp::use_rtps_relay_now().

◆ LOCATOR_KIND_INVALID

const long OpenDDS::DCPS::LOCATOR_KIND_INVALID = -1

Definition at line 78 of file OpenddsDcpsExt.idl.

Referenced by address_to_locator().

◆ LOCATOR_KIND_RESERVED

const long OpenDDS::DCPS::LOCATOR_KIND_RESERVED = 0

Definition at line 79 of file OpenddsDcpsExt.idl.

◆ LOCATOR_KIND_UDPv4

const long OpenDDS::DCPS::LOCATOR_KIND_UDPv4 = 1

Definition at line 80 of file OpenddsDcpsExt.idl.

Referenced by address_to_locator(), and locator_to_address().

◆ LOCATOR_KIND_UDPv6

const long OpenDDS::DCPS::LOCATOR_KIND_UDPv6 = 2

Definition at line 81 of file OpenddsDcpsExt.idl.

Referenced by address_to_locator(), and locator_to_address().

◆ LOCATOR_PORT_INVALID

const unsigned long OpenDDS::DCPS::LOCATOR_PORT_INVALID = 0

Definition at line 82 of file OpenddsDcpsExt.idl.

Referenced by OpenDDS::DCPS::RtpsUdpReceiveStrategy::MessageReceiver::reset().

◆ log_bits

OpenDDS_Dcps_Export bool OpenDDS::DCPS::log_bits = false

Definition at line 18 of file Logging.cpp.

Referenced by OpenDDS::DCPS::BitSubscriber::add_i(), OpenDDS::RTPS::Spdp::enqueue_location_update_i(), OpenDDS::DCPS::Service_Participant::load_common_configuration(), OpenDDS::RTPS::Spdp::process_location_updates_i(), and OpenDDS::RTPS::Spdp::publish_location_update_i().

◆ log_level

OpenDDS_Dcps_Export LogLevel OpenDDS::DCPS::log_level

◆ MAX_READERS_PER_ELEM

const CORBA::ULong OpenDDS::DCPS::MAX_READERS_PER_ELEM = 5

Definition at line 26 of file DataSampleElement.h.

Referenced by OpenDDS::DCPS::DataSampleElement::DataSampleElement().

◆ MAX_READERS_TO_RESEND

const int OpenDDS::DCPS::MAX_READERS_TO_RESEND = 5

Definition at line 31 of file SendStateDataSampleList.h.

◆ MCK_RTPS

const MessageCountKind OpenDDS::DCPS::MCK_RTPS = 0

Definition at line 95 of file OpenddsDcpsExt.idl.

Referenced by OpenDDS::RTPS::Spdp::SpdpTransport::handle_input(), OpenDDS::DCPS::RtpsUdpReceiveStrategy::receive_bytes_helper(), OpenDDS::RTPS::Spdp::SpdpTransport::send(), and OpenDDS::DCPS::RtpsUdpSendStrategy::send_single_i().

◆ MCK_STUN

const MessageCountKind OpenDDS::DCPS::MCK_STUN = 1

Definition at line 96 of file OpenddsDcpsExt.idl.

Referenced by OpenDDS::RTPS::Spdp::SendStun::execute(), OpenDDS::RTPS::Spdp::SpdpTransport::handle_input(), OpenDDS::DCPS::RtpsUdpReceiveStrategy::receive_bytes_helper(), and OpenDDS::DCPS::RtpsUdpTransport::IceEndpoint::send().

◆ MONITOR_DOMAIN_ID

const long OpenDDS::DCPS::MONITOR_DOMAIN_ID = -999

Definition at line 13 of file monitor.idl.

Referenced by OpenDDS::DCPS::MonitorFactoryImpl::create_dp_monitor(), and OpenDDS::DCPS::MonitorFactoryImpl::initialize().

◆ MONITOR_TRANSPORT_ID

const long OpenDDS::DCPS::MONITOR_TRANSPORT_ID = 999

Definition at line 14 of file monitor.idl.

◆ multicast_init

MulticastInitializer OpenDDS::DCPS::multicast_init

static

Definition at line 24 of file Multicast.h.

◆ NO_STATUS_MASK

const DDS::StatusMask OpenDDS::DCPS::NO_STATUS_MASK = 0x00000000

Definition at line 322 of file DdsDcpsInfrastructure.idl.

Referenced by OpenDDS::DCPS::DataWriterImpl::cleanup(), and OpenDDS::DCPS::DataReaderImpl::cleanup().

◆ null_tqe_pair

OpenDDS_Dcps_Export const TqePair OpenDDS::DCPS::null_tqe_pair

Definition at line 23 of file TransportQueueElement.cpp.

Referenced by OpenDDS::DCPS::RtpsCustomizedElement::fragment(), OpenDDS::DCPS::TransportSendStrategy::fragmentation_helper(), OpenDDS::DCPS::TransportSendStrategy::get_packet_elems_from_queue(), and OpenDDS::DCPS::TransportSendStrategy::send().

◆ NUMBER_OF_BUILT_IN_TOPICS

const size_t OpenDDS::DCPS::NUMBER_OF_BUILT_IN_TOPICS = 7

Definition at line 50 of file BuiltInTopicUtils.h.

Referenced by OpenDDS::DCPS::SubscriberImpl::is_clean().

◆ ONE_SAMPLE_PER_PACKET

const size_t OpenDDS::DCPS::ONE_SAMPLE_PER_PACKET = 1

Definition at line 65 of file RtpsUdpDataLink.cpp.

◆ OpenDDS_Requires_MonitorFactory_Initializer

const int OpenDDS::DCPS::OpenDDS_Requires_MonitorFactory_Initializer

static

Initial value:

=

MonitorFactory::service_initialize()

Definition at line 96 of file MonitorFactory.h.

◆ OpenDDS_Requires_MonitorFactoryImpl_Initializer

int OpenDDS::DCPS::OpenDDS_Requires_MonitorFactoryImpl_Initializer

static

Initial value:

=

MonitorFactoryImpl::service_initialize()

Definition at line 97 of file MonitorFactoryImpl.h.

◆ PUBLISHER_MONITOR_TOPIC

const string OpenDDS::DCPS::PUBLISHER_MONITOR_TOPIC = "Publisher Monitor"

Definition at line 18 of file monitor.idl.

Referenced by OpenDDS::DCPS::MonitorFactoryImpl::initialize().

◆ REPO_SECTION_NAME

const ACE_TCHAR OpenDDS::DCPS::REPO_SECTION_NAME[] = ACE_TEXT("repository")

static

Definition at line 131 of file Service_Participant.cpp.

Referenced by OpenDDS::DCPS::InfoRepoDiscovery::Config::discovery_config(), OpenDDS::DCPS::InfoRepoDiscovery::removeDataWriterRemote(), and OpenDDS::DCPS::Service_Participant::set_repo_ior().

◆ RTPS_RELAY_STUN_PROTOCOL

const string OpenDDS::DCPS::RTPS_RELAY_STUN_PROTOCOL = "RtpsRelay:STUN"

Definition at line 60 of file OpenddsDcpsExt.idl.

Referenced by OpenDDS::DCPS::RtpsUdpTransport::disable_relay_stun_task(), OpenDDS::RTPS::Spdp::SpdpTransport::disable_relay_stun_task(), OpenDDS::DCPS::RtpsUdpTransport::process_relay_sra(), and OpenDDS::RTPS::Spdp::SpdpTransport::process_relay_sra().

◆ RTPS_SECTION_NAME

const ACE_TCHAR OpenDDS::DCPS::RTPS_SECTION_NAME[] = ACE_TEXT("rtps_discovery")

static

Definition at line 132 of file Service_Participant.cpp.

Referenced by OpenDDS::RTPS::RtpsDiscovery::Config::discovery_config(), OpenDDS::DCPS::Service_Participant::get_discovery(), and OpenDDS::RTPS::RtpsDiscovery::~RtpsDiscovery().

◆ rtps_udp_init

RtpsUdpInitializer OpenDDS::DCPS::rtps_udp_init

static

Definition at line 24 of file RtpsUdp.h.

◆ security_debug

OpenDDS_Dcps_Export SecurityDebug OpenDDS::DCPS::security_debug

Definition at line 32 of file debug.cpp.

◆ SERVICE_PARTICIPANT_MONITOR_TOPIC

const string OpenDDS::DCPS::SERVICE_PARTICIPANT_MONITOR_TOPIC = "Service Participant Monitor"

Definition at line 15 of file monitor.idl.

Referenced by OpenDDS::DCPS::MonitorFactoryImpl::initialize().

◆ shmem_init

ShmemInitializer OpenDDS::DCPS::shmem_init

static

Definition at line 24 of file Shmem.h.

◆ SUBSCRIBER_MONITOR_TOPIC

const string OpenDDS::DCPS::SUBSCRIBER_MONITOR_TOPIC = "Subscriber Monitor"

Definition at line 19 of file monitor.idl.

Referenced by OpenDDS::DCPS::MonitorFactoryImpl::initialize().

◆ tcp_initializer

Tcp_Initializer OpenDDS::DCPS::tcp_initializer

static

Definition at line 33 of file Tcp.h.

◆ TOPIC_MONITOR_TOPIC

const string OpenDDS::DCPS::TOPIC_MONITOR_TOPIC = "Topic Monitor"

Definition at line 17 of file monitor.idl.

Referenced by OpenDDS::DCPS::MonitorFactoryImpl::initialize().

◆ transport_debug

OpenDDS_Dcps_Export TransportDebug OpenDDS::DCPS::transport_debug

Definition at line 26 of file debug.cpp.

◆ Transport_debug_level

OpenDDS_Dcps_Export unsigned int OpenDDS::DCPS::Transport_debug_level = 0

Transport Logging verbosity level.

Definition at line 25 of file debug.cpp.

◆ TRANSPORT_MONITOR_TOPIC

const string OpenDDS::DCPS::TRANSPORT_MONITOR_TOPIC = "Transport Monitor"

Definition at line 24 of file monitor.idl.

Referenced by OpenDDS::DCPS::MonitorFactoryImpl::initialize().

◆ TRANSPORT_SECTION_NAME

const ACE_TCHAR OpenDDS::DCPS::TRANSPORT_SECTION_NAME[] = ACE_TEXT("transport")

static

Definition at line 186 of file TransportDefs.h.

Referenced by OpenDDS::DCPS::TransportRegistry::load_transport_configuration().

◆ TRANSPORT_TEMPLATE_SECTION_NAME

const ACE_TCHAR OpenDDS::DCPS::TRANSPORT_TEMPLATE_SECTION_NAME[] = ACE_TEXT("transport_template")

static

Definition at line 187 of file TransportDefs.h.

Referenced by OpenDDS::DCPS::TransportRegistry::load_transport_configuration(), and OpenDDS::DCPS::TransportRegistry::load_transport_templates().

◆ udp_init

UdpInitializer OpenDDS::DCPS::udp_init

static

Definition at line 24 of file Udp.h.

◆ uint16_cdr_size

const size_t OpenDDS::DCPS::uint16_cdr_size = 2

Definition at line 80 of file Serializer.h.

Referenced by operator<<(), operator>>(), primitive_serialized_size(), OpenDDS::DCPS::Serializer::read_ushort_array(), serialized_size_list_end_parameter_id(), serialized_size_parameter_id(), and OpenDDS::DCPS::Serializer::write_ushort_array().

◆ uint32_cdr_size

const size_t OpenDDS::DCPS::uint32_cdr_size = 4

Definition at line 82 of file Serializer.h.

Referenced by OpenDDS::Security::CryptoBuiltInImpl::decode_rtps_message(), operator<<(), operator>>(), OpenDDS::DCPS::Serializer::peek(), OpenDDS::RTPS::populate_locators(), primitive_serialized_size(), primitive_serialized_size_ulong(), OpenDDS::DCPS::Serializer::read_ulong_array(), serialized_size_list_end_parameter_id(), serialized_size_parameter_id(), OpenDDS::DCPS::Serializer::skip_delimiter(), OpenDDS::DCPS::Serializer::write_delimiter(), and OpenDDS::DCPS::Serializer::write_ulong_array().

◆ uint64_cdr_size

const size_t OpenDDS::DCPS::uint64_cdr_size = 8

Definition at line 84 of file Serializer.h.

Referenced by operator<<(), operator>>(), primitive_serialized_size(), OpenDDS::DCPS::Serializer::read_ulonglong_array(), and OpenDDS::DCPS::Serializer::write_ulonglong_array().

◆ uint8_cdr_size

const size_t OpenDDS::DCPS::uint8_cdr_size = 1

Definition at line 78 of file Serializer.h.

Referenced by operator<<(), operator>>(), primitive_serialized_size(), primitive_serialized_size_ulong(), OpenDDS::DCPS::Serializer::read_octet_array(), and OpenDDS::DCPS::Serializer::write_octet_array().

◆ UNALIGNED_CDR_DATA_REPRESENTATION

const DDS::DataRepresentationId_t OpenDDS::DCPS::UNALIGNED_CDR_DATA_REPRESENTATION = -12140

Definition at line 570 of file DdsDcpsCore.idl.

Referenced by QosCommon::get_data_presentation_id_kind(), dds::operator!=(), repr_to_encoding_kind(), repr_to_string(), set_reader_effective_data_rep_qos(), set_writer_effective_data_rep_qos(), OpenDDS::DCPS::DataWriterImpl::setup_serialization(), and OpenDDS::DCPS::Qos_Helper::valid().

◆ unknown_sequence_range

OpenDDS_Dcps_Export const SequenceRange OpenDDS::DCPS::unknown_sequence_range

Referenced by OpenDDS::DCPS::RtpsCustomizedElement::fragment(), and OpenDDS::DCPS::RtpsSampleHeader::split().

◆ VENDORID_OCI

const GuidVendorId_t OpenDDS::DCPS::VENDORID_OCI = { 0x01, 0x03 }

Vendor Id value specified for OCI is used for OpenDDS.

Definition at line 30 of file GuidUtils.h.

Referenced by OpenDDS::DCPS::EndpointRegistry::build_id(), OpenDDS::DCPS::GuidBuilder::create(), OpenDDS::RTPS::Spdp::fini_bit(), OpenDDS::RTPS::GuidGenerator::populate(), and OpenDDS::Security::CryptoBuiltInImpl::register_matched_remote_participant().

◆ xcdr1_pid_alignment

const size_t OpenDDS::DCPS::xcdr1_pid_alignment = 4

Definition at line 90 of file Serializer.h.

Referenced by OpenDDS::DCPS::Serializer::read_parameter_id(), serialized_size_list_end_parameter_id(), serialized_size_parameter_id(), OpenDDS::DCPS::Serializer::write_list_end_parameter_id(), and OpenDDS::DCPS::Serializer::write_parameter_id().

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ ActionConnectionRecord

◆ AstNode

◆ BundlingCache

◆ CoherencyGroup

◆ ConnectionInfoFlags

◆ ConnectionRecordDataReaderImpl

◆ ConstSample_rch

◆ DataBlockAllocator

◆ DataLink_rch

◆ DataLinkIdType

◆ DataLinkSet_rch

◆ DataReaderCallbacks_rch

◆ DataReaderCallbacks_wrch

◆ DataReaderImpl_rch

◆ DataSample

◆ DataSampleElementAllocator

◆ DataSampleHeaderAllocator

◆ DataWriterCallbacks_rch

◆ DataWriterCallbacks_wrch

◆ DataWriterImpl_rch

◆ DisassociationStatus

◆ Discovery_rch

◆ DispatchService_rch

◆ DRAssociations

◆ DRAssociationsPeriodic

◆ DWAssociations

◆ DWAssociationsPeriodic

◆ EntityKey_t

◆ EventBase_rch

◆ EventDispatcher_rch

◆ GuidCountSequence

◆ GuidPrefix_t

◆ GUIDSeq

◆ GuidVendorId_t

◆ InfoRepoDiscovery_rch

◆ InstanceState_rch

◆ InternalEntity_wrch

◆ InternalThreadBuiltinTopicDataDataReaderImpl

◆ JobQueue_rch

◆ JobQueue_wrch

◆ LatencyStatisticsSeq

◆ LocalObject_ptr

◆ LocalObject_var

◆ LocatorCache

◆ LocatorSeq

◆ MD5Result

◆ Message_Block_Ptr

◆ MessageBlockAllocator

◆ MessageCountKind

◆ MessageCountSequence

◆ MonotonicClock

◆ MonotonicTimePoint

◆ MulticastDataLink_rch

◆ MulticastInst_rch

◆ MulticastPeer

◆ MulticastReceiveStrategy_rch

◆ MulticastSendStrategy_rch

◆ MulticastSession_rch

◆ MulticastSessionFactory_rch

◆ MulticastTransport_rch

◆ NetworkConfigMonitor_rch

◆ NVPSeq

◆ Observer_rch

◆ ParticipantBuiltinTopicDataDataReaderImpl

◆ ParticipantId

◆ ParticipantLocation

◆ ParticipantLocationBuiltinTopicDataDataReaderImpl

◆ Priority

◆ PublicationBuiltinTopicDataDataReaderImpl

◆ PublicationDisconnectedStatus

◆ PublicationId

◆ PublicationInstance_rch

◆ PublicationReconnectedStatus