ExecStatus
LqBool<VY>::propagate(Space& home, const ModEventDelta&) {
if (status == (VS_ZERO | VS_ONE)) {
GECODE_ME_CHECK(y.gq(home,2));
return home.ES_SUBSUMED(*this);
}
if (c.empty()) {
assert((status != 0) && (y.min() >= 1));
return home.ES_SUBSUMED(*this);
}
if (y.max() == 1) {
if (status == VS_ZERO) {
// Mark that everything is done
status = VS_ZERO | VS_ONE;
for (Advisors<ViewAdvisor<BoolView> > as(c); as(); ++as)
GECODE_ME_CHECK(as.advisor().view().zero(home));
return home.ES_SUBSUMED(*this);
}
if (status == VS_ONE) {
// Mark that everything is done
status = VS_ZERO | VS_ONE;
for (Advisors<ViewAdvisor<BoolView> > as(c); as(); ++as)
GECODE_ME_CHECK(as.advisor().view().one(home));
return home.ES_SUBSUMED(*this);
}
}
if (y.min() == 2)
return home.ES_SUBSUMED(*this);
return ES_FIX;
}
int main()
{
Profile summary;
retain<Profile> as(&summary); // ***
{
Profile part;
retain<Profile> as(&part); // ***
int n=5;
int ans=fibonacci(n);
std::cout << "fibonacci(" << n << ")=" << ans << " " << part << std::endl;
}
{
Profile part;
retain<Profile> as(&part); // ***
int n=10;
int ans=fibonacci(n);
std::cout << "fibonacci(" << n << ")=" << ans << " " << part << std::endl;
}
std::cout << "summary: " << summary << std::endl;
return 0;
}
ExecStatus
GqBool<VY>::propagate(Space& home, const ModEventDelta&) {
if (status == (VS_ZERO | VS_ONE))
return home.ES_SUBSUMED(*this);
if (c.empty()) {
assert(status != 0);
GECODE_ME_CHECK(y.lq(home,1));
return home.ES_SUBSUMED(*this);
}
if (y.max() <= 1)
return home.ES_SUBSUMED(*this);
if (y.min() == 2) {
Advisors<ViewAdvisor<BoolView> > as(c);
assert(as());
ViewAdvisor<BoolView>& a(as.advisor());
++as;
if (!as()) {
// Only a single view is left
if (status == VS_ZERO) {
GECODE_ME_CHECK(a.view().one(home));
} else if (status == VS_ONE) {
GECODE_ME_CHECK(a.view().zero(home));
} else {
return ES_FAILED;
}
return home.ES_SUBSUMED(*this);
}
}
return ES_FIX;
}
inline size_t
Single<View>::dispose(Space& home) {
// Cancel remaining advisors
for (Advisors<Index> as(c); as(); ++as)
x[as.advisor().i].cancel(home,as.advisor());
c.dispose(home);
(void) NaryPropagator<View,PC_INT_NONE>::dispose(home);
return sizeof(*this);
}
std::vector<u8> DecryptVerifyCCM(const std::vector<u8>& cipher, const CCMNonce& nonce,
size_t slot_id) {
if (!IsNormalKeyAvailable(slot_id)) {
LOG_ERROR(HW_AES, "Key slot %zu not available. Will use zero key.", slot_id);
}
const AESKey normal = GetNormalKey(slot_id);
const std::size_t pdata_size = cipher.size() - CCM_MAC_SIZE;
std::vector<u8> pdata(pdata_size);
try {
CCM_3DSVariant::Decryption d;
d.SetKeyWithIV(normal.data(), AES_BLOCK_SIZE, nonce.data(), CCM_NONCE_SIZE);
d.SpecifyDataLengths(0, pdata_size, 0);
CryptoPP::AuthenticatedDecryptionFilter df(
d, new CryptoPP::ArraySink(pdata.data(), pdata_size));
CryptoPP::ArraySource as(cipher.data(), cipher.size(), true, new CryptoPP::Redirector(df));
if (!df.GetLastResult()) {
LOG_ERROR(HW_AES, "FAILED");
return {};
}
} catch (const CryptoPP::Exception& e) {
LOG_ERROR(HW_AES, "FAILED with: %s", e.what());
return {};
}
return pdata;
}
void
flushdi(void)
{
int n;
Rune *p;
if(ndi == 0 || difmtinit == 0)
return;
fmtrune(&difmt, Uunformatted);
p = runefmtstrflush(&difmt);
memset(&difmt, 0, sizeof difmt);
difmtinit = 0;
if(p == nil)
warn("out of memory in diversion %C%S", dot, di[ndi-1]);
else{
n = runestrlen(p);
if(n > 0 && p[n-1] != '\n'){
p = runerealloc(p, n+2);
p[n] = '\n';
p[n+1] = 0;
}
}
as(di[ndi-1], p);
free(p);
}
int main()
{ AddStreamRetain as(std::cerr); // ***
LOG("start");
std::string logFileName="tmp/messages.log";
std::ofstream logFile(logFileName.c_str());
bool logFileOk = !!logFile;
{ AddStreamRetain as_if(logFile,logFileOk); // ***
LOG("open log file '" << logFileName << "': " << (logFileOk ? "ok" : "failed"));
std::string songFileName="tmp/song.out";
std::ofstream songFile(songFileName.c_str());
bool songFileOk = !!songFile;
LOG("open song file '" << songFileName << "': " << (songFileOk ? "ok" : "failed"));
std::stringstream sout;
{ NullStreamRetain as; // stop precursion to ancestor retains
{ AddStreamRetain as_if(songFile,songFileOk); // ***
{ AddStreamRetain as(sout); // ***
sing();
}
}
}
LOG("sung: " << sout.str());
}
LOG("finish");
return 0;
}
static BSONObj bigObj() {
BSONObjBuilder b;
b.appendOID("_id", 0, true);
string as( 187, 'a' );
b.append( "a", as );
return b.obj();
}
int main() {
// Create the main window
sf::RenderWindow window(sf::VideoMode(800, 600), "SFML window");
nb::AnimatedSprite as("AnimatedSpriteInfo.nbas");
as.setPosition(200, 200);
as.play("spinningswitching");
while (window.isOpen()) {
// Handle events
sf::Event e;
while (window.pollEvent(e)) {
if (e.type == sf::Event::Closed) {
window.close();
}
}
as.logic(1000/60);
window.clear();
window.draw(as);
window.display();
sf::sleep(sf::milliseconds(1000/60));
}
return 0;
}
// Read polynomial from an input stream of the form:
// CONST_VALUE/var_1;var_2;...;var_n/coef_1,(var_idx_1,var_order_1)...()/coef_2,(var_idx_2,var_order_2)...()/
void PolyNomial::ReadFrom(istream& is)
{
Clear();
string str;
getline(is, str, '/');
constValue_ = atof(str.c_str());
getline(is, str, '/');
stringstream ss(str);
string strVar;
int i = 0;
while(getline(ss, strVar, ';'))
{
assert(varsearch_.find(strVar) == varsearch_.end());
var_.append(strVar);
varsearch_.insert(map<string, int>::value_type(strVar, i));
i++;
}
i = 0;
map<string, int> strngItems;
while (getline(is, str, '/'))
{
VarCont vc;
int varIdx;
double varOrder;
stringstream as(str);
string strTmp;
getline(as, strTmp, ',');
double coef = atof(strTmp.c_str());
while (getline(as, strTmp, '('))
{
getline(as, strTmp, ',');
varIdx = atoi(strTmp.c_str());
getline(as, strTmp, ')');
varOrder = atof(strTmp.c_str());
vc.insert(map<int,double>::value_type(varIdx, varOrder));
}
string strItem = GenerateItemString(vc);
map<string, int>::const_iterator citer = strngItems.find(strItem);
if (citer != strngItems.end())
{
int itemIdx = citer->second;
coef_[itemIdx] += coef; //dedup & merge
continue;
}
strItems_.append(strItem);
strngItems.insert(map<string, int>::value_type(strItem, i++));
coef_.append(coef);
items_.append(vc);
}
numVar_ = var_.size();
varValue_.growToSize(numVar_, 0);
numItems_ = strItems_.size();
}
void MainWindow::on_pushButton_2_clicked()
{
AddStudents as(m_Students);
as.setModal(true);
as.run();
as.exec();
}
int
LoadDisplayResources( struct display *d )
{
int i, ret;
char **ent;
if (Setjmp( cnftalk.errjmp ))
return -1; /* may memleak */
if ((ret = startConfig( GC_gDisplay, &d->cfg.dep, FALSE )) <= 0)
return ret;
GSendStr( d->name );
GSendStr( d->class2 );
LoadResources( &d->cfg );
/* Debug( "display(%s, %s) resources: %[*x\n", d->name, d->class2,
d->cfg.numCfgEnt, ((char **)d->cfg.data) + d->cfg.numCfgEnt );*/
ret = 1;
for (i = 0; i < as(dpyVal); i++) {
if (!(ent = FindCfgEnt( d, dpyVal[i].id )))
ret = -1;
else
ApplyResource( dpyVal[i].id, ent,
(char **)(((char *)d) + dpyVal[i].off) );
}
if (ret < 0)
LogError( "Internal error: config reader supplied incomplete data\n" );
return ret;
}
void TestTest::testAbstractScheme()
{
try {
AbstractScheme as(std::make_shared<SchemeParameterDefault>(), std::make_shared<SchemeBuffer>());
as.set("diqu", QObject::tr("安徽"));
as.set("huji", QObject::tr("农业"));
as.set("shixian", QObject::tr("回归生育"));
as.set("duiji", QObject::tr("分释"));
as.set("hunpei", QObject::tr(""));
as.set("koujinplusshiji", QObject::tr("农d11_非d11"));
as.set("qianyi", QObject::tr("z"));
schememetadataPtr meta_renkougaiyao(new schememetadata("META_RENKOUGAIYAO"));
SchemePtr schemePtr = as.generate(meta_renkougaiyao);
qDebug() << "name" << schemePtr->getName() << endl;
schemePtr->getBuffer()->forceRead(schemePtr.get());
QVERIFY2(true, "Failure");
} catch (const ValueNotExist& e) {
qDebug() << "value not exist at" << e.value();
}
catch(const RecordNotExist& e){
qDebug() << "Record not exist at" << e.name();
}
}
int Z3_API Z3_algebraic_eval(Z3_context c, Z3_ast p, unsigned n, Z3_ast a[]) {
Z3_TRY;
LOG_Z3_algebraic_eval(c, p, n, a);
RESET_ERROR_CODE();
polynomial::manager & pm = mk_c(c)->pm();
polynomial_ref _p(pm);
polynomial::scoped_numeral d(pm.m());
expr2polynomial converter(mk_c(c)->m(), pm, 0, true);
if (!converter.to_polynomial(to_expr(p), _p, d) ||
static_cast<unsigned>(max_var(_p)) >= n) {
SET_ERROR_CODE(Z3_INVALID_ARG);
return 0;
}
algebraic_numbers::manager & _am = am(c);
scoped_anum_vector as(_am);
if (!to_anum_vector(c, n, a, as)) {
SET_ERROR_CODE(Z3_INVALID_ARG);
return 0;
}
{
cancel_eh<algebraic_numbers::manager> eh(_am);
api::context::set_interruptable si(*(mk_c(c)), eh);
scoped_timer timer(mk_c(c)->params().m_timeout, &eh);
vector_var2anum v2a(as);
int r = _am.eval_sign_at(_p, v2a);
if (r > 0) return 1;
else if (r < 0) return -1;
else return 0;
}
Z3_CATCH_RETURN(0);
}
Z3_ast_vector Z3_API Z3_algebraic_roots(Z3_context c, Z3_ast p, unsigned n, Z3_ast a[]) {
Z3_TRY;
LOG_Z3_algebraic_roots(c, p, n, a);
RESET_ERROR_CODE();
polynomial::manager & pm = mk_c(c)->pm();
polynomial_ref _p(pm);
polynomial::scoped_numeral d(pm.m());
expr2polynomial converter(mk_c(c)->m(), pm, 0, true);
if (!converter.to_polynomial(to_expr(p), _p, d) ||
static_cast<unsigned>(max_var(_p)) >= n + 1) {
SET_ERROR_CODE(Z3_INVALID_ARG);
return 0;
}
algebraic_numbers::manager & _am = am(c);
scoped_anum_vector as(_am);
if (!to_anum_vector(c, n, a, as)) {
SET_ERROR_CODE(Z3_INVALID_ARG);
return 0;
}
scoped_anum_vector roots(_am);
{
cancel_eh<algebraic_numbers::manager> eh(_am);
api::context::set_interruptable si(*(mk_c(c)), eh);
scoped_timer timer(mk_c(c)->params().m_timeout, &eh);
vector_var2anum v2a(as);
_am.isolate_roots(_p, v2a, roots);
}
Z3_ast_vector_ref* result = alloc(Z3_ast_vector_ref, mk_c(c)->m());
mk_c(c)->save_object(result);
for (unsigned i = 0; i < roots.size(); i++) {
result->m_ast_vector.push_back(au(c).mk_numeral(roots.get(i), false));
}
RETURN_Z3(of_ast_vector(result));
Z3_CATCH_RETURN(0);
}
MessageTask* MessageTask::convertToObject( const std::string byte ) {
MessageTask* b;
std::istringstream file(byte.c_str());
boost::archive::text_iarchive as(file);
as & b;
return b;
}
vm_value &vm_value::convert(int32_t new_type)
{
if (type != new_type) {
*this = as(new_type);
}
return *this;
}
MissionSpec::MissionSpec()
{
initialiser::initXSD();
// construct a default mission
About about("");
FlatWorldGenerator flat_world_gen;
flat_world_gen.generatorString( "3;7,220*1,5*3,2;3;,biome_1" );
ServerHandlers server_handlers;
server_handlers.FlatWorldGenerator( flat_world_gen );
ServerQuitFromTimeUp time_up( 10000 );
server_handlers.ServerQuitFromTimeUp().push_back( time_up );
ServerQuitWhenAnyAgentFinishes any_quits;
server_handlers.ServerQuitWhenAnyAgentFinishes().push_back( any_quits );
ServerSection server_section( server_handlers );
this->mission = boost::make_shared<Mission>( about, server_section );
// add a single default agent
AgentHandlers ah;
ObservationFromFullStats obs;
ah.ObservationFromFullStats( obs );
ContinuousMovementCommands cmc;
ah.ContinuousMovementCommands( cmc );
AgentStart agent_start;
AgentSection as( "Cristina", agent_start, ah );
this->mission->AgentSection().push_back(as);
}
void
Airspaces::Optimise()
{
if (!owns_children || task_projection.Update()) {
// dont update task_projection if not owner!
// task projection changed, so need to push items back onto stack
// to re-build airspace envelopes
for (const auto &i : airspace_tree)
tmp_as.push_back(&i.GetAirspace());
airspace_tree.clear();
}
if (!tmp_as.empty()) {
while (!tmp_as.empty()) {
Airspace as(*tmp_as.front(), task_projection);
airspace_tree.insert(as);
tmp_as.pop_front();
}
airspace_tree.optimise();
}
++serial;
}
TEST(QiAutoService, AutoReConnect)
{
TestSessionPair pair;
boost::shared_ptr<Pong> pong(new Pong());
qi::AnyObject pongAsObject = qi::AnyValue::from(pong).to<qi::AnyObject>();
qi::Future<unsigned int> fut = pair.server()->registerService("Ping pong", pongAsObject);
fut.wait();
qi::AutoService<PongProxy> as("Ping pong", pair.client());
as.waitForReady().wait();
EXPECT_EQ(42, as->incr());
pair.server()->unregisterService(fut.value());
qi::Future<unsigned int> fut2 = pair.server()->registerService("Ping pong", pongAsObject);
fut2.wait();
while(true)
{
try
{
EXPECT_EQ(43, as->incr().value());
break;
}
catch (std::runtime_error e)
{
std::cout << e.what() << std::endl;
}
}
}
// Apply lBFGS Approximate Hessian
void applyB( Vector<Real> &Bv, const Vector<Real> &v ) const {
// Get Generic Secant State
const Teuchos::RCP<SecantState<Real> >& state = Secant<Real>::get_state();
Real one(1);
// Apply initial Hessian approximation to v
Secant<Real>::applyB0(Bv,v);
std::vector<Teuchos::RCP<Vector<Real> > > a(state->current+1);
std::vector<Teuchos::RCP<Vector<Real> > > b(state->current+1);
Real bv(0), av(0), bs(0), as(0);
for (int i = 0; i <= state->current; i++) {
b[i] = Bv.clone();
b[i]->set(*(state->gradDiff[i]));
b[i]->scale(one/sqrt(state->product[i]));
bv = v.dot(b[i]->dual());
Bv.axpy(bv,*b[i]);
a[i] = Bv.clone();
Secant<Real>::applyB0(*a[i],*(state->iterDiff[i]));
for (int j = 0; j < i; j++) {
bs = (state->iterDiff[i])->dot(b[j]->dual());
a[i]->axpy(bs,*b[j]);
as = (state->iterDiff[i])->dot(a[j]->dual());
a[i]->axpy(-as,*a[j]);
}
as = (state->iterDiff[i])->dot(a[i]->dual());
a[i]->scale(one/sqrt(as));
av = v.dot(a[i]->dual());
Bv.axpy(-av,*a[i]);
}
}
int main(int argc, char** argv)
{
ros::init(argc, argv, "action_server");
ros::NodeHandle nh;
ros::Rate loop_rate(10);
actionlib::SimpleActionServer<intros_action_example::fibonacciAction> as(nh,
"action_server/fibonacci",boost::bind(&FiboCallback, _1, &as),false);
as.start();
ROS_INFO("Hola tio!");
ros::spin();
return 0;
}
bool RC4Test::firstTest()
{
Out() << "First RC4 test" << endl;
SHA1Hash a = SHA1Hash::generate((Uint8*)"keyA",4);
SHA1Hash b = SHA1Hash::generate((Uint8*)"keyB",4);
RC4Encryptor as(b,a);
RC4Encryptor bs(a,b);
char* test = "Dit is een test";
int tlen = strlen(test);
Uint8* dec = (Uint8*)as.encrypt((Uint8*)test,tlen);
bs.decrypt(dec,tlen);
if (memcmp(dec,test,tlen) == 0)
{
Out() << "Test succesfull" << endl;
Out() << QString(test) << endl;
Out() << QString((char*)dec) << endl;
return true;
}
else
{
Out() << "Test not succesfull" << endl;
Out() << QString(test) << endl;
Out() << QString((char*)dec) << endl;
return false;
}
}
static void tst5() {
params_ref ps;
nlsat::solver s(ps);
unsynch_mpq_manager & qm = s.qm();
anum_manager & am = s.am();
nlsat::pmanager & pm = s.pm();
nlsat::assignment as(am);
small_object_allocator allocator;
nlsat::interval_set_manager ism(am, allocator);
nlsat::evaluator ev(as, pm, allocator);
nlsat::var x0, x1;
x0 = pm.mk_var();
x1 = pm.mk_var();
polynomial_ref p(pm);
polynomial_ref _x0(pm), _x1(pm);
_x0 = pm.mk_polynomial(x0);
_x1 = pm.mk_polynomial(x1);
p = (_x0^2) + (_x1^2) - 2;
nlsat::poly * _p[1] = { p.get() };
bool is_even[1] = { false };
nlsat::bool_var b = s.mk_ineq_atom(nlsat::atom::GT, 1, _p, is_even);
nlsat::atom * a = s.bool_var2atom(b);
SASSERT(a != 0);
nlsat::interval_set_ref i(ism);
scoped_anum zero(am);
am.set(zero, 0);
as.set(0, zero);
i = ev.infeasible_intervals(a, true);
std::cout << "1) " << i << "\n";
as.set(1, zero);
i = ev.infeasible_intervals(a, true);
std::cout << "2) " << i << "\n";
}
void HerosSprite::init(const sf::Texture& texture)
{
mul::sfe::SpriteGenerator sg(texture, {12,8}, {32,32});
mul::sfe::AnimatedSprite<std::string> as(true, true);
setPosition(400, 300);
addFrame(MoveDown, sg.get(1), sf::seconds(0.25));
addFrame(MoveDown, sg.get(2), sf::seconds(0.25));
addFrame(MoveDown, sg.get(1), sf::seconds(0.25));
addFrame(MoveDown, sg.get(0), sf::seconds(0.25));
addFrame(MoveLeft, sg.get(13), sf::seconds(0.25));
addFrame(MoveLeft, sg.get(14), sf::seconds(0.25));
addFrame(MoveLeft, sg.get(13), sf::seconds(0.25));
addFrame(MoveLeft, sg.get(12), sf::seconds(0.25));
addFrame(MoveRight, sg.get(25), sf::seconds(0.25));
addFrame(MoveRight, sg.get(26), sf::seconds(0.25));
addFrame(MoveRight, sg.get(25), sf::seconds(0.25));
addFrame(MoveRight, sg.get(24), sf::seconds(0.25));
addFrame(MoveUp, sg.get(37), sf::seconds(0.25));
addFrame(MoveUp, sg.get(38), sf::seconds(0.25));
addFrame(MoveUp, sg.get(37), sf::seconds(0.25));
addFrame(MoveUp, sg.get(36), sf::seconds(0.25));
play(MoveDown);
}
void
Airspaces::Optimise()
{
if (IsEmpty())
/* avoid assertion failure in uninitialised task_projection */
return;
if (!owns_children || task_projection.Update()) {
// dont update task_projection if not owner!
// task projection changed, so need to push items back onto stack
// to re-build airspace envelopes
for (const auto &i : QueryAll())
tmp_as.push_back(&i.GetAirspace());
airspace_tree.clear();
}
for (AbstractAirspace *i : tmp_as) {
Airspace as(*i, task_projection);
airspace_tree.insert(as);
}
tmp_as.clear();
++serial;
}
static void tst6() {
params_ref ps;
reslimit rlim;
nlsat::solver s(rlim, ps);
anum_manager & am = s.am();
nlsat::pmanager & pm = s.pm();
nlsat::assignment as(am);
nlsat::explain& ex = s.get_explain();
nlsat::var x0, x1, x2, a, b, c, d;
a = s.mk_var(false);
b = s.mk_var(false);
c = s.mk_var(false);
d = s.mk_var(false);
x0 = s.mk_var(false);
x1 = s.mk_var(false);
x2 = s.mk_var(false);
polynomial_ref p1(pm), p2(pm), p3(pm), p4(pm), p5(pm);
polynomial_ref _x0(pm), _x1(pm), _x2(pm);
polynomial_ref _a(pm), _b(pm), _c(pm), _d(pm);
_x0 = pm.mk_polynomial(x0);
_x1 = pm.mk_polynomial(x1);
_x2 = pm.mk_polynomial(x2);
_a = pm.mk_polynomial(a);
_b = pm.mk_polynomial(b);
_c = pm.mk_polynomial(c);
_d = pm.mk_polynomial(d);
p1 = (_a*(_x0^2)) + _x2 + 2;
p2 = (_b*_x1) - (2*_x2) - _x0 + 8;
nlsat::scoped_literal_vector lits(s);
lits.push_back(mk_gt(s, p1));
lits.push_back(mk_gt(s, p2));
lits.push_back(mk_gt(s, (_c*_x0) + _x2 + 1));
lits.push_back(mk_gt(s, (_d*_x0) - _x1 + 5*_x2));
scoped_anum zero(am), one(am), two(am);
am.set(zero, 0);
am.set(one, 1);
am.set(two, 2);
as.set(0, one);
as.set(1, one);
as.set(2, two);
as.set(3, two);
as.set(4, two);
as.set(5, one);
as.set(6, one);
s.set_rvalues(as);
project(s, ex, x0, 2, lits.c_ptr());
project(s, ex, x1, 3, lits.c_ptr());
project(s, ex, x2, 3, lits.c_ptr());
project(s, ex, x2, 2, lits.c_ptr());
project(s, ex, x2, 4, lits.c_ptr());
project(s, ex, x2, 3, lits.c_ptr()+1);
}
int main(int a, char **b){
int (*k)(int, int) = somar;
printf("\n%d\n" ,k(2, 2));
void (*as)(int, int) = print;
as(2, 2);
return 0;
}
int main(int argc, char * argv[]) {
bool pass = true;
{
const int CAPACITY = 6;
const int STACKS = 3;
ArrayStack<int> as(CAPACITY, STACKS);
// Initially, all the stacks are empty.
for (int i = 0; i < STACKS; ++i) {
pass = pass && as.Empty(i);
}
// We can push CAPACITY / STACKS elements to each stack and they will become full.
for (int i = 0; i < STACKS; ++i) {
for (int j = 0; j < CAPACITY / STACKS; ++j) {
as.Push(i, (i * 10 + j));
}
pass = pass && as.Full(i);
}
// If we push one more element to the stacks, they will throw exceptions.
for (int i = 0; i < STACKS; ++i) {
try {
as.Push(i, -1);
} catch(const std::exception & e) {
std::string msg(e.what());
pass = pass && (msg == "Stack is already full.");
}
}
// Now we peek at the top element of each stack.
for (int i = 0; i < STACKS; ++i) {
pass = pass && (as.Peek(i) == (i * 10 + CAPACITY / STACKS - 1));
}
// We pop CAPACITY / STACKS elements out of each stack and they will
// become empty.
for (int i = 0; i < STACKS; ++i) {
for (int j = 0; j < CAPACITY / STACKS; ++j) {
as.Pop(i);
}
pass = pass && (as.Empty(i));
}
// If we try to pop again, the stack will throw exceptions.
for (int i = 0; i < STACKS; ++i) {
try {
as.Pop(i);
} catch(const std::exception & e) {
std::string msg(e.what());
pass = pass && (msg == "Stack is already empty.");
}
}
}
return (pass ? 0 : -1);
}
forceinline size_t
LinkMulti::dispose(Space& home) {
Advisors<Advisor> as(c);
x.cancel(home,as.advisor());
c.dispose(home);
(void) MixNaryOnePropagator<BoolView,PC_BOOL_NONE,IntView,PC_INT_DOM>
::dispose(home);
return sizeof(*this);
}
