1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
/* -*- C++ -*- */
//=============================================================================
/**
* @file Constraint_Interpreter.h
*
* $Id$
*
* @author Seth Widoff <sbw1@cs.wustl.edu>
*/
//=============================================================================
#ifndef TAO_CONSTRAINT_INTERPRETER_H
#define TAO_CONSTRAINT_INTERPRETER_H
#include /**/ "ace/pre.h"
#include "Constraint_Nodes.h"
#include "Constraint_Visitors.h"
#include "Interpreter.h"
#include "orbsvcs/orbsvcs/CosTradingS.h"
#include "orbsvcs/orbsvcs/CosTradingReposS.h"
class TAO_Constraint_Evaluator;
class TAO_Constraint_Validator;
/**
* @class TAO_Constraint_Interpreter
*
* @brief TAO_Constraint_Interpreter will, given a constraint string whose
* syntax and semantics comply with the trader specification for the
* constraint language, determine if a CosTrading::Offer meets the
* constraints.
*
* TAO_Constraint_Interpreter will first build an expression tree
* representing the constraint expression using Lex and Yacc. Then,
* using a TAO_Constraint_Validator, it will validate the semantic
* correctness of the tree. When the evaluate method is invoked with
* an Offer, the TAO_Constraint_Interpreter will construct an
* EvaluationVisitor, which will evaluate the tree and decide
* whether the offer meets the constraints.
*/
class TAO_Trading_Export TAO_Constraint_Interpreter : public TAO_Interpreter
{
public:
// = Initialization and termination methods.
TAO_Constraint_Interpreter (const CosTradingRepos::ServiceTypeRepository::TypeStruct& ts,
const char* constraints
ACE_ENV_ARG_DECL)
ACE_THROW_SPEC ((CosTrading::IllegalConstraint,
CORBA::NO_MEMORY));
/**
* This constructor builds an expression tree representing the
* constraint specified in <constraints>, and throws an Illegal
* Constraint exception if the constraint given has syntax errors or
* semantic errors, such as mismatched types.
*/
TAO_Constraint_Interpreter (TAO_Constraint_Validator& validator,
const char* constraints
ACE_ENV_ARG_DECL)
ACE_THROW_SPEC ((CosTrading::IllegalConstraint,
CORBA::NO_MEMORY));
/// Destructor
~TAO_Constraint_Interpreter (void);
CORBA::Boolean evaluate (CosTrading::Offer* offer);
CORBA::Boolean evaluate (TAO_Constraint_Evaluator& evaluator);
// Determine whether an offer fits the constraints with which the
// tree was constructed. This method is thread safe (hopefully).
};
/**
* @class TAO_Preference_Interpreter
*
* @brief The TAO_Preference_Interpreter will, given a valid preference
* string and offers, will order the offers based on the offers'
* compliance with the preferences.
*
* Each time the order_offer method is invoked, the
* TAO_Preference_Interpreter stores the offer reference in the
* order dictated by its evaluation of the preference string. After
* the TAO_Preference_Interpreter client has finished ordering all
* the offers, it will extract the offers in order using the
* remove_offer method.
*/
class TAO_Trading_Export TAO_Preference_Interpreter : public TAO_Interpreter
{
public:
// = Initialization and termination methods.
TAO_Preference_Interpreter (const CosTradingRepos::ServiceTypeRepository::TypeStruct& ts,
const char* preference
ACE_ENV_ARG_DECL)
ACE_THROW_SPEC ((CosTrading::Lookup::IllegalPreference,
CORBA::NO_MEMORY));
/**
* Parse the preference string, determining first if it's
* valid. Throw an IllegalPreference exception if the preference
* doesn't conform to the BNF grammar for preferences.
*/
TAO_Preference_Interpreter (TAO_Constraint_Validator& validator,
const char* preference
ACE_ENV_ARG_DECL)
ACE_THROW_SPEC ((CosTrading::Lookup::IllegalPreference,
CORBA::NO_MEMORY));
/// Destructor
~TAO_Preference_Interpreter(void);
void order_offer (CosTrading::Offer* offer,
CosTrading::OfferId offer_id = 0);
/// Evaluate the offer, and order it internally based on the results
/// of the evaluation.
void order_offer (TAO_Constraint_Evaluator& evaluator,
CosTrading::Offer* offer,
CosTrading::OfferId offer_id = 0);
int remove_offer (CosTrading::Offer*& offer,
CosTrading::OfferId& offer_id);
/// Remove the next offer. The offer returned will be the next in the
/// ordering determined by the preference string.
int remove_offer (CosTrading::Offer*& offer);
/// Return the number of offers remaining in the ordering.
size_t num_offers (void);
struct Preference_Info
{
/// True if the preference evaluation didn't return an error for this offer.
CORBA::Boolean evaluated_;
/// The value of the preference evaluation.
TAO_Literal_Constraint value_;
/// The offer id of this offer.
CosTrading::OfferId offer_id_;
/// A pointer to the offer.
CosTrading::Offer* offer_;
};
typedef ACE_Unbounded_Queue<Preference_Info> Ordered_Offers;
private:
/// Disallow copying.
TAO_Preference_Interpreter (const TAO_Preference_Interpreter&);
TAO_Preference_Interpreter& operator= (const TAO_Preference_Interpreter&);
/// The ordered list of offers.
Ordered_Offers offers_;
};
#include /**/ "ace/post.h"
#endif /* TAO_CONSTRAINT_INTERPRETER_H */
|
