void
be_component::gen_skel_inheritance (TAO_OutStream *os)
{
AST_Component *base = this->base_component ();
if (base != 0)
{
*os << "public virtual POA_" << base->name ();
}
else
{
*os << "public virtual POA_Components::CCMObject";
}
long nsupports = this->n_inherits ();
AST_Type **supports = this->supports ();
AST_Type *supported = 0;
for (long i = 0; i < nsupports; ++i)
{
supported = supports[i];
if (supported->is_abstract ())
{
continue;
}
*os << "," << be_nl;
*os << "public virtual POA_" << supported->name ();
}
}
// OBV_ class must be in OBV_ namespace.
int
be_visitor_valuetype_obv_ch::visit_valuetype (be_valuetype *node)
{
// Only visit non-abstract non-imported valuetype.
if (node->is_abstract () || node->imported ())
{
return 0;
}
TAO_OutStream *os = this->ctx_->stream ();
*os << be_nl_2 << "// TAO_IDL - Generated from" << be_nl
<< "// " << __FILE__ << ":" << __LINE__ ;
// OBV_ class maps only to a typedef if we are optimizing accessors.
if (node->opt_accessor ())
{
*os << be_nl_2 << "typedef " << node->full_name () << " ";
if (!node->is_nested ())
{
*os << "OBV_";
}
*os << node->local_name () << ";" << be_nl;
}
else
{
*os << be_nl_2 << "// OBV_ class" << be_nl;
*os << "class " << be_global->stub_export_macro() << " ";
if (!node->is_nested())
{
*os << "OBV_";
}
*os << node->local_name () << be_idt_nl
<< ": public virtual "
<< node->full_name ();
// STEP 1 (about which previous implementer forgot ):
// Generate inheritance from corresponding OBV_ classes.
//------>>>
// Here we need to be careful. There are few cases to consider:
//
// (1) We have VT with concrete factory and no inhereted VT with
// concrete factory then we need to mix-in RefCounter
//
// (2) We have VT with concerete factory and inheretence from
// another (not abstract or empty abstract <would like to
// know how to go there>) then its OBV_ already has mix-in
//
// (3) We have VT that supports an abstract interface. In this case,
// we will add implementations of _add_ref and _remove_ref that
// call this->DefaultValueRefCountBase and so it must be mixed in
//
// (4) The rest. Don't need to bother about anything, just inherit
// whatever there is.
//
int i = 0;
AST_Type *inherited = 0;
for (; i < node->n_inherits (); ++i)
{
inherited = node->inherits ()[i];
// We need only concrete valuetypes.
if (inherited->is_abstract ())
{
continue;
}
*os << "," << be_nl;
// dump the scoped name.
*os << " public virtual OBV_";
*os << inherited->full_name();
} // end of for loop
if (this->obv_need_ref_counter (node))
{
*os << "," << be_nl;
// dump the scoped name.
*os << " public virtual ::CORBA::DefaultValueRefCountBase";
}
*os << be_uidt_nl;
//------>>>
// STEP 2: Generate the body ==
*os << "{";
// Generate code for the OBV_ class definition.
if (this->visit_valuetype_scope (node) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"(%N:%l) be_visitor_valuetype_obv_ch::"
"visit_valuetype - "
"codegen for scope failed\n"),
-1);
}
// If we inherit from CORBA::Object and/or CORBA::AbstractBase
// (in addition to CORBA::ValueBase) we have to add these
// to avoid ambiguity.
if (node->n_supports () > 0)
{
*os << be_nl_2 << "// TAO_IDL - Generated from" << be_nl
<< "// " << __FILE__ << ":" << __LINE__ ;
*os << be_nl_2 << "virtual void _add_ref (void);" << be_nl;
*os << "virtual void _remove_ref (void);";
}
if (node->have_operation ())
{
this->begin_private ();
}
else
{
this->begin_public ();
}
*os << be_nl;
// Default constructor.
if (! node->is_nested ())
{
*os << "OBV_";
}
*os << node->local_name () << " (void);";
// Initializing constructor.
if (node->has_member ())
{
*os << be_nl;
if (! node->is_nested ())
{
*os << "OBV_";
}
*os << node->local_name () << " (" << be_idt << be_idt;
unsigned long index = 0;
this->gen_obv_init_constructor_args (node, index);
*os << be_uidt_nl
<< ");" << be_uidt;
}
// Virtual destructor.
*os << be_nl << "virtual ~";
if (! node->is_nested ())
{
*os << "OBV_";
}
*os << node->local_name () << " (void);";
// Virtual _copy_value() only provided in OBV_* class when
// ::CORBA::DefaultValueRefCountBase has been included.
// The OBV_ class is concrete in this case and so requires
// a _copy_value definition.
// Otherwise, the end user derives from this abstract
// OBV_* class and it is up to them to provide the correct
// implimentation of the _copy_value() there.
if (this->obv_need_ref_counter (node))
{
*os << be_uidt_nl << be_nl << "public:" << be_idt_nl
<< "virtual ::CORBA::ValueBase *_copy_value (void);";
}
// Map fields to private data.
if (!node->opt_accessor ())
{
*os << be_nl << be_uidt_nl << "protected:" << be_idt_nl;
*os << "virtual ::CORBA::Boolean" << be_nl
<< "_tao_marshal__" << node->flat_name ()
<< " (TAO_OutputCDR &, TAO_ChunkInfo &) const;" << be_nl_2;
*os << "virtual ::CORBA::Boolean" << be_nl
<< "_tao_unmarshal__" << node->flat_name ()
<< " (TAO_InputCDR &, TAO_ChunkInfo &);" << be_nl_2;
*os << "::CORBA::Boolean "
<< "_tao_marshal_state (TAO_OutputCDR &, TAO_ChunkInfo &) const;"
<< be_nl
<< "::CORBA::Boolean "
<< "_tao_unmarshal_state (TAO_InputCDR &, TAO_ChunkInfo &);"
<< be_nl
<< "virtual void "
<< "truncation_hook (void);"
<< be_uidt_nl << be_nl;
*os << "private:" << be_idt;
this->gen_pd (node);
}
*os << be_nl
<< "CORBA::Boolean require_truncation_;" << be_uidt_nl
<< "};";
}
return 0;
}
