Element( const id_type id )
: i_( id & 0x00000000ffffffff )
, c_( ( id & 0xffffffff00000000 ) >> 32 )
{}
Element( int i, int c ) : i_( i ), c_( c ) {}
Element( const Element& x ) : i_( x.i_ ), c_( x.c_ ) {}
Element( const Element& x, int c ) : i_( x.i_ ), c_( c ) {}
~Element() {}
id_type operator()() const
{
return ( static_cast< id_type >( c_ ) << 32 ) | ( static_cast< id_type >( i_ ) );
}
int color() const {
return c_;
}
bool operator<( const Element& x ) const
{
if ( c_ == x.c_ ) return i_ < x.i_;
return c_ < x.c_;
}
bool operator==( const Element& x ) const {
return i_ == x.i_ && c_ == x.c_;
}
};
int Triangle::getIndex(unsigned int _index) const {
if (_index > 2){
std::cerr << "Wrong index!" << std::endl;
exit(-1);
}
return i_(_index);
}
expectation()
: BOOST_PP_REPEAT(MOCK_NUM_ARGS,
MOCK_EXPECTATION_INITIALIZE, _)
BOOST_PP_COMMA_IF(MOCK_NUM_ARGS)
i_( boost::make_shared< unlimited >() )
, file_( "unknown location" )
, line_( 0 )
{}
expectation( const char* file, int line )
: BOOST_PP_REPEAT(MOCK_NUM_ARGS,
MOCK_EXPECTATION_INITIALIZE, _)
BOOST_PP_COMMA_IF(MOCK_NUM_ARGS)
i_( boost::make_shared< unlimited >() )
, file_( file )
, line_( line )
{}
~expectation()
{
for( sequences_cit it = sequences_.begin();
it != sequences_.end(); ++it )
(*it)->remove( this );
}
expectation& once()
{
i_ = boost::make_shared< detail::once >();
return *this;
}
expectation& never()
{
i_ = boost::make_shared< detail::never >();
return *this;
}
expectation& exactly( std::size_t count )
{
i_ = boost::make_shared< detail::exactly >( count );
return *this;
}
Triangle::Triangle(unsigned int _i0, unsigned int _i1, unsigned int _i2){
i_(0) = _i0;
i_(1) = _i1;
i_(2) = _i2;
}
Triangle::Triangle(){
i_(0) = -1;
i_(1) = -1;
i_(2) = -1;
}
std::string rev_regex(const std::string &rx_, const lexertl::state_machine &sm_)
{
std::string str_;
std::string curr_;
token_stack stack_;
lexertl::citerator iter_(rx_.c_str(), rx_.c_str() + rx_.length(), sm_);
lexertl::citerator end_;
std::size_t parens_ = 0;
for (; iter_ != end_; ++iter_)
{
switch (iter_->id)
{
case eCharset:
case eMacro:
case eComment:
stack_.push(token_pair((eToken)iter_->id, iter_->str()));
break;
case eString:
{
lexertl::citerator i_(iter_->start + 1, iter_->end - 1, sm_);
lexertl::citerator e_;
std::string str_;
for (; i_ != e_; ++i_)
{
str_ = i_->str() + str_;
}
str_ = '"' + str_ + '"';
stack_.push(token_pair((eToken)iter_->id, str_));
break;
}
case eQuantifier:
if (stack_.empty())
{
throw std::runtime_error("Quantifier without regex.");
}
stack_.top().second += iter_->str();
break;
case eDifference:
if (stack_.empty())
{
throw std::runtime_error("Difference without regex.");
}
stack_.top().second += iter_->str();
++iter_;
stack_.top().second += iter_->str();
break;
case eBOL:
// Reverse to eEOL
stack_.push(token_pair(eEOL, std::string(1, '$')));
break;
case eEOL:
// Reverse to eBOL
stack_.push(token_pair(eBOL, std::string(1, '^')));
break;
case eOr:
reduce_stack(stack_);
stack_.push(token_pair((eToken)iter_->id, iter_->str()));
break;
case eOpen:
stack_.push(token_pair((eToken)iter_->id, iter_->str()));
++parens_;
break;
case eClose:
{
if (parens_ < 1)
{
throw std::runtime_error("Unbalanced parens in regex.");
}
std::string str_;
reduce_stack(stack_);
str_ = stack_.top().second;
str_ += iter_->str();
stack_.pop();
stack_.top().second += str_;
stack_.top().first = eCharset;
--parens_;
break;
}
default:
throw std::runtime_error("Unknown regex token.");
break;
}
}
for (; !stack_.empty(); stack_.pop())
{
str_ += stack_.top().second;
}
return str_;
}
