constraint_visitors.cpp

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

            this->queue_.dequeue_operand ();
        }
    }

  return return_value;
}

int
TAO_Constraint_Evaluator::
visit_less_than (TAO_Binary_Constraint* boolean_lt)
{
  return this->visit_bin_op (boolean_lt, TAO_LT);
}

int
TAO_Constraint_Evaluator::
visit_less_than_equal (TAO_Binary_Constraint* boolean_lte)
{
  return this->visit_bin_op (boolean_lte, TAO_LE);
}

int
TAO_Constraint_Evaluator::
visit_greater_than (TAO_Binary_Constraint* boolean_gt)
{
  return this->visit_bin_op (boolean_gt, TAO_GT);
}

int
TAO_Constraint_Evaluator::
visit_greater_than_equal (TAO_Binary_Constraint* boolean_gte)
{
  return this->visit_bin_op (boolean_gte, TAO_GE);
}

int
TAO_Constraint_Evaluator::
visit_equal (TAO_Binary_Constraint* boolean_eq)
{
  return this->visit_bin_op (boolean_eq, TAO_EQ);
}

int
TAO_Constraint_Evaluator::
visit_not_equal (TAO_Binary_Constraint* boolean_neq)
{
  return this->visit_bin_op (boolean_neq, TAO_NE);
}

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

int
TAO_Constraint_Evaluator::
visit_property (TAO_Property_Constraint* literal)
{
  ACE_UNUSED_ARG (literal);
  return -1;
  // A derived class decides how to do this.
}

/*@@ pradeep: where is this used?

CORBA::Boolean
TAO_find_string (CosTradingSequences::StringSeq& sequence,
                 const char* element)
{
 int length = sequence.length (),
    return_value = 0;

  for (int i = 0; i < length; i++)
    {
      if (ACE_OS::strcmp (sequence[i], element) == 0)
        {
          return_value = 1;
          break;
        }
    }

  return (CORBA::Boolean) return_value;
}
*/

CORBA::Boolean
TAO_Constraint_Evaluator::
sequence_does_contain (CORBA::Any* sequence,
                      TAO_Literal_Constraint& element)
{
  // Helper method to cast the void* value returned from the sequence
  // any into a sequence type locally compiled from idl. The sequence
  // wrapper uses the [] operator to locate the target element in the
  // sequence.

  ACE_DECLARE_NEW_CORBA_ENV;
  CORBA::Boolean return_value = 0;
  CORBA::TypeCode_var type = sequence->type ();
  CORBA::TCKind sequence_type = CORBA::tk_void;
  ACE_TRY
    {
      sequence_type =
        TAO_Sequence_Extracter_Base::sequence_type (type.in () ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return return_value;
    }
  ACE_ENDTRY;
  //  ACE_CHECK_RETURN (return_value);

  if (sequence_type == CORBA::tk_void)
    return return_value;

  switch (sequence_type)
    {
    case CORBA::tk_short:
      {
        CORBA::Long value = element;
        return_value = ::TAO_find (*sequence, ACE_static_cast (CORBA::Short, value));
      }
    break;
    case CORBA::tk_ushort:
      {
        CORBA::ULong value = element;
        return_value = ::TAO_find (*sequence, ACE_static_cast (CORBA::UShort, value));
      }
      break;
    case CORBA::tk_long:
      {
        CORBA::Long value = element;
        return_value = ::TAO_find (*sequence, value);
      }
      break;
    case CORBA::tk_ulong:
      {
        CORBA::ULong value = element;
        return_value = ::TAO_find (*sequence, value);
      }
      break;
    case CORBA::tk_float:
      {
        CORBA::Double value = element;
        return_value = ::TAO_find (*sequence, ACE_static_cast (CORBA::Float, value));
      }
      break;
    case CORBA::tk_double:
      {
        CORBA::Double value = element;
        return_value = ::TAO_find (*sequence, value);
      }
      break;
    case CORBA::tk_boolean:
      {
        CORBA::Boolean value = element;
        return_value = ::TAO_find (*sequence, value);
      }
      break;
    case CORBA::tk_string:
      {
        const char* value = element;
        return_value = ::TAO_find (*sequence, value);
      }
      break;
    default:
      break;
    }

  return return_value;
}

// Explicit template specializations

int
TAO_Element_Equal<CORBA::Short>::
operator () (TAO_DynSequence_i& dyn_any,
             CORBA::Short element) const
{
  int return_value = 0;
  ACE_TRY_NEW_ENV
    {
      CORBA::Short value = dyn_any.get_short (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      return_value = (value == element);
    }
  ACE_CATCHANY
    {
    }
  ACE_ENDTRY;
  return return_value;
}

int
TAO_Element_Equal<CORBA::UShort>::
operator () (TAO_DynSequence_i& dyn_any,
             CORBA::UShort element) const
{
  int return_value = 0;
  ACE_TRY_NEW_ENV
    {
      CORBA::UShort value = dyn_any.get_ushort (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      return_value = (value == element);
    }
  ACE_CATCHANY
    {
    }
  ACE_ENDTRY;
  return return_value;
}

int
TAO_Element_Equal<CORBA::Long>::
operator () (TAO_DynSequence_i& dyn_any,
             CORBA::Long element) const
{
  int return_value = 0;
  ACE_TRY_NEW_ENV
    {
      CORBA::Long value = dyn_any.get_long (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      return_value = (value == element);
    }
  ACE_CATCHANY
    {
    }
  ACE_ENDTRY;
  return return_value;
}

int
TAO_Element_Equal<CORBA::ULong>::
operator () (TAO_DynSequence_i& dyn_any,
             CORBA::ULong element) const
{
  int return_value = 0;
  ACE_TRY_NEW_ENV
    {
      CORBA::ULong value = dyn_any.get_ulong (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      return_value = (value == element);
    }
  ACE_CATCHANY
    {
    }
  ACE_ENDTRY;
  return return_value;
}

int
TAO_Element_Equal<CORBA::Float>::
operator () (TAO_DynSequence_i& dyn_any,
             CORBA::Float element) const
{
  int return_value = 0;
  ACE_TRY_NEW_ENV
    {
      CORBA::Float value = dyn_any.get_float (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      return_value = (value == element);
    }
  ACE_CATCHANY {} ACE_ENDTRY;
  return return_value;
}

int
TAO_Element_Equal<CORBA::Double>::
operator () (TAO_DynSequence_i& dyn_any,
             CORBA::Double element) const
{
  int return_value = 0;
  ACE_TRY_NEW_ENV
    {
      CORBA::Double value = dyn_any.get_short (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      return_value = (value == element);
    }
  ACE_CATCHANY {} ACE_ENDTRY;
  return return_value;
}

int
TAO_Element_Equal<CORBA::Boolean>::
operator () (TAO_DynSequence_i& dyn_any,
             CORBA::Boolean element) const
{
  int return_value = 0;
  ACE_TRY_NEW_ENV
    {
    CORBA::Boolean value = (CORBA::Boolean) dyn_any.get_short (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      return_value = (value == element);
    }
  ACE_CATCHANY {} ACE_ENDTRY;
  return return_value;
}

int
TAO_Element_Equal<const char*>::
operator () (TAO_DynSequence_i& dyn_any,
             const char* element) const
{
  int return_value = 0;
  ACE_TRY_NEW_ENV
    {
      const char* value = dyn_any.get_string (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      return_value = (ACE_OS::strcmp (value, element) == 0);
    }
  ACE_CATCHANY {} ACE_ENDTRY;
  return return_value;
}

TAO_Constraint_Validator::
TAO_Constraint_Validator (void)
{
  // No-Op.
}

TAO_Constraint_Validator::~TAO_Constraint_Validator (void)
{
  for (TAO_Typecode_Table::iterator type_iter (this->type_map_);
       ! type_iter.done ();
       type_iter++)
    {
      CORBA::TypeCode_ptr corba_type = (*type_iter).int_id_;
      CORBA::release (corba_type);
    }
}

int
TAO_Constraint_Validator::validate (TAO_Constraint* root)
{
  return root->accept(this);
}

int
TAO_Constraint_Validator::visit_constraint (TAO_Unary_Constraint* constraint)
{
  int return_value = -1;
  TAO_Expression_Type type;
  TAO_Constraint* operand = constraint->operand ();
  this->extract_type (operand, type);

  if (this->expr_returns_boolean (type))
    return_value =  operand->accept (this);

  return return_value;
}

int
TAO_Constraint_Validator::visit_first (TAO_Noop_Constraint *)
{
  return 0;
}

int
TAO_Constraint_Validator::visit_random (TAO_Noop_Constraint *)
{
  return 0;
}

int
TAO_Constraint_Validator::visit_with (TAO_Unary_Constraint* unary_with)
{
  return this->visit_constraint (unary_with);
}

int
TAO_Constraint_Validator::visit_min (TAO_Unary_Constraint* unary_min)
{
  return this->visit_unary_minus (unary_min);
}

int
TAO_Constraint_Validator::visit_max (TAO_Unary_Constraint* unary_max)
{
  return this->visit_unary_minus (unary_max);
}

int
TAO_Constraint_Validator::
visit_and (TAO_Binary_Constraint* boolean_and)
{
  int return_value = -1;
  TAO_Constraint* left = boolean_and->left_operand (),
    *right = boolean_and->right_operand ();
  TAO_Expression_Type left_type, right_type;
  this->extract_type (left, left_type);
  this->extract_type (right, right_type);

  // Can only "and" expressions that return a boolean value
  if (this->expr_returns_boolean (left_type) &&
      this->expr_returns_boolean (right_type))
    {
      if (left->accept (this) == 0 &&
          right->accept (this) == 0)
        return_value = 0;
    }

  return return_value;
}

int
TAO_Constraint_Validator::
visit_or(TAO_Binary_Constraint* boolean_or)
{
  // The types for or are the same as those for and.