static unsigned int
WINAPI startHook(void* arg)
{
// Ensure that the thread doesn't go away until run() has
// completed.
//
IceUtil::ThreadPtr thread;
try
{
IceUtil::Thread* rawThread = static_cast<IceUtil::Thread*>(arg);
//
// Ensure that the thread doesn't go away until run() has
// completed.
//
thread = rawThread;
//
// Initialize the random number generator in each thread on
// Windows (the rand() seed is thread specific).
//
unsigned int seed = static_cast<unsigned int>(IceUtil::Time::now().toMicroSeconds());
srand(seed ^ thread->getThreadControl().id());
//
// See the comment in IceUtil::Thread::start() for details.
//
rawThread->__decRef();
thread->run();
}
catch(...)
{
if(!thread->name().empty())
{
cerr << thread->name() << " terminating" << endl;
}
std::terminate();
}
thread->_done();
return 0;
}
/***********************************************************
tell the server to shutdown
***********************************************************/
void MaintenanceInterfaceServant::Shutdown(const Ice::Current&)
{
IceUtil::ThreadPtr t = new ShutdownThread(_communicator, _worldname, _wcH);
t->start();
}
int
run(const CommunicatorPtr& communicator, const string& envName)
{
const string dbName = "binary";
Freeze::ConnectionPtr connection = createConnection(communicator, envName);
ByteIntMap m1(connection, dbName);
//
// Populate the database with the alphabet
//
populateDB(connection, m1);
//
// Test ==, swap and communicator()
//
ByteIntMap m(connection, dbName + "-tmp");
test(!(m == m1));
test(m != m1);
m.swap(m1);
test(!(m == m1));
test(m != m1);
test(m1.size() == 0);
test(m.communicator() == m1.communicator() == communicator);
vector<Byte>::const_iterator j;
ByteIntMap::iterator p;
ByteIntMap::const_iterator cp;
cout << "testing populate... " << flush;
//
// First try non-const iterator
//
for(j = alphabet.begin(); j != alphabet.end(); ++j)
{
p = m.find(*j);
test(p != m.end());
test(p->first == *j && p->second == j - alphabet.begin());
}
//
// Next try const iterator
//
for(j = alphabet.begin(); j != alphabet.end(); ++j)
{
cp = m.find(*j);
test(cp != m.end());
test(cp->first == *j && cp->second == j - alphabet.begin());
}
test(!m.empty());
test(m.size() == alphabet.size());
cout << "ok" << endl;
cout << "testing map::find... " << flush;
j = find(alphabet.begin(), alphabet.end(), 'n');
cp = m.find(*j);
test(cp != m.end());
test(cp->first == 'n' && cp->second == j - alphabet.begin());
cout << "ok" << endl;
cout << "testing erase... " << flush;
//
// erase first offset characters (first offset characters is
// important for later verification of the correct second value in
// the map).
//
int offset = 3;
vector<Byte> bytes;
bytes.push_back('a');
bytes.push_back('b');
bytes.push_back('c');
for(j = bytes.begin(); j != bytes.end(); ++j)
{
p = m.find(*j);
test(p != m.end());
m.erase(p);
//
// Release locks to avoid self deadlock
//
p = m.end();
p = m.find(*j);
test(p == m.end());
vector<Byte>::iterator r = find(alphabet.begin(), alphabet.end(), *j);
test(r != alphabet.end());
alphabet.erase(r);
}
for(j = alphabet.begin(); j != alphabet.end(); ++j)
{
cp = m.find(*j);
test(cp != m.end());
test(cp->first == *j && cp->second == (j - alphabet.begin()) + offset);
}
cout << "ok" << endl;
//
// Get an iterator for the deleted element - this should fail.
//
cout << "testing map::find (again)... " << flush;
cp = m.find('a');
test(cp == m.end());
cout << "ok" << endl;
cout << "testing iterators... " << flush;
p = m.begin();
ByteIntMap::iterator p2 = p;
//
// Verify both iterators point at the same element, and that
// element is in the map.
//
test(p == p2);
test(p->first == p2->first && p->second == p2->second);
test(find(alphabet.begin(), alphabet.end(), p->first) != alphabet.end());
//
// Create iterator that points at 'n'
//
p = m.find('n');
p2 = p;
//
// Verify both iterators point at 'n'
//
test(p == p2);
test(p->first == 'n' && p->second == 13);
test(p2->first == 'n' && p2->second == 13);
//
// Create cursor that points at 'n'
//
p = m.find('n');
test(p->first == 'n' && p->second == 13);
++p;
p2 = p;
//
// Verify cloned cursors are independent
//
test(p->first != 'n' && p->second != 13);
pair<const Byte, const Int> data = *p;
++p;
test(p->first != data.first && p->second != data.second);
++p;
test(p2->first == data.first && p2->second == data.second);
p = m.find('n');
p2 = ++p;
test(p2->first == p->first);
char c = p2->first;
p2 = p++;
test(c == p2->first); // p2 should still be the same
test(p2->first != p->first && (++p2)->first == p->first);
cout << "ok" << endl;
//
// Test writing into an iterator.
//
cout << "testing iterator.set... " << flush;
p = m.find('d');
test(p != m.end() && p->second == 3);
test(m.find('a') == m.end());
ByteIntMap::value_type i1('a', 1);
m.put(i1);
//
// Note: VC++ won't accept this
//
//m.put(ByteIntMap::value_type('a', 1));
p = m.find('a');
test(p != m.end() && p->second == 1);
ByteIntMap::value_type i2('a', 0);
m.put(i2);
//
// Note: VC++ won't accept this
//
//m.put(ByteIntMap::value_type('a', 0));
p = m.find('a');
test(p != m.end() && p->second == 0);
//
// Test inserts
//
ByteIntMap::value_type i3('a', 7);
pair<ByteIntMap::iterator, bool> insertResult = m.insert(i3);
test(insertResult.first == m.find('a'));
test(insertResult.first->second == 0);
test(insertResult.second == false);
insertResult.first = m.end();
p = m.insert(m.end(), i3);
test(p == m.find('a'));
test(p->second == 0);
ByteIntMap::value_type i4('b', 7);
insertResult = m.insert(i4);
test(insertResult.first == m.find('b'));
test(insertResult.first->second == 7);
test(insertResult.second == true);
insertResult.first = m.end();
ByteIntMap::value_type i5('c', 8);
p = m.insert(m.end(), i5);
test(p == m.find('c'));
test(p->second == 8);
p = m.find('a');
test(p != m.end() && p->second == 0);
p.set(1);
test(p != m.end() && p->second == 1);
//
// This is necessary to release the locks held
// by p and avoid a self-deadlock
//
p = m.end();
p = m.find('a');
test(p != m.end() && p->second == 1);
cout << "ok" << endl;
//
// Re-populate
//
populateDB(connection, m);
cout << "testing algorithms... " << flush;
for_each(m.begin(), m.end(), ForEachTest);
//
// Inefficient, but this is just a test. Ensure that both forms of
// operator== & != are tested.
//
ByteIntMap::value_type toFind('n', 13);
p = find(m.begin(), m.end(), toFind);
test(p != m.end());
test(*p == toFind);
test(toFind == *p);
test(!(*p != toFind));
test(!(toFind != *p));
p = find_if(m.begin(), m.end(), FindIfTest);
test(p->first == 'b');
//
// find_first_of. First construct a map with keys n, o, p,
// q. The test must find one of the types (it doesn't matter
// which since the container doesn't have to maintain sorted
// order).
//
j = find(alphabet.begin(), alphabet.end(), 'n');
map<Byte, const Int> pairs;
pairs.insert(pair<const Byte, const Int>(*j, static_cast<Int>(j - alphabet.begin())));
++j;
pairs.insert(pair<const Byte, const Int>(*j, static_cast<Int>(j - alphabet.begin())));
++j;
pairs.insert(pair<const Byte, const Int>(*j, static_cast<Int>(j - alphabet.begin())));
++j;
pairs.insert(pair<const Byte, const Int>(*j, static_cast<Int>(j - alphabet.begin())));
p = find_first_of(m.begin(), m.end(), pairs.begin(), pairs.end());
test(p != m.end());
test(p->first == 'n' || p->first == 'o' || p->first == 'p' || p->first == 'q');
j = find(alphabet.begin(), alphabet.end(), 'n');
p = find_first_of(m.begin(), m.end(), j, j + 4, FindFirstOfTest);
test(p != m.end());
test(p->first == 'n' || p->first == 'o' || p->first == 'p' || p->first == 'q');
pairs.clear();
for(p = m.begin(); p != m.end(); ++p)
{
pairs.insert(pair<const Byte, const Int>(p->first, p->second));
}
test(pairs.size() == m.size());
map<Byte, const Int>::const_iterator pit;
for(pit = pairs.begin(); pit != pairs.end(); ++pit)
{
p = m.find(pit->first);
test(p != m.end());
}
cout << "ok" << endl;
cout << "testing index ... " << flush;
m.clear();
populateDB(connection, m);
//
// Exact match
//
size_t length = alphabet.size();
for(size_t k = 0; k < length; ++k)
{
p = m.findByValue(static_cast<Int>(k));
test(p != m.end());
test(p->first == alphabet[k]);
test(++p == m.end());
}
//
// 2 items at 17
//
m.put(ByteIntMap::value_type(alphabet[21], static_cast<Int>(17)));
p = m.findByValue(17);
test(p != m.end());
test(p->first == alphabet[17] || p->first == alphabet[21]);
test(++p != m.end());
test(p->first == alphabet[17] || p->first == alphabet[21]);
test(++p == m.end());
test(m.valueCount(17) == 2);
p = m.findByValue(17);
test(p != m.end());
m.erase(p);
test(++p != m.end());
test(p->first == alphabet[17] || p->first == alphabet[21]);
test(++p == m.end());
test(m.valueCount(17) == 1);
p = m.findByValue(17);
test(p != m.end());
test(p->first == alphabet[17] || p->first == alphabet[21]);
try
{
p.set(18);
test(false);
}
catch(const DatabaseException&)
{
// Expected
}
test(p->first == alphabet[17] || p->first == alphabet[21]);
test(++p == m.end());
test(m.valueCount(17) == 1);
m.put(ByteIntMap::value_type(alphabet[21], static_cast<Int>(17)));
//
// Non-exact match
//
p = m.findByValue(21);
test(p == m.end());
test(m.valueCount(21) == 0);
p = m.findByValue(21, false);
test(p == m.end());
p = m.findByValue(22, false);
int previous = 21;
int count = 0;
while(p != m.end())
{
test(p->second > previous);
previous = p->second;
++p;
count++;
}
test(count == 4);
cout << "ok " << endl;
cout << "testing concurrent access... " << flush;
m.clear();
populateDB(connection, m);
vector<IceUtil::ThreadControl> controls;
for(int i = 0; i < 5; ++i)
{
IceUtil::ThreadPtr rt = new ReadThread(communicator, envName, dbName);
controls.push_back(rt->start());
IceUtil::ThreadPtr wt = new WriteThread(communicator, envName, dbName);
controls.push_back(wt->start());
}
for(vector<IceUtil::ThreadControl>::iterator q = controls.begin(); q != controls.end(); ++q)
{
q->join();
}
cout << "ok" << endl;
cout << "testing index creation... " << flush;
{
IntIdentityMap iim(connection, "intIdentity");
Ice::Identity odd;
odd.name = "foo";
odd.category = "odd";
Ice::Identity even;
even.name = "bar";
even.category = "even";
TransactionHolder txHolder(connection);
for(int i = 0; i < 1000; i++)
{
if(i % 2 == 0)
{
iim.put(IntIdentityMap::value_type(i, even));
}
else
{
iim.put(IntIdentityMap::value_type(i, odd));
}
}
txHolder.commit();
}
{
IntIdentityMapWithIndex iim(connection, "intIdentity");
test(iim.categoryCount("even") == 500);
test(iim.categoryCount("odd") == 500);
{
int count = 0;
IntIdentityMapWithIndex::iterator p = iim.findByCategory("even");
while(p != iim.end())
{
test(p->first % 2 == 0);
++p;
++count;
}
test(count == 500);
}
{
int count = 0;
IntIdentityMapWithIndex::iterator p = iim.findByCategory("odd");
while(p != iim.end())
{
test(p->first % 2 == 1);
++p;
++count;
}
test(count == 500);
}
iim.clear();
}
cout << "ok" << endl;
cout << "testing sorting... " << flush;
{
SortedMap sm(connection, "sortedMap");
TransactionHolder txHolder(connection);
for(int i = 0; i < 1000; i++)
{
int k = rand() % 1000;
Ice::Identity id;
id.name = "foo";
id.category = 'a' + static_cast<char>(k % 26);
sm.put(SortedMap::value_type(k, id));
}
txHolder.commit();
}
{
SortedMap sm(connection, "sortedMap");
{
for(int i = 0; i < 100; ++i)
{
int k = rand() % 1000;
SortedMap::iterator p = sm.lower_bound(k);
if(p != sm.end())
{
test(p->first >= k);
SortedMap::iterator q = sm.upper_bound(k);
if(q == sm.end())
{
test(p->first == k);
}
else
{
test((p->first == k && q->first > k) ||
(p->first > k && q->first == p->first));
}
}
}
}
{
for(int i = 0; i < 100; ++i)
{
string category;
category = static_cast<char>('a' + rand() % 26);
SortedMap::iterator p = sm.findByCategory(category);
if(p != sm.end())
{
SortedMap::iterator q = sm.lowerBoundForCategory(category);
test(p == q);
do
{
q++;
} while(q != sm.end() && q->second.category == category);
if(q != sm.end())
{
test(q == sm.upperBoundForCategory(category));
}
}
else
{
SortedMap::iterator q = sm.lowerBoundForCategory(category);
if(q != sm.end())
{
test(p != q);
test(q->second.category < category);
category = q->second.category;
do
{
q++;
} while(q != sm.end() && q->second.category == category);
if(q != sm.end())
{
test(q == sm.upperBoundForCategory(category));
}
}
}
}
}
{
string category = "z";
SortedMap::iterator p = sm.lowerBoundForCategory(category);
while(p != sm.end())
{
test(p->second.category <= category);
category = p->second.category;
// cerr << category << ":" << p->first << endl;
++p;
}
}
sm.clear();
}
cout << "ok" << endl;
cout << "testing wstring... " << flush;
{
WstringWstringMap wsm(connection, "wstringMap");
TransactionHolder txHolder(connection);
wsm.put(WstringWstringMap::value_type(L"AAAAA", L"aaaaa"));
wsm.put(WstringWstringMap::value_type(L"BBBBB", L"bbbbb"));
wsm.put(WstringWstringMap::value_type(L"CCCCC", L"ccccc"));
wsm.put(WstringWstringMap::value_type(L"DDDDD", L"ddddd"));
wsm.put(WstringWstringMap::value_type(L"EEEEE", L"eeeee"));
txHolder.commit();
}
{
WstringWstringMap wsm(connection, "wstringMap");
{
WstringWstringMap::iterator p = wsm.find(L"BBBBB");
test(p != wsm.end());
test(p->second == L"bbbbb");
p = wsm.findByValue(L"ddddd");
test(p != wsm.end());
test(p->first == L"DDDDD");
}
wsm.clear();
}
cout << "ok" << endl;
return EXIT_SUCCESS;
}
/***********************************************************
connect to the server
***********************************************************/
int ServerConnectionHandler::Connect(const std::string &user, const std::string &password,
bool &ircon, std::string & reason)
{
Disconnect();
Ice::RouterPrx defaultRouter = _communicator->getDefaultRouter();
if(!defaultRouter)
{
LogHandler::getInstance()->LogToFile(std::string("Can not connect: no default router set"));
return 0;
}
try
{
_router = Glacier2::RouterPrx::checkedCast(defaultRouter);
}
catch(const IceUtil::Exception& ex)
{
LogHandler::getInstance()->LogToFile(std::string("Exception connecting to the server: ") + ex.what());
return 0;
}
catch(...)
{
LogHandler::getInstance()->LogToFile(std::string("Unknown exception connecting to the server. "));
return 0;
}
if(!_router)
{
LogHandler::getInstance()->LogToFile(std::string("Can not connect: configured router is not a Glacier2 router"));
return 0;
}
try
{
_session = LbaNet::ClientSessionPrx::uncheckedCast(_router->createSession(user, password));
}
catch(const Glacier2::PermissionDeniedException& ex)
{
LogHandler::getInstance()->LogToFile(std::string("Permission denied: ") + ex.what());
LogHandler::getInstance()->InformUser("Permission denied.");
reason = ex.reason;
return -1;
}
try
{
std::string verS = _session->GetVersion();
Ice::PropertiesPtr prop = _communicator->getProperties();
std::string serverV = prop->getPropertyWithDefault("LbanetServerVersion", "v0");
if(verS != serverV)
{
reason = "Server version mismatch - please update your game.";
Disconnect();
return -1;
}
}
catch(const Ice::Exception& ex)
{
LogHandler::getInstance()->LogToFile(std::string("Error getting server version: ") + ex.what());
return 0;
}
try
{
_adapter = _communicator->createObjectAdapter("LbaNetClient");
_adapter->activate();
}
catch(const Ice::Exception& ex)
{
LogHandler::getInstance()->LogToFile(std::string("Error creating adapter: ") + ex.what());
return 0;
}
// clear online list
ThreadSafeWorkpile::JoinEvent evcl;
evcl.ListName = "online";
evcl.Clear = true;
ThreadSafeWorkpile::getInstance()->HappenedJoinEvent(evcl);
// fill it with already connected people
if(_session)
{
Ice::Long ownid = -1;
LbaNet::ConnectedL listco = _session->GetConnected(ownid);
ThreadSafeWorkpile::getInstance()->SetPlayerId(ownid);
LbaNet::ConnectedL::const_iterator it = listco.begin();
LbaNet::ConnectedL::const_iterator end = listco.end();
for(;it != end; ++it)
{
ThreadSafeWorkpile::JoinEvent ev;
ev.ListName = "online";
ev.Joined = true;
ev.Clear = false;
ev.Nickname = it->first;
ev.Status = it->second.Status;
ev.Color = it->second.NameColor;
ThreadSafeWorkpile::getInstance()->HappenedJoinEvent(ev);
ThreadSafeWorkpile::getInstance()->ChatColorChanged(ev.Nickname, ev.Color);
}
//synchronize time with server
//SynchronizedTimeHandler::getInstance()->Initialize(session);
}
IceUtil::ThreadPtr t = new SendingLoopThread(_adapter, _session,
_router->getServerProxy()->ice_getIdentity().category,
user);
_tc = t->start();
_thread_started = true;
//---------------------------------------------------------------
// start the irc thread
Ice::PropertiesPtr prop = _communicator->getProperties();
_ircOn = (prop->getPropertyAsInt("IrcOn") == 1);
std::string IrcServer = prop->getProperty("IrcServer");
std::string IrcChannel = "#" + prop->getProperty("IrcChannel");
if(_ircOn)
{
ircon = true;
IrcThread::IrcCoInfo coi;
coi.Server = IrcServer;
coi.Nickname = user;
coi.Channel = IrcChannel;
_ircth = new IrcThread(coi);
_tcirc = _ircth->start();
}
else
ircon = false;
return 1;
}
void C2S_Put(
const std::string& bucketID,
const std::string& objID,
const FleCS::ByteSeq& content)
{
_LOG(objID);
string boID = bucketID + "/" + objID;
GlobalLock lock(boID, 'W');
/*Get Random server to write to */
/*
*0->flecs12
*1->flecs22
*2->REDIS_HOST
*/
int s1 = getRand();
int s2=s1;
while(s2!=s1)
s2=getRand();
redisContext *c;
redisReply *reply;
struct timeval timeout = { 1, 500000 }; // 1.5 seconds
c = redisConnectWithTimeout((char*)"REDIS_HOST ", 6379, timeout);
if (c->err) {
_LOG("Connection error"<<c->errstr);
//exit(1);
}
_LOG("Redis connected");
/* Set a key */
reply = (redisReply*)redisCommand(c, "SET %s %s",(string(bucketID + ":" + objID).c_str()),(string(FleCSServer::stg_root_dir)+ "/" + bucketID + "/" + objID).c_str());
_LOG("SET:"<< reply->str);
freeReplyObject(reply);
reply = (redisReply*)redisCommand(c, "GET %s",(string(bucketID + ":" + objID).c_str()));
_LOG("GET:"<< reply->str);
_writefile(reply->str, content);
//_writefile((string(FleCSServer::stg_root_dir) + "/" + boID).c_str(), content);
freeReplyObject(reply);
// propagate update to the other servers.
map<string, FleCS::SM2SPrx*>& s = FleCSServer::peer_servers;
#ifdef _SERIAL_PROCESSING
for (map<string, FleCS::SM2SPrx*>::const_iterator i = s.begin(); i != s.end(); ++ i)
{
string endpoint = dynamic_cast<string>(*(i->first));
(*(i->second))->Put(bucketID, objID, content);
}
#else // Parallel processing (by default)
vector<IceUtil::ThreadPtr> tpv;
vector<IceUtil::ThreadControl> tcv;
for (map<string, FleCS::SM2SPrx*>::const_iterator i = s.begin(); i != s.end(); ++ i)
{
IceUtil::ThreadPtr t = new PutThread(*(i->second), bucketID, objID, content);
tcv.push_back(t->start());
tpv.push_back(t);
}
for (vector<IceUtil::ThreadControl>::iterator j = tcv.begin(); j != tcv.end(); ++ j)
j->join();
#endif
}
void
twoways(const Ice::CommunicatorPtr& communicator, const Test::MyClassPrxPtr& p)
{
{
p->ice_ping();
}
{
#ifdef ICE_CPP11_MAPPING
test(Test::MyClassPrx::ice_staticId() == Test::MyClassDisp::ice_staticId());
#else
test(Test::MyClassPrx::ice_staticId() == Test::MyClass::ice_staticId());
#endif
test(Ice::ObjectPrx::ice_staticId() == Ice::Object::ice_staticId());
}
{
test(p->ice_isA(Test::MyClass::ice_staticId()));
}
{
test(p->ice_id() == Test::MyDerivedClass::ice_staticId());
}
{
Ice::StringSeq ids = p->ice_ids();
test(ids.size() == 3);
test(ids[0] == "::Ice::Object");
test(ids[1] == "::Test::MyClass");
test(ids[2] == "::Test::MyDerivedClass");
}
{
p->opVoid();
}
{
Ice::Byte b;
Ice::Byte r;
r = p->opByte(Ice::Byte(0xff), Ice::Byte(0x0f), b);
test(b == Ice::Byte(0xf0));
test(r == Ice::Byte(0xff));
}
{
bool b;
bool r;
r = p->opBool(true, false, b);
test(b);
test(!r);
}
{
Ice::Short s;
Ice::Int i;
Ice::Long l;
Ice::Long r;
r = p->opShortIntLong(10, 11, 12, s, i, l);
test(s == 10);
test(i == 11);
test(l == 12);
test(r == 12);
r = p->opShortIntLong(numeric_limits<Ice::Short>::min(), numeric_limits<Ice::Int>::min(),
numeric_limits<Ice::Long>::min(), s, i, l);
test(s == numeric_limits<Ice::Short>::min());
test(i == numeric_limits<Ice::Int>::min());
test(l == numeric_limits<Ice::Long>::min());
test(r == numeric_limits<Ice::Long>::min());
r = p->opShortIntLong(numeric_limits<Ice::Short>::max(), numeric_limits<Ice::Int>::max(),
numeric_limits<Ice::Long>::max(), s, i, l);
test(s == numeric_limits<Ice::Short>::max());
test(i == numeric_limits<Ice::Int>::max());
test(l == numeric_limits<Ice::Long>::max());
test(r == numeric_limits<Ice::Long>::max());
}
{
Ice::Float f;
Ice::Double d;
Ice::Double r;
r = p->opFloatDouble(Ice::Float(3.14), Ice::Double(1.1E10), f, d);
test(f == Ice::Float(3.14));
test(d == Ice::Double(1.1E10));
test(r == Ice::Double(1.1E10));
r = p->opFloatDouble(numeric_limits<Ice::Float>::min(), numeric_limits<Ice::Double>::min(), f, d);
test(f == numeric_limits<Ice::Float>::min());
test(d == numeric_limits<Ice::Double>::min());
test(r == numeric_limits<Ice::Double>::min());
r = p->opFloatDouble(numeric_limits<Ice::Float>::max(), numeric_limits<Ice::Double>::max(), f, d);
test(f == numeric_limits<Ice::Float>::max());
test(d == numeric_limits<Ice::Double>::max());
test(r == numeric_limits<Ice::Double>::max());
}
{
string s;
string r;
r = p->opString("hello", "world", s);
test(s == "world hello");
test(r == "hello world");
}
{
Test::MyEnum e;
Test::MyEnum r;
r = p->opMyEnum(ICE_ENUM(MyEnum, enum2), e);
test(e == ICE_ENUM(MyEnum, enum2));
test(r == ICE_ENUM(MyEnum, enum3));
}
{
Test::MyClassPrxPtr c1;
Test::MyClassPrxPtr c2;
Test::MyClassPrxPtr r;
r = p->opMyClass(p, c1, c2);
test(Ice::proxyIdentityAndFacetEqual(c1, p));
test(!Ice::proxyIdentityAndFacetEqual(c2, p));
test(Ice::proxyIdentityAndFacetEqual(r, p));
test(c1->ice_getIdentity() == communicator->stringToIdentity("test"));
test(c2->ice_getIdentity() == communicator->stringToIdentity("noSuchIdentity"));
test(r->ice_getIdentity() == communicator->stringToIdentity("test"));
r->opVoid();
c1->opVoid();
try
{
c2->opVoid();
test(false);
}
catch(const Ice::ObjectNotExistException&)
{
}
r = p->opMyClass(0, c1, c2);
test(c1 == 0);
test(c2 != 0);
test(Ice::proxyIdentityAndFacetEqual(r, p));
r->opVoid();
}
{
Test::Structure si1;
si1.p = p;
si1.e = ICE_ENUM(MyEnum, enum3);
si1.s.s = "abc";
Test::Structure si2;
si2.p = 0;
si2.e = ICE_ENUM(MyEnum, enum2);
si2.s.s = "def";
Test::Structure so;
Test::Structure rso = p->opStruct(si1, si2, so);
test(rso.p == 0);
test(rso.e == ICE_ENUM(MyEnum, enum2));
test(rso.s.s == "def");
#ifdef ICE_CPP11_MAPPING
test(Ice::targetEquals(so.p, p));
#else
test(so.p == p);
#endif
test(so.e == ICE_ENUM(MyEnum, enum3));
test(so.s.s == "a new string");
so.p->opVoid();
}
{
Test::ByteS bsi1;
Test::ByteS bsi2;
bsi1.push_back(Ice::Byte(0x01));
bsi1.push_back(Ice::Byte(0x11));
bsi1.push_back(Ice::Byte(0x12));
bsi1.push_back(Ice::Byte(0x22));
bsi2.push_back(Ice::Byte(0xf1));
bsi2.push_back(Ice::Byte(0xf2));
bsi2.push_back(Ice::Byte(0xf3));
bsi2.push_back(Ice::Byte(0xf4));
Test::ByteS bso;
Test::ByteS rso;
rso = p->opByteS(bsi1, bsi2, bso);
test(bso.size() == 4);
test(bso[0] == Ice::Byte(0x22));
test(bso[1] == Ice::Byte(0x12));
test(bso[2] == Ice::Byte(0x11));
test(bso[3] == Ice::Byte(0x01));
test(rso.size() == 8);
test(rso[0] == Ice::Byte(0x01));
test(rso[1] == Ice::Byte(0x11));
test(rso[2] == Ice::Byte(0x12));
test(rso[3] == Ice::Byte(0x22));
test(rso[4] == Ice::Byte(0xf1));
test(rso[5] == Ice::Byte(0xf2));
test(rso[6] == Ice::Byte(0xf3));
test(rso[7] == Ice::Byte(0xf4));
}
{
Test::BoolS bsi1;
Test::BoolS bsi2;
bsi1.push_back(true);
bsi1.push_back(true);
bsi1.push_back(false);
bsi2.push_back(false);
Test::BoolS bso;
Test::BoolS rso;
rso = p->opBoolS(bsi1, bsi2, bso);
test(bso.size() == 4);
test(bso[0]);
test(bso[1]);
test(!bso[2]);
test(!bso[3]);
test(rso.size() == 3);
test(!rso[0]);
test(rso[1]);
test(rso[2]);
}
{
Test::ShortS ssi;
Test::IntS isi;
Test::LongS lsi;
ssi.push_back(1);
ssi.push_back(2);
ssi.push_back(3);
isi.push_back(5);
isi.push_back(6);
isi.push_back(7);
isi.push_back(8);
lsi.push_back(10);
lsi.push_back(30);
lsi.push_back(20);
Test::ShortS sso;
Test::IntS iso;
Test::LongS lso;
Test::LongS rso;
rso = p->opShortIntLongS(ssi, isi, lsi, sso, iso, lso);
test(sso.size() == 3);
test(sso[0] == 1);
test(sso[1] == 2);
test(sso[2] == 3);
test(iso.size() == 4);
test(iso[0] == 8);
test(iso[1] == 7);
test(iso[2] == 6);
test(iso[3] == 5);
test(lso.size() == 6);
test(lso[0] == 10);
test(lso[1] == 30);
test(lso[2] == 20);
test(lso[3] == 10);
test(lso[4] == 30);
test(lso[5] == 20);
test(rso.size() == 3);
test(rso[0] == 10);
test(rso[1] == 30);
test(rso[2] == 20);
}
{
Test::FloatS fsi;
Test::DoubleS dsi;
fsi.push_back(Ice::Float(3.14));
fsi.push_back(Ice::Float(1.11));
dsi.push_back(Ice::Double(1.1E10));
dsi.push_back(Ice::Double(1.2E10));
dsi.push_back(Ice::Double(1.3E10));
Test::FloatS fso;
Test::DoubleS dso;
Test::DoubleS rso;
rso = p->opFloatDoubleS(fsi, dsi, fso, dso);
test(fso.size() == 2);
test(fso[0] == ::Ice::Float(3.14));
test(fso[1] == ::Ice::Float(1.11));
test(dso.size() == 3);
test(dso[0] == ::Ice::Double(1.3E10));
test(dso[1] == ::Ice::Double(1.2E10));
test(dso[2] == ::Ice::Double(1.1E10));
test(rso.size() == 5);
test(rso[0] == ::Ice::Double(1.1E10));
test(rso[1] == ::Ice::Double(1.2E10));
test(rso[2] == ::Ice::Double(1.3E10));
test(::Ice::Float(rso[3]) == ::Ice::Float(3.14));
test(::Ice::Float(rso[4]) == ::Ice::Float(1.11));
}
{
Test::StringS ssi1;
Test::StringS ssi2;
ssi1.push_back("abc");
ssi1.push_back("de");
ssi1.push_back("fghi");
ssi2.push_back("xyz");
Test::StringS sso;
Test::StringS rso;
rso = p->opStringS(ssi1, ssi2, sso);
test(sso.size() == 4);
test(sso[0] == "abc");
test(sso[1] == "de");
test(sso[2] == "fghi");
test(sso[3] == "xyz");
test(rso.size() == 3);
test(rso[0] == "fghi");
test(rso[1] == "de");
test(rso[2] == "abc");
}
{
Test::ByteSS bsi1;
bsi1.resize(2);
Test::ByteSS bsi2;
bsi2.resize(2);
bsi1[0].push_back(Ice::Byte(0x01));
bsi1[0].push_back(Ice::Byte(0x11));
bsi1[0].push_back(Ice::Byte(0x12));
bsi1[1].push_back(Ice::Byte(0xff));
bsi2[0].push_back(Ice::Byte(0x0e));
bsi2[1].push_back(Ice::Byte(0xf2));
bsi2[1].push_back(Ice::Byte(0xf1));
Test::ByteSS bso;
Test::ByteSS rso;
rso = p->opByteSS(bsi1, bsi2, bso);
test(bso.size() == 2);
test(bso[0].size() == 1);
test(bso[0][0] == Ice::Byte(0xff));
test(bso[1].size() == 3);
test(bso[1][0] == Ice::Byte(0x01));
test(bso[1][1] == Ice::Byte(0x11));
test(bso[1][2] == Ice::Byte(0x12));
test(rso.size() == 4);
test(rso[0].size() == 3);
test(rso[0][0] == Ice::Byte(0x01));
test(rso[0][1] == Ice::Byte(0x11));
test(rso[0][2] == Ice::Byte(0x12));
test(rso[1].size() == 1);
test(rso[1][0] == Ice::Byte(0xff));
test(rso[2].size() == 1);
test(rso[2][0] == Ice::Byte(0x0e));
test(rso[3].size() == 2);
test(rso[3][0] == Ice::Byte(0xf2));
test(rso[3][1] == Ice::Byte(0xf1));
}
{
Test::BoolSS bsi1;
bsi1.resize(3);
Test::BoolSS bsi2;
bsi2.resize(1);
bsi1[0].push_back(true);
bsi1[1].push_back(false);
bsi1[2].push_back(true);
bsi1[2].push_back(true);
bsi2[0].push_back(false);
bsi2[0].push_back(false);
bsi2[0].push_back(true);
Test::BoolSS bso;
Test::BoolSS rso;
rso = p->opBoolSS(bsi1, bsi2, bso);
test(bso.size() == 4);
test(bso[0].size() == 1);
test(bso[0][0]);
test(bso[1].size() == 1);
test(!bso[1][0]);
test(bso[2].size() == 2);
test(bso[2][0]);
test(bso[2][1]);
test(bso[3].size() == 3);
test(!bso[3][0]);
test(!bso[3][1]);
test(bso[3][2]);
test(rso.size() == 3);
test(rso[0].size() == 2);
test(rso[0][0]);
test(rso[0][1]);
test(rso[1].size() == 1);
test(!rso[1][0]);
test(rso[2].size() == 1);
test(rso[2][0]);
}
{
Test::ShortSS ssi;
ssi.resize(3);
Test::IntSS isi;
isi.resize(2);
Test::LongSS lsi;
lsi.resize(1);
ssi[0].push_back(1);
ssi[0].push_back(2);
ssi[0].push_back(5);
ssi[1].push_back(13);
isi[0].push_back(24);
isi[0].push_back(98);
isi[1].push_back(42);
lsi[0].push_back(496);
lsi[0].push_back(1729);
Test::LongSS rso;
Test::ShortSS sso;
Test::IntSS iso;
Test::LongSS lso;
rso = p->opShortIntLongSS(ssi, isi, lsi, sso, iso, lso);
test(rso.size() == 1);
test(rso[0].size() == 2);
test(rso[0][0] == 496);
test(rso[0][1] == 1729);
test(sso.size() == 3);
test(sso[0].size() == 3);
test(sso[0][0] == 1);
test(sso[0][1] == 2);
test(sso[0][2] == 5);
test(sso[1].size() == 1);
test(sso[1][0] == 13);
test(sso[2].size() == 0);
test(iso.size() == 2);
test(iso[0].size() == 1);
test(iso[0][0] == 42);
test(iso[1].size() == 2);
test(iso[1][0] == 24);
test(iso[1][1] == 98);
test(lso.size() == 2);
test(lso[0].size() == 2);
test(lso[0][0] == 496);
test(lso[0][1] == 1729);
test(lso[1].size() == 2);
test(lso[1][0] == 496);
test(lso[1][1] == 1729);
}
{
Test::FloatSS fsi;
fsi.resize(3);
Test::DoubleSS dsi;
dsi.resize(1);
fsi[0].push_back(Ice::Float(3.14));
fsi[1].push_back(Ice::Float(1.11));
dsi[0].push_back(Ice::Double(1.1E10));
dsi[0].push_back(Ice::Double(1.2E10));
dsi[0].push_back(Ice::Double(1.3E10));
Test::FloatSS fso;
Test::DoubleSS dso;
Test::DoubleSS rso;
rso = p->opFloatDoubleSS(fsi, dsi, fso, dso);
test(fso.size() == 3);
test(fso[0].size() == 1);
test(fso[0][0] == ::Ice::Float(3.14));
test(fso[1].size() == 1);
test(fso[1][0] == ::Ice::Float(1.11));
test(fso[2].size() == 0);
test(dso.size() == 1);
test(dso[0].size() == 3);
test(dso[0][0] == ::Ice::Double(1.1E10));
test(dso[0][1] == ::Ice::Double(1.2E10));
test(dso[0][2] == ::Ice::Double(1.3E10));
test(rso.size() == 2);
test(rso[0].size() == 3);
test(rso[0][0] == ::Ice::Double(1.1E10));
test(rso[0][1] == ::Ice::Double(1.2E10));
test(rso[0][2] == ::Ice::Double(1.3E10));
test(rso[1].size() == 3);
test(rso[1][0] == ::Ice::Double(1.1E10));
test(rso[1][1] == ::Ice::Double(1.2E10));
test(rso[1][2] == ::Ice::Double(1.3E10));
}
{
Test::StringSS ssi1;
ssi1.resize(2);
Test::StringSS ssi2;
ssi2.resize(3);
ssi1[0].push_back("abc");
ssi1[1].push_back("de");
ssi1[1].push_back("fghi");
ssi2[2].push_back("xyz");
Test::StringSS sso;
Test::StringSS rso;
rso = p->opStringSS(ssi1, ssi2, sso);
test(sso.size() == 5);
test(sso[0].size() == 1);
test(sso[0][0] == "abc");
test(sso[1].size() == 2);
test(sso[1][0] == "de");
test(sso[1][1] == "fghi");
test(sso[2].size() == 0);
test(sso[3].size() == 0);
test(sso[4].size() == 1);
test(sso[4][0] == "xyz");
test(rso.size() == 3);
test(rso[0].size() == 1);
test(rso[0][0] == "xyz");
test(rso[1].size() == 0);
test(rso[2].size() == 0);
}
{
Test::StringSSS sssi1;
sssi1.resize(2);
sssi1[0].resize(2);
sssi1[0][0].push_back("abc");
sssi1[0][0].push_back("de");
sssi1[0][1].push_back("xyz");
sssi1[1].resize(1);
sssi1[1][0].push_back("hello");
Test::StringSSS sssi2;
sssi2.resize(3);
sssi2[0].resize(2);
sssi2[0][0].push_back("");
sssi2[0][0].push_back("");
sssi2[0][1].push_back("abcd");
sssi2[1].resize(1);
sssi2[1][0].push_back("");
Test::StringSSS ssso;
Test::StringSSS rsso;
rsso = p->opStringSSS(sssi1, sssi2, ssso);
test(ssso.size() == 5);
test(ssso[0].size() == 2);
test(ssso[0][0].size() == 2);
test(ssso[0][1].size() == 1);
test(ssso[1].size() == 1);
test(ssso[1][0].size() == 1);
test(ssso[2].size() == 2);
test(ssso[2][0].size() == 2);
test(ssso[2][1].size() == 1);
test(ssso[3].size() == 1);
test(ssso[3][0].size() == 1);
test(ssso[4].size() == 0);
test(ssso[0][0][0] == "abc");
test(ssso[0][0][1] == "de");
test(ssso[0][1][0] == "xyz");
test(ssso[1][0][0] == "hello");
test(ssso[2][0][0] == "");
test(ssso[2][0][1] == "");
test(ssso[2][1][0] == "abcd");
test(ssso[3][0][0] == "");
test(rsso.size() == 3);
test(rsso[0].size() == 0);
test(rsso[1].size() == 1);
test(rsso[1][0].size() == 1);
test(rsso[2].size() == 2);
test(rsso[2][0].size() == 2);
test(rsso[2][1].size() == 1);
test(rsso[1][0][0] == "");
test(rsso[2][0][0] == "");
test(rsso[2][0][1] == "");
test(rsso[2][1][0] == "abcd");
}
{
Test::ByteBoolD di1;
di1[10] = true;
di1[100] = false;
Test::ByteBoolD di2;
di2[10] = true;
di2[11] = false;
di2[101] = true;
Test::ByteBoolD _do;
Test::ByteBoolD ro = p->opByteBoolD(di1, di2, _do);
test(_do == di1);
test(ro.size() == 4);
test(ro[10] == true);
test(ro[11] == false);
test(ro[100] == false);
test(ro[101] == true);
}
{
Test::ShortIntD di1;
di1[110] = -1;
di1[1100] = 123123;
Test::ShortIntD di2;
di2[110] = -1;
di2[111] = -100;
di2[1101] = 0;
Test::ShortIntD _do;
Test::ShortIntD ro = p->opShortIntD(di1, di2, _do);
test(_do == di1);
test(ro.size() == 4);
test(ro[110] == -1);
test(ro[111] == -100);
test(ro[1100] == 123123);
test(ro[1101] == 0);
}
{
Test::LongFloatD di1;
di1[999999110] = Ice::Float(-1.1);
di1[999999111] = Ice::Float(123123.2);
Test::LongFloatD di2;
di2[999999110] = Ice::Float(-1.1);
di2[999999120] = Ice::Float(-100.4);
di2[999999130] = Ice::Float(0.5);
Test::LongFloatD _do;
Test::LongFloatD ro = p->opLongFloatD(di1, di2, _do);
test(_do == di1);
test(ro.size() == 4);
test(ro[999999110] == Ice::Float(-1.1));
test(ro[999999120] == Ice::Float(-100.4));
test(ro[999999111] == Ice::Float(123123.2));
test(ro[999999130] == Ice::Float(0.5));
}
{
Test::StringStringD di1;
di1["foo"] = "abc -1.1";
di1["bar"] = "abc 123123.2";
Test::StringStringD di2;
di2["foo"] = "abc -1.1";
di2["FOO"] = "abc -100.4";
di2["BAR"] = "abc 0.5";
Test::StringStringD _do;
Test::StringStringD ro = p->opStringStringD(di1, di2, _do);
test(_do == di1);
test(ro.size() == 4);
test(ro["foo"] == "abc -1.1");
test(ro["FOO"] == "abc -100.4");
test(ro["bar"] == "abc 123123.2");
test(ro["BAR"] == "abc 0.5");
}
{
Test::StringMyEnumD di1;
di1["abc"] = ICE_ENUM(MyEnum, enum1);
di1[""] = ICE_ENUM(MyEnum, enum2);
Test::StringMyEnumD di2;
di2["abc"] = ICE_ENUM(MyEnum, enum1);
di2["qwerty"] = ICE_ENUM(MyEnum, enum3);
di2["Hello!!"] = ICE_ENUM(MyEnum, enum2);
Test::StringMyEnumD _do;
Test::StringMyEnumD ro = p->opStringMyEnumD(di1, di2, _do);
test(_do == di1);
test(ro.size() == 4);
test(ro["abc"] == ICE_ENUM(MyEnum, enum1));
test(ro["qwerty"] == ICE_ENUM(MyEnum, enum3));
test(ro[""] == ICE_ENUM(MyEnum, enum2));
test(ro["Hello!!"] == ICE_ENUM(MyEnum, enum2));
}
{
Test::MyEnumStringD di1;
di1[ICE_ENUM(MyEnum, enum1)] = "abc";
Test::MyEnumStringD di2;
di2[ICE_ENUM(MyEnum, enum2)] = "Hello!!";
di2[ICE_ENUM(MyEnum, enum3)] = "qwerty";
Test::MyEnumStringD _do;
Test::MyEnumStringD ro = p->opMyEnumStringD(di1, di2, _do);
test(_do == di1);
test(ro.size() == 3);
test(ro[ICE_ENUM(MyEnum, enum1)] == "abc");
test(ro[ICE_ENUM(MyEnum, enum2)] == "Hello!!");
test(ro[ICE_ENUM(MyEnum, enum3)] == "qwerty");
}
{
Test::MyStruct s11 = { 1, 1 };
Test::MyStruct s12 = { 1, 2 };
Test::MyStructMyEnumD di1;
di1[s11] = ICE_ENUM(MyEnum, enum1);
di1[s12] = ICE_ENUM(MyEnum, enum2);
Test::MyStruct s22 = { 2, 2 };
Test::MyStruct s23 = { 2, 3 };
Test::MyStructMyEnumD di2;
di2[s11] = ICE_ENUM(MyEnum, enum1);
di2[s22] = ICE_ENUM(MyEnum, enum3);
di2[s23] = ICE_ENUM(MyEnum, enum2);
Test::MyStructMyEnumD _do;
Test::MyStructMyEnumD ro = p->opMyStructMyEnumD(di1, di2, _do);
test(_do == di1);
test(ro.size() == 4);
test(ro[s11] == ICE_ENUM(MyEnum, enum1));
test(ro[s12] == ICE_ENUM(MyEnum, enum2));
test(ro[s22] == ICE_ENUM(MyEnum, enum3));
test(ro[s23] == ICE_ENUM(MyEnum, enum2));
}
{
Test::ByteBoolDS dsi1;
dsi1.resize(2);
Test::ByteBoolDS dsi2;
dsi2.resize(1);
Test::ByteBoolD di1;
di1[10] = true;
di1[100] = false;
Test::ByteBoolD di2;
di2[10] = true;
di2[11] = false;
di2[101] = true;
Test::ByteBoolD di3;
di3[100] = false;
di3[101] = false;
dsi1[0] = di1;
dsi1[1] = di2;
dsi2[0] = di3;
try {
Test::ByteBoolDS _do;
Test::ByteBoolDS ro = p->opByteBoolDS(dsi1, dsi2, _do);
test(ro.size() == 2);
test(ro[0].size() == 3);
test(ro[0][10] == true);
test(ro[0][11] == false);
test(ro[0][101] == true);
test(ro[1].size() == 2);
test(ro[1][10] == true);
test(ro[1][100] == false);
test(_do.size() == 3);
test(_do[0].size() == 2);
test(_do[0][100] == false);
test(_do[0][101] == false);
test(_do[1].size() == 2);
test(_do[1][10] == true);
test(_do[1][100] == false);
test(_do[2].size() == 3);
test(_do[2][10] == true);
test(_do[2][11] == false);
test(_do[2][101] == true);
}
catch(const Ice::OperationNotExistException&)
{
}
}
{
Test::ShortIntDS dsi1;
dsi1.resize(2);
Test::ShortIntDS dsi2;
dsi2.resize(1);
Test::ShortIntD di1;
di1[110] = -1;
di1[1100] = 123123;
Test::ShortIntD di2;
di2[110] = -1;
di2[111] = -100;
di2[1101] = 0;
Test::ShortIntD di3;
di3[100] = -1001;
dsi1[0] = di1;
dsi1[1] = di2;
dsi2[0] = di3;
try
{
Test::ShortIntDS _do;
Test::ShortIntDS ro = p->opShortIntDS(dsi1, dsi2, _do);
test(ro.size() == 2);
test(ro[0].size() == 3);
test(ro[0][110] == -1);
test(ro[0][111] == -100);
test(ro[0][1101] == 0);
test(ro[1].size() == 2);
test(ro[1][110] == -1);
test(ro[1][1100] == 123123);
test(_do.size() == 3);
test(_do[0].size() == 1);
test(_do[0][100] == -1001);
test(_do[1].size() == 2);
test(_do[1][110] == -1);
test(_do[1][1100] == 123123);
test(_do[2].size() == 3);
test(_do[2][110] == -1);
test(_do[2][111] == -100);
test(_do[2][1101] == 0);
}
catch(const Ice::OperationNotExistException&)
{
}
}
{
Test::LongFloatDS dsi1;
dsi1.resize(2);
Test::LongFloatDS dsi2;
dsi2.resize(1);
Test::LongFloatD di1;
di1[999999110] = Ice::Float(-1.1);
di1[999999111] = Ice::Float(123123.2);
Test::LongFloatD di2;
di2[999999110] = Ice::Float(-1.1);
di2[999999120] = Ice::Float(-100.4);
di2[999999130] = Ice::Float(0.5);
Test::LongFloatD di3;
di3[999999140] = Ice::Float(3.14);
dsi1[0] = di1;
dsi1[1] = di2;
dsi2[0] = di3;
try
{
Test::LongFloatDS _do;
Test::LongFloatDS ro = p->opLongFloatDS(dsi1, dsi2, _do);
test(ro.size() == 2);
test(ro[0].size() == 3);
test(ro[0][999999110] == Ice::Float(-1.1));
test(ro[0][999999120] == Ice::Float(-100.4));
test(ro[0][999999130] == Ice::Float(0.5));
test(ro[1].size() == 2);
test(ro[1][999999110] == Ice::Float(-1.1));
test(ro[1][999999111] == Ice::Float(123123.2));
test(_do.size() == 3);
test(_do[0].size() == 1);
test(_do[0][999999140] == Ice::Float(3.14));
test(_do[1].size() == 2);
test(_do[1][999999110] == Ice::Float(-1.1));
test(_do[1][999999111] == Ice::Float(123123.2));
test(_do[2].size() == 3);
test(_do[2][999999110] == Ice::Float(-1.1));
test(_do[2][999999120] == Ice::Float(-100.4));
test(_do[2][999999130] == Ice::Float(0.5));
}
catch(const Ice::OperationNotExistException&)
{
}
}
{
Test::StringStringDS dsi1;
dsi1.resize(2);
Test::StringStringDS dsi2;
dsi2.resize(1);
Test::StringStringD di1;
di1["foo"] = "abc -1.1";
di1["bar"] = "abc 123123.2";
Test::StringStringD di2;
di2["foo"] = "abc -1.1";
di2["FOO"] = "abc -100.4";
di2["BAR"] = "abc 0.5";
Test::StringStringD di3;
di3["f00"] = "ABC -3.14";
dsi1[0] = di1;
dsi1[1] = di2;
dsi2[0] = di3;
try
{
Test::StringStringDS _do;
Test::StringStringDS ro = p->opStringStringDS(dsi1, dsi2, _do);
test(ro.size() == 2);
test(ro[0].size() == 3);
test(ro[0]["foo"] == "abc -1.1");
test(ro[0]["FOO"] == "abc -100.4");
test(ro[0]["BAR"] == "abc 0.5");
test(ro[1].size() == 2);
test(ro[1]["foo"] == "abc -1.1");
test(ro[1]["bar"] == "abc 123123.2");
test(_do.size() == 3);
test(_do[0].size() == 1);
test(_do[0]["f00"] == "ABC -3.14");
test(_do[1].size() == 2);
test(_do[1]["foo"] == "abc -1.1");
test(_do[1]["bar"] == "abc 123123.2");
test(_do[2].size() == 3);
test(_do[2]["foo"] == "abc -1.1");
test(_do[2]["FOO"] == "abc -100.4");
test(_do[2]["BAR"] == "abc 0.5");
}
catch(const Ice::OperationNotExistException&)
{
}
}
{
Test::StringMyEnumDS dsi1;
dsi1.resize(2);
Test::StringMyEnumDS dsi2;
dsi2.resize(1);
Test::StringMyEnumD di1;
di1["abc"] = ICE_ENUM(MyEnum, enum1);
di1[""] = ICE_ENUM(MyEnum, enum2);
Test::StringMyEnumD di2;
di2["abc"] = ICE_ENUM(MyEnum, enum1);
di2["qwerty"] = ICE_ENUM(MyEnum, enum3);
di2["Hello!!"] = ICE_ENUM(MyEnum, enum2);
Test::StringMyEnumD di3;
di3["Goodbye"] = ICE_ENUM(MyEnum, enum1);
dsi1[0] = di1;
dsi1[1] = di2;
dsi2[0] = di3;
try
{
Test::StringMyEnumDS _do;
Test::StringMyEnumDS ro = p->opStringMyEnumDS(dsi1, dsi2, _do);
test(ro.size() == 2);
test(ro[0].size() == 3);
test(ro[0]["abc"] == ICE_ENUM(MyEnum, enum1));
test(ro[0]["qwerty"] == ICE_ENUM(MyEnum, enum3));
test(ro[0]["Hello!!"] == ICE_ENUM(MyEnum, enum2));
test(ro[1].size() == 2);
test(ro[1]["abc"] == ICE_ENUM(MyEnum, enum1));
test(ro[1][""] == ICE_ENUM(MyEnum, enum2));
test(_do.size() == 3);
test(_do[0].size() == 1);
test(_do[0]["Goodbye"] == ICE_ENUM(MyEnum, enum1));
test(_do[1].size() == 2);
test(_do[1]["abc"] == ICE_ENUM(MyEnum, enum1));
test(_do[1][""] == ICE_ENUM(MyEnum, enum2));
test(_do[2].size() == 3);
test(_do[2]["abc"] == ICE_ENUM(MyEnum, enum1));
test(_do[2]["qwerty"] == ICE_ENUM(MyEnum, enum3));
test(_do[2]["Hello!!"] == ICE_ENUM(MyEnum, enum2));
}
catch(const Ice::OperationNotExistException&)
{
}
}
{
Test::MyEnumStringDS dsi1;
dsi1.resize(2);
Test::MyEnumStringDS dsi2;
dsi2.resize(1);
Test::MyEnumStringD di1;
di1[ICE_ENUM(MyEnum, enum1)] = "abc";
Test::MyEnumStringD di2;
di2[ICE_ENUM(MyEnum, enum2)] = "Hello!!";
di2[ICE_ENUM(MyEnum, enum3)] = "qwerty";
Test::MyEnumStringD di3;
di3[ICE_ENUM(MyEnum, enum1)] = "Goodbye";
dsi1[0] = di1;
dsi1[1] = di2;
dsi2[0] = di3;
try
{
Test::MyEnumStringDS _do;
Test::MyEnumStringDS ro = p->opMyEnumStringDS(dsi1, dsi2, _do);
test(ro.size() == 2);
test(ro[0].size() == 2);
test(ro[0][ICE_ENUM(MyEnum, enum2)] == "Hello!!");
test(ro[0][ICE_ENUM(MyEnum, enum3)] == "qwerty");
test(ro[1].size() == 1);
test(ro[1][ICE_ENUM(MyEnum, enum1)] == "abc");
test(_do.size() == 3);
test(_do[0].size() == 1);
test(_do[0][ICE_ENUM(MyEnum, enum1)] == "Goodbye");
test(_do[1].size() == 1);
test(_do[1][ICE_ENUM(MyEnum, enum1)] == "abc");
test(_do[2].size() == 2);
test(_do[2][ICE_ENUM(MyEnum, enum2)] == "Hello!!");
test(_do[2][ICE_ENUM(MyEnum, enum3)] == "qwerty");
}
catch(const Ice::OperationNotExistException&)
{
}
}
{
Test::MyStructMyEnumDS dsi1;
dsi1.resize(2);
Test::MyStructMyEnumDS dsi2;
dsi2.resize(1);
Test::MyStruct s11 = { 1, 1 };
Test::MyStruct s12 = { 1, 2 };
Test::MyStructMyEnumD di1;
di1[s11] = ICE_ENUM(MyEnum, enum1);
di1[s12] = ICE_ENUM(MyEnum, enum2);
Test::MyStruct s22 = { 2, 2 };
Test::MyStruct s23 = { 2, 3 };
Test::MyStructMyEnumD di2;
di2[s11] = ICE_ENUM(MyEnum, enum1);
di2[s22] = ICE_ENUM(MyEnum, enum3);
di2[s23] = ICE_ENUM(MyEnum, enum2);
Test::MyStructMyEnumD di3;
di3[s23] = ICE_ENUM(MyEnum, enum3);
dsi1[0] = di1;
dsi1[1] = di2;
dsi2[0] = di3;
try
{
Test::MyStructMyEnumDS _do;
Test::MyStructMyEnumDS ro = p->opMyStructMyEnumDS(dsi1, dsi2, _do);
test(ro.size() == 2);
test(ro[0].size() == 3);
test(ro[0][s11] == ICE_ENUM(MyEnum, enum1));
test(ro[0][s22] == ICE_ENUM(MyEnum, enum3));
test(ro[0][s23] == ICE_ENUM(MyEnum, enum2));
test(ro[1].size() == 2);
test(ro[1][s11] == ICE_ENUM(MyEnum, enum1));
test(ro[1][s12] == ICE_ENUM(MyEnum, enum2));
test(_do.size() == 3);
test(_do[0].size() == 1);
test(_do[0][s23] == ICE_ENUM(MyEnum, enum3));
test(_do[1].size() == 2);
test(_do[1][s11] == ICE_ENUM(MyEnum, enum1));
test(_do[1][s12] == ICE_ENUM(MyEnum, enum2));
test(_do[2].size() == 3);
test(_do[2][s11] == ICE_ENUM(MyEnum, enum1));
test(_do[2][s22] == ICE_ENUM(MyEnum, enum3));
test(_do[2][s23] == ICE_ENUM(MyEnum, enum2));
}
catch(const Ice::OperationNotExistException&)
{
}
}
{
Test::ByteByteSD sdi1;
Test::ByteByteSD sdi2;
Test::ByteS si1;
Test::ByteS si2;
Test::ByteS si3;
si1.push_back(Ice::Byte(0x01));
si1.push_back(Ice::Byte(0x11));
si2.push_back(Ice::Byte(0x12));
si3.push_back(Ice::Byte(0xf2));
si3.push_back(Ice::Byte(0xf3));
sdi1[Ice::Byte(0x01)] = si1;
sdi1[Ice::Byte(0x22)] = si2;
sdi2[Ice::Byte(0xf1)] = si3;
try
{
Test::ByteByteSD _do;
Test::ByteByteSD ro = p->opByteByteSD(sdi1, sdi2, _do);
test(_do == sdi2);
test(ro.size() == 3);
test(ro[Ice::Byte(0x01)].size() == 2);
test(ro[Ice::Byte(0x01)][0] == Ice::Byte(0x01));
test(ro[Ice::Byte(0x01)][1] == Ice::Byte(0x11));
test(ro[Ice::Byte(0x22)].size() == 1);
test(ro[Ice::Byte(0x22)][0] == Ice::Byte(0x12));
test(ro[Ice::Byte(0xf1)].size() == 2);
test(ro[Ice::Byte(0xf1)][0] == Ice::Byte(0xf2));
test(ro[Ice::Byte(0xf1)][1] == Ice::Byte(0xf3));
}
catch(const Ice::OperationNotExistException&)
{
}
}
{
Test::BoolBoolSD sdi1;
Test::BoolBoolSD sdi2;
Test::BoolS si1;
Test::BoolS si2;
si1.push_back(true);
si1.push_back(false);
si2.push_back(false);
si2.push_back(true);
si2.push_back(true);
sdi1[false] = si1;
sdi1[true] = si2;
sdi2[false] = si1;
try
{
Test::BoolBoolSD _do;
Test::BoolBoolSD ro = p->opBoolBoolSD(sdi1, sdi2, _do);
test(_do == sdi2);
test(ro.size() == 2);
test(ro[false].size() == 2);
test(ro[false][0] == true);
test(ro[false][1] == false);
test(ro[true].size() == 3);
test(ro[true][0] == false);
test(ro[true][1] == true);
test(ro[true][2] == true);
}
catch(const Ice::OperationNotExistException&)
{
}
}
{
Test::ShortShortSD sdi1;
Test::ShortShortSD sdi2;
Test::ShortS si1;
Test::ShortS si2;
Test::ShortS si3;
si1.push_back(1);
si1.push_back(2);
si1.push_back(3);
si2.push_back(4);
si2.push_back(5);
si3.push_back(6);
si3.push_back(7);
sdi1[1] = si1;
sdi1[2] = si2;
sdi2[4] = si3;
try
{
Test::ShortShortSD _do;
Test::ShortShortSD ro = p->opShortShortSD(sdi1, sdi2, _do);
test(_do == sdi2);
test(ro.size() == 3);
test(ro[1].size() == 3);
test(ro[1][0] == 1);
test(ro[1][1] == 2);
test(ro[1][2] == 3);
test(ro[2].size() == 2);
test(ro[2][0] == 4);
test(ro[2][1] == 5);
test(ro[4].size() == 2);
test(ro[4][0] == 6);
test(ro[4][1] == 7);
}
catch(const Ice::OperationNotExistException&)
{
}
}
{
Test::IntIntSD sdi1;
Test::IntIntSD sdi2;
Test::IntS si1;
Test::IntS si2;
Test::IntS si3;
si1.push_back(100);
si1.push_back(200);
si1.push_back(300);
si2.push_back(400);
si2.push_back(500);
si3.push_back(600);
si3.push_back(700);
sdi1[100] = si1;
sdi1[200] = si2;
sdi2[400] = si3;
try
{
Test::IntIntSD _do;
Test::IntIntSD ro = p->opIntIntSD(sdi1, sdi2, _do);
test(_do == sdi2);
test(ro.size() == 3);
test(ro[100].size() == 3);
test(ro[100][0] == 100);
test(ro[100][1] == 200);
test(ro[100][2] == 300);
test(ro[200].size() == 2);
test(ro[200][0] == 400);
test(ro[200][1] == 500);
test(ro[400].size() == 2);
test(ro[400][0] == 600);
test(ro[400][1] == 700);
}
catch(const Ice::OperationNotExistException&)
{
}
}
{
Test::LongLongSD sdi1;
Test::LongLongSD sdi2;
Test::LongS si1;
Test::LongS si2;
Test::LongS si3;
si1.push_back(999999110);
si1.push_back(999999111);
si1.push_back(999999110);
si2.push_back(999999120);
si2.push_back(999999130);
si3.push_back(999999110);
si3.push_back(999999120);
sdi1[999999990] = si1;
sdi1[999999991] = si2;
sdi2[999999992] = si3;
try
{
Test::LongLongSD _do;
Test::LongLongSD ro = p->opLongLongSD(sdi1, sdi2, _do);
test(_do == sdi2);
test(ro.size() == 3);
test(ro[999999990].size() == 3);
test(ro[999999990][0] == 999999110);
test(ro[999999990][1] == 999999111);
test(ro[999999990][2] == 999999110);
test(ro[999999991].size() == 2);
test(ro[999999991][0] == 999999120);
test(ro[999999991][1] == 999999130);
test(ro[999999992].size() == 2);
test(ro[999999992][0] == 999999110);
test(ro[999999992][1] == 999999120);
}
catch(const Ice::OperationNotExistException&)
{
}
}
{
Test::StringFloatSD sdi1;
Test::StringFloatSD sdi2;
Test::FloatS si1;
Test::FloatS si2;
Test::FloatS si3;
si1.push_back(Ice::Float(-1.1));
si1.push_back(Ice::Float(123123.2));
si1.push_back(Ice::Float(100.0));
si2.push_back(Ice::Float(42.24));
si2.push_back(Ice::Float(-1.61));
si3.push_back(Ice::Float(-3.14));
si3.push_back(Ice::Float(3.14));
sdi1["abc"] = si1;
sdi1["ABC"] = si2;
sdi2["aBc"] = si3;
try
{
Test::StringFloatSD _do;
Test::StringFloatSD ro = p->opStringFloatSD(sdi1, sdi2, _do);
test(_do == sdi2);
test(ro.size() == 3);
test(ro["abc"].size() == 3);
test(ro["abc"][0] == Ice::Float(-1.1));
test(ro["abc"][1] == Ice::Float(123123.2));
test(ro["abc"][2] == Ice::Float(100.0));
test(ro["ABC"].size() == 2);
test(ro["ABC"][0] == Ice::Float(42.24));
test(ro["ABC"][1] == Ice::Float(-1.61));
test(ro["aBc"].size() == 2);
test(ro["aBc"][0] == Ice::Float(-3.14));
test(ro["aBc"][1] == Ice::Float(3.14));
}
catch(const Ice::OperationNotExistException&)
{
}
}
{
Test::StringDoubleSD sdi1;
Test::StringDoubleSD sdi2;
Test::DoubleS si1;
Test::DoubleS si2;
Test::DoubleS si3;
si1.push_back(Ice::Double(1.1E10));
si1.push_back(Ice::Double(1.2E10));
si1.push_back(Ice::Double(1.3E10));
si2.push_back(Ice::Double(1.4E10));
si2.push_back(Ice::Double(1.5E10));
si3.push_back(Ice::Double(1.6E10));
si3.push_back(Ice::Double(1.7E10));
sdi1["Hello!!"] = si1;
sdi1["Goodbye"] = si2;
sdi2[""] = si3;
try
{
Test::StringDoubleSD _do;
Test::StringDoubleSD ro = p->opStringDoubleSD(sdi1, sdi2, _do);
test(_do == sdi2);
test(ro.size() == 3);
test(ro["Hello!!"].size() == 3);
test(ro["Hello!!"][0] == Ice::Double(1.1E10));
test(ro["Hello!!"][1] == Ice::Double(1.2E10));
test(ro["Hello!!"][2] == Ice::Double(1.3E10));
test(ro["Goodbye"].size() == 2);
test(ro["Goodbye"][0] == Ice::Double(1.4E10));
test(ro["Goodbye"][1] == Ice::Double(1.5E10));
test(ro[""].size() == 2);
test(ro[""][0] == Ice::Double(1.6E10));
test(ro[""][1] == Ice::Double(1.7E10));
}
catch(const Ice::OperationNotExistException&)
{
}
}
{
Test::StringStringSD sdi1;
Test::StringStringSD sdi2;
Test::StringS si1;
Test::StringS si2;
Test::StringS si3;
si1.push_back("abc");
si1.push_back("de");
si1.push_back("fghi");
si2.push_back("xyz");
si2.push_back("or");
si3.push_back("and");
si3.push_back("xor");
sdi1["abc"] = si1;
sdi1["def"] = si2;
sdi2["ghi"] = si3;
try
{
Test::StringStringSD _do;
Test::StringStringSD ro = p->opStringStringSD(sdi1, sdi2, _do);
test(_do == sdi2);
test(ro.size() == 3);
test(ro["abc"].size() == 3);
test(ro["abc"][0] == "abc");
test(ro["abc"][1] == "de");
test(ro["abc"][2] == "fghi");
test(ro["def"].size() == 2);
test(ro["def"][0] == "xyz");
test(ro["def"][1] == "or");
test(ro["ghi"].size() == 2);
test(ro["ghi"][0] == "and");
test(ro["ghi"][1] == "xor");
}
catch(const Ice::OperationNotExistException&)
{
}
}
{
Test::MyEnumMyEnumSD sdi1;
Test::MyEnumMyEnumSD sdi2;
Test::MyEnumS si1;
Test::MyEnumS si2;
Test::MyEnumS si3;
si1.push_back(ICE_ENUM(MyEnum, enum1));
si1.push_back(ICE_ENUM(MyEnum, enum1));
si1.push_back(ICE_ENUM(MyEnum, enum2));
si2.push_back(ICE_ENUM(MyEnum, enum1));
si2.push_back(ICE_ENUM(MyEnum, enum2));
si3.push_back(ICE_ENUM(MyEnum, enum3));
si3.push_back(ICE_ENUM(MyEnum, enum3));
sdi1[ICE_ENUM(MyEnum, enum3)] = si1;
sdi1[ICE_ENUM(MyEnum, enum2)] = si2;
sdi2[ICE_ENUM(MyEnum, enum1)] = si3;
try
{
Test::MyEnumMyEnumSD _do;
Test::MyEnumMyEnumSD ro = p->opMyEnumMyEnumSD(sdi1, sdi2, _do);
test(_do == sdi2);
test(ro.size() == 3);
test(ro[ICE_ENUM(MyEnum, enum3)].size() == 3);
test(ro[ICE_ENUM(MyEnum, enum3)][0] == ICE_ENUM(MyEnum, enum1));
test(ro[ICE_ENUM(MyEnum, enum3)][1] == ICE_ENUM(MyEnum, enum1));
test(ro[ICE_ENUM(MyEnum, enum3)][2] == ICE_ENUM(MyEnum, enum2));
test(ro[ICE_ENUM(MyEnum, enum2)].size() == 2);
test(ro[ICE_ENUM(MyEnum, enum2)][0] == ICE_ENUM(MyEnum, enum1));
test(ro[ICE_ENUM(MyEnum, enum2)][1] == ICE_ENUM(MyEnum, enum2));
test(ro[ICE_ENUM(MyEnum, enum1)].size() == 2);
test(ro[ICE_ENUM(MyEnum, enum1)][0] == ICE_ENUM(MyEnum, enum3));
test(ro[ICE_ENUM(MyEnum, enum1)][1] == ICE_ENUM(MyEnum, enum3));
}
catch(const Ice::OperationNotExistException&)
{
}
}
{
const int lengths[] = { 0, 1, 2, 126, 127, 128, 129, 253, 254, 255, 256, 257, 1000 };
for(unsigned int l = 0; l != sizeof(lengths) / sizeof(*lengths); ++l)
{
Test::IntS s;
for(int i = 0; i < lengths[l]; ++i)
{
s.push_back(i);
}
Test::IntS r = p->opIntS(s);
test(r.size() == static_cast<size_t>(lengths[l]));
for(int j = 0; j < static_cast<int>(r.size()); ++j)
{
test(r[j] == -j);
}
}
}
{
Ice::Context ctx;
ctx["one"] = "ONE";
ctx["two"] = "TWO";
ctx["three"] = "THREE";
{
Test::StringStringD r = p->opContext();
test(p->ice_getContext().empty());
test(r != ctx);
}
{
Test::StringStringD r = p->opContext(ctx);
test(p->ice_getContext().empty());
test(r == ctx);
}
{
Test::MyClassPrxPtr p2 = ICE_CHECKED_CAST(Test::MyClassPrx, p->ice_context(ctx));
test(p2->ice_getContext() == ctx);
Test::StringStringD r = p2->opContext();
test(r == ctx);
r = p2->opContext(ctx);
test(r == ctx);
}
#ifndef ICE_OS_WINRT
if(p->ice_getConnection() && communicator->getProperties()->getProperty("Ice.Default.Protocol") != "bt")
{
//
// Test implicit context propagation
//
string impls[] = {"Shared", "PerThread"};
for(int i = 0; i < 2; i++)
{
Ice::InitializationData initData;
initData.properties = communicator->getProperties()->clone();
initData.properties->setProperty("Ice.ImplicitContext", impls[i]);
Ice::CommunicatorPtr ic = Ice::initialize(initData);
Ice::Context ctx;
ctx["one"] = "ONE";
ctx["two"] = "TWO";
ctx["three"] = "THREE";
Test::MyClassPrxPtr p = ICE_UNCHECKED_CAST(Test::MyClassPrx,
ic->stringToProxy("test:" + getTestEndpoint(ic, 0)));
ic->getImplicitContext()->setContext(ctx);
test(ic->getImplicitContext()->getContext() == ctx);
test(p->opContext() == ctx);
test(ic->getImplicitContext()->containsKey("zero") == false);
string r = ic->getImplicitContext()->put("zero", "ZERO");
test(r == "");
test(ic->getImplicitContext()->containsKey("zero") == true);
test(ic->getImplicitContext()->get("zero") == "ZERO");
ctx = ic->getImplicitContext()->getContext();
test(p->opContext() == ctx);
Ice::Context prxContext;
prxContext["one"] = "UN";
prxContext["four"] = "QUATRE";
Ice::Context combined = prxContext;
combined.insert(ctx.begin(), ctx.end());
test(combined["one"] == "UN");
p = ICE_UNCHECKED_CAST(Test::MyClassPrx, p->ice_context(prxContext));
ic->getImplicitContext()->setContext(Ice::Context());
test(p->opContext() == prxContext);
ic->getImplicitContext()->setContext(ctx);
test(p->opContext() == combined);
test(ic->getImplicitContext()->remove("one") == "ONE");
if(impls[i] == "PerThread")
{
IceUtil::ThreadPtr thread = new PerThreadContextInvokeThread(p->ice_context(Ice::Context()));
thread->start();
thread->getThreadControl().join();
}
ic->getImplicitContext()->setContext(Ice::Context()); // Clear the context to avoid leak report.
ic->destroy();
}
}
#endif
}
{
Ice::Double d = 1278312346.0 / 13.0;
Test::DoubleS ds(5, d);
p->opDoubleMarshaling(d, ds);
}
p->opIdempotent();
p->opNonmutating();
test(p->opByte1(0xFF) == 0xFF);
test(p->opShort1(0x7FFF) == 0x7FFF);
test(p->opInt1(0x7FFFFFFF) == 0x7FFFFFFF);
test(p->opLong1(0x7FFFFFFFFFFFFFFFLL) == 0x7FFFFFFFFFFFFFFFLL);
test(p->opFloat1(1.0) == 1.0);
test(p->opDouble1(1.0) == 1.0);
test(p->opString1("opString1") == "opString1");
Test::MyDerivedClassPrxPtr d = ICE_UNCHECKED_CAST(Test::MyDerivedClassPrx, p);
Test::MyStruct1 s;
s.tesT = "Test::MyStruct1::s";
s.myClass = 0;
s.myStruct1 = "Test::MyStruct1::myStruct1";
s = d->opMyStruct1(s);
test(s.tesT == "Test::MyStruct1::s");
test(s.myClass == 0);
test(s.myStruct1 == "Test::MyStruct1::myStruct1");
Test::MyClass1Ptr c = ICE_MAKE_SHARED(Test::MyClass1);
c->tesT = "Test::MyClass1::testT";
c->myClass = 0;
c->myClass1 = "Test::MyClass1::myClass1";
c = d->opMyClass1(c);
test(c->tesT == "Test::MyClass1::testT");
test(c->myClass == 0);
test(c->myClass1 == "Test::MyClass1::myClass1");
Test::StringS seq;
p->opStringS1(seq);
Test::ByteBoolD dict;
p->opByteBoolD1(dict);
}
void ARobot::planifica(Scene *scn,int event){
// _robot->parar();
_scn=scn;
tiposEstrategias es=AMANHATTAN;
if (event == NEWAI){
cout<<"ARobot::"<<_id<<":: NEWAI:"<<_object->getPos()[0]<<":"<<_object->getPos()[1]<<endl;
_lMov.clear();
_guardia = -1;
Search *b = new Search(_id, scn->getMap(), scn->getMarca(_id+2)->getPos()[0]%scn->getGrid(), scn->getMarca(_id+2)->getPos()[1]%scn->getGrid(), scn->getMarca(_id+2)->getPos()[0]/scn->getGrid(), scn->getMarca(_id+2)->getPos()[1]/scn->getGrid(), scn->getAncho()/scn->getGrid()+1, scn->getAlto()/scn->getGrid()+1, scn->getMarca(_id+2)->getRatio()[0], scn->getMarca(_id+2)->getRatio()[1], es, _object->getId()+3, _object->getPos()[0]/scn->getGrid(), _object->getPos()[1]/scn->getGrid());
//Search *b = new Search(_id, scn->getMap(), scn->getMarca(_id+2)->getPos()[0]%scn->getGrid(), scn->getMarca(_id+2)->getPos()[1]%scn->getGrid(), scn->getMarca(_id+2)->getPos()[0]/scn->getGrid(), scn->getMarca(_id+2)->getPos()[1]/scn->getGrid(), scn->getAncho()/scn->getGrid()+1, scn->getAlto()/scn->getGrid()+1, scn->getMarca(_id+2)->getRatio()[0], scn->getMarca(_id+2)->getRatio()[1], es, _id, fin0,fin1);
//State *e = new State(_id,scn->getMarca(_id+2)->getPos()[0]%scn->getGrid(),scn->getMarca(_id+2)->getPos()[1]%scn->getGrid(),scn->getMarca(_id+2)->getPos()[0]/scn->getGrid(),scn->getMarca(_id+2)->getPos()[1]/scn->getGrid(),scn->getMarca(_id+2)->getRatio()[0],scn->getMarca(_id+2)->getRatio()[1],scn->getAncho()/scn->getGrid()+1,scn->getAlto()/scn->getGrid()+1,_object->getPos()[0],_object->getPos()[1],scn->getGrid(),scn->getGrid(),scn->arrayToVectorMap());
IceUtil::ThreadPtr t = new AI(b,this);
t->start();
}else if (event == MOVIMIENTO){
cout<<"ARobot::"<<_id<<":: MOVIMIENTO"<<endl;
if (casillaValida(scn)){
if ((int)_lMov.size() <= scn->getMarca(_id+2)->getRatio()[0]+1){
if(_guardia>0){
fin0 = -1, fin1 = -1;
switch(_guardia){
case 1:
_guardia = 2;
fin0 = scn->getFin()[0]/scn->getGrid();
fin1 = scn->getCenter()[1]/scn->getGrid();
break;
case 2:
_guardia = 3;
fin0 = scn->getCenter()[0]/scn->getGrid();;
fin1 = scn->getCenter()[1]/scn->getGrid();;
break;
case 3:
_guardia = 4;
fin0 = scn->getCenter()[0]/scn->getGrid();;
fin1 = scn->getFin()[1]/scn->getGrid();
break;
case 4:
_guardia = 1;
fin0 = scn->getFin()[0]/scn->getGrid();
fin1 = scn->getFin()[1]/scn->getGrid();
break;
}
_lMov.clear();
Search *b = new Search(_id, scn->getMap(), scn->getMarca(_id+2)->getPos()[0]%scn->getGrid(), scn->getMarca(_id+2)->getPos()[1]%scn->getGrid(), scn->getMarca(_id+2)->getPos()[0]/scn->getGrid(), scn->getMarca(_id+2)->getPos()[1]/scn->getGrid(), scn->getAncho()/scn->getGrid()+1, scn->getAlto()/scn->getGrid()+1, scn->getMarca(_id+2)->getRatio()[0], scn->getMarca(_id+2)->getRatio()[1], es, _id, fin0,fin1);
IceUtil::ThreadPtr t = new AI(b,this);
t->start();
// cout<<"TIDDDDDD:"<<tc.id()<<endl;
} else {
orientarO(scn);
}
}else{
if ((scn->getMarca(_id+2)->getPos()[0]/scn->getGrid() == static_cast<int>(_pos[0]/scn->getGrid())) && (scn->getMarca(_id+2)->getPos()[1]/scn->getGrid()) == static_cast<int>(_pos[1]/scn->getGrid())){
orientar(scn);
}else{
// cout<<"nextm ove"<<endl;
nextMov();
orientar(scn);
}
}
}else{
_lMov.clear();
if(_guardia>0){
Search *b = new Search(_id, scn->getMap(), scn->getMarca(_id+2)->getPos()[0]%scn->getGrid(), scn->getMarca(_id+2)->getPos()[1]%scn->getGrid(), scn->getMarca(_id+2)->getPos()[0]/scn->getGrid(), scn->getMarca(_id+2)->getPos()[1]/scn->getGrid(), scn->getAncho()/scn->getGrid()+1, scn->getAlto()/scn->getGrid()+1, scn->getMarca(_id+2)->getRatio()[0], scn->getMarca(_id+2)->getRatio()[1], es, _id, fin0,fin1);
IceUtil::ThreadPtr t = new AI(b,this);
t->start();
// cout<<"TIDDDDDD:"<<tc.id()<<endl;
}else{
Search *b = new Search(_id, scn->getMap(), scn->getMarca(_id+2)->getPos()[0]%scn->getGrid(), scn->getMarca(_id+2)->getPos()[1]%scn->getGrid(), scn->getMarca(_id+2)->getPos()[0]/scn->getGrid(), scn->getMarca(_id+2)->getPos()[1]/scn->getGrid(), scn->getAncho()/scn->getGrid()+1, scn->getAlto()/scn->getGrid()+1, scn->getMarca(_id+2)->getRatio()[0], scn->getMarca(_id+2)->getRatio()[1], es, _object->getId()+3, _object->getPos()[0]/scn->getGrid(), _object->getPos()[1]/scn->getGrid());
//State *e = new State(_id,scn->getMarca(_id+2)->getPos()[0]%scn->getGrid(),scn->getMarca(_id+2)->getPos()[1]%scn->getGrid(),scn->getMarca(_id+2)->getPos()[0]/scn->getGrid(),scn->getMarca(_id+2)->getPos()[1]/scn->getGrid(),scn->getMarca(_id+2)->getRatio()[0],scn->getMarca(_id+2)->getRatio()[1],scn->getAncho()/scn->getGrid()+1,scn->getAlto()/scn->getGrid()+1,scn->getFin()[0]/scn->getGrid(),scn->getFin()[1]/scn->getGrid(),scn->getGrid(),scn->getGrid(),scn->arrayToVectorMap());
IceUtil::ThreadPtr t = new AI(b,this);
t->start();
}
}
}else if (event == GUARDAI){
cout<<"ARobot::"<<_id<<":: GUARDAI"<<endl;
_lMov.clear();
if (_guardia==-1){
_guardia = 1;
// for (int j=0;j<=scn->getAlto()/scn->getGrid();j++){
// for (int i=0;i<=scn->getAncho()/scn->getGrid();i++){
// std::cout<<scn->getMap(i,j);
// }
// std::cout<<""<<std::endl;
// }
fin0=scn->getFin()[0]/scn->getGrid();
fin1=scn->getFin()[1]/scn->getGrid();
}
// cout<<"ARobot:: Inicio: "<<scn->getMarca(_id+2)->getPos()[0]/scn->getGrid()<<" : "<<scn->getMarca(_id+2)->getPos()[1]/scn->getGrid()<<endl;
// cout<<"ARobot:: ratio: "<<scn->getMarca(_id+2)->getRatio()[0]<<" : "<<scn->getMarca(_id+2)->getRatio()[1]<<endl;
Search *b = new Search(_id, scn->getMap(), scn->getMarca(_id+2)->getPos()[0]%scn->getGrid(), scn->getMarca(_id+2)->getPos()[1]%scn->getGrid(), scn->getMarca(_id+2)->getPos()[0]/scn->getGrid(), scn->getMarca(_id+2)->getPos()[1]/scn->getGrid(), scn->getAncho()/scn->getGrid()+1, scn->getAlto()/scn->getGrid()+1, scn->getMarca(_id+2)->getRatio()[0], scn->getMarca(_id+2)->getRatio()[1], es, _id, fin0,fin1);
//State *e = new State(_id,scn->getMarca(_id+2)->getPos()[0]%scn->getGrid(),scn->getMarca(_id+2)->getPos()[1]%scn->getGrid(),scn->getMarca(_id+2)->getPos()[0]/scn->getGrid(),scn->getMarca(_id+2)->getPos()[1]/scn->getGrid(),scn->getMarca(_id+2)->getRatio()[0],scn->getMarca(_id+2)->getRatio()[1],scn->getAncho()/scn->getGrid()+1,scn->getAlto()/scn->getGrid()+1,scn->getFin()[0]/scn->getGrid(),scn->getFin()[1]/scn->getGrid(),scn->getGrid(),scn->getGrid(),scn->arrayToVectorMap());
IceUtil::ThreadPtr t = new AI(b,this);
t->start();
// cout<<"TIDDDDDD:"<<tc.id()<<endl;
}
double po[2] = {scn->getMarca(_id+2)->getPos()[0],scn->getMarca(_id+2)->getPos()[1]};
setPos(po);
// _markerInfo = markerInfo;
// _pos[0] = _markerInfo->pos[0];
// _pos[1] = _markerInfo->pos[1];
// std::cout<<"Rotacion: "<<rotacion<<std::endl;
// std::cout<<"Angulo final: "<<_ang<<std::endl;
// std::cout<<"Posicion: ["<<_pos[0]<<","<<_pos[1]<<"]"<<std::endl;
// std::cout<<"Posicion final: ["<<_fin[0]<<","<<_fin[1]<<"]"<<std::endl;
// std::cout<<"State: "<<_State<<" Direccion: "<<_direccion<<std::endl;
// std::cout<<"Accion: "<<accion<<std::endl;
// if ((accion == 0) || (accion == 1)){
// double final[2];
// if (_pos[0] > ((fin[0] - inicio[0]) / 2 + inicio[0])){
// if (_pos[1] > ((fin[1] - inicio[1]) / 2 + inicio[1])){
// setDir(1);
// final[0] = fin[0];
// final[1] = fin[1];
// setFin(final);
// }else{
// setDir(2);
// final[0] = fin[0];
// final[1] = inicio[1];
// setFin(final);
// }
// }else{
// if (_pos[1] > ((fin[1] - inicio[1]) / 2 + inicio[1])){
// setDir(4);
// final[0] = inicio[0];
// final[1] = fin[1];
// setFin(final);
// }else{
// setDir(3);
// final[0] = inicio[0];
// final[1] = inicio[1];
// setFin(final);
// }
// }
// }else{
// if (rotacion>(_ang+10) || rotacion<(_ang-10)){
// if (_ang>rotacion){
// if (_ang-rotacion<180){
// _robot->izquierda();
// }
// else{
// _robot->derecha();
// }
// }else{
// if (_ang-rotacion<180){
// _robot->derecha();
// }
// else{
// _robot->izquierda();
// }
// }
// if (accion == 4)
// setEst(2);
// else
// setEst(6);
// }else{ //Ya está orientado (Dentro del umbral)
// _robot->avanzar();
// if (accion == 4)
// setEst(1);
// else
// setEst(5);
// }
// }
}