bdlat_symbolicconverter

Classes
struct	bdlat_SymbolicConverter
class	bdlat_SymbolicConverter_Imp
class	bdlat_SymbolicConverter_StoreValue< LVALUE_TYPE >
class	bdlat_SymbolicConverter_LoadValue< RVALUE_TYPE >
class	bdlat_SymbolicConverter_StoreInSequence< SEQUENCE_TYPE >
class	bdlat_SymbolicConverter_StoreInChoice< CHOICE_TYPE >
class	bdlat_SymbolicConverter_StoreInArrayElement< ARRAY_TYPE >
class	bdlat_SymbolicConverter_StoreInNullable< NULLABLE_TYPE >
struct	bdlat_SymbolicConverter_Imp_resolveDynamicRhsProxy< LHS_TYPE, LHS_CATEGORY >
	Component-private struct. Do not use. More...
struct	bdlat_SymbolicConverter_Imp_resolveDynamicLhsProxy< RHS_TYPE, RHS_CATEGORY >
	Component-private struct. Do not use. More...

Functions
template<class LHS_TYPE , class RHS_TYPE >
int	bdlat_SymbolicConverter_Imp::convert (LHS_TYPE *lhs, bdlat_TypeCategory::Sequence lhsCategory, const RHS_TYPE &rhs, bdlat_TypeCategory::Sequence rhsCategory)
	Convert to sequence from sequence.
template<class LHS_TYPE , class RHS_TYPE >
int	bdlat_SymbolicConverter_Imp::convert (LHS_TYPE *lhs, bdlat_TypeCategory::Choice lhsCategory, const RHS_TYPE &rhs, bdlat_TypeCategory::Choice rhsCategory)
	Convert to choice from choice.
template<class LHS_TYPE , class RHS_TYPE >
int	bdlat_SymbolicConverter_Imp::convert (LHS_TYPE *lhs, bdlat_TypeCategory::Array lhsCategory, const RHS_TYPE &rhs, bdlat_TypeCategory::Array rhsCategory)
	Convert to array from array.
template<class LHS_TYPE , class RHS_TYPE >
int	bdlat_SymbolicConverter_Imp::convert (LHS_TYPE *lhs, bdlat_TypeCategory::Enumeration lhsCategory, const RHS_TYPE &rhs, bdlat_TypeCategory::Enumeration rhsCategory)
	Convert to enum from enum.
template<class LHS_TYPE , class RHS_TYPE >
int	bdlat_SymbolicConverter_Imp::convert (LHS_TYPE *lhs, bdlat_TypeCategory::Enumeration lhsCategory, const RHS_TYPE &rhs, bdlat_TypeCategory::Simple rhsCategory)
	Convert to enum from simple type.
template<class LHS_TYPE , class RHS_TYPE >
int	bdlat_SymbolicConverter_Imp::convert (LHS_TYPE *lhs, bdlat_TypeCategory::Simple lhsCategory, const RHS_TYPE &rhs, bdlat_TypeCategory::Enumeration rhsCategory)
	Convert to simple type from enum.
template<class LHS_TYPE , class RHS_TYPE >
int	bdlat_SymbolicConverter_Imp::convert (LHS_TYPE *lhs, bdlat_TypeCategory::NullableValue lhsCategory, const RHS_TYPE &rhs, bdlat_TypeCategory::NullableValue rhsCategory)
	Convert to nullable from nullable.
template<class LHS_TYPE , class RHS_TYPE , class RHS_CATEGORY >
int	bdlat_SymbolicConverter_Imp::convert (LHS_TYPE *lhs, bdlat_TypeCategory::NullableValue lhsCategory, const RHS_TYPE &rhs, RHS_CATEGORY rhsCategory)
	Convert to nullable from non-nullable.
template<class LHS_TYPE , class LHS_CATEGORY , class RHS_TYPE >
int	bdlat_SymbolicConverter_Imp::convert (LHS_TYPE *lhs, LHS_CATEGORY lhsCategory, const RHS_TYPE &rhs, bdlat_TypeCategory::NullableValue rhsCategory)
	Convert to non-nullable from nullable.
template<class LHS_TYPE , class RHS_TYPE >
int	bdlat_SymbolicConverter_Imp::convert (LHS_TYPE *lhs, bdlat_TypeCategory::CustomizedType lhsCategory, const RHS_TYPE &rhs, bdlat_TypeCategory::NullableValue rhsCategory)
template<class LHS_TYPE , class RHS_TYPE >
int	bdlat_SymbolicConverter_Imp::convert (LHS_TYPE *lhs, bdlat_TypeCategory::CustomizedType lhsCategory, const RHS_TYPE &rhs, bdlat_TypeCategory::CustomizedType rhsCategory)
	Convert to customized from customized.
template<class LHS_TYPE , class RHS_TYPE , class RHS_CATEGORY >
int	bdlat_SymbolicConverter_Imp::convert (LHS_TYPE *lhs, bdlat_TypeCategory::CustomizedType lhsCategory, const RHS_TYPE &rhs, RHS_CATEGORY rhsCategory)
	Convert to customized from non-customized.
template<class LHS_TYPE , class LHS_CATEGORY , class RHS_TYPE >
int	bdlat_SymbolicConverter_Imp::convert (LHS_TYPE *lhs, LHS_CATEGORY lhsCategory, const RHS_TYPE &rhs, bdlat_TypeCategory::CustomizedType rhsCategory)
	Convert to non-customized from customized.
template<class LHS_TYPE , class RHS_TYPE >
int	bdlat_SymbolicConverter_Imp::convert (LHS_TYPE *lhs, bdlat_TypeCategory::NullableValue lhsCategory, const RHS_TYPE &rhs, bdlat_TypeCategory::CustomizedType rhsCategory)
template<class LHS_TYPE , class RHS_TYPE >
int	bdlat_SymbolicConverter_Imp::convert (LHS_TYPE *lhs, bdlat_TypeCategory::Simple lhsCategory, const RHS_TYPE &rhs, bdlat_TypeCategory::Simple rhsCategory)
template<class LHS_TYPE , class LHS_CATEGORY , class RHS_TYPE , class RHS_CATEGORY >
int	bdlat_SymbolicConverter_Imp::convert (LHS_TYPE *lhs, LHS_CATEGORY lhsCategory, const RHS_TYPE &rhs, RHS_CATEGORY rhsCategory)
template<class LHS_TYPE , class RHS_TYPE >
int	bdlat_SymbolicConverter_Imp::resolveDynamicTypes (LHS_TYPE *lhs, bdlat_TypeCategory::DynamicType lhsCategory, const RHS_TYPE &rhs, bdlat_TypeCategory::DynamicType rhsCategory)
	Resolve dynamic types.
template<class LHS_TYPE , class RHS_TYPE , class RHS_CATEGORY >
int	bdlat_SymbolicConverter_Imp::resolveDynamicTypes (LHS_TYPE *lhs, bdlat_TypeCategory::DynamicType lhsCategory, const RHS_TYPE &rhs, RHS_CATEGORY rhsCategory)
template<class LHS_TYPE , class LHS_CATEGORY , class RHS_TYPE >
int	bdlat_SymbolicConverter_Imp::resolveDynamicTypes (LHS_TYPE *lhs, LHS_CATEGORY lhsCategory, const RHS_TYPE &rhs, bdlat_TypeCategory::DynamicType rhsCategory)
template<class LHS_TYPE , class LHS_CATEGORY , class RHS_TYPE , class RHS_CATEGORY >
int	bdlat_SymbolicConverter_Imp::resolveDynamicTypes (LHS_TYPE *lhs, LHS_CATEGORY lhsCategory, const RHS_TYPE &rhs, RHS_CATEGORY rhsCategory)
	bdlat_SymbolicConverter_Imp::bdlat_SymbolicConverter_Imp (bsl::ostream *errorStream)
	Create the imp object.
template<class LHS_TYPE , class RHS_TYPE >
int	bdlat_SymbolicConverter_Imp::convert (LHS_TYPE *lhs, const RHS_TYPE &rhs)
	Implementation for convert function.
bsl::ostream &	bdlat_SymbolicConverter_Imp::errorStream ()
	Return a reference to the error stream.
	bdlat_SymbolicConverter_StoreValue< LVALUE_TYPE >::bdlat_SymbolicConverter_StoreValue (LVALUE_TYPE *destination, bdlat_SymbolicConverter_Imp *imp)
template<class RVALUE_TYPE , class INFO_TYPE >
int	bdlat_SymbolicConverter_StoreValue< LVALUE_TYPE >::operator() (const RVALUE_TYPE &object, const INFO_TYPE &) const
	Assign the specified object to *d_lValue_p.
template<class RVALUE_TYPE >
int	bdlat_SymbolicConverter_StoreValue< LVALUE_TYPE >::operator() (const RVALUE_TYPE &object) const
	Assign the specified object to *d_lValue_p.
	bdlat_SymbolicConverter_LoadValue< RVALUE_TYPE >::bdlat_SymbolicConverter_LoadValue (const RVALUE_TYPE &value, bdlat_SymbolicConverter_Imp *imp)
template<class LVALUE_TYPE , class INFO_TYPE >
int	bdlat_SymbolicConverter_LoadValue< RVALUE_TYPE >::operator() (LVALUE_TYPE *object, const INFO_TYPE &) const
	Assign d_value to the specified *object.
template<class LVALUE_TYPE >
int	bdlat_SymbolicConverter_LoadValue< RVALUE_TYPE >::operator() (LVALUE_TYPE *object) const
	Assign d_value to the specified *object.
	bdlat_SymbolicConverter_StoreInSequence< SEQUENCE_TYPE >::bdlat_SymbolicConverter_StoreInSequence (SEQUENCE_TYPE *destination, bdlat_SymbolicConverter_Imp *imp)
template<class SOURCE_MEMBER_TYPE , class INFO_TYPE >
int	bdlat_SymbolicConverter_StoreInSequence< SEQUENCE_TYPE >::operator() (const SOURCE_MEMBER_TYPE &sourceMember, const INFO_TYPE &info) const
	bdlat_SymbolicConverter_StoreInChoice< CHOICE_TYPE >::bdlat_SymbolicConverter_StoreInChoice (CHOICE_TYPE *destination, bdlat_SymbolicConverter_Imp *imp)
template<class SOURCE_MEMBER_TYPE , class INFO_TYPE >
int	bdlat_SymbolicConverter_StoreInChoice< CHOICE_TYPE >::operator() (const SOURCE_MEMBER_TYPE &sourceMember, const INFO_TYPE &info) const
	bdlat_SymbolicConverter_StoreInArrayElement< ARRAY_TYPE >::bdlat_SymbolicConverter_StoreInArrayElement (ARRAY_TYPE *array, int index, bdlat_SymbolicConverter_Imp *imp)
template<class SOURCE_ELEMENT_TYPE >
int	bdlat_SymbolicConverter_StoreInArrayElement< ARRAY_TYPE >::operator() (const SOURCE_ELEMENT_TYPE &sourceElement) const
	bdlat_SymbolicConverter_StoreInNullable< NULLABLE_TYPE >::bdlat_SymbolicConverter_StoreInNullable (NULLABLE_TYPE *destination, bdlat_SymbolicConverter_Imp *imp)
template<class VALUE_TYPE >
int	bdlat_SymbolicConverter_StoreInNullable< NULLABLE_TYPE >::operator() (const VALUE_TYPE &value) const
template<class LHS_TYPE , class RHS_TYPE >
static int	bdlat_SymbolicConverter::convert (LHS_TYPE *lhs, const RHS_TYPE &rhs)
template<class LHS_TYPE , class RHS_TYPE >
static int	bdlat_SymbolicConverter::convert (LHS_TYPE *lhs, const RHS_TYPE &rhs, bsl::ostream &errorStream)

Detailed Description

Outline

• Purpose
• Classes
• Description
  • Usage
    • Example 1: Basic Usage

Purpose

Provide a utility for convert types with matching member symbols.

Classes

• bdlat_SymbolicConverter: symbolic converter utility

See also

Description

The bdlat_SymbolicConverter utility provided by this component defines a single parameterized function convert. The convert function takes two arguments: a destination and a source object. The destination and source objects may be of different types.

Each type can fall into one of the following categories:

Category          Reference
--------          ---------
Sequence          bdlat_sequencefunctions
Choice            bdlat_choicefunctions
Array             bdlat_arrayfunctions
Enumeration       bdlat_enumfunctions
NullableValue     bdlat_nullablevaluefunctions
CustomizedType    bdlat_customizedtypefunctions
Simple            basic C++ fundamental types & other value-semantic types

The bdlat_SymbolicConverter utility converts from one type to another using the following criteria:

Destination Category  Source Category   Comments
--------------------  ---------------   --------
Sequence              Sequence          The conversion will fail if each
                                        attribute in the set of attributes
                                        from the source does not have a
                                        corresponding attribute (with the
                                        same name) in the destination.  The
                                        conversion will also fail if any
                                        attributes from the source fail to
                                        convert to the corresponding
                                        attribute in the destination.  Any
                                        attribute in the destination that
                                        does not have a corresponding
                                        attribute in the source will be set
                                        to its default value.
 
Choice                Choice            The conversion will fail if the
                                        destination does not have a
                                        selection with the same name as the
                                        current selection in the source.
                                        The conversion will also fail if
                                        the selection from the source fails
                                        to convert to the corresponding
                                        selection in the destination.  If
                                        nothing is selected in the source,
                                        then the destination will be reset.
 
Array                 Array             The conversion will fail if the
                                        elements in the source fail to
                                        convert to the elements in the
                                        destination.  Upon completion, the
                                        destination array will contain the
                                        same number of elements as the
                                        source array.
 
Enumeration           Enumeration       The conversion will fail if the
                                        destination does not have a string
                                        value that is identical to the
                                        string value of the source.
 
Enumeration           char/short/int    The conversion will fail if the
                                        destination does not have an
                                        enumerator with the numeric value
                                        of the source.
 
char/short/int        Enumeration       The conversion will fail if the
                                        numeric value of the enumeration is
                                        outside the bounds of the
                                        destination type.
 
Enumeration           bsl::string       The conversion will fail if the
                                        destination does not have an
                                        enumerator with the symbolic string
                                        name of the source.
 
bsl::string           Enumeration       This conversion always succeeds.
 
NullableValue         NullableValue     The conversion will fail if the
                                        source has a value that fails to
                                        convert to the destination value.
                                        If the source is null, then the
                                        destination is nulled.
 
NullableValue         AnyType           The conversion will fail if the
                                        source fails to convert to the
                                        destination value.
 
AnyType               NullableValue     The conversion will fail if the
                                        source is not null and the value in
                                        the source fails to convert to the
                                        destination.  If the source is
                                        null, then the destination will
                                        be set to its default value.
 
CustomizedType        CustomizedType    The conversion will fail if the
                                        base value in the source fails to
                                        convert to the base value in the
                                        destination and the base value is
                                        able to convert to the customized
                                        value.
 
CustomizedType        AnyType           The conversion will fail if the
                                        source fails to convert to the base
                                        value in the destination and the
                                        base value is able to convert to
                                        the customized value.
 
AnyType               CustomizedType    The conversion will fail if the
                                        base value in the source fails to
                                        convert to the destination.
 
SimpleType            SimpleType        The conversion will fail if there
                                        is no accessible compile-time
                                        assignment operator from the
                                        destination to the source.  This is
                                        determined using
                                        'bslmf_isconvertible'.

Any other combination of destination and source categories will fail to convert.

Usage

This section illustrates intended use of this component.

Example 1: Basic Usage

This component can be used with types supported by the bdlat framework. In particular, types generated by the bas_codegen.pl tool can be used. For example, suppose we have the following XML schema inside a file called xsdfile.xsd:

<?xml version='1.0' encoding='UTF-8'?>
<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'
           xmlns:bdem='http://bloomberg.com/schemas/bdem'
           elementFormDefault='unqualified'>
 
    <xs:complexType name='Employee'>
        <xs:sequence>
            <xs:element name='Name'   type='string'/>
            <xs:element name='Dept'   type='string'/>
            <xs:element name='Age'    type='int'/>
            <xs:element name='Salary' type='float'/>
        </xs:sequence>
    </xs:complexType>
 
    <xs:complexType name='Trainee'>
        <xs:sequence>
            <xs:element name='Name' type='string'/>
            <xs:element name='Dept' type='string'/>
            <xs:element name='Age'  type='int'/>
        </xs:sequence>
    </xs:complexType>
 
</xs:schema>

Using the bas_codegen.pl tool, we can generate C++ classes for this schema:

$ bas_codegen.pl -g h -g cpp -p test xsdfile.xsd

This tool will generate the header and implementation files for the test_employee and test_trainee components in the current directory.

Now suppose we want to create a hireTrainee function, that converts a trainee to an employee. Such a function could be written as follows:

#include <test_employee.h>
#include <test_trainee.h>
 
#include <bdlat_symbolicconverter.h>
 
using namespace BloombergLP;
 
int hireTrainee(test::Employee       *result,
                const test::Trainee&  trainee,
                float                 salary)
{
    int retCode = bdlat_SymbolicConverter::convert(result, trainee);
 
    result->salary() = salary;
 
    return retCode;
}

The hireTrainee function can be used as follows:

void usageExample()
{
    test::Trainee trainee;
 
    trainee.name() = "Bob";
    trainee.dept() = "RnD";
    trainee.age()  = 24;
 
    test::Employee employee;
 
    int result = hireTrainee(&employee, trainee, 20000.00f);
 
    assert(0         == result);
    assert("Bob"     == employee.name());
    assert("RnD"     == employee.dept());
    assert(24        == employee.age());
    assert(20000.00f == employee.salary());
}

Function Documentation

bdlat_SymbolicConverter_Imp()

bdlat_SymbolicConverter_Imp::bdlat_SymbolicConverter_Imp ( bsl::ostream *  errorStream )

inline

bdlat_SymbolicConverter_LoadValue()

template<class RVALUE_TYPE >

bdlat_SymbolicConverter_LoadValue< RVALUE_TYPE >::bdlat_SymbolicConverter_LoadValue ( const RVALUE_TYPE &  value, bdlat_SymbolicConverter_Imp *  imp  )

inlineexplicit

bdlat_SymbolicConverter_StoreInArrayElement()

template<class ARRAY_TYPE >

bdlat_SymbolicConverter_StoreInArrayElement< ARRAY_TYPE >::bdlat_SymbolicConverter_StoreInArrayElement ( ARRAY_TYPE *  array, int  index, bdlat_SymbolicConverter_Imp *  imp  )

inline

bdlat_SymbolicConverter_StoreInChoice()

template<class CHOICE_TYPE >

bdlat_SymbolicConverter_StoreInChoice< CHOICE_TYPE >::bdlat_SymbolicConverter_StoreInChoice ( CHOICE_TYPE *  destination, bdlat_SymbolicConverter_Imp *  imp  )

inlineexplicit

bdlat_SymbolicConverter_StoreInNullable()

template<class NULLABLE_TYPE >

bdlat_SymbolicConverter_StoreInNullable< NULLABLE_TYPE >::bdlat_SymbolicConverter_StoreInNullable ( NULLABLE_TYPE *  destination, bdlat_SymbolicConverter_Imp *  imp  )

inlineexplicit

bdlat_SymbolicConverter_StoreInSequence()

template<class SEQUENCE_TYPE >

bdlat_SymbolicConverter_StoreInSequence< SEQUENCE_TYPE >::bdlat_SymbolicConverter_StoreInSequence ( SEQUENCE_TYPE *  destination, bdlat_SymbolicConverter_Imp *  imp  )

inlineexplicit

bdlat_SymbolicConverter_StoreValue()

template<class LVALUE_TYPE >

bdlat_SymbolicConverter_StoreValue< LVALUE_TYPE >::bdlat_SymbolicConverter_StoreValue ( LVALUE_TYPE *  destination, bdlat_SymbolicConverter_Imp *  imp  )

inlineexplicit

convert() [1/19]

template<class LHS_TYPE , class RHS_TYPE >

int bdlat_SymbolicConverter_Imp::convert	(	LHS_TYPE *	lhs,
		bdlat_TypeCategory::Array	lhsCategory,
		const RHS_TYPE &	rhs,
		bdlat_TypeCategory::Array	rhsCategory
	)

convert() [2/19]

template<class LHS_TYPE , class RHS_TYPE >

int bdlat_SymbolicConverter_Imp::convert	(	LHS_TYPE *	lhs,
		bdlat_TypeCategory::Choice	lhsCategory,
		const RHS_TYPE &	rhs,
		bdlat_TypeCategory::Choice	rhsCategory
	)

convert() [3/19]

template<class LHS_TYPE , class RHS_TYPE >

int bdlat_SymbolicConverter_Imp::convert ( LHS_TYPE *  lhs, bdlat_TypeCategory::CustomizedType  lhsCategory, const RHS_TYPE &  rhs, bdlat_TypeCategory::CustomizedType  rhsCategory  )

inline

convert() [4/19]

template<class LHS_TYPE , class RHS_TYPE >

int bdlat_SymbolicConverter_Imp::convert	(	LHS_TYPE *	lhs,
		bdlat_TypeCategory::CustomizedType	lhsCategory,
		const RHS_TYPE &	rhs,
		bdlat_TypeCategory::NullableValue	rhsCategory
	)

Convert to customized type from nullable. Note that this overload is required to resolve ambiguities when there are nullable and customized types in the same sequence.

convert() [5/19]

template<class LHS_TYPE , class RHS_TYPE , class RHS_CATEGORY >

int bdlat_SymbolicConverter_Imp::convert	(	LHS_TYPE *	lhs,
		bdlat_TypeCategory::CustomizedType	lhsCategory,
		const RHS_TYPE &	rhs,
		RHS_CATEGORY	rhsCategory
	)

convert() [6/19]

template<class LHS_TYPE , class RHS_TYPE >

int bdlat_SymbolicConverter_Imp::convert ( LHS_TYPE *  lhs, bdlat_TypeCategory::Enumeration  lhsCategory, const RHS_TYPE &  rhs, bdlat_TypeCategory::Enumeration  rhsCategory  )

inline

convert() [7/19]

template<class LHS_TYPE , class RHS_TYPE >

int bdlat_SymbolicConverter_Imp::convert ( LHS_TYPE *  lhs, bdlat_TypeCategory::Enumeration  lhsCategory, const RHS_TYPE &  rhs, bdlat_TypeCategory::Simple  rhsCategory  )

inline

convert() [8/19]

template<class LHS_TYPE , class RHS_TYPE >

int bdlat_SymbolicConverter_Imp::convert ( LHS_TYPE *  lhs, bdlat_TypeCategory::NullableValue  lhsCategory, const RHS_TYPE &  rhs, bdlat_TypeCategory::CustomizedType  rhsCategory  )

inline

Convert to nullable from customized. Note that this overload is required to resolve ambiguities when there are nullable and customized types in the same sequence.

convert() [9/19]

template<class LHS_TYPE , class RHS_TYPE >

int bdlat_SymbolicConverter_Imp::convert	(	LHS_TYPE *	lhs,
		bdlat_TypeCategory::NullableValue	lhsCategory,
		const RHS_TYPE &	rhs,
		bdlat_TypeCategory::NullableValue	rhsCategory
	)

convert() [10/19]

template<class LHS_TYPE , class RHS_TYPE , class RHS_CATEGORY >

int bdlat_SymbolicConverter_Imp::convert ( LHS_TYPE *  lhs, bdlat_TypeCategory::NullableValue  lhsCategory, const RHS_TYPE &  rhs, RHS_CATEGORY  rhsCategory  )

inline

convert() [11/19]

template<class LHS_TYPE , class RHS_TYPE >

int bdlat_SymbolicConverter_Imp::convert ( LHS_TYPE *  lhs, bdlat_TypeCategory::Sequence  lhsCategory, const RHS_TYPE &  rhs, bdlat_TypeCategory::Sequence  rhsCategory  )

inline

convert() [12/19]

template<class LHS_TYPE , class RHS_TYPE >

int bdlat_SymbolicConverter_Imp::convert ( LHS_TYPE *  lhs, bdlat_TypeCategory::Simple  lhsCategory, const RHS_TYPE &  rhs, bdlat_TypeCategory::Enumeration  rhsCategory  )

inline

convert() [13/19]

template<class LHS_TYPE , class RHS_TYPE >

int bdlat_SymbolicConverter_Imp::convert ( LHS_TYPE *  lhs, bdlat_TypeCategory::Simple  lhsCategory, const RHS_TYPE &  rhs, bdlat_TypeCategory::Simple  rhsCategory  )

inline

Convert to simple from simple of the same type. Note that this just evaluates to an assignment using the assignment operator.

convert() [14/19]

template<class LHS_TYPE , class RHS_TYPE >

int bdlat_SymbolicConverter::convert ( LHS_TYPE *  lhs, const RHS_TYPE &  rhs  )

inlinestatic

Convert the value of the specified rhs object to the specified (modifiable) lhs object. Optionally specify an errorStream to print error messages. Return 0 on success and a non-zero value otherwise. The supported conversions are described in the bdlat_symbolicconverter component-level documentation.

convert() [15/19]

template<class LHS_TYPE , class RHS_TYPE >

int bdlat_SymbolicConverter_Imp::convert ( LHS_TYPE *  lhs, const RHS_TYPE &  rhs  )

inline

convert() [16/19]

template<class LHS_TYPE , class RHS_TYPE >

int bdlat_SymbolicConverter::convert ( LHS_TYPE *  lhs, const RHS_TYPE &  rhs, bsl::ostream &  errorStream  )

inlinestatic

convert() [17/19]

template<class LHS_TYPE , class LHS_CATEGORY , class RHS_TYPE >

int bdlat_SymbolicConverter_Imp::convert ( LHS_TYPE *  lhs, LHS_CATEGORY  lhsCategory, const RHS_TYPE &  rhs, bdlat_TypeCategory::CustomizedType  rhsCategory  )

inline

convert() [18/19]

template<class LHS_TYPE , class LHS_CATEGORY , class RHS_TYPE >

int bdlat_SymbolicConverter_Imp::convert	(	LHS_TYPE *	lhs,
		LHS_CATEGORY	lhsCategory,
		const RHS_TYPE &	rhs,
		bdlat_TypeCategory::NullableValue	rhsCategory
	)

convert() [19/19]

template<class LHS_TYPE , class LHS_CATEGORY , class RHS_TYPE , class RHS_CATEGORY >

int bdlat_SymbolicConverter_Imp::convert ( LHS_TYPE *  lhs, LHS_CATEGORY  lhsCategory, const RHS_TYPE &  rhs, RHS_CATEGORY  rhsCategory  )

inline

No match found. This function does nothing, it just returns a FAILURE code (to be used to detect type-mismatch at runtime).

errorStream()

bsl::ostream & bdlat_SymbolicConverter_Imp::errorStream ( )

inline

operator()() [1/8]

template<class LVALUE_TYPE >

template<class RVALUE_TYPE >

int bdlat_SymbolicConverter_StoreValue< LVALUE_TYPE >::operator() ( const RVALUE_TYPE &  object ) const

inline

operator()() [2/8]

template<class LVALUE_TYPE >

template<class RVALUE_TYPE , class INFO_TYPE >

int bdlat_SymbolicConverter_StoreValue< LVALUE_TYPE >::operator() ( const RVALUE_TYPE &  object, const INFO_TYPE &    ) const

inline

operator()() [3/8]

template<class ARRAY_TYPE >

template<class SOURCE_ELEMENT_TYPE >

int bdlat_SymbolicConverter_StoreInArrayElement< ARRAY_TYPE >::operator() ( const SOURCE_ELEMENT_TYPE &  sourceElement ) const

inline

operator()() [4/8]

template<class SEQUENCE_TYPE >

template<class SOURCE_MEMBER_TYPE , class INFO_TYPE >

int bdlat_SymbolicConverter_StoreInSequence< SEQUENCE_TYPE >::operator() ( const SOURCE_MEMBER_TYPE &  sourceMember, const INFO_TYPE &  info  ) const

inline

operator()() [5/8]

template<class CHOICE_TYPE >

template<class SOURCE_MEMBER_TYPE , class INFO_TYPE >

int bdlat_SymbolicConverter_StoreInChoice< CHOICE_TYPE >::operator()	(	const SOURCE_MEMBER_TYPE &	sourceMember,
		const INFO_TYPE &	info
	)		const

operator()() [6/8]

template<class NULLABLE_TYPE >

template<class VALUE_TYPE >

int bdlat_SymbolicConverter_StoreInNullable< NULLABLE_TYPE >::operator() ( const VALUE_TYPE &  value ) const

inline

operator()() [7/8]

template<class RVALUE_TYPE >

template<class LVALUE_TYPE >

int bdlat_SymbolicConverter_LoadValue< RVALUE_TYPE >::operator() ( LVALUE_TYPE *  object ) const

inline

operator()() [8/8]

template<class RVALUE_TYPE >

template<class LVALUE_TYPE , class INFO_TYPE >

int bdlat_SymbolicConverter_LoadValue< RVALUE_TYPE >::operator() ( LVALUE_TYPE *  object, const INFO_TYPE &    ) const

inline

resolveDynamicTypes() [1/4]

template<class LHS_TYPE , class RHS_TYPE >

int bdlat_SymbolicConverter_Imp::resolveDynamicTypes ( LHS_TYPE *  lhs, bdlat_TypeCategory::DynamicType  lhsCategory, const RHS_TYPE &  rhs, bdlat_TypeCategory::DynamicType  rhsCategory  )

inline

resolveDynamicTypes() [2/4]

template<class LHS_TYPE , class RHS_TYPE , class RHS_CATEGORY >

int bdlat_SymbolicConverter_Imp::resolveDynamicTypes ( LHS_TYPE *  lhs, bdlat_TypeCategory::DynamicType  lhsCategory, const RHS_TYPE &  rhs, RHS_CATEGORY  rhsCategory  )

inline

resolveDynamicTypes() [3/4]

template<class LHS_TYPE , class LHS_CATEGORY , class RHS_TYPE >

int bdlat_SymbolicConverter_Imp::resolveDynamicTypes ( LHS_TYPE *  lhs, LHS_CATEGORY  lhsCategory, const RHS_TYPE &  rhs, bdlat_TypeCategory::DynamicType  rhsCategory  )

inline

resolveDynamicTypes() [4/4]

template<class LHS_TYPE , class LHS_CATEGORY , class RHS_TYPE , class RHS_CATEGORY >

int bdlat_SymbolicConverter_Imp::resolveDynamicTypes ( LHS_TYPE *  lhs, LHS_CATEGORY  lhsCategory, const RHS_TYPE &  rhs, RHS_CATEGORY  rhsCategory  )

inline