pberr
/
mw_server
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

MWMap class

0.2
Pedro Berrocal 5 years ago
parent
152d9ed8c9
commit
592e5bac99
12 changed files with 195 additions and 5687 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +1
    -1
      README.md
  2. +0
    -1113
      include/MW.h
  3. +0
    -2568
      include/MWSession.h
  4. +0
    -825
      src/MW.cpp
  5. +0
    -1173
      src/MW.h
  6. +1
    -1
      src/MW.ice
  7. BIN
      src/MW.o
  8. +91
    -0
      src/MWMap.cpp
  9. +38
    -0
      src/MWMap.h
  10. +7
    -6
      src/MWServer.cpp
  11. +22
    -0
      src/MWSessionI.cpp
  12. +35
    -0
      src/MWSessionI.h

+ 1
- 1
README.md View File

@ -24,7 +24,7 @@ slice2cpp Printer.ice
### Compile & link
```
c++ -I. -DICE_CPP11_MAPPING -c Printer.cpp Server.cpp -std=c++11 -pthread
c++ -I. -DICE_CPP11_MAPPING -c MW.cpp MWServer.cpp MWMap.cpp -std=c++11 -lIce++11 -pthread
c++ -o server Printer.o Server.o -lIce++11 -pthread -std=c++11
```

+ 0
- 1113
include/MW.h
File diff suppressed because it is too large
View File


+ 0
- 2568
include/MWSession.h
File diff suppressed because it is too large
View File


+ 0
- 825
src/MW.cpp View File

@ -1,825 +0,0 @@
// **********************************************************************
//
// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
//
// Ice version 3.7.1
//
// <auto-generated>
//
// Generated from file `MW.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//
#include <MW.h>
#include <IceUtil/PushDisableWarnings.h>
#include <Ice/LocalException.h>
#include <Ice/ValueFactory.h>
#include <Ice/OutgoingAsync.h>
#include <Ice/InputStream.h>
#include <Ice/OutputStream.h>
#include <Ice/LocalException.h>
#include <Ice/SlicedData.h>
#include <IceUtil/PopDisableWarnings.h>
#if defined(_MSC_VER)
# pragma warning(disable:4458) // declaration of ... hides class member
#elif defined(__clang__)
# pragma clang diagnostic ignored "-Wshadow"
#elif defined(__GNUC__)
# pragma GCC diagnostic ignored "-Wshadow"
#endif
#ifndef ICE_IGNORE_VERSION
# if ICE_INT_VERSION / 100 != 307
# error Ice version mismatch!
# endif
# if ICE_INT_VERSION % 100 > 50
# error Beta header file detected
# endif
# if ICE_INT_VERSION % 100 < 1
# error Ice patch level mismatch!
# endif
#endif
#ifdef ICE_CPP11_MAPPING // C++11 mapping
namespace
{
const ::std::string iceC_MW_MWCallback_ids[2] =
{
"::Ice::Object",
"::MW::MWCallback"
};
const ::std::string iceC_MW_MWCallback_ops[] =
{
"ice_id",
"ice_ids",
"ice_isA",
"ice_ping",
"status"
};
const ::std::string iceC_MW_MWCallback_status_name = "status";
const ::std::string iceC_MW_MWSession_ids[3] =
{
"::Glacier2::Session",
"::Ice::Object",
"::MW::MWSession"
};
const ::std::string iceC_MW_MWSession_ops[] =
{
"destroy",
"ice_id",
"ice_ids",
"ice_isA",
"ice_ping",
"sendCoords",
"setCallback"
};
const ::std::string iceC_MW_MWSession_setCallback_name = "setCallback";
const ::std::string iceC_MW_MWSession_sendCoords_name = "sendCoords";
}
bool
MW::MWCallback::ice_isA(::std::string s, const ::Ice::Current&) const
{
return ::std::binary_search(iceC_MW_MWCallback_ids, iceC_MW_MWCallback_ids + 2, s);
}
::std::vector<::std::string>
MW::MWCallback::ice_ids(const ::Ice::Current&) const
{
return ::std::vector<::std::string>(&iceC_MW_MWCallback_ids[0], &iceC_MW_MWCallback_ids[2]);
}
::std::string
MW::MWCallback::ice_id(const ::Ice::Current&) const
{
return ice_staticId();
}
const ::std::string&
MW::MWCallback::ice_staticId()
{
static const ::std::string typeId = "::MW::MWCallback";
return typeId;
}
/// \cond INTERNAL
bool
MW::MWCallback::_iceD_status(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
_iceCheckMode(::Ice::OperationMode::Normal, current.mode);
auto istr = inS.startReadParams();
::std::string iceP_s;
istr->readAll(iceP_s);
inS.endReadParams();
this->status(::std::move(iceP_s), current);
inS.writeEmptyParams();
return true;
}
/// \endcond
/// \cond INTERNAL
bool
MW::MWCallback::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_MW_MWCallback_ops, iceC_MW_MWCallback_ops + 5, current.operation);
if(r.first == r.second)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
switch(r.first - iceC_MW_MWCallback_ops)
{
case 0:
{
return _iceD_ice_id(in, current);
}
case 1:
{
return _iceD_ice_ids(in, current);
}
case 2:
{
return _iceD_ice_isA(in, current);
}
case 3:
{
return _iceD_ice_ping(in, current);
}
case 4:
{
return _iceD_status(in, current);
}
default:
{
assert(false);
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
}
}
/// \endcond
bool
MW::MWSession::ice_isA(::std::string s, const ::Ice::Current&) const
{
return ::std::binary_search(iceC_MW_MWSession_ids, iceC_MW_MWSession_ids + 3, s);
}
::std::vector<::std::string>
MW::MWSession::ice_ids(const ::Ice::Current&) const
{
return ::std::vector<::std::string>(&iceC_MW_MWSession_ids[0], &iceC_MW_MWSession_ids[3]);
}
::std::string
MW::MWSession::ice_id(const ::Ice::Current&) const
{
return ice_staticId();
}
const ::std::string&
MW::MWSession::ice_staticId()
{
static const ::std::string typeId = "::MW::MWSession";
return typeId;
}
/// \cond INTERNAL
bool
MW::MWSession::_iceD_setCallback(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
_iceCheckMode(::Ice::OperationMode::Normal, current.mode);
auto istr = inS.startReadParams();
::std::shared_ptr<MWCallbackPrx> iceP_callback;
istr->readAll(iceP_callback);
inS.endReadParams();
this->setCallback(::std::move(iceP_callback), current);
inS.writeEmptyParams();
return true;
}
/// \endcond
/// \cond INTERNAL
bool
MW::MWSession::_iceD_sendCoords(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
_iceCheckMode(::Ice::OperationMode::Normal, current.mode);
auto istr = inS.startReadParams();
::std::string iceP_coords;
istr->readAll(iceP_coords);
inS.endReadParams();
this->sendCoords(::std::move(iceP_coords), current);
inS.writeEmptyParams();
return true;
}
/// \endcond
/// \cond INTERNAL
bool
MW::MWSession::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_MW_MWSession_ops, iceC_MW_MWSession_ops + 7, current.operation);
if(r.first == r.second)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
switch(r.first - iceC_MW_MWSession_ops)
{
case 0:
{
return _iceD_destroy(in, current);
}
case 1:
{
return _iceD_ice_id(in, current);
}
case 2:
{
return _iceD_ice_ids(in, current);
}
case 3:
{
return _iceD_ice_isA(in, current);
}
case 4:
{
return _iceD_ice_ping(in, current);
}
case 5:
{
return _iceD_sendCoords(in, current);
}
case 6:
{
return _iceD_setCallback(in, current);
}
default:
{
assert(false);
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
}
}
/// \endcond
/// \cond INTERNAL
void
MW::MWCallbackPrx::_iceI_status(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::std::string& iceP_s, const ::Ice::Context& context)
{
outAsync->invoke(iceC_MW_MWCallback_status_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::DefaultFormat, context,
[&](::Ice::OutputStream* ostr)
{
ostr->writeAll(iceP_s);
},
nullptr);
}
/// \endcond
/// \cond INTERNAL
::std::shared_ptr<::Ice::ObjectPrx>
MW::MWCallbackPrx::_newInstance() const
{
return ::IceInternal::createProxy<MWCallbackPrx>();
}
/// \endcond
const ::std::string&
MW::MWCallbackPrx::ice_staticId()
{
return MWCallback::ice_staticId();
}
/// \cond INTERNAL
void
MW::MWSessionPrx::_iceI_setCallback(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::std::shared_ptr<MWCallbackPrx>& iceP_callback, const ::Ice::Context& context)
{
outAsync->invoke(iceC_MW_MWSession_setCallback_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::DefaultFormat, context,
[&](::Ice::OutputStream* ostr)
{
ostr->writeAll(iceP_callback);
},
nullptr);
}
/// \endcond
/// \cond INTERNAL
void
MW::MWSessionPrx::_iceI_sendCoords(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::std::string& iceP_coords, const ::Ice::Context& context)
{
outAsync->invoke(iceC_MW_MWSession_sendCoords_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::DefaultFormat, context,
[&](::Ice::OutputStream* ostr)
{
ostr->writeAll(iceP_coords);
},
nullptr);
}
/// \endcond
/// \cond INTERNAL
::std::shared_ptr<::Ice::ObjectPrx>
MW::MWSessionPrx::_newInstance() const
{
return ::IceInternal::createProxy<MWSessionPrx>();
}
/// \endcond
const ::std::string&
MW::MWSessionPrx::ice_staticId()
{
return MWSession::ice_staticId();
}
#else // C++98 mapping
namespace
{
const ::std::string iceC_MW_MWCallback_status_name = "status";
const ::std::string iceC_MW_MWSession_setCallback_name = "setCallback";
const ::std::string iceC_MW_MWSession_sendCoords_name = "sendCoords";
}
/// \cond INTERNAL
::IceProxy::Ice::Object* ::IceProxy::MW::upCast(MWCallback* p) { return p; }
void
::IceProxy::MW::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< MWCallback>& v)
{
::Ice::ObjectPrx proxy;
istr->read(proxy);
if(!proxy)
{
v = 0;
}
else
{
v = new MWCallback;
v->_copyFrom(proxy);
}
}
/// \endcond
::Ice::AsyncResultPtr
IceProxy::MW::MWCallback::_iceI_begin_status(const ::std::string& iceP_s, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
{
::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_MW_MWCallback_status_name, del, cookie, sync);
try
{
result->prepare(iceC_MW_MWCallback_status_name, ::Ice::Normal, context);
::Ice::OutputStream* ostr = result->startWriteParams(::Ice::DefaultFormat);
ostr->write(iceP_s);
result->endWriteParams();
result->invoke(iceC_MW_MWCallback_status_name);
}
catch(const ::Ice::Exception& ex)
{
result->abort(ex);
}
return result;
}
void
IceProxy::MW::MWCallback::end_status(const ::Ice::AsyncResultPtr& result)
{
_end(result, iceC_MW_MWCallback_status_name);
}
/// \cond INTERNAL
::IceProxy::Ice::Object*
IceProxy::MW::MWCallback::_newInstance() const
{
return new MWCallback;
}
/// \endcond
const ::std::string&
IceProxy::MW::MWCallback::ice_staticId()
{
return ::MW::MWCallback::ice_staticId();
}
/// \cond INTERNAL
::IceProxy::Ice::Object* ::IceProxy::MW::upCast(MWSession* p) { return p; }
void
::IceProxy::MW::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< MWSession>& v)
{
::Ice::ObjectPrx proxy;
istr->read(proxy);
if(!proxy)
{
v = 0;
}
else
{
v = new MWSession;
v->_copyFrom(proxy);
}
}
/// \endcond
::Ice::AsyncResultPtr
IceProxy::MW::MWSession::_iceI_begin_setCallback(const ::MW::MWCallbackPrx& iceP_callback, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
{
::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_MW_MWSession_setCallback_name, del, cookie, sync);
try
{
result->prepare(iceC_MW_MWSession_setCallback_name, ::Ice::Normal, context);
::Ice::OutputStream* ostr = result->startWriteParams(::Ice::DefaultFormat);
ostr->write(iceP_callback);
result->endWriteParams();
result->invoke(iceC_MW_MWSession_setCallback_name);
}
catch(const ::Ice::Exception& ex)
{
result->abort(ex);
}
return result;
}
void
IceProxy::MW::MWSession::end_setCallback(const ::Ice::AsyncResultPtr& result)
{
_end(result, iceC_MW_MWSession_setCallback_name);
}
::Ice::AsyncResultPtr
IceProxy::MW::MWSession::_iceI_begin_sendCoords(const ::std::string& iceP_coords, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
{
::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_MW_MWSession_sendCoords_name, del, cookie, sync);
try
{
result->prepare(iceC_MW_MWSession_sendCoords_name, ::Ice::Normal, context);
::Ice::OutputStream* ostr = result->startWriteParams(::Ice::DefaultFormat);
ostr->write(iceP_coords);
result->endWriteParams();
result->invoke(iceC_MW_MWSession_sendCoords_name);
}
catch(const ::Ice::Exception& ex)
{
result->abort(ex);
}
return result;
}
void
IceProxy::MW::MWSession::end_sendCoords(const ::Ice::AsyncResultPtr& result)
{
_end(result, iceC_MW_MWSession_sendCoords_name);
}
/// \cond INTERNAL
::IceProxy::Ice::Object*
IceProxy::MW::MWSession::_newInstance() const
{
return new MWSession;
}
/// \endcond
const ::std::string&
IceProxy::MW::MWSession::ice_staticId()
{
return ::MW::MWSession::ice_staticId();
}
MW::MWCallback::~MWCallback()
{
}
/// \cond INTERNAL
::Ice::Object* MW::upCast(MWCallback* p) { return p; }
/// \endcond
namespace
{
const ::std::string iceC_MW_MWCallback_ids[2] =
{
"::Ice::Object",
"::MW::MWCallback"
};
}
bool
MW::MWCallback::ice_isA(const ::std::string& s, const ::Ice::Current&) const
{
return ::std::binary_search(iceC_MW_MWCallback_ids, iceC_MW_MWCallback_ids + 2, s);
}
::std::vector< ::std::string>
MW::MWCallback::ice_ids(const ::Ice::Current&) const
{
return ::std::vector< ::std::string>(&iceC_MW_MWCallback_ids[0], &iceC_MW_MWCallback_ids[2]);
}
const ::std::string&
MW::MWCallback::ice_id(const ::Ice::Current&) const
{
return ice_staticId();
}
const ::std::string&
MW::MWCallback::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
static const ::std::string typeId = "::MW::MWCallback";
return typeId;
#else
return iceC_MW_MWCallback_ids[1];
#endif
}
/// \cond INTERNAL
bool
MW::MWCallback::_iceD_status(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
_iceCheckMode(::Ice::Normal, current.mode);
::Ice::InputStream* istr = inS.startReadParams();
::std::string iceP_s;
istr->read(iceP_s);
inS.endReadParams();
this->status(iceP_s, current);
inS.writeEmptyParams();
return true;
}
/// \endcond
namespace
{
const ::std::string iceC_MW_MWCallback_all[] =
{
"ice_id",
"ice_ids",
"ice_isA",
"ice_ping",
"status"
};
}
/// \cond INTERNAL
bool
MW::MWCallback::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_MW_MWCallback_all, iceC_MW_MWCallback_all + 5, current.operation);
if(r.first == r.second)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
switch(r.first - iceC_MW_MWCallback_all)
{
case 0:
{
return _iceD_ice_id(in, current);
}
case 1:
{
return _iceD_ice_ids(in, current);
}
case 2:
{
return _iceD_ice_isA(in, current);
}
case 3:
{
return _iceD_ice_ping(in, current);
}
case 4:
{
return _iceD_status(in, current);
}
default:
{
assert(false);
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
}
}
/// \endcond
/// \cond STREAM
void
MW::MWCallback::_iceWriteImpl(::Ice::OutputStream* ostr) const
{
ostr->startSlice(ice_staticId(), -1, true);
::Ice::StreamWriter< MWCallback, ::Ice::OutputStream>::write(ostr, *this);
ostr->endSlice();
}
void
MW::MWCallback::_iceReadImpl(::Ice::InputStream* istr)
{
istr->startSlice();
::Ice::StreamReader< MWCallback, ::Ice::InputStream>::read(istr, *this);
istr->endSlice();
}
/// \endcond
/// \cond INTERNAL
void
MW::_icePatchObjectPtr(MWCallbackPtr& handle, const ::Ice::ObjectPtr& v)
{
handle = MWCallbackPtr::dynamicCast(v);
if(v && !handle)
{
IceInternal::Ex::throwUOE(MWCallback::ice_staticId(), v);
}
}
/// \endcond
MW::MWSession::~MWSession()
{
}
/// \cond INTERNAL
::Ice::Object* MW::upCast(MWSession* p) { return p; }
/// \endcond
namespace
{
const ::std::string iceC_MW_MWSession_ids[3] =
{
"::Glacier2::Session",
"::Ice::Object",
"::MW::MWSession"
};
}
bool
MW::MWSession::ice_isA(const ::std::string& s, const ::Ice::Current&) const
{
return ::std::binary_search(iceC_MW_MWSession_ids, iceC_MW_MWSession_ids + 3, s);
}
::std::vector< ::std::string>
MW::MWSession::ice_ids(const ::Ice::Current&) const
{
return ::std::vector< ::std::string>(&iceC_MW_MWSession_ids[0], &iceC_MW_MWSession_ids[3]);
}
const ::std::string&
MW::MWSession::ice_id(const ::Ice::Current&) const
{
return ice_staticId();
}
const ::std::string&
MW::MWSession::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
static const ::std::string typeId = "::MW::MWSession";
return typeId;
#else
return iceC_MW_MWSession_ids[2];
#endif
}
/// \cond INTERNAL
bool
MW::MWSession::_iceD_setCallback(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
_iceCheckMode(::Ice::Normal, current.mode);
::Ice::InputStream* istr = inS.startReadParams();
MWCallbackPrx iceP_callback;
istr->read(iceP_callback);
inS.endReadParams();
this->setCallback(iceP_callback, current);
inS.writeEmptyParams();
return true;
}
/// \endcond
/// \cond INTERNAL
bool
MW::MWSession::_iceD_sendCoords(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
_iceCheckMode(::Ice::Normal, current.mode);
::Ice::InputStream* istr = inS.startReadParams();
::std::string iceP_coords;
istr->read(iceP_coords);
inS.endReadParams();
this->sendCoords(iceP_coords, current);
inS.writeEmptyParams();
return true;
}
/// \endcond
namespace
{
const ::std::string iceC_MW_MWSession_all[] =
{
"destroy",
"ice_id",
"ice_ids",
"ice_isA",
"ice_ping",
"sendCoords",
"setCallback"
};
}
/// \cond INTERNAL
bool
MW::MWSession::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_MW_MWSession_all, iceC_MW_MWSession_all + 7, current.operation);
if(r.first == r.second)
{
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
switch(r.first - iceC_MW_MWSession_all)
{
case 0:
{
return _iceD_destroy(in, current);
}
case 1:
{
return _iceD_ice_id(in, current);
}
case 2:
{
return _iceD_ice_ids(in, current);
}
case 3:
{
return _iceD_ice_isA(in, current);
}
case 4:
{
return _iceD_ice_ping(in, current);
}
case 5:
{
return _iceD_sendCoords(in, current);
}
case 6:
{
return _iceD_setCallback(in, current);
}
default:
{
assert(false);
throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}
}
}
/// \endcond
/// \cond STREAM
void
MW::MWSession::_iceWriteImpl(::Ice::OutputStream* ostr) const
{
ostr->startSlice(ice_staticId(), -1, true);
::Ice::StreamWriter< MWSession, ::Ice::OutputStream>::write(ostr, *this);
ostr->endSlice();
}
void
MW::MWSession::_iceReadImpl(::Ice::InputStream* istr)
{
istr->startSlice();
::Ice::StreamReader< MWSession, ::Ice::InputStream>::read(istr, *this);
istr->endSlice();
}
/// \endcond
/// \cond INTERNAL
void
MW::_icePatchObjectPtr(MWSessionPtr& handle, const ::Ice::ObjectPtr& v)
{
handle = MWSessionPtr::dynamicCast(v);
if(v && !handle)
{
IceInternal::Ex::throwUOE(MWSession::ice_staticId(), v);
}
}
/// \endcond
namespace Ice
{
}
#endif

+ 0
- 1173
src/MW.h
File diff suppressed because it is too large
View File


+ 1
- 1
src/MW.ice View File

@ -12,6 +12,6 @@ module MW
interface MWSession extends Glacier2::Session
{
void setCallback(MWCallback* callback);
void sendCoords(string coords);
void sendPosition(string positon);
}
}

BIN
src/MW.o View File


+ 91
- 0
src/MWMap.cpp View File

@ -0,0 +1,91 @@
#include <Ice/Ice.h>
#include <MWSessionI.h>
#include <list>
#include <MWMap.h>
using namespace std;
using namespace MW;
MWMap*
MWMap::instance()
{
static mwMap mwMapInstance;
return &mwMap Instance;
}
void
MWMap::enter(const shared_ptr<MWSessionPrx>& session, const shared_ptr<MWCallbackPrx>& callback,
const Ice::Current& current)
{
lock_guard<mutex> sync(_mutex);
_callback.push_back(callback);
auto p = _connectionMap.find(current.con);
if (p == _connectionMap.end())
{
cout << "Enter: create a new entry in connection map" << endl;
_connectionMap[current.con].push_back(session);
//
// Never close this connection from Glacier2 and turn on heartbeats with a timeout of 30s
//
current.con->setACM(30, Ice::ACMClose::CloseOff, Ice::ACMHeartbeat::HeartbeatAlways);
current.con->setCloseCallback([this](const shared_ptr<Ice::Connection>& con)
{
deadRouter(con);
)};
}
else
{
cout << "enter: add session to existing connection map entry" << endl;
p->second.push_back(session);
}
}
void
MWMap::leave(const shared_ptr<MWCallbackPrx>& callback, const Ice::Current& current)
{
lock_guard(mutex) sync(_mutex);
_callbacks.remove_if([&callback](const shared_ptr<MWCallbackPrx>& cb) { return Ice::proxyIdentifyEqual(callback, cb); });
_connectionMap[current.con].remove_if([&current](const share_ptr<MWSessionPrx>& s) {return current.id == s->ice_getIdentity(); });
}
void
MWMap::message(const string& data) const
{
lock_guard<mutex> sync(const_cast<mutex&>(_mutex));
for(const auto& cb: _callbacks)
{
cb->messageAsync(data);
}
}
void
MWMap::dearRouter()
{
cout << "Detected dead router. Detroying all sessions " << endl;
list<shared_ptr<MWSessionPrx>> sessions;
lock_guar<mutex> sync(_mutex);
auto p = _connectionMap.find(con);
if(p != _connectionMap.end())
{
sessions.swap(p->second);
_connectionMap.erase(p);
}
for(auto& s: sessions )
{
s->destroy();
}
}
void
MWMap::destroy()
{
lock_guard<mutex> sync(_mutex);
_callbacks.clear();
_connectionMap.clear();
}

+ 38
- 0
src/MWMap.h View File

@ -0,0 +1,38 @@
#ifndef MW_MAP_SESSION_I_H
#define MW_MAP_SESSION_I_H
#include <Ice/Ice.h>
#include <MWSessionI.h>
#include <list>
using namespace std;
using namespace MW;
//
// MWMap helper singleton
//
class MWMap
{
public:
static mwMap* instance();
void enter(const shared_ptr<MWSessionPrx>&, const shared_ptr<MWCallbackPrx>&, const Ice::Current&);
void leave(const shared_ptr<MWCallbackPrx>&, const Ice::Current&);
void message(const string&) const;
void deadRouter(const shared_ptr<Ice::Connection>&);
void destroy();
private:
mutex _mutex;
list<shared_ptr<MWCallbackPrx>> _callbacks;
//
// Map of connection from Glacier2 to proxies of Chat Sessions in this server
//
map<shared_ptr<Ice::Connection>, list<shared_ptr<MWSessionPrx>>> _connectionMap;
};
#endif

+ 7
- 6
src/MWServer.cpp View File

@ -1,18 +1,19 @@
#include <Ice/Ice.h>
#include <Glacier2/Glacier2.h>
#include <MW.h>
#include <MWSessionI.h>
using namespace std;
using namespace MW;
class DummyPermissionsVerifierI : public Glacier2::PermissionVerifier
class DummyPermissionsVerifierI : public Glacier2::PermissionsVerifier
{
public:
virtual bool
checkPermissions(string userId, string password, string&, const Ice::Current&) const override
{
cout << userId << endl;
cout << "User " << userId << " with password " << password << " has joined the map" << endl;
return true;
}
@ -47,16 +48,16 @@ main(int argc, char* argv[])
{
auto adapter = ich->createObjectAdapter("MWServer");
auto dpv = make_shared<DummyPermissionsVerifierI()>;
auto dpv = make_shared<DummyPermissionsVerifierI>();
adapter->add(dpv, Ice::stringToIdentity("MWSessionVerifier"));
// auto mwsm = make_shared<MWSessionManagerI()>;
// adapter->add(mwsm, Ice::stringToIdentity("MWSessionManager"));
auto mwsm = make_shared<MWSessionManagerI>();
adapter->add(mwsm, Ice::stringToIdentity("MWSessionManager"));
adapter->activate();
ich->waitForShutdown();
// mwsm->destroy();
mwsm->destroy();
}
}


+ 22
- 0
src/MWSessionI.cpp View File

@ -0,0 +1,22 @@
#include <Ice/Ice.h>
#include <MWSessionI.h>
#include <list>
using namespace std;
using namespace MW;
MWSessionI::ChatSessionI(const string& userId) :
_userId(userId)
{
}
void
MWSessionCallback::setCallback(shared_ptr<MWCallbackPrx>, const Ice::Current& current)
{
lock_guard<mutex> sync(mutex);
if(!_callback)
{
_callback = callback
}
}

+ 35
- 0
src/MWSessionI.h View File

@ -0,0 +1,35 @@
#ifndef MW_SESSION_I_H
#define MW_SESSION_I_H
#include <MW.h>
#include <Glacier2/Glacier2.h>
#include <mutex>
class MWSessionI : public MW::MWSession
{
public:
MWSessionI(const std::string&);
virtual void setCallback(std::shared_ptr<MW::MWCallbackPrx>, const Ice::Current&) override;
virtual void sendPosition(std::string, const Ice::Current&) override;
virtual void destroy(const Ice::Current&) override;
private:
std::mutex _mutex;
const std::string _userId;
std::shared_ptr<MW::MWCallbackPrx> _callback;
};
class MWSessionManagerI : public Glacier2::SessionManager
{
public:
virtual std::shared_ptr<Glacier2::SessionPrx>
create(std::string, std::shared_ptr<Glacier2::SessionControlPrx>, const Ice::Current&) override;
void destroy();
};
#endif

Write Preview
Loading…
Cancel
Save