type_t dequeue() {
type_t event(heap[0].event);
unsigned parent = 0;
unsigned counter = heap[--heapsize].counter;
while(true) {
unsigned child = (parent << 1) + 1;
if(child >= heapsize) break;
if(child + 1 < heapsize && gte(heap[child].counter, heap[child + 1].counter)) child++;
if(gte(heap[child].counter, counter)) break;
heap[parent].counter = heap[child].counter;
heap[parent].event = heap[child].event;
parent = child;
}
heap[parent].counter = counter;
heap[parent].event = heap[heapsize].event;
return event;
}
transform_list_ptr parse_transform(std::string const& str, std::string const& encoding)
{
transform_list_ptr tl = boost::make_shared<transform_list>();
transcoder tc(encoding);
expression_grammar<std::string::const_iterator> ge(tc);
transform_expression_grammar__string gte(ge);
if (!parse_transform(*tl, str, gte))
{
tl.reset();
}
return tl;
}
//counter is relative to current time (eg enqueue(64, ...) fires in 64 ticks);
//counter cannot exceed std::numeric_limits<unsigned>::max() >> 1.
void enqueue(unsigned counter, type_t event) {
unsigned child = heapsize++;
counter += basecounter;
while(child) {
unsigned parent = (child - 1) >> 1;
if(gte(counter, heap[parent].counter)) break;
heap[child].counter = heap[parent].counter;
heap[child].event = heap[parent].event;
child = parent;
}
heap[child].counter = counter;
heap[child].event = event;
}
TEST(ExpressionAlgoIsSubsetOf, Compare_NaN) {
ParsedMatchExpression nan("{x: NaN}");
ParsedMatchExpression lt("{x: {$lt: 5}}");
ParsedMatchExpression lte("{x: {$lte: 5}}");
ParsedMatchExpression gte("{x: {$gte: 5}}");
ParsedMatchExpression gt("{x: {$gt: 5}}");
ASSERT_TRUE(expression::isSubsetOf(nan.get(), nan.get()));
ASSERT_FALSE(expression::isSubsetOf(nan.get(), lt.get()));
ASSERT_FALSE(expression::isSubsetOf(lt.get(), nan.get()));
ASSERT_FALSE(expression::isSubsetOf(nan.get(), lte.get()));
ASSERT_FALSE(expression::isSubsetOf(lte.get(), nan.get()));
ASSERT_FALSE(expression::isSubsetOf(nan.get(), gte.get()));
ASSERT_FALSE(expression::isSubsetOf(gte.get(), nan.get()));
ASSERT_FALSE(expression::isSubsetOf(nan.get(), gt.get()));
ASSERT_FALSE(expression::isSubsetOf(gt.get(), nan.get()));
}
void Conditions::Gte(const string& name, const string& value) {
shared_ptr<Condition::Base> gte(new Condition::Gte(name, value));
vector< shared_ptr<Condition::Base> >::push_back(gte);
}
inline void tick(unsigned ticks) {
basecounter += ticks;
while(heapsize && gte(basecounter, heap[0].counter)) callback(dequeue());
}
int main( int argc , char * argv[] ) {
std::cout << "算术" << std::endl;
int a = 10 , b = 20;
int ret;
std::plus<int>add;
ret = add(a,b);
std::cout << ret << std::endl;
std::minus<int> min;
ret = min(b,a);
std::cout << ret << std::endl;
std::multiplies<int> mp;
ret = mp(a,b);
std::cout << ret << std::endl;
std::divides<int> divi;
ret = divi(a,b);
std::cout << ret << std::endl;
std::modulus<int> mod;
ret = mod(a,b);
std::cout << ret << std::endl;
std::negate<int> neg;
ret = neg(a);
std::cout << ret << std::endl;
std::cout << "关系" <<std::endl;
int a2 = 10 , b2 = 20;
int ret2;
std::equal_to<int> et;
ret2 = et(a,b);
std::cout << ret2 <<std::endl;
std::not_equal_to<int> net;
ret2 = net(a,b);
std::cout << ret2 << std::endl;
std::greater<int>gt;
ret2 = gt(b,a);
std::cout << ret2 << std::endl;
std::greater_equal<int> gte;
ret2 = gte(a,b);
std::cout << ret2 <<std::endl;
std::less<int> ls;
ret2 = ls(a,b);
std::cout << ret2 << std::endl;
std::less_equal<int> lel;
ret2 = lel(a,b);
std::cout << ret2 << std::endl;
std::cout << "逻辑" << std::endl;
int ret3;
std::logical_and<int> la;
ret3 = la(a,b);
std::cout << ret3 <<std::endl;
std::logical_or<int> lo;
ret3 = lo(a,b);
std::cout << ret3 << std::endl;
std::logical_not<int>ln;
ret3 = ln(b);
std::cout << ret3 <<std::endl;
return EXIT_SUCCESS;
}
inline bool gte(const T1& lhs, const T2& rhs) {
return lhs.get_head() >= rhs.get_head() &&
( !(rhs.get_head() >= lhs.get_head()) ||
gte(lhs.get_tail(), rhs.get_tail()));
}
