bool Constraint::decompose()
{
bool sep = false;
if(extension() && !universal() && (arity() == 3 || (arity()>=4 && (getDefCost()>MIN_COST || ((NaryConstraint *) this)->size()>1)))) {
TSCOPE scopeinv;
getScope(scopeinv);
EnumeratedVariable * vx = NULL;
EnumeratedVariable * vz = NULL;
for(TSCOPE::reverse_iterator it1 = scopeinv.rbegin(); it1 != scopeinv.rend() && !sep; ++it1) {
TSCOPE::reverse_iterator it2 = it1;
for(++it2; it2 != scopeinv.rend() && !sep; ++it2) {
vx = (EnumeratedVariable *) wcsp->getVar((*it2).first);
vz = (EnumeratedVariable *) wcsp->getVar((*it1).first);
if(ToulBar2::verbose >= 1) cout << /*"\n" <<*/ vx->getName() << " and " << vz->getName() << " are separable in ";
sep = separability(vx,vz);
if(sep && ToulBar2::verbose >= 1) {
cout << " YES";
#ifndef NDEBUG
if (!ishard()) cout << " with finite costs";
#endif
cout << endl;
}
if(!sep && ToulBar2::verbose >= 1) cout << " NO" << endl;
}
}
if(sep) separate(vx,vz);
if(ToulBar2::verbose >= 3) cout << "=====================================================" << endl;
}
return sep;
}
FATAL_TEST(traits, safe_overload_nonvariadic) {
overloading_test def;
FATAL_EXPECT_EQ(ctor::def, def.type);
overloading_test copy(def);
FATAL_EXPECT_EQ(ctor::copy, copy.type);
overloading_test move(std::move(def));
FATAL_EXPECT_EQ(ctor::move, move.type);
overloading_test universal(0);
FATAL_EXPECT_EQ(ctor::universal, universal.type);
overloading_test foo{Foo()};
FATAL_EXPECT_EQ(ctor::universal, foo.type);
}
FATAL_TEST(traits, safe_overload_variadic_t) {
variadic_overloading_test_t def;
FATAL_EXPECT_EQ(ctor::def, def.type);
variadic_overloading_test_t copy(def);
FATAL_EXPECT_EQ(ctor::copy, copy.type);
variadic_overloading_test_t move(std::move(def));
FATAL_EXPECT_EQ(ctor::move, move.type);
variadic_overloading_test_t i(0);
FATAL_EXPECT_EQ(ctor::universal, i.type);
variadic_overloading_test_t foo{Foo()};
FATAL_EXPECT_EQ(ctor::universal, foo.type);
variadic_overloading_test_t universal(copy, move);
FATAL_EXPECT_EQ(ctor::universal, universal.type);
}
gearman_return_t error_code() const
{
return universal().error_code();
}
void enqueue(const T &t) {
auto node = MSQueueNode::freelist.alloc();
node->data_ = universal(t);
enqueueNode(node);
}
void enqueue(T &&t) {
auto node = MSQueueNode::freelist.alloc();
node->data_ = universal(std::move(t));
enqueueNode(node);
}
void avrisp()
{
static uint16_t address = 0;
uint8_t ch = getch();
switch (ch)
{
case '0': // signon
_error = 0;
reply();
break;
case '1':
if (receiveEop())
{
Serial.print("AVR ISP");
Serial.write(STK_OK);
}
break;
case 'A':
replyVersion(getch());
break;
case 'B':
fill(20);
setParameters();
reply();
break;
case 'E': // extended parameters - ignore for now
fill(5);
reply();
break;
case 'P':
_programming ? pulse(LED_ERROR, 3) : beginProgramming();
reply();
break;
case 'U': // set address (word)
address = getch() | (getch() << 8);
reply();
break;
case 0x60: //STK_PROG_FLASH
getch();
getch();
reply();
break;
case 0x61: //STK_PROG_DATA
getch();
reply();
break;
case 0x64: //STK_PROG_PAGE
programPage(address);
break;
case 0x74: //STK_READ_PAGE 't'
readPage(address);
break;
case 'V': //0x56
universal();
break;
case 'Q': //0x51
_error = 0;
endProgramming();
reply();
break;
case 0x75: //STK_READ_SIGN 'u'
readSignature();
break;
// expecting a command, not CRC_EOP
// this is how we can get back in sync
case CRC_EOP:
_error = true;
Serial.write(STK_NOSYNC);
break;
default: // anything else we will return STK_UNKNOWN
_error = true;
if (receiveEop())
Serial.write(STK_UNKNOWN);
break;
}
}
void avrisp(int ReceivedByte){
// is pmode active?
if (ram.isp.pmode) LEDs_TurnOnLEDs(LEDS_PMODE);
else LEDs_TurnOffLEDs(LEDS_PMODE);
// is there an error?
if (ram.isp.error) LEDs_TurnOnLEDs(LEDS_ERR);
else LEDs_TurnOffLEDs(LEDS_ERR);
// read in bytes from the CDC interface
if (!(ReceivedByte < 0)){
switch (ReceivedByte) {
case STK_GET_SYNC:
ram.isp.error = 0;
replyOK();
break;
case STK_GET_SIGNON:
if (getch() == CRC_EOP) {
sendCDCbyte(STK_INSYNC);
sendCDCbyte('A');
sendCDCbyte('V');
sendCDCbyte('R');
sendCDCbyte(' ');
sendCDCbyte('I');
sendCDCbyte('S');
sendCDCbyte('P');
sendCDCbyte(STK_OK);
}
break;
case STK_GET_PARM:
get_parameters(getch());
break;
case STK_SET_PARM:
set_parameters();
replyOK();
break;
case STK_SET_PARM_EXT: // extended parameters - ignore for now
fill(5);
replyOK();
break;
case STK_PMODE_START:
start_pmode();
replyOK();
break;
case STK_SET_ADDR:
ram.isp._addr = getch();
ram.isp._addr += 256 * getch();
replyOK();
break;
case STK_PROG_FLASH:
//uint8_t low = getch();
getch();
//uint8_t high = getch();
getch();
replyOK();
break;
case STK_PROG_DATA:
//uint8_t data = getch();
getch();
replyOK();
break;
case STK_PROG_PAGE:
program_page();
break;
case STK_READ_PAGE:
read_page();
break;
case STK_UNIVERSAL:
universal();
break;
case STK_PMODE_END:
ram.isp.error = 0;
end_pmode();
replyOK();
break;
case STK_READ_SIGN:
read_signature();
break;
// expecting a command, not CRC_EOP
// this is how we can get back in sync
case CRC_EOP:
ram.isp.error++;
sendCDCbyte(STK_NOSYNC);
break;
// anything else we will return STK_UNKNOWN
default:
ram.isp.error++;
if (CRC_EOP == getch())
sendCDCbyte(STK_UNKNOWN);
else
sendCDCbyte(STK_NOSYNC);
}
}
}
