TAO/TAO_IDL/be/be_visitor_valuebox/valuebox_ch.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    valuebox_ch.cpp
   5  *
   6  *  Visitor generating code for valueboxes in the client header
   7  *
   8  *  @author Gary Maxey
   9  */
  10 //=============================================================================
  11
  12 #include "valuebox.h"
  13
  14 // ******************************************************
  15 // Valuebox visitor for client header
  16 // ******************************************************
  17
  18 be_visitor_valuebox_ch::be_visitor_valuebox_ch (be_visitor_context *ctx)
  19   : be_visitor_valuebox (ctx)
  20 {
  21 }
  22
  23 be_visitor_valuebox_ch::~be_visitor_valuebox_ch (void)
  24 {
  25 }
  26
  27 int
  28 be_visitor_valuebox_ch::visit_valuebox (be_valuebox *node)
  29 {
  30   // Nothing to do if we are imported or code is already generated.
  31   if (node->cli_hdr_gen () || node->imported ())
  32     {
  33       return 0;
  34     }
  35
  36   TAO_OutStream *os = this->ctx_->stream ();
  37
  38   this->ctx_->node (node); // save the node
  39
  40   TAO_INSERT_COMMENT (os);
  41
  42   *os << be_nl_2
  43       << "class " << node->local_name () << ";" ;
  44
  45   // Generate the _var and _out template class declarations.
  46   *os << be_nl_2
  47       << "typedef" << be_idt_nl
  48       << "TAO_Value_Var_T<" << be_idt << be_idt_nl
  49       << node->local_name () << be_uidt_nl
  50       << ">" << be_uidt_nl
  51       << node->local_name () << "_var;" << be_uidt_nl << be_nl
  52       << "typedef" << be_idt_nl
  53       << "TAO_Value_Out_T<" << be_idt << be_idt_nl
  54       << node->local_name () << be_uidt_nl
  55       << ">" << be_uidt_nl
  56       << node->local_name () << "_out;" << be_uidt;
  57
  58   *os << be_nl_2 << "class " << be_global->stub_export_macro ()
  59       << " " << node->local_name ();
  60   *os << be_idt_nl <<": public virtual ::CORBA::DefaultValueRefCountBase";
  61
  62   *os << be_uidt << be_nl
  63       << "{" << be_nl
  64       << "public:" << be_idt;
  65
  66   node->gen_stub_decls (os);
  67
  68   // _downcast method
  69   *os << be_nl_2
  70       << "static " << node->local_name () << "* "
  71       << "_downcast ( ::CORBA::ValueBase *);" << be_nl;
  72
  73   // _copy_value method
  74   *os << "::CORBA::ValueBase * _copy_value (void);" << be_nl_2;
  75
  76   // repository id methods
  77   *os << "virtual const char* "
  78       << "_tao_obv_repository_id (void) const;"
  79       << be_nl_2
  80       << "virtual void "
  81       << "_tao_obv_truncatable_repo_ids (Repository_Id_List &ids) const;"
  82       << be_nl_2
  83       << "static const char* "
  84       << "_tao_obv_static_repository_id (void);" << be_nl_2;
  85
  86   // unmarshal method
  87   *os << "static ::CORBA::Boolean _tao_unmarshal (" << be_idt << be_idt_nl
  88       << "TAO_InputCDR &," << be_nl
  89       << node->local_name () << " *&" << be_uidt_nl
  90       << ");" << be_uidt_nl << be_nl;
  91
  92   if (be_global->tc_support ())
  93     {
  94       *os << "virtual ::CORBA::TypeCode_ptr _tao_type (void) const;"
  95           << be_nl_2;
  96     }
  97
  98   be_type *bt = dynamic_cast<be_type*> (node->boxed_type ());
  99
 100   // Emit the type specific elements.  The visit_* methods in this
 101   // module do that work.
 102   if (!bt || (bt->accept (this) == -1))
 103     {
 104       ACE_ERROR_RETURN ((LM_ERROR,
 105                          ACE_TEXT ("be_visitor_valuebox_ch::")
 106                          ACE_TEXT ("visit_valuebox - ")
 107                          ACE_TEXT ("type-specific valuebox")
 108                          ACE_TEXT (" code generation failed\n")),
 109                         -1);
 110     }
 111
 112   TAO_INSERT_COMMENT (os);
 113
 114   // Generate the "protected" destructor
 115
 116   *os << be_uidt_nl << be_nl << "protected:" << be_idt_nl;
 117
 118   *os << "virtual ~" << node->local_name () << " (void);" << be_nl;
 119
 120   // Methods for marshalling and unmarshalling the value
 121   *os << "virtual ::CORBA::Boolean "
 122       << "_tao_marshal_v (TAO_OutputCDR &) const;" << be_nl;
 123   *os << "virtual ::CORBA::Boolean "
 124       << "_tao_unmarshal_v (TAO_InputCDR &);" << be_nl;
 125   *os << "virtual ::CORBA::Boolean "
 126       << "_tao_match_formal_type (ptrdiff_t ) const;" << be_nl;
 127
 128   // Private unimplemented default assignment operator
 129   *os << be_uidt_nl << "private:" << be_idt_nl;
 130   *os << "void operator= (const " << node->local_name () << " & val);"
 131       << be_nl;
 132
 133   *os << be_uidt_nl
 134       << "};";
 135
 136   // Generate typecode declaration.
 137   if (be_global->tc_support ())
 138     {
 139       be_visitor_context ctx (*this->ctx_);
 140       be_visitor_typecode_decl visitor (&ctx);
 141
 142       if (node->accept (&visitor) == -1)
 143         {
 144           ACE_ERROR_RETURN ((LM_ERROR,
 145                              ACE_TEXT ("be_visitor_valuebox_ch::")
 146                              ACE_TEXT ("visit_valuebox - ")
 147                              ACE_TEXT ("TypeCode declaration failed\n")),
 148                             -1);
 149         }
 150     }
 151
 152   // Indicate that code is already generated for this node.
 153   node->cli_hdr_gen (true);
 154
 155   return 0;
 156 }
 157
 158
 159 int
 160 be_visitor_valuebox_ch::visit_array (be_array *node)
 161 {
 162   TAO_OutStream *os = this->ctx_->stream ();
 163
 164   TAO_INSERT_COMMENT (os);
 165
 166   this->emit_default_constructor();
 167
 168   // Public constructor that takes a const array argument
 169   this->emit_constructor_one_arg (node, "", "const ", "");
 170
 171   // Public copy constructor
 172   this->emit_copy_constructor ();
 173
 174   *os << be_nl << "// assignment operator" << be_nl;
 175
 176   // Public assignment operator that takes a const array argument
 177   this->emit_assignment (node, "", "const ", "");
 178
 179   // Public accessor and modifier methods
 180   *os << "// Accessors and modifier" << be_nl;
 181
 182   *os << "const " << node->full_name () << "_slice* "
 183       << "_value (void) const;" << be_nl;
 184
 185   *os << node->full_name () << "_slice* " << "_value (void);" << be_nl;
 186
 187   *os << "void" << " _value (const " << node->full_name () << " val);"
 188       << be_nl_2;
 189
 190   // Overloaded subscript operators
 191   *os << "const " << node->full_name ()
 192       << "_slice & operator[] ( ::CORBA::ULong index) const;" << be_nl;
 193
 194   *os << node->full_name ()
 195       << "_slice &  operator[] ( ::CORBA::ULong index);"
 196       << be_nl_2;
 197
 198   // Explicit conversion functions
 199   *os << "const " << node->full_name ()
 200       << "_slice * _boxed_in (void) const;"
 201       << be_nl;
 202
 203   *os << node->full_name () << "_slice * _boxed_inout (void);" << be_nl;
 204
 205   *os << node->full_name () << "_slice * _boxed_out (void);" << be_nl
 206       << be_nl;
 207
 208   // Member variable of underlying type;
 209   this->emit_boxed_member_var (node, "_var");
 210
 211   return 0;
 212 }
 213
 214
 215 int
 216 be_visitor_valuebox_ch::visit_enum (be_enum *node)
 217 {
 218   return this->emit_for_predef_enum (node, "", false);
 219 }
 220
 221
 222 int
 223 be_visitor_valuebox_ch::visit_interface (be_interface *node)
 224 {
 225   return this->emit_for_predef_enum (node, "_ptr", false);
 226 }
 227
 228
 229 int
 230 be_visitor_valuebox_ch::visit_predefined_type (be_predefined_type *node)
 231 {
 232   return this->emit_for_predef_enum (
 233     node,
 234     "",
 235     node->pt () == AST_PredefinedType::PT_any);
 236 }
 237
 238
 239 int
 240 be_visitor_valuebox_ch::visit_sequence (be_sequence *node)
 241 {
 242   TAO_OutStream *os = this->ctx_->stream ();
 243
 244   // Retrieve the node being visited by this be_visitor_valuebox_ch.
 245   be_decl * vb_node = this->ctx_->node ();
 246
 247   if (node->anonymous ())
 248     { // Our sequence is anonymous so we must generate a declaration
 249       // for it.
 250       be_visitor_context ctx (*this->ctx_);
 251       ctx.node (node);
 252
 253       // First generate the sequence declaration.
 254       be_visitor_sequence_ch visitor (&ctx);
 255
 256       if (node->accept (&visitor) == -1)
 257         {
 258           ACE_ERROR_RETURN ((LM_ERROR,
 259                              "(%N:%l) be_visitor_valuebox_ch::"
 260                              "visit_sequence - "
 261                              "codegen failed\n"),
 262                             -1);
 263         }
 264     }
 265
 266   // Retrieve the base type since we will need to do some code
 267   // generation for it.
 268   be_type *bt = dynamic_cast<be_type*> (node->base_type ());
 269
 270   if (bt == 0)
 271     {
 272       ACE_ERROR_RETURN ((LM_ERROR,
 273                          "(%N:%l) be_visitor_valuebox_ch::"
 274                          "visit_sequence - "
 275                          "Bad element type\n"),
 276                         -1);
 277     }
 278
 279   // Indicate that this type has been used as a sequence element.
 280   bt->seen_in_sequence (true);
 281
 282   TAO_INSERT_COMMENT (os);
 283
 284   this->emit_default_constructor();
 285
 286   if (node->unbounded ())
 287     {
 288       // Public constructor with one argument of type ULong
 289       *os << vb_node->local_name () << " ( ::CORBA::ULong max);" << be_nl;
 290     }
 291
 292   // Public constructor for sequence with supplied buffer
 293   *os << vb_node->local_name () << " (" << be_idt << be_idt;
 294
 295   if (node->unbounded ())
 296     {
 297       *os << be_nl << "::CORBA::ULong max,";
 298     }
 299
 300   *os << be_nl << "::CORBA::ULong length," << be_nl;
 301
 302   // Generate the base type for the buffer.
 303   be_visitor_context ctx (*this->ctx_);
 304   ctx.state (TAO_CodeGen::TAO_SEQUENCE_BUFFER_TYPE_CH);
 305   be_visitor_sequence_buffer_type bt_visitor (&ctx);
 306   if (bt->accept (&bt_visitor) == -1)
 307     {
 308       ACE_ERROR_RETURN ((LM_ERROR,
 309                          " (%N:%l) be_visitor_valuebox_ch::visit_sequence - "
 310                          "base type visit failed\n"),
 311                         -1);
 312     }
 313
 314   *os << " * buf," << be_nl
 315       << "::CORBA::Boolean release = false);" << be_uidt
 316       << be_uidt_nl;
 317
 318   // Public constructor with single argument of type const T&
 319   this->emit_constructor_one_arg (node, "", "const ", "&");
 320
 321   // Public copy constructor
 322   this->emit_copy_constructor ();
 323
 324   *os << be_nl << "// assignment operator" << be_nl;
 325
 326   // Public assignment operator with one argument of type const T&
 327   this->emit_assignment (node, "", "const ", "&");
 328
 329   // Public accessor and modifier methods
 330   this->emit_accessor_modifier (node);
 331
 332   // Access to the boxed value for method signatures
 333   this->emit_boxed_access (node, "", "const ", "&", "*");
 334
 335   // Generate accessors
 336
 337   // Generate base type for sequence then remainder of operator []
 338   if (bt->accept (&bt_visitor) == -1)
 339     {
 340       ACE_ERROR_RETURN ((LM_ERROR,
 341                           " (%N:%l) be_visitor_valuebox_ch::"
 342                            "visit_sequence - "
 343                           "base type visit failed\n"),
 344                          -1);
 345     }
 346   *os << "& operator[] ( ::CORBA::ULong index);" << be_nl;
 347
 348   // Generate base type for sequence then remainder of operator []
 349   *os << "const ";
 350
 351   if (bt->accept (&bt_visitor) == -1)
 352     {
 353       ACE_ERROR_RETURN ((LM_ERROR,
 354                          " (%N:%l) be_visitor_valuebox_ch::"
 355                          "visit_sequence - "
 356                          "base type visit failed\n"),
 357                         -1);
 358     }
 359
 360   *os << "& operator[] ( ::CORBA::ULong index) const;" << be_nl_2
 361       << "::CORBA::ULong maximum (void) const;" << be_nl
 362       << "::CORBA::ULong length (void) const;" << be_nl
 363       << "void length ( ::CORBA::ULong len);" << be_nl_2;
 364
 365   // Member variable of underlying type;
 366   this->emit_boxed_member_var (node, "_var");
 367
 368   return 0;
 369 }
 370
 371
 372 int
 373 be_visitor_valuebox_ch::visit_string (be_string *node)
 374 {
 375   TAO_OutStream *os = this->ctx_->stream ();
 376
 377   const char *string_type;
 378   const char *char_type;
 379
 380   if (node->node_type () == AST_Decl::NT_string)
 381     {
 382       string_type = "String";
 383       char_type = "char";
 384     }
 385   else if (node->node_type () == AST_Decl::NT_wstring)
 386     {
 387       string_type = "WString";
 388       char_type = "::CORBA::WChar";
 389     }
 390   else
 391     {
 392       ACE_ERROR ((LM_ERROR,
 393                   "(%N:%l) be_visitor_valuebox_ch::visit_string -"
 394                   "unexpected string node type=%d\n", node->node_type ()));
 395       return -1;
 396     }
 397
 398   // Retrieve the node being visited by this be_visitor_valuebox_ch.
 399   be_decl * vb_node = this->ctx_->node ();
 400
 401   TAO_INSERT_COMMENT (os);
 402
 403   this->emit_default_constructor ();
 404   this->emit_constructor_one_arg (node, "", "", "");
 405
 406   // Public constructor with one argument of type const char *
 407   this->emit_constructor_one_arg (node, "", "const ", "");
 408
 409   // Public constructor with one argument of type const CORBA::String_var&
 410   *os << vb_node->local_name () << " (const ::CORBA::" << string_type
 411       << "_var& var);" << be_nl;
 412
 413   // Public copy constructor
 414   this->emit_copy_constructor ();
 415
 416   *os << "// assignment operators" << be_nl;
 417
 418   // Public assignment operator with one argument of type char *
 419   this->emit_assignment (node, "", "", "");
 420
 421   // Public assignment operator with one argument of type const char *
 422   this->emit_assignment (node, "", "const ", "");
 423
 424   // Public assignment operator with one argument of type
 425   // const CORBA::String_var&
 426   *os << vb_node->local_name () << "& operator= (const ::CORBA::"
 427       << string_type << "_var& var);" << be_nl_2;
 428
 429   *os << "// Accessor" << be_nl;
 430
 431   // Accessor function takes no arguments and returns a const char *
 432   *os << "const " << node->full_name ()
 433       << " _value (void) const;" << be_nl_2;
 434
 435   *os << "// Modifiers" << be_nl;
 436
 437   // Modifier function with one argument of type char *
 438   *os << "void _value (" << node->full_name () << " val);" << be_nl;
 439
 440   // Modifier function with one argument of type const char *
 441   *os << "void _value (const " << node->full_name () << " val);"
 442       << be_nl;
 443
 444   // Modifier function with one argument of type const CORBA::String_var&
 445   *os << "void _value (const ::CORBA::" << string_type << "_var& var);"
 446       << be_nl_2;
 447
 448   // Access to the boxed value for method signatures
 449   this->emit_boxed_access (node, "", "const ", "", "");
 450
 451   // Overloaded subscript operators
 452   *os << "// Allows access and modification using a slot." << be_nl
 453       << char_type << " & operator[] ( ::CORBA::ULong slot);"
 454       << be_nl_2
 455       << "// Allows only accessing thru a slot." << be_nl
 456       << char_type << " operator[] ( ::CORBA::ULong slot) const;"
 457       << be_nl;
 458
 459   // Member variable of underlying type;
 460   *os << be_uidt_nl << "private:" << be_idt_nl
 461       << "::CORBA::" << string_type << "_var" << " _pd_value;" << be_nl;
 462
 463   return 0;
 464 }
 465
 466
 467 int
 468 be_visitor_valuebox_ch::visit_structure (be_structure *node)
 469 {
 470   TAO_OutStream *os = this->ctx_->stream ();
 471
 472   TAO_INSERT_COMMENT (os);
 473
 474   this->emit_default_constructor();
 475
 476   // Public constructor with one argument of const T&
 477   this->emit_constructor_one_arg (node, "", "const ", "&");
 478
 479   // Public copy constructor
 480   this->emit_copy_constructor ();
 481
 482   *os << be_nl << "// Assignment operator" << be_nl;
 483
 484   // Public assignment operator with one argument of type const T&
 485   this->emit_assignment (node, "", "const ", "&");
 486
 487   // Public accessor and modifier methods
 488   this->emit_accessor_modifier (node);
 489
 490   // Access to the boxed value for method signatures
 491   if (node->size_type() == AST_Type::FIXED)
 492     {
 493       this->emit_boxed_access (node, "", "const ", "&", "");
 494     }
 495   else
 496     {
 497       this->emit_boxed_access (node, "", "const ", "&", "*");
 498     }
 499
 500   // Now generate the accessor and modifier functions for each struct
 501   // member.  These functions have the same signatures as
 502   // acessor and modifier functions for union members.
 503
 504   AST_Decl *d = 0;
 505   AST_Field *field = 0;
 506   be_type *bt = 0;
 507   be_visitor_context ctx (*this->ctx_);
 508
 509   for (UTL_ScopeActiveIterator si (node, UTL_Scope::IK_decls);
 510        !si.is_done ();
 511         si.next ())
 512     {
 513       d = si.item ();
 514
 515       if (d == 0 || (field = dynamic_cast<AST_Field*> (d)) == 0)
 516         {
 517           ACE_ERROR ((LM_ERROR,
 518                       "(%N:%l) be_visitor_valuebox_ch::visit_structure -"
 519                       "bad node in this scope\n"));
 520           break;
 521         }
 522
 523       bt = dynamic_cast<be_type*> (field->field_type ());
 524
 525       // Set the node to be visited
 526       ctx.node (dynamic_cast<be_decl*> (d));
 527
 528       // Create a visitor and use that to process the type.
 529       be_visitor_valuebox_field_ch visitor (&ctx);
 530
 531       if (bt->accept (&visitor) == -1)
 532         {
 533           ACE_ERROR ((LM_ERROR,
 534                       "(%N:%l) be_visitor_valuebox_ch::visit_structure"
 535                       " - codegen for struct type failed\n"));
 536         }
 537     }
 538
 539   TAO_INSERT_COMMENT (os);
 540
 541   // Member variable of underlying type;
 542   this->emit_boxed_member_var (node, "_var");
 543
 544   return 0;
 545 }
 546
 547
 548 int
 549 be_visitor_valuebox_ch::visit_typedef (be_typedef *node)
 550 {
 551   // Make a decision based on the primitive base type.
 552   be_type *bt = node->primitive_base_type ();
 553
 554   if (!bt || (bt->accept (this) == -1))
 555     {
 556       ACE_ERROR_RETURN ((LM_ERROR,
 557                          " (%N:%l) be_visitor_valuebox_ch::"
 558                          "visit_typedef - "
 559                          "Bad primitive type\n"),
 560                         -1);
 561     }
 562
 563   return 0;
 564 }
 565
 566
 567 int
 568 be_visitor_valuebox_ch::visit_union (be_union *node)
 569 {
 570   TAO_OutStream *os = this->ctx_->stream ();
 571
 572   TAO_INSERT_COMMENT (os);
 573
 574   this->emit_default_constructor();
 575
 576   // Public constructor with single argument of type const T&
 577   this->emit_constructor_one_arg (node, "", "const ", "&");
 578
 579   // Public copy constructor
 580   this->emit_copy_constructor ();
 581
 582   *os << be_nl << "// Assignment operator" << be_nl;
 583
 584   // Public assignment operator with one argument of type const T&
 585   this->emit_assignment (node, "", "const ", "&");
 586
 587   // Public accessor and modifier methods
 588   this->emit_accessor_modifier (node);
 589
 590   // Access to the boxed value for method signatures
 591   if (node->size_type() == AST_Type::FIXED)
 592     {
 593       this->emit_boxed_access (node, "", "const ", "&", "");
 594     }
 595   else
 596     {
 597       this->emit_boxed_access (node, "", "const ", "&", "*");
 598     }
 599
 600   // Now generate the accessor and modifier functions for each union
 601   // member.
 602
 603   AST_Decl *d = 0;
 604   AST_Field *field = 0;
 605   be_type *bt = 0;
 606   be_visitor_context ctx (*this->ctx_);
 607
 608   for (UTL_ScopeActiveIterator si (node, UTL_Scope::IK_decls);
 609        !si.is_done ();
 610         si.next ())
 611     {
 612       d = si.item ();
 613
 614       if (d == 0 || (field = dynamic_cast<AST_Field*> (d)) == 0)
 615         {
 616           ACE_ERROR ((LM_ERROR,
 617                       "(%N:%l) be_visitor_valuebox_ch::visit_union -"
 618                       "bad node in this scope\n"));
 619           break;
 620         }
 621
 622       bt = dynamic_cast<be_type*> (field->field_type ());
 623
 624       // Set the node to be visited
 625       ctx.node (dynamic_cast<be_decl*> (d));
 626
 627       // Create a visitor and use that to process the type.
 628       be_visitor_valuebox_field_ch visitor (&ctx);
 629
 630       if (bt->accept (&visitor) == -1)
 631         {
 632           ACE_ERROR ((LM_ERROR,
 633                       "(%N:%l) be_visitor_valuebox_ch::visit_union"
 634                       " - codegen for struct type failed\n"));
 635         }
 636     }
 637
 638   // Retrieve the disriminant type.
 639   bt = dynamic_cast<be_type*> (node->disc_type ());
 640
 641   if (!bt)
 642     {
 643       ACE_ERROR_RETURN ((LM_ERROR,
 644                          "(%N:%l) be_visitor_valuebox_ch::visit_union - "
 645                          "bad disciminant type\n"),
 646                         -1);
 647     }
 648
 649   // The discriminant type may have to be defined here if it was an enum
 650   // declaration inside of the union statement.
 651
 652   be_visitor_union_discriminant_ch ud_visitor (&ctx);
 653
 654   if (bt->accept (&ud_visitor) == -1)
 655     {
 656       ACE_ERROR_RETURN ((LM_ERROR,
 657                          "(%N:%l) be_visitor_union_ch::"
 658                          " visit_union - "
 659                          "codegen for discriminant failed\n"),
 660                         -1);
 661     }
 662
 663   TAO_INSERT_COMMENT (os);
 664
 665   // Member variable of underlying type;
 666   this->emit_boxed_member_var (node, "_var");
 667
 668   return 0;
 669 }
 670
 671
 672 int
 673 be_visitor_valuebox_ch::emit_for_predef_enum (be_type *node,
 674                                               const char * type_suffix,
 675                                               bool is_any)
 676 {
 677   TAO_OutStream *os = this->ctx_->stream ();
 678
 679   TAO_INSERT_COMMENT (os);
 680
 681   this->emit_default_constructor ();
 682
 683   if (is_any)
 684     {
 685       this->emit_constructor_one_arg (node, "", "const ", "&");
 686     }
 687   else
 688     { // Public constructor with one argument of underlying type
 689       this->emit_constructor_one_arg (node, type_suffix, "", "");
 690     }
 691
 692   // Public copy constructor
 693   this->emit_copy_constructor ();
 694
 695   *os << be_nl << "// Assignment operator" << be_nl;
 696
 697   if (is_any)
 698     { // Public assignment operator with one argument of type const T&
 699       this->emit_assignment (node, "", "const ::", "&");
 700
 701       this->emit_accessor_modifier (node);
 702
 703       // Access to the boxed value for method signatures
 704       this->emit_boxed_access (node, "", "const ::", "&", "*");
 705
 706       // Member variable of underlying type;
 707       this->emit_boxed_member_var (node, "_var");
 708     }
 709   else
 710     { // Public assignment operator with one argument of underlying type
 711       this->emit_assignment (node, type_suffix, "", "");
 712
 713       // Public accessor and modifier methods
 714       *os << "// Accessor and modifier" << be_nl;
 715
 716       *os << node->full_name () << type_suffix
 717           << " _value (void) const;" << be_nl;
 718
 719       *os << "void" << " _value (" << node->full_name () << type_suffix
 720           << " val);" << be_nl_2;
 721
 722       // Access to the boxed value for method signatures
 723       this->emit_boxed_access (node, type_suffix, "", "", "");
 724
 725       // Member variable of underlying type;
 726       this->emit_boxed_member_var (node, type_suffix);
 727     }
 728
 729   return 0;
 730 }
 731
 732 void
 733 be_visitor_valuebox_ch::emit_default_constructor (void)
 734 {
 735   TAO_OutStream *os = this->ctx_->stream ();
 736
 737   // Retrieve the node being visited by this be_visitor_valuebox_ch.
 738   be_decl * vb_node = this->ctx_->node ();
 739
 740   *os << be_nl_2 << "// Constructors" << be_nl;
 741
 742   // Public default constructor
 743   *os << vb_node->local_name () << " (void);" << be_nl;
 744 }
 745
 746 void
 747 be_visitor_valuebox_ch::emit_constructor_one_arg (be_decl *node,
 748                                                   const char * type_suffix,
 749                                                   const char * const_prefix,
 750                                                   const char * ref_modifier)
 751 {
 752   TAO_OutStream *os = this->ctx_->stream ();
 753
 754   // Retrieve the node being visited by this be_visitor_valuebox_ch.
 755   be_decl * vb_node = this->ctx_->node ();
 756
 757   // Public constructor with one argument of underlying type
 758   *os << vb_node->local_name () << " (" << const_prefix << node->full_name ()
 759       << type_suffix << ref_modifier << " val);" << be_nl;
 760 }
 761
 762 void
 763 be_visitor_valuebox_ch::emit_copy_constructor (void)
 764 {
 765   TAO_OutStream *os = this->ctx_->stream ();
 766
 767   // Retrieve the node being visited by this be_visitor_valuebox_ch.
 768   be_decl * vb_node = this->ctx_->node ();
 769
 770   // Public Copy constructor
 771   *os << vb_node->local_name ()
 772       << " (const " << vb_node->local_name () << "& val);" << be_nl;
 773 }
 774
 775 void
 776 be_visitor_valuebox_ch::emit_assignment (be_decl *node,
 777                                          const char * type_suffix,
 778                                          const char * const_prefix,
 779                                          const char * ref_modifier)
 780 {
 781   TAO_OutStream *os = this->ctx_->stream ();
 782
 783   // Retrieve the node being visited by this be_visitor_valuebox_ch.
 784   be_decl * vb_node = this->ctx_->node ();
 785
 786   *os << vb_node->local_name () << "& operator= (" << const_prefix
 787       << node->full_name () << type_suffix << ref_modifier << " val);"
 788       << be_nl_2;
 789 }
 790
 791 void
 792 be_visitor_valuebox_ch::emit_boxed_access (be_decl *node,
 793                                            const char * type_suffix,
 794                                            const char *const_prefix,
 795                                            const char *in_ref_modifier,
 796                                            const char *out_ref_modifier)
 797 {
 798   TAO_OutStream *os = this->ctx_->stream ();
 799
 800   *os << "// Access to the boxed value for method signatures" << be_nl;
 801
 802   // Access to the boxed value for method signatures
 803   *os << const_prefix << node->full_name () << type_suffix << in_ref_modifier
 804       << " _boxed_in (void) const;" << be_nl
 805       << node->full_name () << type_suffix << "&"
 806       << " _boxed_inout (void);" << be_nl
 807       << node->full_name () << type_suffix << out_ref_modifier << "&"
 808       << " _boxed_out (void);" << be_nl;
 809 }
 810
 811 void
 812 be_visitor_valuebox_ch::emit_accessor_modifier (be_decl *node)
 813 {
 814   TAO_OutStream *os = this->ctx_->stream ();
 815
 816   *os << "// Accessors and modifier" << be_nl;
 817
 818   // Public accessor method (const)
 819   *os << "const " << node->full_name () << "& _value (void) const;"
 820       << be_nl;
 821
 822   // Public accessor method
 823   *os << node->full_name () << "& _value (void);" << be_nl;
 824
 825   // Public modifier method
 826   *os << "void" << " _value (const " << node->full_name () << "& val);"
 827       << be_nl_2;
 828 }
 829
 830
 831 void
 832 be_visitor_valuebox_ch::emit_boxed_member_var (be_decl *node,
 833                                                const char * type_suffix)
 834 {
 835   TAO_OutStream *os = this->ctx_->stream ();
 836
 837   // Member variable of underlying type;
 838   *os << be_uidt_nl << "private:" << be_idt_nl
 839       << node->full_name () << type_suffix << " _pd_value;" << be_nl;
 840 }