bdlat_customizedtypefunctions

Detailed Description

Provide a namespace defining customized type functions.

Outline

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

Purpose

Provide a namespace defining customized type functions.

Classes

• bdlat_CustomizedTypeFunctions: namespace for customized type functions

See also

Description

The bdlat_CustomizedTypeFunctions namespace provided in this component defines parameterized functions that expose "customized type" behavior for "customized type" types. See the package-level documentation for a brief description of "customized type" types.

The functions in this namespace allow users to:

• convert from base type to customized type (convertFromBaseType).
• convert from customized type to base type (convertToBaseType).

Also, the meta-function IsCustomizedType contains a compile-time constant value that is non-zero if the parameterized TYPE exposes "customized type" behavior through the bdlat_CustomizedTypeFunctions namespace.

The BaseType meta-function contains a typedef Type that specifies the base type of the value for the parameterized "customized type" type.

This component specializes all of these functions for types that have the bdlat_TypeTraitBasicCustomizedType trait.

Types that do not have the bdlat_TypeTraitBasicCustomizedType trait can be plugged into the bdlat framework. This is done by overloading the bdlat_customizedType* functions inside the namespace of the plugged in type. Note that the placeholders YOUR_TYPE and BASE_TYPE are not template arguments. The former should be replaced with the name of the type being plugged into the framework. The latter is a type defined by the above-mentioned BaseType meta-function for YOUR_TYPE.

// MANIPULATORS
 
/// Convert from the specified `value` to the specified customized `object`.
/// Return 0 if successful and non-zero otherwise.
int bdlat_customizedTypeConvertFromBaseType(YOUR_TYPE        *object,
                                            const BASE_TYPE&  value);
 
// ACCESSORS
 
/// Load into the specified `result` the value of the specified `object`.
const BASE_TYPE& bdlat_customizedTypeConvertToBaseType(
                                                   const YOUR_TYPE& object);

Also, the IsCustomizedType meta-function must be specialized for the YOUR_TYPE type in the bdlat_CustomizedTypeFunctions namespace.

Usage

This section illustrates intended use of this component.

Example 1: Basic Usage

Suppose we have a customized type called Cusip, holding an object of type bsl::string with a restriction that the length of the string cannot be longer than nine characters. We can obtain the value of the string using the following code:

mine::Cusip myCusip("281C82UE");
bsl::string base = bdlat_CustomizedTypeFunctions::convertToBaseType(
                                                                   myCusip);
 
assert("281C82UE" == base);

Attempting to assign a string longer than nine characters will not succeed:

bsl::string invalidCusip = "1234567890";
 
int retCode = bdlat_CustomizedTypeFunctions::convertFromBaseType(
                                                              &myCusip,
                                                              invalidCusip);
assert(0 != retCode);

For the purpose of this example, the class definition is as follows:

#include <bdlat_customizedtypefunctions.h>
#include <bdlb_string.h>
#include <bsls_assert.h>
#include <sstream>
#include <string>
 
namespace BloombergLP {
namespace mine {
 
/// Identification number for the US and Canada.  It is a 9-digit number
/// consisting of 8 digits and a check digit.  The Bloomberg ID will be
/// returned for Corp, Govt, Pfd if a CUSIP is not available.
class Cusip {
  private:
    // PRIVATE DATA MEMBERS
    bsl::string d_value;  // stored value
 
    // FRIENDS
    friend bool operator==(const Cusip& lhs, const Cusip& rhs);
    friend bool operator!=(const Cusip& lhs, const Cusip& rhs);
  public:
    // TYPES
    typedef bsl::string BaseType;
 
    // CREATORS
 
    /// Create an object of type `Cusip` having the default value.
    /// Optionally specify a `basicAllocator` used to supply memory.  If
    /// `basicAllocator` is 0, the currently installed default allocator is
    /// used.
    explicit Cusip(bslma::Allocator *basicAllocator = 0);
 
    /// Create an object of type `Cusip` having the value of the specified
    /// `original` object.  Optionally specify a `basicAllocator` used to
    /// supply memory.  If `basicAllocator` is 0, the currently installed
    /// default allocator is used.
    Cusip(const Cusip& original, bslma::Allocator *basicAllocator = 0);
 
    /// Create an object of type `Cusip` having the specified `value`.
    /// Optionally specify a `basicAllocator` used to supply memory.  If
    /// `basicAllocator` is 0, the currently installed default allocator is
    /// used.
    explicit Cusip(const bsl::string&  value,
                   bslma::Allocator   *basicAllocator = 0);
 
    /// Destroy this object.
    ~Cusip();
 
    // MANIPULATORS
 
    /// Assign to this object the value of the specified `rhs` object.
    Cusip& operator=(const Cusip& rhs);
 
    /// Reset this object to the default value (i.e., its value upon default
    /// construction).
    void reset();
 
    /// Convert from the specified `value` to this type.  Return 0 if
    /// successful and non-zero otherwise.
    int fromString(const bsl::string& value);
 
    // ACCESSORS
 
    /// Format this object to the specified output `stream` at the
    /// optionally specified indentation `level` and return a reference to
    /// the modifiable `stream`.  If `level` is specified, optionally
    /// specify `spacesPerLevel`, the number of spaces per indentation level
    /// for this and all of its nested objects.  Each line is indented by
    /// the absolute value of `level * spacesPerLevel`.  If `level` is
    /// negative, suppress indentation of the first line.  If
    /// `spacesPerLevel` is negative, suppress line breaks and format the
    /// entire output on one line.  If `stream` is initially invalid, this
    /// operation has no effect.  Note that a trailing newline is provided
    /// in multiline mode only.
    bsl::ostream& print(bsl::ostream& stream,
                        int           level = 0,
                        int           spacesPerLevel = 4) const;
 
    /// Convert this value to `bsl::string`.
    const bsl::string& toString() const;
};
 
// FREE OPERATORS
 
/// Return `true` if the specified `lhs` and `rhs` attribute objects have
/// the same value, and `false` otherwise.  Two attribute objects have the
/// same value if each respective attribute has the same value.
bool operator==(const Cusip& lhs, const Cusip& rhs);
 
/// Return `true` if the specified `lhs` and `rhs` attribute objects do not
/// have the same value, and `false` otherwise.  Two attribute objects do
/// not have the same value if one or more respective attributes differ in
/// values.
bool operator!=(const Cusip& lhs, const Cusip& rhs);
 
/// Format the specified `rhs` to the specified output `stream` and return a
/// reference to the modifiable `stream`.
bsl::ostream& operator<<(bsl::ostream& stream, const Cusip& rhs);

The class implementation is straightforward and is deferred to the end of this usage example.

We can now make Cusip expose "customized type" behavior by implementing bdlat_CustomizedTypeFunctions for Cusip. The first method (the longer one) overloads all the bdlat_customizedType* functions. In the second method, we show how to bypass this by simply declaring the class mine::Cusip to have the bdlat_TypeTraitBasicCustomizedType trait.

Longer Usage

First, we should forward declare all the functions that we will implement inside the mine namespace:

// MANIPULATORS
 
/// Convert from the specified `value` to the specified customized `object`.
///  Return 0 if successful and non-zero otherwise.
int bdlat_customizedTypeConvertFromBaseType(Cusip              *object,
                                            const bsl::string&  value);
 
// ACCESSORS
 
/// Load into the specified `result` the value of the specified `object`.
const bsl::string& bdlat_customizedTypeConvertToBaseType(
                                                       const Cusip& object);

Next, we provide the definitions for each of these functions:

// MANIPULATORS
int bdlat_customizedTypeConvertFromBaseType(Cusip              *object,
                                            const bsl::string&  value)
{
    return object->fromString(value);
}
 
// ACCESSORS
const bsl::string& bdlat_customizedTypeConvertToBaseType(
                                                        const Cusip& object)
{
    return object.toString();
}
 
}  // close namespace mine

Finally, we need to specialize the IsCustomizedType meta-function in the bdlat_CustomizedTypeFunctions namespace for the mine::Cusip type. This makes the bdlat infrastructure recognize mine::Cusip as a customized type abstraction:

namespace bdlat_CustomizedTypeFunctions {
 
    template <>
    struct IsCustomizedType<mine::Cusip> : bsl::true_type {
    };
 
    template <>
    struct BaseType<mine::Cusip> {
        typedef bsl::string Type;
    };
 
}  // close namespace bdlat_CustomizedTypeFunctions
}  // close namespace BloombergLP

The bdlat infrastructure (and any component that uses this infrastructure) will now recognize mine::Cusip as a "customized" type.

Shorter Usage

We can bypass all the code from the longer usage example by simply declaring mine::Cusip to have the bdlat_TypeTraitBasicCustomizedType trait as follows:

namespace BloombergLP {
 
// TRAITS
 
BDLAT_DECL_CUSTOMIZEDTYPE_WITH_ALLOCATOR_TRAITS(mine::Cusip)
 
}  // close namespace BloombergLP

Again, the bdlat infrastructure (and any component that uses this infrastructure) will now recognize mine::Cusip as a "customized" type.

For example, suppose we have the following XML data:

<?xml version='1.0' encoding='UTF-8' ?>
<Cusip>
    <value>"281C82UE"</value>
</Cusip>

Using the balxml_decoder component, we can load this XML data into a mine::Cusip object:

#include <balxml_decoder.h>
 
void decodeMyCustomizedTypeFromXML(bsl::istream& inputData)
{
    Cusip object;
 
    balxml::DecoderOptions options;
    balxml::MiniReader     reader;
    balxml::ErrorInfo      errInfo;
 
    balxml::Decoder decoder(&options, &reader, &errInfo);
    int result = decoder.decode(inputData, &object);
 
    assert(0          == result);
    assert("281C82UE" == object.toString());
}

Note that the bdlat framework can be used for functionality other than encoding/decoding into XML. When mine::Cusip is plugged into the framework, then it will be automatically usable within the framework. For example, the following snippets of code will convert a string from a stream and load it into a Cusip object:

int readCusip(bsl::istream& stream, mine::Cusip *cusip)
{
    bsl::string value;
    stream >> value;
 
    return bdlat_CustomizedTypeFunctions::convertFromBaseType(cusip, value);
}

Now we have a generic function that takes an input stream and a Cusip object, and inputs its value. We can use this generic function as follows:

void usageExample()
{
    bsl::stringstream ss;
    mine::Cusip object;
 
    ss << "281C82UE\n1234567890\n";
 
    assert(0          == readCusip(ss, &object));
    assert("281C82UE" == object.toString());
 
    assert(0          != readCusip(ss, &object));
}

This concludes the usage example.

For completeness, we finish by providing the straightforward details of the implementation of the class Cusip:

namespace BloombergLP {
namespace mine {
 
// CREATORS
 
inline
Cusip::Cusip(bslma::Allocator *basicAllocator)
: d_value(basicAllocator)
{
}
 
inline
Cusip::Cusip(const Cusip& original, bslma::Allocator *basicAllocator)
: d_value(original.d_value, basicAllocator)
{
}
 
inline
Cusip::Cusip(const bsl::string& value, bslma::Allocator *basicAllocator)
: d_value(value, basicAllocator)
{
}
 
inline
Cusip::~Cusip()
{
}
 
// MANIPULATORS
 
inline
Cusip& Cusip::operator=(const Cusip& rhs)
{
    d_value = rhs.d_value;
    return *this;
}
 
inline
void Cusip::reset()
{
    // bdlat_ValueTypeFunctions::reset(&d_value);
    d_value.erase();
}
 
inline
int Cusip::fromString(const bsl::string& value)
{
    enum { SUCCESS = 0, FAILURE = -1 };
 
    globalFlag = 1;
 
    if (9 < value.size()) {
        return FAILURE;
    }
 
    d_value = value;
 
    return SUCCESS;
}
 
// ACCESSORS
 
inline
bsl::ostream& Cusip::print(bsl::ostream& stream,
                           int           level,
                           int           spacesPerLevel) const
{
    return bdlb::PrintMethods::print(stream,
                                    d_value,
                                    level,
                                    spacesPerLevel);
}
 
inline
const bsl::string& Cusip::toString() const
{
    globalFlag = 2;
 
    return d_value;
}
 
// FREE OPERATORS
 
inline
bool operator==(const Cusip& lhs, const Cusip& rhs)
{
    return lhs.d_value == rhs.d_value;
}
 
inline
bool operator!=(const Cusip& lhs, const Cusip& rhs)
{
    return lhs.d_value != rhs.d_value;
}
 
inline
bsl::ostream& operator<<(bsl::ostream& stream, const Cusip& rhs)
{
    return rhs.print(stream, 0, -1);
}
 
}  // close namespace mine
}  // close namespace BloombergLP

Classes
struct	bdlat_CustomizedTypeFunctions_Imp

Functions
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, bool value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, int value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, char value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, short value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, bsls::Types::Int64 value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, unsigned int value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, unsigned char value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, unsigned short value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, bsls::Types::Uint64 value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, float value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, double value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, const bdlt::Date &value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, const bdlt::DateTz &value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, const bdlt::Datetime &value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, const bdlt::DatetimeTz &value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, const bdlt::Time &value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, const bdlt::TimeTz &value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, const bsl::string &value)
template<class TYPE >
static int	bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType (TYPE *object, const bsl::vector< char > &value)
template<class TYPE >
static const bool &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, bool *)
template<class TYPE >
static const int &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, int *)
template<class TYPE >
static const char &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, char *)
template<class TYPE >
static const short &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, short *)
template<class TYPE >
static const bsls::Types::Int64 &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, bsls::Types::Int64 *)
template<class TYPE >
static const unsigned int &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, unsigned int *)
template<class TYPE >
static const unsigned char &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, unsigned char *)
template<class TYPE >
static const unsigned short &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, unsigned short *)
template<class TYPE >
static const bsls::Types::Uint64 &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, bsls::Types::Uint64 *)
template<class TYPE >
static const float &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, float *)
template<class TYPE >
static const double &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, double *)
template<class TYPE >
static const bdlt::Date &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, bdlt::Date *)
template<class TYPE >
static const bdlt::DateTz &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, bdlt::DateTz *)
template<class TYPE >
static const bdlt::Datetime &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, bdlt::Datetime *)
template<class TYPE >
static const bdlt::DatetimeTz &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, bdlt::DatetimeTz *)
template<class TYPE >
static const bdlt::Time &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, bdlt::Time *)
template<class TYPE >
static const bdlt::TimeTz &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, bdlt::TimeTz *)
template<class TYPE >
static const bsl::string &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, bsl::string *)
template<class TYPE >
static const bsl::vector< char > &	bdlat_CustomizedTypeFunctions_Imp::convertToBaseType (const TYPE &object, bsl::vector< char > *)

Function Documentation

convertFromBaseType() [1/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, bool  value  )

inlinestatic

convertFromBaseType() [2/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, bsls::Types::Int64  value  )

inlinestatic

convertFromBaseType() [3/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, bsls::Types::Uint64  value  )

inlinestatic

convertFromBaseType() [4/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, char  value  )

inlinestatic

convertFromBaseType() [5/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, const bdlt::Date &  value  )

inlinestatic

convertFromBaseType() [6/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, const bdlt::Datetime &  value  )

inlinestatic

convertFromBaseType() [7/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, const bdlt::DatetimeTz &  value  )

inlinestatic

convertFromBaseType() [8/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, const bdlt::DateTz &  value  )

inlinestatic

convertFromBaseType() [9/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, const bdlt::Time &  value  )

inlinestatic

convertFromBaseType() [10/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, const bdlt::TimeTz &  value  )

inlinestatic

convertFromBaseType() [11/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, const bsl::string &  value  )

inlinestatic

convertFromBaseType() [12/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, const bsl::vector< char > &  value  )

inlinestatic

convertFromBaseType() [13/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, double  value  )

inlinestatic

convertFromBaseType() [14/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, float  value  )

inlinestatic

convertFromBaseType() [15/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, int  value  )

inlinestatic

convertFromBaseType() [16/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, short  value  )

inlinestatic

convertFromBaseType() [17/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, unsigned char  value  )

inlinestatic

convertFromBaseType() [18/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, unsigned int  value  )

inlinestatic

convertFromBaseType() [19/19]

template<class TYPE >

int bdlat_CustomizedTypeFunctions_Imp::convertFromBaseType ( TYPE *  object, unsigned short  value  )

inlinestatic

convertToBaseType() [1/19]

template<class TYPE >

const bdlt::Date & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, bdlt::Date *    )

inlinestatic

convertToBaseType() [2/19]

template<class TYPE >

const bdlt::Datetime & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, bdlt::Datetime *    )

inlinestatic

convertToBaseType() [3/19]

template<class TYPE >

const bdlt::DatetimeTz & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, bdlt::DatetimeTz *    )

inlinestatic

convertToBaseType() [4/19]

template<class TYPE >

const bdlt::DateTz & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, bdlt::DateTz *    )

inlinestatic

convertToBaseType() [5/19]

template<class TYPE >

const bdlt::Time & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, bdlt::Time *    )

inlinestatic

convertToBaseType() [6/19]

template<class TYPE >

const bdlt::TimeTz & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, bdlt::TimeTz *    )

inlinestatic

convertToBaseType() [7/19]

template<class TYPE >

const bool & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, bool *    )

inlinestatic

convertToBaseType() [8/19]

template<class TYPE >

const bsl::string & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, bsl::string *    )

inlinestatic

convertToBaseType() [9/19]

template<class TYPE >

const bsl::vector< char > & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, bsl::vector< char > *    )

inlinestatic

convertToBaseType() [10/19]

template<class TYPE >

const bsls::Types::Int64 & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, bsls::Types::Int64 *    )

inlinestatic

convertToBaseType() [11/19]

template<class TYPE >

const bsls::Types::Uint64 & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, bsls::Types::Uint64 *    )

inlinestatic

convertToBaseType() [12/19]

template<class TYPE >

const char & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, char *    )

inlinestatic

convertToBaseType() [13/19]

template<class TYPE >

const double & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, double *    )

inlinestatic

convertToBaseType() [14/19]

template<class TYPE >

const float & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, float *    )

inlinestatic

convertToBaseType() [15/19]

template<class TYPE >

const int & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, int *    )

inlinestatic

convertToBaseType() [16/19]

template<class TYPE >

const short & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, short *    )

inlinestatic

convertToBaseType() [17/19]

template<class TYPE >

const unsigned char & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, unsigned char *    )

inlinestatic

convertToBaseType() [18/19]

template<class TYPE >

const unsigned int & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, unsigned int *    )

inlinestatic

convertToBaseType() [19/19]

template<class TYPE >

const unsigned short & bdlat_CustomizedTypeFunctions_Imp::convertToBaseType ( const TYPE &  object, unsigned short *    )

inlinestatic