summaryrefslogtreecommitdiff
path: root/TAO/tao/AnyTypeCode/TypeCode_Case_Enum_T.cpp
blob: 3d8de6f4b43142891c08862dcc8af829c8dfad53 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
// $Id$

#ifndef TAO_TYPECODE_CASE_ENUM_T_CPP
#define TAO_TYPECODE_CASE_ENUM_T_CPP

#include "tao/AnyTypeCode/Any_Unknown_IDL_Type.h"
#include "TypeCode_Case_T.h"

#include "tao/CDR.h"
#include "tao/AnyTypeCode/Any.h"

#ifndef __ACE_INLINE__
# include "tao/AnyTypeCode/TypeCode_Case_Enum_T.inl"
#endif /* __ACE_INLINE__ */

TAO_BEGIN_VERSIONED_NAMESPACE_DECL

// ----------------------------------------------------------------


template <typename StringType,
          typename TypeCodeType>
TAO::TypeCode::Case<StringType, TypeCodeType> *
TAO::TypeCode::Case_Enum_T<StringType,
                           TypeCodeType>::clone (void) const
{
  Case<StringType, TypeCodeType> * p = 0;

  typedef Case_Enum_T<StringType,
                      TypeCodeType> case_type;

  // The compiler generated memberwise copy constructor is sufficient.
  ACE_NEW_RETURN (p,
                  case_type (*this),
                  p);

  return p;
}

template <typename StringType,
          typename TypeCodeType>
bool
TAO::TypeCode::Case_Enum_T<StringType,
                           TypeCodeType>::marshal_label (TAO_OutputCDR & cdr) const
{
  return
    (cdr << this->label_);
}

template <typename StringType,
          typename TypeCodeType>
bool
TAO::TypeCode::Case_Enum_T<StringType,
                           TypeCodeType>::equal_label (::CORBA::ULong index,
                                                       ::CORBA::TypeCode_ptr tc
                                                       ) const
{
  CORBA::Any_var const any = tc->member_label (index
                                              );

  // The equality operator == below is guaranteed to be defined for
  // the discriminator type since an IDL union discriminator type must
  // be any of the following: (1) an integer, (2) a character, (3) a
  // boolean, or (4) an enumeration.

  CORBA::ULong tc_label;
  if ((any.in () >>= tc_label)
      && this->label_ == tc_label)
    {
      return true;
    }

  return false;
}

template <typename StringType,
          typename TypeCodeType>
CORBA::Any *
TAO::TypeCode::Case_Enum_T<StringType,
                           TypeCodeType>::label (void) const
{
    TAO_OutputCDR out_cdr;

    out_cdr.write_ulong (this->label_);

    CORBA::Any *retval = 0;
    ACE_NEW_THROW_EX (retval,
                        CORBA::Any,
                        CORBA::NO_MEMORY ());

    TAO_InputCDR in_cdr (out_cdr);
    TAO::Unknown_IDL_Type *unk = 0;
    ACE_NEW_THROW_EX (unk,
                      TAO::Unknown_IDL_Type (this->discriminator_tc_.in (),
                                             in_cdr),
                      CORBA::NO_MEMORY ());

    CORBA::Any_var safe_value (retval);

    retval->replace (unk);

    return safe_value._retn ();
}

TAO_END_VERSIONED_NAMESPACE_DECL

#endif  /* TAO_TYPECODE_CASE_T_CPP */