TAO_Constraint_Validator Class Reference

TAO_Constraint_Validator ensures that in an expression tree passed to it, the operands of each operation match the correct types. More...

#include <Constraint_Visitors.h>

Inheritance diagram for TAO_Constraint_Validator:

[legend]Collaboration diagram for TAO_Constraint_Validator:

[legend]List of all members.

Public Member Functions
	TAO_Constraint_Validator (void)
	Constructor.
virtual	~TAO_Constraint_Validator (void)
	Destructor.
int	validate (TAO_Constraint *root)
virtual int	visit_constraint (TAO_Unary_Constraint *constraint)
virtual int	visit_with (TAO_Unary_Constraint *unary_with)
virtual int	visit_min (TAO_Unary_Constraint *unary_min)
virtual int	visit_max (TAO_Unary_Constraint *unary_max)
virtual int	visit_first (TAO_Noop_Constraint *noop_first)
virtual int	visit_random (TAO_Noop_Constraint *noop_random)
virtual int	visit_and (TAO_Binary_Constraint *boolean_and)
	The two operands must return a boolean value.
virtual int	visit_or (TAO_Binary_Constraint *boolean_or)
virtual int	visit_not (TAO_Unary_Constraint *unary_not)
	The operand must return a boolean value.
virtual int	visit_exist (TAO_Unary_Constraint *unary_exist)
virtual int	visit_unary_minus (TAO_Unary_Constraint *unary_minus)
	The operand must return a number to be negated.
virtual int	visit_add (TAO_Binary_Constraint *boolean_add)
	Both operands must return numeric results.
virtual int	visit_sub (TAO_Binary_Constraint *boolean_sub)
virtual int	visit_mult (TAO_Binary_Constraint *boolean_mult)
virtual int	visit_div (TAO_Binary_Constraint *boolean_div)
virtual int	visit_twiddle (TAO_Binary_Constraint *binary_twiddle)
	Both operands must return strings.
virtual int	visit_in (TAO_Binary_Constraint *binary_in)
virtual int	visit_less_than (TAO_Binary_Constraint *boolean_lt)
	The left and right operands must both be of the same simple type.
virtual int	visit_less_than_equal (TAO_Binary_Constraint *boolean_lte)
virtual int	visit_greater_than (TAO_Binary_Constraint *boolean_gt)
virtual int	visit_greater_than_equal (TAO_Binary_Constraint *boolean_gte)
virtual int	visit_equal (TAO_Binary_Constraint *boolean_eq)
virtual int	visit_not_equal (TAO_Binary_Constraint *boolean_neq)
virtual int	visit_literal (TAO_Literal_Constraint *literal)
	The property must be defined in the service type description.
virtual int	visit_property (TAO_Property_Constraint *literal)
Protected Attributes
TAO_Typecode_Table	type_map_
Private Member Functions
CORBA::TypeCode *	extract_type (TAO_Constraint *expr_type, TAO_Expression_Type &type)
int	expr_returns_boolean (TAO_Expression_Type expr_type)
int	expr_returns_number (TAO_Expression_Type expr_type)
int	expr_returns_string (TAO_Expression_Type expr_type)
	TAO_Constraint_Validator (const TAO_Constraint_Validator &)
TAO_Constraint_Validator &	operator= (const TAO_Constraint_Validator &)

---

Detailed Description

TAO_Constraint_Validator ensures that in an expression tree passed to it, the operands of each operation match the correct types.

TAO_Constraint_Validator uses the visitor pattern to traverse all the nodes in an expression tree, checking that for each operator node the operands are of the proper data type it they're literals, or that they exist in the service type definition _and_ have the proper type, if they're property names. The algorithm for type checking is as follows: ensure that operand expression(s) return the correct types using expr_returns* methods. If they (or it) return the correct types, call accept on each operand until all return true or one returns false, at which point we can back out of the traversal and indicate failure.

Definition at line 116 of file Constraint_Visitors.h.

---

Constructor & Destructor Documentation

TAO_Constraint_Validator::TAO_Constraint_Validator

(

void

)

Constructor.

Definition at line 770 of file Constraint_Visitors.cpp.

{
  // No-Op.
}

TAO_Constraint_Validator::~TAO_Constraint_Validator

(

void

)

[virtual]

Destructor.

Definition at line 775 of file Constraint_Visitors.cpp.

References CORBA::release().

{
  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);
    }
}

TAO_Constraint_Validator::TAO_Constraint_Validator

(

const TAO_Constraint_Validator &

)

[private]

---

Member Function Documentation

int TAO_Constraint_Validator::expr_returns_boolean

(

TAO_Expression_Type

expr_type

)

[private]

expr_returns_boolean returns 1 if <expr_type>, when evaluated, will return a boolean.

Definition at line 1197 of file Constraint_Visitors.cpp.

References TAO_BOOLEAN.

Referenced by visit_and(), and visit_equal().

{
  // If the expression is a boolean operations, a boolean literal, or
  // a boolean property, return 1.
  int return_value = 0;

  if (expr_type <= TAO_BOOLEAN)
    return_value = 1;

  return return_value;
}

int TAO_Constraint_Validator::expr_returns_number

(

TAO_Expression_Type

expr_type

)

[private]

expr_returns_boolean returns 1 if <expr_type>, when evaluated, will return a number.

Definition at line 1211 of file Constraint_Visitors.cpp.

References TAO_DOUBLE, TAO_NUMBER, TAO_PLUS, and TAO_SIGNED.

Referenced by visit_add(), visit_div(), visit_equal(), and visit_less_than().

{
  // If the expression is a number operation, a numeric literal, or a
  // numeric property, return 1.
  int return_value = 0;

  if ((expr_type >= TAO_PLUS && expr_type <= TAO_NUMBER) ||
      (expr_type >= TAO_SIGNED && expr_type <= TAO_DOUBLE))
    return_value = 1;

  return return_value;
}

int TAO_Constraint_Validator::expr_returns_string

(

TAO_Expression_Type

expr_type

)

[private]

expr_returns_boolean returns 1 if <expr_type>, when evaluated, will return a string.

Definition at line 1225 of file Constraint_Visitors.cpp.

References TAO_STRING.

Referenced by visit_equal(), visit_less_than(), and visit_twiddle().

{
  // If the expression is an operation with a string return value, a
  // string literal, or a property whose type is string, return 1.
  int return_value = 0;

  if (expr_type == TAO_STRING)
    return_value = 1;

  return return_value;
}

CORBA::TypeCode * TAO_Constraint_Validator::extract_type	(	TAO_Constraint *	expr_type,
		TAO_Expression_Type &	type
	)			[private]

Definition at line 1178 of file Constraint_Visitors.cpp.

References TAO_Literal_Constraint::comparable_type(), TAO_Constraint::expr_type(), TAO_Property_Constraint::name(), and TAO_IDENT.

Referenced by visit_add(), visit_and(), visit_constraint(), visit_div(), visit_equal(), visit_in(), visit_less_than(), visit_not(), visit_twiddle(), and visit_unary_minus().

{
  CORBA::TypeCode* return_value = 0;

  type = expr->expr_type ();
  if (type == TAO_IDENT)
    {
      TAO_Property_Constraint* prop = (TAO_Property_Constraint*) expr;
      CORBA::String_var prop_name (prop->name ());

      if (this->type_map_.find (prop_name, return_value) == 0)
        type = TAO_Literal_Constraint::comparable_type (return_value);
    }

  return return_value;
}

TAO_Constraint_Validator& TAO_Constraint_Validator::operator=

(

const TAO_Constraint_Validator &

)

[private]

int TAO_Constraint_Validator::validate

(

TAO_Constraint *

root

)

Validate returns 1 if the expression tree whose root is <root> makes semantic sense, in that the operands for each operation comply with each other and the types accepted by the operator.

Definition at line 787 of file Constraint_Visitors.cpp.

References TAO_Constraint::accept().

Referenced by TAO_Constraint_Interpreter::TAO_Constraint_Interpreter(), and TAO_Preference_Interpreter::TAO_Preference_Interpreter().

{
  return root->accept(this);
}

int TAO_Constraint_Validator::visit_add

(

TAO_Binary_Constraint *

boolean_add

)

[virtual]

Both operands must return numeric results.

Implements TAO_Constraint_Visitor.

Definition at line 917 of file Constraint_Visitors.cpp.

References TAO_Constraint::accept(), expr_returns_number(), extract_type(), TAO_Binary_Constraint::left_operand(), and TAO_Binary_Constraint::right_operand().

Referenced by visit_mult(), and visit_sub().

{
  // All the mathematical operators require numeric operands.
  int return_value = -1;
  TAO_Constraint* left = boolean_add->left_operand (),
    *right = boolean_add->right_operand ();
  TAO_Expression_Type left_type, right_type;
  this->extract_type (left, left_type);
  this->extract_type (right, right_type);

  if (this->expr_returns_number (left_type) &&
      this->expr_returns_number (right_type))
    {
      if (left->accept (this) == 0 &&
          right->accept (this) == 0)
        return_value = 0;
    }

  return return_value;
}

int TAO_Constraint_Validator::visit_and

(

TAO_Binary_Constraint *

boolean_and

)

[virtual]

The two operands must return a boolean value.

Implements TAO_Constraint_Visitor.

Definition at line 838 of file Constraint_Visitors.cpp.

References TAO_Constraint::accept(), expr_returns_boolean(), extract_type(), TAO_Binary_Constraint::left_operand(), and TAO_Binary_Constraint::right_operand().

Referenced by visit_or().

{
  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_constraint

(

TAO_Unary_Constraint *

constraint

)

[virtual]

Implements TAO_Constraint_Visitor.

Definition at line 793 of file Constraint_Visitors.cpp.

References TAO_Constraint::accept(), extract_type(), and TAO_Unary_Constraint::operand().

Referenced by visit_with().

{
  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_div

(

TAO_Binary_Constraint *

boolean_div

)

[virtual]

Implements TAO_Constraint_Visitor.

Definition at line 954 of file Constraint_Visitors.cpp.

References TAO_Constraint::accept(), expr_returns_number(), extract_type(), TAO_Binary_Constraint::left_operand(), TAO_Binary_Constraint::right_operand(), TAO_DOUBLE, TAO_SIGNED, and TAO_UNSIGNED.

{
  // Div not only requires that both of its operands be numeric, but
  // also the the demoninator not be zero. However, since the
  // denominator can be an expression who's value can only be
  // determined while evaulating the constraint expression, this
  // method detects only when the demoniator is a literal whose value
  // is zero.
  int return_value = -1;
  TAO_Constraint* left = boolean_div->left_operand (),
    *right = boolean_div->right_operand ();
  TAO_Expression_Type left_type, right_type;
  this->extract_type (left, left_type);
  this->extract_type (right, right_type);

  if (this->expr_returns_number (left_type) &&
      this->expr_returns_number (right_type))
    {
      // Prevent division by zero, a no no.
      int right_isnt_zero = 1;
      switch(right->expr_type ())
        {
        case TAO_UNSIGNED:
          right_isnt_zero =
            (static_cast<CORBA::ULongLong>
               (*dynamic_cast<TAO_Literal_Constraint*> (right)) != 0);
          break;
        case TAO_SIGNED:
          right_isnt_zero =
            (static_cast<CORBA::LongLong>
               (*dynamic_cast<TAO_Literal_Constraint*> (right)) != 0);
          break;
        case TAO_DOUBLE:
          right_isnt_zero =
            (static_cast<CORBA::Double>
               (*dynamic_cast<TAO_Literal_Constraint*> (right)) != 0.0);
          break;
        }

      if (right_isnt_zero)
        {
          if (left->accept (this) == 0 &&
              right->accept (this) == 0)
            return_value = 0;
        }
    }

  return return_value;
}

int TAO_Constraint_Validator::visit_equal

(

TAO_Binary_Constraint *

boolean_eq

)

[virtual]

Implements TAO_Constraint_Visitor.

Definition at line 1132 of file Constraint_Visitors.cpp.

References TAO_Constraint::accept(), expr_returns_boolean(), expr_returns_number(), expr_returns_string(), extract_type(), TAO_Binary_Constraint::left_operand(), and TAO_Binary_Constraint::right_operand().

Referenced by visit_not_equal().

{
  int return_value = -1;
  TAO_Constraint* left = boolean_eq->left_operand (),
    *right = boolean_eq->right_operand ();
  TAO_Expression_Type left_type, right_type;
  this->extract_type (left, left_type);
  this->extract_type (right, right_type);

  if ((this->expr_returns_number (left_type) &&
       this->expr_returns_number (right_type)) ||
      (this->expr_returns_string (left_type) &&
       this->expr_returns_string (right_type)) ||
      (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_exist

(

TAO_Unary_Constraint *

unary_exist

)

[virtual]

The operand must return a valid (i.e., present in the service type description) property name.

Implements TAO_Constraint_Visitor.

Definition at line 885 of file Constraint_Visitors.cpp.

References TAO_Constraint::accept(), TAO_Constraint::expr_type(), TAO_Unary_Constraint::operand(), and TAO_IDENT.

{
  // Exist simply requires that its operand be a property name
  // included in the service type.
  int return_value = -1;
  TAO_Constraint* operand = unary_exist->operand ();
  TAO_Expression_Type type = operand->expr_type ();

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

  return return_value;
}

int TAO_Constraint_Validator::visit_first

(

TAO_Noop_Constraint *

noop_first

)

[virtual]

Implements TAO_Constraint_Visitor.

Definition at line 807 of file Constraint_Visitors.cpp.

{
  return 0;
}

int TAO_Constraint_Validator::visit_greater_than

(

TAO_Binary_Constraint *

boolean_gt

)

[virtual]

Implements TAO_Constraint_Visitor.

Definition at line 1118 of file Constraint_Visitors.cpp.

References visit_less_than().

{
  return this->visit_less_than (boolean_gt);
}

int TAO_Constraint_Validator::visit_greater_than_equal

(

TAO_Binary_Constraint *

boolean_gte

)

[virtual]

Implements TAO_Constraint_Visitor.

Definition at line 1125 of file Constraint_Visitors.cpp.

References visit_less_than().

{
  return this->visit_less_than(boolean_gte);
}

int TAO_Constraint_Validator::visit_in

(

TAO_Binary_Constraint *

binary_in

)

[virtual]

The right operand must be a sequence of the same simple type as the left operand.

Implements TAO_Constraint_Visitor.

Definition at line 1029 of file Constraint_Visitors.cpp.

References TAO_Constraint::accept(), extract_type(), TAO_Binary_Constraint::left_operand(), TAO_Binary_Constraint::right_operand(), TAO_Sequence_Extracter_Base::sequence_type(), TAO_SEQUENCE, CORBA::tk_boolean, CORBA::tk_double, CORBA::tk_float, CORBA::tk_long, CORBA::tk_longlong, CORBA::tk_short, CORBA::tk_string, CORBA::tk_ulong, CORBA::tk_ulonglong, CORBA::tk_ushort, and CORBA::tk_void.

{
  // In requires that the right operand be a sequence of a simple type
  // and that its left operand be an expression that evaluates to a
  // value of the same simple type.
  int return_value = -1;
  TAO_Expression_Type left_type, right_type;
  TAO_Constraint
    *left = binary_in->left_operand (),
    *right = binary_in->right_operand ();

  CORBA::TypeCode* prop_type = this->extract_type (right, right_type);
  this->extract_type (left, left_type);

  if (right_type == TAO_SEQUENCE)
    {
      CORBA::Boolean types_match = 0;
      CORBA::TCKind seq_type = CORBA::tk_void;
      try
        {
          seq_type =
            TAO_Sequence_Extracter_Base::sequence_type (prop_type);
        }
      catch (const CORBA::Exception&)
        {
          return return_value;
        }

      if (seq_type != CORBA::tk_void)
        {
          if (this->expr_returns_number (left_type))
            {
              types_match = (seq_type == CORBA::tk_short ||
                             seq_type == CORBA::tk_ushort ||
                             seq_type == CORBA::tk_long ||
                             seq_type == CORBA::tk_ulong ||
                             seq_type == CORBA::tk_longlong ||
                             seq_type == CORBA::tk_ulonglong ||
                             seq_type == CORBA::tk_float ||
                             seq_type == CORBA::tk_double);
            }
          else if (this->expr_returns_boolean (left_type))
            types_match = (seq_type == CORBA::tk_boolean);
          else if (this->expr_returns_string (left_type))
            types_match = (seq_type == CORBA::tk_string);

          if (types_match)
            return_value = left->accept (this);
        }
    }

  return return_value;
}

int TAO_Constraint_Validator::visit_less_than

(

TAO_Binary_Constraint *

boolean_lt

)

[virtual]

The left and right operands must both be of the same simple type.

Implements TAO_Constraint_Visitor.

Definition at line 1085 of file Constraint_Visitors.cpp.

References TAO_Constraint::accept(), expr_returns_number(), expr_returns_string(), extract_type(), TAO_Binary_Constraint::left_operand(), and TAO_Binary_Constraint::right_operand().

Referenced by visit_greater_than(), visit_greater_than_equal(), and visit_less_than_equal().

{
  // Comparison operations require that both operands be of the same
  // simple type.
  int return_value = -1;
  TAO_Constraint* left = boolean_lt->left_operand (),
    *right = boolean_lt->right_operand ();
  TAO_Expression_Type left_type, right_type;
  this->extract_type (left, left_type);
  this->extract_type (right, right_type);

  if ((this->expr_returns_number (left_type) &&
       this->expr_returns_number (right_type)) ||
      (this->expr_returns_string (left_type) &&
       this->expr_returns_string (right_type)))
    {
      if (left->accept (this) == 0 &&
          right->accept (this) == 0)
        return_value = 0;
    }

  return return_value;
}

int TAO_Constraint_Validator::visit_less_than_equal

(

TAO_Binary_Constraint *

boolean_lte

)

[virtual]

Implements TAO_Constraint_Visitor.

Definition at line 1111 of file Constraint_Visitors.cpp.

References visit_less_than().

{
  return this->visit_less_than (boolean_lte);
}

int TAO_Constraint_Validator::visit_literal

(

TAO_Literal_Constraint *

literal

)

[virtual]

The property must be defined in the service type description.

Implements TAO_Constraint_Visitor.

Definition at line 1165 of file Constraint_Visitors.cpp.

{
  return 0;
}

int TAO_Constraint_Validator::visit_max

(

TAO_Unary_Constraint *

unary_max

)

[virtual]

Implements TAO_Constraint_Visitor.

Definition at line 831 of file Constraint_Visitors.cpp.

References visit_unary_minus().

{
  return this->visit_unary_minus (unary_max);
}

int TAO_Constraint_Validator::visit_min

(

TAO_Unary_Constraint *

unary_min

)

[virtual]

Implements TAO_Constraint_Visitor.

Definition at line 825 of file Constraint_Visitors.cpp.

References visit_unary_minus().

{
  return this->visit_unary_minus (unary_min);
}

int TAO_Constraint_Validator::visit_mult

(

TAO_Binary_Constraint *

boolean_mult

)

[virtual]

Implements TAO_Constraint_Visitor.

Definition at line 947 of file Constraint_Visitors.cpp.

References visit_add().

{
  return this->visit_add (boolean_mult);
}

int TAO_Constraint_Validator::visit_not

(

TAO_Unary_Constraint *

unary_not

)

[virtual]

The operand must return a boolean value.

Implements TAO_Constraint_Visitor.

Definition at line 869 of file Constraint_Visitors.cpp.

References TAO_Constraint::accept(), extract_type(), and TAO_Unary_Constraint::operand().

{
  int return_value = -1;
  // Not can only negate an expression that returns a boolean.
  TAO_Expression_Type type;
  TAO_Constraint* operand = unary_not->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_not_equal

(

TAO_Binary_Constraint *

boolean_neq

)

[virtual]

Implements TAO_Constraint_Visitor.

Definition at line 1158 of file Constraint_Visitors.cpp.

References visit_equal().

{
  return this->visit_equal (boolean_neq);
}

int TAO_Constraint_Validator::visit_or

(

TAO_Binary_Constraint *

boolean_or

)

[virtual]

Implements TAO_Constraint_Visitor.

Definition at line 861 of file Constraint_Visitors.cpp.

References visit_and().

{
  // The types for or are the same as those for and.
  return this->visit_and (boolean_or);
}

int TAO_Constraint_Validator::visit_property

(

TAO_Property_Constraint *

literal

)

[virtual]

Implements TAO_Constraint_Visitor.

Definition at line 1172 of file Constraint_Visitors.cpp.

{
  return 0;
}

int TAO_Constraint_Validator::visit_random

(

TAO_Noop_Constraint *

noop_random

)

[virtual]

Implements TAO_Constraint_Visitor.

Definition at line 813 of file Constraint_Visitors.cpp.

{
  return 0;
}

int TAO_Constraint_Validator::visit_sub

(

TAO_Binary_Constraint *

boolean_sub

)

[virtual]

Implements TAO_Constraint_Visitor.

Definition at line 940 of file Constraint_Visitors.cpp.

References visit_add().

{
  return this->visit_add (boolean_sub);
}

int TAO_Constraint_Validator::visit_twiddle

(

TAO_Binary_Constraint *

binary_twiddle

)

[virtual]

Both operands must return strings.

Implements TAO_Constraint_Visitor.

Definition at line 1006 of file Constraint_Visitors.cpp.

References TAO_Constraint::accept(), expr_returns_string(), extract_type(), TAO_Binary_Constraint::left_operand(), and TAO_Binary_Constraint::right_operand().

{
  // Twiddle requires that both of its operand be strings.
  int return_value = -1;
  TAO_Constraint* left = binary_twiddle->left_operand (),
    *right = binary_twiddle->right_operand ();
  TAO_Expression_Type left_type, right_type;
  this->extract_type (left, left_type);
  this->extract_type (right, right_type);

  if  (this->expr_returns_string (left_type) &&
      this->expr_returns_string (right_type))
    {
      if (left->accept (this) == 0 &&
          right->accept (this) == 0)
        return_value = 0;
    }

  return return_value;
}

int TAO_Constraint_Validator::visit_unary_minus

(

TAO_Unary_Constraint *

unary_minus

)

[virtual]

The operand must return a number to be negated.

Implements TAO_Constraint_Visitor.

Definition at line 901 of file Constraint_Visitors.cpp.

References TAO_Constraint::accept(), extract_type(), and TAO_Unary_Constraint::operand().

Referenced by visit_max(), and visit_min().

{
  // Unary minus can only negate a numeric operand.
  int return_value = -1;
  TAO_Expression_Type type;
  TAO_Constraint* operand = unary_minus->operand ();
  this->extract_type (operand, type);

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

  return return_value;
}

int TAO_Constraint_Validator::visit_with

(

TAO_Unary_Constraint *

unary_with

)

[virtual]

Implements TAO_Constraint_Visitor.

Definition at line 819 of file Constraint_Visitors.cpp.

References visit_constraint().

{
  return this->visit_constraint (unary_with);
}

---

Member Data Documentation

TAO_Typecode_Table TAO_Constraint_Validator::type_map_ [protected]

A map gleaned from the ServiceTypeStruct, which correlates property names with their types.

Definition at line 185 of file Constraint_Visitors.h.

---

The documentation for this class was generated from the following files:

• Constraint_Visitors.h
• Constraint_Visitors.cpp

---