notify_constraint_visitors.cpp

这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用于网络游戏医学图像网关的高qos要求.更详细的内容可阅读相应的材料

/* Notify_Constraint_Visitors.cpp,v 1.28 2003/12/06 18:41:28 bala Exp */

#include "Notify_Constraint_Visitors.h"
#include "orbsvcs/ETCL/ETCL_Constraint.h"
#include "orbsvcs/ETCL/ETCL_y.h"
#include "tao/Any_Unknown_IDL_Type.h"
#include "tao/DynamicAny/DynArray_i.h"
#include "tao/DynamicAny/DynSequence_i.h"
#include "tao/DynamicAny/DynStruct_i.h"
#include "tao/DynamicAny/DynUnion_i.h"
#include "tao/DynamicAny/DynEnum_i.h"
#include "tao/DynamicAny/DynAnyFactory.h"
#include "tao/Any_Unknown_IDL_Type.h"

TAO_Notify_Constraint_Visitor::TAO_Notify_Constraint_Visitor (void)
  : implicit_id_ (TAO_Notify_Constraint_Visitor::EMPTY)
{
  (void) this->implicit_ids_.bind (ACE_CString ("filterable_data",
                                                0,
                                                0),
                                   FILTERABLE_DATA);
  (void) this->implicit_ids_.bind (ACE_CString ("header",
                                                0,
                                                0),
                                   HEADER);
  (void) this->implicit_ids_.bind (ACE_CString ("remainder_of_body",
                                                0,
                                                0),
                                   REMAINDER_OF_BODY);
  (void) this->implicit_ids_.bind (ACE_CString ("fixed_header",
                                                0,
                                                0),
                                   FIXED_HEADER);
  (void) this->implicit_ids_.bind (ACE_CString ("variable_header",
                                                0,
                                                0),
                                   VARIABLE_HEADER);
  (void) this->implicit_ids_.bind (ACE_CString ("event_name",
                                                0,
                                                0),
                                   EVENT_NAME);
  (void) this->implicit_ids_.bind (ACE_CString ("event_type",
                                                0,
                                                0),
                                   EVENT_TYPE);
  (void) this->implicit_ids_.bind (ACE_CString ("domain_name",
                                                0,
                                                0),
                                   DOMAIN_NAME);
  (void) this->implicit_ids_.bind (ACE_CString ("type_name",
                                                0,
                                                0),
                                   TYPE_NAME);
}

int
TAO_Notify_Constraint_Visitor::bind_structured_event (
    const CosNotification::StructuredEvent &s_event
  )
{
  // The two sequences contained in a structured event are
  // copied into hash tables so iteration is done only once.

  CORBA::ULong length = s_event.filterable_data.length ();
  CORBA::ULong index = 0;

  for (index = 0; index < length; ++index)
    {
      ACE_CString name_str (s_event.filterable_data[index].name, 0, 0);

      int status =
        this->filterable_data_.bind (
            name_str,
            ACE_const_cast (CORBA::Any *,
                            &s_event.filterable_data[index].value)
          );

      if (status != 0)
        {
          return -1;
        }
    }

  length = s_event.header.variable_header.length ();

  for (index = 0; index < length; ++index)
    {
      ACE_CString name_str (s_event.header.variable_header[index].name, 0, 0);

      int status =
        this->variable_header_.bind (
            name_str,
            ACE_const_cast (CORBA::Any *,
                            &s_event.header.variable_header[index].value)
          );

      if (status != 0)
        {
          return -1;
        }
    }

  this->domain_name_ =
    CORBA::string_dup (s_event.header.fixed_header.event_type.domain_name);

  this->type_name_ =
    CORBA::string_dup (s_event.header.fixed_header.event_type.type_name);

  this->event_name_ =
    CORBA::string_dup (s_event.header.fixed_header.event_name);

  this->remainder_of_body_ = s_event.remainder_of_body;

  return 0;
}

CORBA::Boolean
TAO_Notify_Constraint_Visitor::evaluate_constraint (
    TAO_ETCL_Constraint* root
  )
{
  CORBA::Boolean result = 0;
  this->queue_.reset ();

  // Evaluate the constraint in root_;
  if (root != 0)
    {
      if ((root->accept (this) == 0) &&
          (! this->queue_.is_empty ()))
        {
          TAO_ETCL_Literal_Constraint top;
          this->queue_.dequeue_head (top);
          result = (CORBA::Boolean) top;
        }
    }

  // If a property couldn't be evaluated we must return 0.
  return result;
}

int
TAO_Notify_Constraint_Visitor::visit_literal (
    TAO_ETCL_Literal_Constraint *literal
  )
{
  this->queue_.enqueue_head (*literal);
  return 0;
}

int
TAO_Notify_Constraint_Visitor::visit_identifier (TAO_ETCL_Identifier *ident)
{
  int return_value = -1;
  const char *name = ident->value ();
  ACE_CString key (name, 0, 0);

  CORBA::Any *any = 0;

  if (this->filterable_data_.find (key, any) == 0)
    {
      if (any != 0)
        {
          this->queue_.enqueue_head (TAO_ETCL_Literal_Constraint (any));
          return_value = 0;
        }
    }

  return return_value;
}

int
TAO_Notify_Constraint_Visitor::visit_union_value (
    TAO_ETCL_Union_Value *union_value
  )
{
  switch (union_value->sign ())
  {
    case 0:
      this->queue_.enqueue_head (*union_value->string ());
      break;
    case -1:
      this->queue_.enqueue_head (-(*union_value->integer ()));
      break;
    case 1:
      this->queue_.enqueue_head (*union_value->integer ());
      break;
    default:
      return -1;
  }

  return 0;
}

int
TAO_Notify_Constraint_Visitor::visit_union_pos (
    TAO_ETCL_Union_Pos *union_pos
  )
{
  ACE_DECLARE_NEW_CORBA_ENV;
  ACE_TRY
    {
      if (union_pos->union_value ()->accept (this) == 0)
        {
          TAO_ETCL_Literal_Constraint disc_val;
          this->queue_.dequeue_head (disc_val);

          TAO_DynUnion_i dyn_union;
          dyn_union.init (this->current_value_.in ()
                          ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;

          CORBA::TypeCode_var tc = this->current_value_->type ();

          switch (disc_val.expr_type ())
          {
            case TAO_ETCL_INTEGER:
            case TAO_ETCL_SIGNED:
            case TAO_ETCL_UNSIGNED:
              {
                CORBA::Any disc_any;
                CORBA::TypeCode_var disc_tc =
                  tc->discriminator_type (ACE_ENV_SINGLE_ARG_PARAMETER);
                ACE_TRY_CHECK;
                CORBA::TCKind disc_kind =
                  TAO_DynAnyFactory::unalias (disc_tc.in ()
                                              ACE_ENV_ARG_PARAMETER);
                ACE_TRY_CHECK;

                switch (disc_kind)
                {
                  case CORBA::tk_boolean:
                    disc_any <<= CORBA::Any::from_boolean ((CORBA::Boolean) disc_val);
                    break;
                  case CORBA::tk_short:
                    disc_any <<= (CORBA::Short) ((CORBA::Long) disc_val);
                    break;
                  case CORBA::tk_ushort:
                    disc_any <<= (CORBA::UShort) ((CORBA::ULong) disc_val);
                    break;
                  case CORBA::tk_long:
                    disc_any <<= (CORBA::Long) disc_val;
                    break;
                  case CORBA::tk_ulong:
                    disc_any <<= (CORBA::ULong) disc_val;
                    break;
                  case CORBA::tk_enum:
                    {
                      TAO_OutputCDR cdr;
                      cdr.write_ulong ((CORBA::ULong) disc_val);

                      TAO::Unknown_IDL_Type *unk = 0;
                      ACE_NEW_RETURN (unk,
                                      TAO::Unknown_IDL_Type (
                                          disc_tc.in (),
                                          cdr.begin (),
                                          TAO_ENCAP_BYTE_ORDER
                                        ),
                                      -1);

                      disc_any.replace (unk);
                      break;
                    }
                  // @@@ (JP) I don't think ETCL handles 64-bit
                  // integers at this point, and I also think that
                  // chars and/or wchars will just come out in the
                  // constraint as (w)strings of length 1.
                  case CORBA::tk_longlong:
                  case CORBA::tk_ulonglong:
                  case CORBA::tk_char:
                  case CORBA::tk_wchar:
                  default:
                    return -1;
                }

                DynamicAny::DynAny_var dyn_any =
                  TAO_DynAnyFactory::make_dyn_any (disc_any
                                                   ACE_ENV_ARG_PARAMETER);
                ACE_TRY_CHECK;
                dyn_union.set_discriminator (dyn_any.in ()
                                             ACE_ENV_ARG_PARAMETER);
                ACE_TRY_CHECK;
                DynamicAny::DynAny_var u_member =
                  dyn_union.member (ACE_ENV_SINGLE_ARG_PARAMETER);
                ACE_TRY_CHECK;
                this->current_value_ =
                  u_member->to_any (ACE_ENV_SINGLE_ARG_PARAMETER);
                ACE_TRY_CHECK;

                break;
              }
            case TAO_ETCL_STRING:
              {
                const char *name = (const char *) disc_val;
                CORBA::ULong count =
                  tc->member_count (ACE_ENV_SINGLE_ARG_PARAMETER);
                ACE_TRY_CHECK;

                const char *member_name = 0;
                CORBA::ULong i = 0;

                for (i = 0; i < count; ++i)
                  {
                    member_name = tc->member_name (i
                                                   ACE_ENV_ARG_PARAMETER);
                    ACE_TRY_CHECK;

                    if (ACE_OS::strcmp (name, member_name) == 0)
                      {
                        break;
                      }
                  }

                // If there's no match, member_label will throw
                // CORBA::TypeCode::Bounds and the catch block will
                // return -1;
                this->current_value_ = tc->member_label (i
                                                          ACE_ENV_ARG_PARAMETER);
                ACE_TRY_CHECK;

                break;
              }
            // The TAO_ETCL_Union_Value that was put on the queue
            // shouldn't have any other type.
            default:
              return -1;
          }

          TAO_ETCL_Constraint *nested = union_pos->component ();

          // If there's no nested component, then we just want the
          // union member value on the queue. Otherwise, we want
          // the member value in current_value_ while we visit
          // the nested component.
          if (nested == 0)
            {
              TAO_ETCL_Literal_Constraint lit (this->current_value_);
              this->queue_.enqueue_head (lit);
              return 0;
            }
          else
            {
              return nested->accept (this);
            }
        }
      else
        {
          return -1;
        }
    }
  ACE_CATCHANY
    {
      return -1;
    }
  ACE_ENDTRY;

  ACE_NOTREACHED (return 0);
}

int
TAO_Notify_Constraint_Visitor::visit_component_pos (
    TAO_ETCL_Component_Pos *pos
  )
{
  ACE_DECLARE_NEW_CORBA_ENV;
  ACE_TRY
    {
      // If we are here (from visit_component) the Any containing the
      // component as found in filterable_data_ will be in current_value_.
      CORBA::TypeCode_var tc = this->current_value_->type ();
      CORBA::TCKind kind = TAO_DynAnyFactory::unalias (tc.in ()
                                                       ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;

      DynamicAny::DynAny_var member;
      CORBA::Boolean success = 0;
      CORBA::ULong slot = (CORBA::ULong) *pos->integer ();

      switch (kind)
      {
        case CORBA::tk_enum:
          {
            TAO_DynEnum_i dyn_enum;
            dyn_enum.init (this->current_value_.in ()
                           ACE_ENV_ARG_PARAMETER);
            ACE_TRY_CHECK;

            success = dyn_enum.seek (slot
                                     ACE_ENV_ARG_PARAMETER);
            ACE_TRY_CHECK;

            if (success == 0)
              {
                return -1;
              }