TAO_Property_Evaluator Class Reference

This class abstracts away the details of obtaining property values and property types. Since the procedure for obtaining the value or type of a dynamic property is disparate from the method for a static property, TAO_Property_Evaluator provides methods that will unify the two approaches under a single interface. Since dynamic properties aren't necessarily supported by a trader, this class accounts for that contingency. The use of indexed lookups allows them to occur in constant time on the CORBA sequences, but requires that the client know the layout of properties ahead of time. More...

#include <Trader_Utils.h>

Inheritance diagram for TAO_Property_Evaluator:

[legend]List of all members.

Public Member Functions
	TAO_Property_Evaluator (const CosTrading::PropertySeq &properties, CORBA::Boolean supports_dp=1)
	TAO_Property_Evaluator (CosTrading::Offer &offer, CORBA::Boolean supports_dp=1)
virtual	~TAO_Property_Evaluator (void)
	Clean up dynamic properties.
int	is_dynamic_property (int index)
CORBA::Any *	property_value (int index)
CORBA::TypeCode_ptr	property_type (int index)
Protected Types
typedef CosTradingDynamic::DynamicProp	DP_Struct
typedef CosTradingDynamic::DynamicPropEval	DP_Eval
Protected Attributes
const CosTrading::PropertySeq &	props_
int	supports_dp_
CORBA::Any **	dp_cache_
Private Member Functions
	TAO_Property_Evaluator (const TAO_Property_Evaluator &)
TAO_Property_Evaluator &	operator= (const TAO_Property_Evaluator &)

---

Detailed Description

This class abstracts away the details of obtaining property values and property types. Since the procedure for obtaining the value or type of a dynamic property is disparate from the method for a static property, TAO_Property_Evaluator provides methods that will unify the two approaches under a single interface. Since dynamic properties aren't necessarily supported by a trader, this class accounts for that contingency. The use of indexed lookups allows them to occur in constant time on the CORBA sequences, but requires that the client know the layout of properties ahead of time.

Definition at line 42 of file Trader_Utils.h.

---

Member Typedef Documentation

typedef CosTradingDynamic::DynamicPropEval TAO_Property_Evaluator::DP_Eval [protected]

Definition at line 89 of file Trader_Utils.h.

typedef CosTradingDynamic::DynamicProp TAO_Property_Evaluator::DP_Struct [protected]

Definition at line 88 of file Trader_Utils.h.

---

Constructor & Destructor Documentation

TAO_Property_Evaluator::TAO_Property_Evaluator	(	const CosTrading::PropertySeq &	properties,
		CORBA::Boolean	supports_dp = 1
	)

Definition at line 193 of file Trader_Utils.cpp.

References props_.

  : props_ (props),
    supports_dp_ (supports_dp),
    dp_cache_ (new CORBA::Any*[props.length ()])
{
  if (this->dp_cache_ != 0)
    {
      for (CORBA::ULong i = 0; i < this->props_.length (); i++)
        this->dp_cache_[i] = 0;
    }
}

TAO_Property_Evaluator::TAO_Property_Evaluator	(	CosTrading::Offer &	offer,
		CORBA::Boolean	supports_dp = 1
	)

Construct an instance of TAO_Property_Evaluator that operates on an <offer> where the support for dynamic properties is dictated by <supports_dynamic_properties>.

Definition at line 208 of file Trader_Utils.cpp.

References props_.

  : props_ (offer.properties),
    supports_dp_ (supports_dp),
    dp_cache_ (new CORBA::Any*[offer.properties.length ()])
{
  if (this->dp_cache_ != 0)
    for (CORBA::ULong i = 0; i < this->props_.length (); i++)
      this->dp_cache_[i] = 0;
}

TAO_Property_Evaluator::~TAO_Property_Evaluator

(

void

)

[virtual]

Clean up dynamic properties.

Definition at line 219 of file Trader_Utils.cpp.

References dp_cache_, and props_.

{
  // Clean up the results of any dynamic properties.
  for (CORBA::ULong i = 0; i < this->props_.length (); i++)
    if (this->dp_cache_[i] != 0)
      delete this->dp_cache_[i];

  delete [] this->dp_cache_;
}

TAO_Property_Evaluator::TAO_Property_Evaluator

(

const TAO_Property_Evaluator &

)

[private]

---

Member Function Documentation

int TAO_Property_Evaluator::is_dynamic_property

(

int

index

)

Returns 1 if the property at index <index> is dynamic. Returns a 0 when the index is out of bounds.

Definition at line 230 of file Trader_Utils.cpp.

References props_.

Referenced by TAO_Offer_Modifier::merge_properties(), TAO_Offer_Filter::ok_to_consider(), and property_value().

{
  int return_value = 0;
  int num_properties = this->props_.length();

  // Ensure index is in bounds.
  if (index >= 0 && index < num_properties)
    {
      // Obtain the value of the property at index <index>.
      const CORBA::Any& value = this->props_[index].value;
      CORBA::TypeCode_var type = value.type ();

      // @@ Seth, this will not work on platforms using environment variable.
      CORBA::Boolean equal = type->equal (CosTradingDynamic::_tc_DynamicProp);

      if (equal)
        return_value = 1;
    }

  return return_value;
}

TAO_Property_Evaluator& TAO_Property_Evaluator::operator=

(

const TAO_Property_Evaluator &

)

[private]

CORBA::TypeCode_ptr TAO_Property_Evaluator::property_type

(

int

index

)

Returns the type of the property whose index is <index>. If the property is dynamic and the trader supports dynamic properties, then the method returns the <returned_type> field of the CosTradingDynamic::DynamicProp struct associated with the property name. If the index is out of bounds, the method returns a null pointer (that is, 0).

Definition at line 310 of file Trader_Utils.cpp.

References props_.

Referenced by TAO_Offer_Modifier::merge_properties().

{
  CORBA::TypeCode_ptr prop_type = CORBA::TypeCode::_nil();

  // Determine if property is both defined and dynamic.
  if (this->is_dynamic_property (index))
    {
      // Extract type information from the DP_Struct.
      const CORBA::Any& value = this->props_[index].value;
      CosTradingDynamic::DynamicProp* dp_struct = 0;
      value >>= dp_struct;

      // Grab a pointer to the returned_type description
      prop_type = CORBA::TypeCode::_duplicate (dp_struct->returned_type.in ());
    }
  else
    // TypeCode is self-evident at this point.
    prop_type = this->props_[index].value.type ();

  return prop_type;
}

CORBA::Any * TAO_Property_Evaluator::property_value

(

int

index

)

Returns value of the property whose index is <index>. If the property at that index is dynamic and the trader supports dynamic properties, then the property_value method will obtain the value of the dynamic property using the evalDP method on the CosTradingDynamic::DynamicPropEval interface, passing on a CosTradingDynamic::DPEvalFailure exception on failure. If the property index is undefined, the method returns a null pointer.

Definition at line 253 of file Trader_Utils.cpp.

References dp_cache_, CosTradingDynamic::DynamicProp::eval_if, CosTradingDynamic::DynamicProp::extra_info, is_dynamic_property(), CORBA::is_nil(), props_, and CosTradingDynamic::DynamicProp::returned_type.

Referenced by TAO_Trader_Constraint_Evaluator::visit_property().

{
  CORBA::Any* prop_val = 0;
  CORBA::Boolean in_cache =
    this->dp_cache_ != 0 && this->dp_cache_[index] != 0;

  int dynamic = this->is_dynamic_property (index);

  if (!dynamic)
    prop_val = (CORBA::Any *) &(this->props_[index].value);
  else if (this->supports_dp_ && in_cache)
    prop_val = this->dp_cache_[index];
  else if (this->supports_dp_)
    {
      // Property is defined at this point.
      CosTradingDynamic::DynamicProp* dp_struct;
      const CORBA::String_var name = this->props_[index].name.in ();
      const CORBA::Any& value = this->props_[index].value;

      // Extract the DP_Struct.
      value >>= dp_struct;

      CosTradingDynamic::DynamicPropEval_var dp_eval =
        CosTradingDynamic::DynamicPropEval::_duplicate (dp_struct->eval_if.in ());

      if (CORBA::is_nil (dp_eval.in ()))
        {
          throw CosTradingDynamic::DPEvalFailure (
            name,
            CORBA::TypeCode::_nil (),
            CORBA::Any ());
        }
      else
        {
          CORBA::TypeCode* type = dp_struct->returned_type.in ();
          CORBA::Any& info = dp_struct->extra_info;

          try
            {
              // Retrieve the value of the dynamic property.
              prop_val = dp_eval->evalDP(name, type, info);

              if (this->dp_cache_ != 0)
                this->dp_cache_[index] = prop_val;
            }
          catch (const CORBA::SystemException&)
            {
              throw
                (CosTradingDynamic::DPEvalFailure (name, type, info));
            }
        }
    }

  return prop_val;
}

---

Member Data Documentation

CORBA::Any** TAO_Property_Evaluator::dp_cache_ [protected]

In order for the client to treat the results of property_value uniformly, we need to collect the dynamically allocated anys retrieved from dynamic properties and free them upon deletion. If we didn't do this, then the property_value method would leak or cause seg faults, since the client wouldn't be able to tell whether or not the return value should be freed.

Definition at line 105 of file Trader_Utils.h.

Referenced by property_value(), and ~TAO_Property_Evaluator().

const CosTrading::PropertySeq& TAO_Property_Evaluator::props_ [protected]

The offer from which the TAO_Property_Evaluator extracts property information.

Definition at line 93 of file Trader_Utils.h.

Referenced by TAO_Property_Evaluator_By_Name::get_property(), is_dynamic_property(), property_type(), property_value(), TAO_Property_Evaluator(), TAO_Property_Evaluator_By_Name::TAO_Property_Evaluator_By_Name(), and ~TAO_Property_Evaluator().

int TAO_Property_Evaluator::supports_dp_ [protected]

Definition at line 95 of file Trader_Utils.h.

---

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

• Trader_Utils.h
• Trader_Utils.cpp

---